| # Copyright (c) 2023 Project CHIP Authors |
| # |
| # 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 logging |
| import re |
| from dataclasses import dataclass |
| from typing import Optional |
| from xml.sax.xmlreader import AttributesImpl |
| |
| from matter_idl.generators.type_definitions import GetDataTypeSizeInBits, IsSignedDataType |
| from matter_idl.matter_idl_types import AccessPrivilege, Attribute, Command, ConstantEntry, DataType, Event, EventPriority, Field |
| |
| LOGGER = logging.getLogger('data-model-xml-data-parsing') |
| |
| |
| @dataclass |
| class ParsedType: |
| name: str |
| is_list: bool = False |
| |
| |
| def ParseInt(value: str, data_type: Optional[DataType] = None) -> int: |
| """ |
| Convert a string that is a known integer into an actual number. |
| |
| Supports decimal or hex values prefixed with '0x' |
| """ |
| if value.startswith('0x'): |
| parsed = int(value[2:], 16) |
| if data_type and IsSignedDataType(data_type): |
| bits = GetDataTypeSizeInBits(data_type) |
| assert (bits) # size MUST be known |
| if parsed & (1 << (bits - 1)): |
| parsed -= 1 << bits |
| return parsed |
| else: |
| return int(value) |
| |
| |
| def ParseOptionalInt(value: str) -> Optional[int]: |
| """Parses numbers as long as they are in an expected format of numbers. |
| |
| "1" parses to 1 |
| "0x12" parses to 18 |
| "Min" parses to None |
| """ |
| if re.match("^-?((0x[0-9a-fA-F]*)|([0-9]*))$", value): |
| return ParseInt(value) |
| |
| return None |
| |
| |
| _TYPE_REMAP = { |
| # unsigned |
| "uint8": "int8u", |
| "uint16": "int16u", |
| "uint24": "int24u", |
| "uint32": "int32u", |
| "uint48": "int48u", |
| "uint52": "int52u", |
| "uint64": "int64u", |
| # signed (map to what zapxml/matter currently has) |
| "int8": "int8s", |
| "int16": "int16s", |
| "int24": "int24s", |
| "int32": "int32s", |
| "int48": "int48s", |
| "int52": "int52s", |
| "int64": "int64s", |
| # other |
| "bool": "boolean", |
| "string": "char_string", |
| "octets": "octet_string", |
| } |
| |
| |
| def NormalizeDataType(t: str) -> str: |
| """Convert data model xml types into matter idl types.""" |
| return _TYPE_REMAP.get(t.lower(), t.replace("-", "_")) |
| |
| |
| # Handle oddities in current data model XML schema for nicer diffs |
| _REF_NAME_MAPPING = { |
| "<<ref_DataTypeEndpointNumber>>": "endpoint_no", |
| "<<ref_DataTypeEpochUs>>": "epoch_us", |
| "<<ref_DataTypeNodeId>>": "node_id", |
| "<<ref_DataTypeOctstr>>": "octet_string", |
| "<<ref_DataTypeString>>": "char_string", |
| "<<ref_DataTypeVendorId>>": "vendor_id", |
| "<<ref_FabricIdx>>": "fabric_idx", |
| } |
| |
| |
| # Handle odd casing and naming |
| _CASE_RENAMES_MAPPING = { |
| "power_mW": "power_mw", |
| "energy_mWh": "energy_mwh" |
| } |
| |
| |
| def ParseType(t: str) -> ParsedType: |
| """Parse a data type entry. |
| |
| Specifically parses a name like "list[Foo Type]". |
| """ |
| |
| # very rough matcher ... |
| is_list = False |
| if t.startswith("list[") and t.endswith("]"): |
| is_list = True |
| t = t[5:-1] |
| elif t.startswith("<<ref_DataTypeList>>[") and t.endswith("]"): |
| is_list = True |
| t = t[21:-1] |
| |
| if t.endswith(" Type"): |
| t = t[:-5] |
| |
| if t in _REF_NAME_MAPPING: |
| t = _REF_NAME_MAPPING[t] |
| |
| if t in _CASE_RENAMES_MAPPING: |
| t = _CASE_RENAMES_MAPPING[t] |
| |
| return ParsedType(name=NormalizeDataType(t), is_list=is_list) |
| |
| |
| def NormalizeName(name: str) -> str: |
| """Convert a free form name from the spec into a programming language |
| name that is appropriate for matter IDL. |
| """ |
| |
| # Trim human name separators |
| for separator in " /-": |
| name = name.replace(separator, '_') |
| while '__' in name: |
| name = name.replace('__', '_') |
| |
| # NOTE: zapt generators for IDL files use a construct of the form |
| # `{{asUpperCamelCase name preserveAcronyms=true}}` |
| # and it is somewhat unclear what preserveAcronyms will do. |
| # |
| # Current assumption is that spec already has acronyms set in |
| # the correct place and at least for some basic tests this method |
| # generates good names |
| # |
| # If any acronyms seem off in naming at some point, more logic may |
| # be needed here. |
| |
| # At this point, we remove all _ and make sure _ is followed by an uppercase |
| while name.endswith('_'): |
| name = name[:-1] |
| |
| while '_' in name: |
| idx = name.find('_') |
| name = name[:idx] + name[idx+1].upper() + name[idx+2:] |
| |
| return name |
| |
| |
| def FieldName(input_name: str) -> str: |
| """Normalized name with the first letter lowercase. """ |
| name = NormalizeName(input_name) |
| |
| # Some exception handling for nicer diffs |
| if name == "ID": |
| return "id" |
| |
| # If the name starts with a all-uppercase thing, keep it that |
| # way. This is typical for "NOC", "IPK", "CSR" and such |
| if len(input_name) > 1: |
| if input_name[0].isupper() and input_name[1].isupper(): |
| return name |
| |
| return name[0].lower() + name[1:] |
| |
| |
| def AttributesToField(attrs: AttributesImpl) -> Field: |
| assert "name" in attrs |
| assert "id" in attrs |
| |
| if "type" in attrs: |
| attr_type = NormalizeDataType(attrs["type"]) |
| else: |
| # TODO: Generally we should not have this, however current implementation |
| # for derived clusters for example want to add things (like conformance |
| # specifically) WITHOUT re-stating things like types |
| # |
| # https://github.com/csa-data-model/projects/issues/365 |
| LOGGER.error(f"Attribute {attrs['name']} has no type") |
| attr_type = "sint32" |
| t = ParseType(attr_type) |
| |
| return Field( |
| name=FieldName(attrs["name"]), |
| code=ParseInt(attrs["id"]), |
| is_list=t.is_list, |
| data_type=DataType(name=t.name), |
| ) |
| |
| |
| def AttributesToBitFieldConstantEntry(attrs: AttributesImpl) -> ConstantEntry: |
| """Creates a constant entry appropriate for bitmaps. |
| """ |
| assert "name" in attrs |
| |
| if 'bit' not in attrs: |
| # TODO: multi-bit fields not supported in XML currently. Be lenient here to have some |
| # diff |
| # Issue: https://github.com/csa-data-model/projects/issues/347 |
| |
| LOGGER.error( |
| f"Constant {attrs['name']} has no bit value (may be multibit)") |
| return ConstantEntry(name="k" + NormalizeName(attrs["name"]), code=0) |
| |
| assert "bit" in attrs |
| |
| return ConstantEntry(name="k" + NormalizeName(attrs["name"]), code=1 << ParseInt(attrs["bit"])) |
| |
| |
| def AttributesToAttribute(attrs: AttributesImpl) -> Attribute: |
| assert "name" in attrs |
| assert "id" in attrs |
| |
| if "type" in attrs: |
| attr_type = NormalizeDataType(attrs["type"]) |
| else: |
| # TODO: we should NOT have this, however we are now lenient |
| # to bad input data |
| LOGGER.error(f"Attribute {attrs['name']} has no type") |
| attr_type = "sint32" |
| |
| t = ParseType(attr_type) |
| |
| return Attribute( |
| definition=Field( |
| code=ParseInt(attrs["id"]), |
| name=FieldName(attrs["name"]), |
| is_list=t.is_list, |
| data_type=DataType(name=t.name), |
| ) |
| ) |
| |
| |
| def AttributesToEvent(attrs: AttributesImpl) -> Event: |
| assert "name" in attrs |
| assert "id" in attrs |
| assert "priority" in attrs |
| |
| if attrs["priority"] == "critical": |
| priority = EventPriority.CRITICAL |
| elif attrs["priority"] == "info": |
| priority = EventPriority.INFO |
| elif attrs["priority"] == "debug": |
| priority = EventPriority.DEBUG |
| elif attrs["priority"] == "desc": |
| LOGGER.warn("Found an event with 'desc' priority: %s" % |
| [item for item in attrs.items()]) |
| priority = EventPriority.CRITICAL |
| else: |
| raise Exception("UNKNOWN event priority: %r" % attrs["priority"]) |
| |
| return Event( |
| name=NormalizeName(attrs["name"]), |
| code=ParseInt(attrs["id"]), |
| priority=priority, |
| fields=[]) |
| |
| |
| def StringToAccessPrivilege(value: str) -> AccessPrivilege: |
| if value == "view": |
| return AccessPrivilege.VIEW |
| elif value == "operate": |
| return AccessPrivilege.OPERATE |
| elif value == "manage": |
| return AccessPrivilege.MANAGE |
| elif value == "admin": |
| return AccessPrivilege.ADMINISTER |
| else: |
| raise Exception("UNKNOWN privilege level: %r" % value) |
| |
| |
| def AttributesToCommand(attrs: AttributesImpl) -> Command: |
| assert "id" in attrs |
| assert "name" in attrs |
| |
| if "response" not in attrs: |
| LOGGER.warn(f"Command {attrs['name']} has no response set.") |
| # Matter IDL has no concept of "no response sent" |
| # Example is DoorLock::"Operating Event Notification" |
| # |
| # However that is not in the impl in general |
| # it is unclear what to do here (and what "NOT" is as conformance) |
| |
| output_param = "DefaultSuccess" |
| else: |
| output_param = NormalizeName(attrs["response"]) |
| if output_param == "Y": |
| output_param = "DefaultSuccess" # IDL name for no specific struct |
| |
| return Command( |
| name=NormalizeName(attrs["name"]), |
| code=ParseInt(attrs["id"]), |
| input_param=None, # not specified YET |
| output_param=output_param |
| ) |
| |
| |
| def ApplyConstraint(attrs, field: Field): |
| """ |
| Handles constraints according to Matter IDL formats. |
| |
| Specifically it does NOT handle min/max values as current IDL |
| format does not support having such values defined. |
| """ |
| assert "type" in attrs |
| |
| constraint_type = attrs["type"] |
| |
| if constraint_type == "allowed": |
| pass # unsure what to do allowed |
| elif constraint_type == "desc": |
| pass # free-form description |
| elif constraint_type in {"countBetween", "maxCount"}: |
| pass # cannot implement count |
| elif constraint_type == "min": |
| # field.data_type.min_value = ParseOptionalInt(attrs["value"]) |
| pass |
| elif constraint_type == "max": |
| # field.data_type.max_value = ParseOptionalInt(attrs["value"]) |
| pass |
| elif constraint_type == "between": |
| # TODO: examples existing in the parsed data which are NOT |
| # handled: |
| # - from="-2.5°C" to="2.5°C" |
| # - from="0%" to="100%" |
| # field.data_type.min_value = ParseOptionalInt(attrs["from"]) |
| # field.data_type.max_value = ParseOptionalInt(attrs["to"]) |
| pass |
| elif constraint_type == "maxLength": |
| field.data_type.max_length = ParseOptionalInt(attrs["value"]) |
| elif constraint_type == "minLength": |
| field.data_type.min_length = ParseOptionalInt(attrs["value"]) |
| elif constraint_type == "lengthBetween": |
| field.data_type.min_length = ParseOptionalInt(attrs["from"]) |
| field.data_type.max_length = ParseOptionalInt(attrs["to"]) |
| else: |
| logging.error(f"UNKNOWN constraint type {constraint_type}") |
