src/controller/python/chip/yaml/format_converter.py - third_party/github/project-chip/connectedhomeip - Git at Google

 #
 #    Copyright (c) 2022 Project CHIP Authors
 #    All rights reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
 #    You may obtain a copy of the License at
 #
 #        http://www.apache.org/licenses/LICENSE-2.0
 #
 #    Unless required by applicable law or agreed to in writing, software
 #    distributed under the License is distributed on an "AS IS" BASIS,
 #    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #

 import typing
 from chip.clusters.Types import Nullable, NullValue
 from chip.tlv import uint, float32
 import enum
 from chip.yaml.errors import ValidationError
 import binascii


 def substitute_in_config_variables(field_value, config_values: dict):
     ''' Substitutes values that are config variables.

     YAML values can contain a string of a configuration variable name. In these instances we
     substitute the configuration variable name with the actual value.

     For examples see unittest src/controller/python/test/unit_tests/test_yaml_format_converter.py

     # TODO This should also substitue any saveAs values as well as perform any required
     # evaluations.

     Args:
         'field_value': Value as extracted from YAML.
         'config_values': Dictionary of global configuration variables.
     Returns:
         Value with all global configuration variables substituted with the real value.
     '''
     if isinstance(field_value, dict):
         return {key: substitute_in_config_variables(
             field_value[key], config_values) for key in field_value}
     if isinstance(field_value, list):
         return [substitute_in_config_variables(item, config_values) for item in field_value]
     if isinstance(field_value, str) and field_value in config_values:
         config_value = config_values[field_value]
         if isinstance(config_value, dict) and 'defaultValue' in config_value:
             # TODO currently we don't validate that if config_value['type'] is provided
             # that the type does in fact match our expectation.
             return config_value['defaultValue']
         return config_values[field_value]

     return field_value


 def convert_yaml_octet_string_to_bytes(s: str) -> bytes:
     '''Convert YAML octet string body to bytes.

     Included handling any c-style hex escapes (e.g. \x5a) and 'hex:' prefix.
     '''
     # Step 1: handle explicit "hex:" prefix
     if s.startswith('hex:'):
         return binascii.unhexlify(s[4:])

     # Step 2: convert non-hex-prefixed to bytes
     # TODO(#23669): This does not properly support utf8 octet strings. We mimic
     # javascript codegen behavior. Behavior of javascript is:
     #   * Octet string character >= u+0200 errors out.
     #   * Any character greater than 0xFF has the upper bytes chopped off.
     as_bytes = [ord(c) for c in s]

     if any([value > 0x200 for value in as_bytes]):
         raise ValueError('Unsupported char in octet string %r' % as_bytes)
     accumulated_hex = ''.join([f"{(v & 0xFF):02x}" for v in as_bytes])
     return binascii.unhexlify(accumulated_hex)


 def convert_name_value_pair_to_dict(arg_values):
     ''' Fix yaml command arguments.

     For some reason, instead of treating the entire data payload of a
     command as a singular struct, the top-level args are specified as 'name'
     and 'value' pairs, while the payload of each argument is itself
     correctly encapsulated. This fixes up this oddity to create a new
     key/value pair with the key being the value of the 'name' field, and
     the value being 'value' field.
     '''
     ret_value = {}

     for item in arg_values:
         ret_value[item['name']] = item['value']

     return ret_value


 def convert_yaml_type(field_value, field_type, inline_cast_dict_to_struct):
     ''' Converts yaml value to provided pythonic type.

     The YAML representation when converted to a dictionary does not line up to
     the python type data model for the various command/attribute/event object
     types. This function converts 'field_value' to the appropriate provided
     'field_type'.

     Args:
         'field_value': Value as extracted from yaml
         'field_type': Pythonic command/attribute/event object type that we
             are converting value to.
         'inline_cast_dict_to_struct': If true, for any dictionary 'field_value'
             types provided we will do a convertion to the corresponding data
             model class in `field_type` by doing field_type.FromDict(...).
     '''
     origin = typing.get_origin(field_type)

     if field_value is None:
         field_value = NullValue

     if (origin == typing.Union or origin == typing.Optional or origin == Nullable):
         underlying_field_type = None

         if field_value is NullValue:
             for t in typing.get_args(field_type):
                 if t == Nullable:
                     return field_value

         for t in typing.get_args(field_type):
             # Comparison below explicitly not using 'isinstance' as that doesn't do what we want.
             if t != Nullable and t != type(None):
                 underlying_field_type = t
                 break

         if (underlying_field_type is None):
             raise ValueError(f"Can't find the underling type for {field_type}")

         field_type = underlying_field_type

     # Dictionary represents a data model struct.
     if (type(field_value) is dict):
         return_field_value = {}
         field_descriptors = field_type.descriptor
         for item in field_value:
             try:
                 # We search for a matching item in the list of field descriptors
                 # for this struct and ensure we can find a field with a matching
                 # label.
                 field_descriptor = next(
                     x for x in field_descriptors.Fields if x.Label.lower() ==
                     item.lower())
             except StopIteration as exc:
                 raise ValidationError(
                     f'Did not find field "{item}" in {str(field_type)}') from None

             return_field_value[field_descriptor.Label] = convert_yaml_type(
                 field_value[item], field_descriptor.Type, inline_cast_dict_to_struct)
         if inline_cast_dict_to_struct:
             return field_type.FromDict(return_field_value)
         return return_field_value
     elif(type(field_value) is float):
         return float32(field_value)
     # list represents a data model list
     elif(type(field_value) is list):
         list_element_type = typing.get_args(field_type)[0]

         # The field type passed in is the type of the list element and not list[T].
         for idx, item in enumerate(field_value):
             field_value[idx] = convert_yaml_type(item, list_element_type,
                                                  inline_cast_dict_to_struct)
         return field_value
     # YAML conversion treats all numbers as ints. Convert to a uint type if the schema
     # type indicates so.
     elif (field_type == uint):
         # Longer number are stored as strings. Need to make this conversion first.
         value = int(field_value)
         return field_type(value)
     # YAML treats enums as ints. Convert to the typed enum class.
     elif (issubclass(field_type, enum.Enum)):
         return field_type(field_value)
     # YAML treats bytes as strings. Convert to a byte string.
     elif (field_type == bytes and type(field_value) != bytes):
         return convert_yaml_octet_string_to_bytes(field_value)
     # By default, just return the field_value casted to field_type.
     else:
         return field_type(field_value)


 def parse_and_convert_yaml_value(field_value, field_type, config_values: dict,
                                  inline_cast_dict_to_struct: bool = False):
     ''' Parse and converts YAML type

     Parsing the YAML value means performing required substitutions and evaluations. Parsing is
     then followed by converting from the YAML type done using yaml.safe_load() to the type used in
     the various command/attribute/event object data model types.

     Args:
         'field_value': Value as extracted from yaml to be parsed
         'field_type': Pythonic command/attribute/event object type that we
             are converting value to.
         'config_values': Dictionary of global configuration variables.
         'inline_cast_dict_to_struct': If true, for any dictionary 'field_value'
             types provided we will do an inline convertion to the corresponding
             struct in `field_type` by doing field_type.FromDict(...).
     '''
     field_value_with_config_variables = substitute_in_config_variables(field_value, config_values)
     return convert_yaml_type(field_value_with_config_variables, field_type,
                              inline_cast_dict_to_struct)
	#
	# Copyright (c) 2022 Project CHIP Authors
	# All rights reserved.
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	#

	import typing
	from chip.clusters.Types import Nullable, NullValue
	from chip.tlv import uint, float32
	import enum
	from chip.yaml.errors import ValidationError
	import binascii


	def substitute_in_config_variables(field_value, config_values: dict):
	''' Substitutes values that are config variables.

	YAML values can contain a string of a configuration variable name. In these instances we
	substitute the configuration variable name with the actual value.

	For examples see unittest src/controller/python/test/unit_tests/test_yaml_format_converter.py

	# TODO This should also substitue any saveAs values as well as perform any required
	# evaluations.

	Args:
	'field_value': Value as extracted from YAML.
	'config_values': Dictionary of global configuration variables.
	Returns:
	Value with all global configuration variables substituted with the real value.
	'''
	if isinstance(field_value, dict):
	return {key: substitute_in_config_variables(
	field_value[key], config_values) for key in field_value}
	if isinstance(field_value, list):
	return [substitute_in_config_variables(item, config_values) for item in field_value]
	if isinstance(field_value, str) and field_value in config_values:
	config_value = config_values[field_value]
	if isinstance(config_value, dict) and 'defaultValue' in config_value:
	# TODO currently we don't validate that if config_value['type'] is provided
	# that the type does in fact match our expectation.
	return config_value['defaultValue']
	return config_values[field_value]

	return field_value


	def convert_yaml_octet_string_to_bytes(s: str) -> bytes:
	'''Convert YAML octet string body to bytes.

	Included handling any c-style hex escapes (e.g. \x5a) and 'hex:' prefix.
	'''
	# Step 1: handle explicit "hex:" prefix
	if s.startswith('hex:'):
	return binascii.unhexlify(s[4:])

	# Step 2: convert non-hex-prefixed to bytes
	# TODO(#23669): This does not properly support utf8 octet strings. We mimic
	# javascript codegen behavior. Behavior of javascript is:
	# * Octet string character >= u+0200 errors out.
	# * Any character greater than 0xFF has the upper bytes chopped off.
	as_bytes = [ord(c) for c in s]

	if any([value > 0x200 for value in as_bytes]):
	raise ValueError('Unsupported char in octet string %r' % as_bytes)
	accumulated_hex = ''.join([f"{(v & 0xFF):02x}" for v in as_bytes])
	return binascii.unhexlify(accumulated_hex)


	def convert_name_value_pair_to_dict(arg_values):
	''' Fix yaml command arguments.

	For some reason, instead of treating the entire data payload of a
	command as a singular struct, the top-level args are specified as 'name'
	and 'value' pairs, while the payload of each argument is itself
	correctly encapsulated. This fixes up this oddity to create a new
	key/value pair with the key being the value of the 'name' field, and
	the value being 'value' field.
	'''
	ret_value = {}

	for item in arg_values:
	ret_value[item['name']] = item['value']

	return ret_value


	def convert_yaml_type(field_value, field_type, inline_cast_dict_to_struct):
	''' Converts yaml value to provided pythonic type.

	The YAML representation when converted to a dictionary does not line up to
	the python type data model for the various command/attribute/event object
	types. This function converts 'field_value' to the appropriate provided
	'field_type'.

	Args:
	'field_value': Value as extracted from yaml
	'field_type': Pythonic command/attribute/event object type that we
	are converting value to.
	'inline_cast_dict_to_struct': If true, for any dictionary 'field_value'
	types provided we will do a convertion to the corresponding data
	model class in `field_type` by doing field_type.FromDict(...).
	'''
	origin = typing.get_origin(field_type)

	if field_value is None:
	field_value = NullValue

	if (origin == typing.Union or origin == typing.Optional or origin == Nullable):
	underlying_field_type = None

	if field_value is NullValue:
	for t in typing.get_args(field_type):
	if t == Nullable:
	return field_value

	for t in typing.get_args(field_type):
	# Comparison below explicitly not using 'isinstance' as that doesn't do what we want.
	if t != Nullable and t != type(None):
	underlying_field_type = t
	break

	if (underlying_field_type is None):
	raise ValueError(f"Can't find the underling type for {field_type}")

	field_type = underlying_field_type

	# Dictionary represents a data model struct.
	if (type(field_value) is dict):
	return_field_value = {}
	field_descriptors = field_type.descriptor
	for item in field_value:
	try:
	# We search for a matching item in the list of field descriptors
	# for this struct and ensure we can find a field with a matching
	# label.
	field_descriptor = next(
	x for x in field_descriptors.Fields if x.Label.lower() ==
	item.lower())
	except StopIteration as exc:
	raise ValidationError(
	f'Did not find field "{item}" in {str(field_type)}') from None

	return_field_value[field_descriptor.Label] = convert_yaml_type(
	field_value[item], field_descriptor.Type, inline_cast_dict_to_struct)
	if inline_cast_dict_to_struct:
	return field_type.FromDict(return_field_value)
	return return_field_value
	elif(type(field_value) is float):
	return float32(field_value)
	# list represents a data model list
	elif(type(field_value) is list):
	list_element_type = typing.get_args(field_type)[0]

	# The field type passed in is the type of the list element and not list[T].
	for idx, item in enumerate(field_value):
	field_value[idx] = convert_yaml_type(item, list_element_type,
	inline_cast_dict_to_struct)
	return field_value
	# YAML conversion treats all numbers as ints. Convert to a uint type if the schema
	# type indicates so.
	elif (field_type == uint):
	# Longer number are stored as strings. Need to make this conversion first.
	value = int(field_value)
	return field_type(value)
	# YAML treats enums as ints. Convert to the typed enum class.
	elif (issubclass(field_type, enum.Enum)):
	return field_type(field_value)
	# YAML treats bytes as strings. Convert to a byte string.
	elif (field_type == bytes and type(field_value) != bytes):
	return convert_yaml_octet_string_to_bytes(field_value)
	# By default, just return the field_value casted to field_type.
	else:
	return field_type(field_value)


	def parse_and_convert_yaml_value(field_value, field_type, config_values: dict,
	inline_cast_dict_to_struct: bool = False):
	''' Parse and converts YAML type

	Parsing the YAML value means performing required substitutions and evaluations. Parsing is
	then followed by converting from the YAML type done using yaml.safe_load() to the type used in
	the various command/attribute/event object data model types.

	Args:
	'field_value': Value as extracted from yaml to be parsed
	'field_type': Pythonic command/attribute/event object type that we
	are converting value to.
	'config_values': Dictionary of global configuration variables.
	'inline_cast_dict_to_struct': If true, for any dictionary 'field_value'
	types provided we will do an inline convertion to the corresponding
	struct in `field_type` by doing field_type.FromDict(...).
	'''
	field_value_with_config_variables = substitute_in_config_variables(field_value, config_values)
	return convert_yaml_type(field_value_with_config_variables, field_type,
	inline_cast_dict_to_struct)