aas-core-codegen 0.0.16__py3-none-any.whl → 0.0.17__py3-none-any.whl

aas_core_codegen/intermediate/_types.py

@@ -15,6 +15,8 @@ from typing import (
     OrderedDict,
     Type,
     get_args,
+    Dict,
+    Any,
 )
 
 import docutils.nodes
@@ -53,12 +55,15 @@ STR_TO_PRIMITIVE_TYPE = {
 }  # type: Mapping[str, PrimitiveType]
 
 # fmt: off
-PRIMITIVE_TYPE_TO_PYTHON_TYPE: Mapping[
-    PrimitiveType,
-    Union[Type[bool], Type[int], Type[float], Type[str], Type[bytearray]]
+PRIMITIVE_TYPE_TO_PYTHON_TYPE: Final[
+    Mapping[
+        PrimitiveType,
+        Union[Type[bool], Type[int], Type[float], Type[str], Type[bytearray]
+        ]
+    ]
 ] = {
     PrimitiveType.BOOL: bool,
-    PrimitiveType.INT : int,
+    PrimitiveType.INT: int,
     PrimitiveType.FLOAT: float,
     PrimitiveType.STR: str,
     PrimitiveType.BYTEARRAY: bytearray,
@@ -834,7 +839,7 @@ class Method(SignatureLike):
                     arg in arg_set
                     for snapshot in contracts.snapshots
                     for arg in snapshot.args
-                    if arg.name != 'self'
+                    if arg != 'self'
                 )
         )[1],
         "All arguments of contracts defined in method arguments except ``self``"
@@ -1066,6 +1071,9 @@ class Enumeration:
     #: Collect IDs (with :py:func:`id`) of the literal objects in a set
     literal_id_set: Final[FrozenSet[int]]
 
+    #: Set of all the literal values
+    literal_value_set: Final[FrozenSet[str]]
+
     def __init__(
         self,
         name: Identifier,
@@ -1086,7 +1094,30 @@ class Enumeration:
             literal.value: literal for literal in self.literals
         }
 
-        self.literal_id_set = frozenset(id(literal) for literal in literals)
+        self.literal_id_set = self.__class__._compute_literal_id_set(literals)
+        self.literal_value_set = frozenset(literal.value for literal in literals)
+
+    @staticmethod
+    def _compute_literal_id_set(
+        literals: Sequence[EnumerationLiteral],
+    ) -> FrozenSet[int]:
+        return frozenset(id(literal) for literal in literals)
+
+    def __getstate__(self) -> Dict[str, Any]:
+        state = self.__dict__.copy()
+
+        state.pop("literal_id_set", None)
+
+        return state
+
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        self.__dict__.update(state)
+
+        # NOTE (mristin):
+        # We rebuild what we could not pickle.
+        setattr(
+            self, "literal_id_set", Enumeration._compute_literal_id_set(self.literals)
+        )
 
     def __repr__(self) -> str:
         """Represent the instance as a string for easier debugging."""
@@ -1132,6 +1163,8 @@ class ConstrainedPrimitive:
     # ``@property`` so that the translation code is forced to use
     # ``_set_descendants``.
 
+    _descendants: Sequence["ConstrainedPrimitive"]
+
     _descendant_id_set: FrozenSet[int]
 
     # endregion
@@ -1169,8 +1202,7 @@ class ConstrainedPrimitive:
         This method is expected to be called only during the translation phase.
         """
         self._ancestors = ancestors
-
-        self._ancestor_id_set = frozenset(id(ancestor) for ancestor in ancestors)
+        self._ancestor_id_set = self.__class__._compute_ancestor_id_set(ancestors)
 
     @require(lambda self, descendants: self not in descendants)
     def _set_descendants(self, descendants: Sequence["ConstrainedPrimitive"]) -> None:
@@ -1179,9 +1211,8 @@ class ConstrainedPrimitive:
 
         This method is expected to be called only during the translation phase.
         """
-        self._descendant_id_set = frozenset(
-            id(descendant) for descendant in descendants
-        )
+        self._descendants = descendants
+        self._descendant_id_set = self.__class__._compute_descendant_id_set(descendants)
 
     def _set_invariants(self, invariants: Sequence[Invariant]) -> None:
         """
@@ -1190,7 +1221,7 @@ class ConstrainedPrimitive:
         This method is expected to be called only during the translation phase.
         """
         self._invariants = invariants
-        self._invariant_id_set = frozenset(id(inv) for inv in invariants)
+        self._invariant_id_set = self.__class__._compute_invariant_id_set(invariants)
 
     # fmt: off
     @require(
@@ -1206,9 +1237,8 @@ class ConstrainedPrimitive:
         This method is expected to be called only during the translation phase.
         """
         self._inheritances = inheritances
-
-        self._inheritance_id_set = frozenset(
-            id(inheritance) for inheritance in self._inheritances
+        self._inheritance_id_set = self.__class__._compute_inheritance_id_set(
+            self._inheritances
         )
 
     # fmt: off
@@ -1273,6 +1303,28 @@ class ConstrainedPrimitive:
         self.description = description
         self.parsed = parsed
 
+    @staticmethod
+    def _compute_ancestor_id_set(
+        ancestors: Sequence["ConstrainedPrimitive"],
+    ) -> FrozenSet[int]:
+        return frozenset(id(ancestor) for ancestor in ancestors)
+
+    @staticmethod
+    def _compute_descendant_id_set(
+        descendants: Sequence["ConstrainedPrimitive"],
+    ) -> FrozenSet[int]:
+        return frozenset(id(descendant) for descendant in descendants)
+
+    @staticmethod
+    def _compute_invariant_id_set(invariants: Sequence[Invariant]) -> FrozenSet[int]:
+        return frozenset(id(inv) for inv in invariants)
+
+    @staticmethod
+    def _compute_inheritance_id_set(
+        inheritances: Sequence["ConstrainedPrimitive"],
+    ) -> FrozenSet[int]:
+        return frozenset(id(inheritance) for inheritance in inheritances)
+
     @property
     def inheritances(self) -> Sequence["ConstrainedPrimitive"]:
         """Return direct parents that this class inherits from."""
@@ -1288,8 +1340,8 @@ class ConstrainedPrimitive:
         """
         Return the ancestor constrained primitives.
 
-         These are the constrained primitives that this one directly or indirectly
-         inherits from.
+        These are the constrained primitives that this one directly or indirectly
+        inherits from.
         """
         return self._ancestors
 
@@ -1313,6 +1365,16 @@ class ConstrainedPrimitive:
 
         return id(constrained_primitive) in self._ancestor_id_set
 
+    @property
+    def descendants(self) -> Sequence["ConstrainedPrimitive"]:
+        """
+        Return the ancestor constrained primitives.
+
+        These are the constrained primitives that directly or indirectly inherit from
+        this one.
+        """
+        return self._descendants
+
     @property
     def descendant_id_set(self) -> FrozenSet[int]:
         """List the IDs (as in Python's ``id`` built-in) of the descendants."""
@@ -1328,6 +1390,40 @@ class ConstrainedPrimitive:
         """Collect IDs (with :py:func:`id`) of the invariant objects in a set."""
         return self._invariant_id_set
 
+    def __getstate__(self) -> Dict[str, Any]:
+        state = self.__dict__.copy()
+
+        state.pop("_inheritance_id_set", None)
+        state.pop("_ancestor_id_set", None)
+        state.pop("_descendant_id_set", None)
+        state.pop("_invariant_id_set", None)
+
+        return state
+
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        self.__dict__.update(state)
+
+        setattr(
+            self,
+            "_inheritance_id_set",
+            self.__class__._compute_inheritance_id_set(self._inheritances),
+        )
+        setattr(
+            self,
+            "_ancestor_id_set",
+            self.__class__._compute_ancestor_id_set(self._ancestors),
+        )
+        setattr(
+            self,
+            "_descendant_id_set",
+            self.__class__._compute_descendant_id_set(self._descendants),
+        )
+        setattr(
+            self,
+            "_invariant_id_set",
+            ConstrainedPrimitive._compute_invariant_id_set(self._invariants),
+        )
+
     def __repr__(self) -> str:
         """Represent the instance as a string for easier debugging."""
         return (
@@ -1457,9 +1553,8 @@ class Class(DBC):
         This method is expected to be called only during the translation phase.
         """
         self._inheritances = inheritances
-
-        self._inheritance_id_set = frozenset(
-            id(inheritance) for inheritance in self._inheritances
+        self._inheritance_id_set = self.__class__._compute_inheritance_id_set(
+            self._inheritances
         )
 
     @require(lambda self, ancestors: self not in ancestors)
@@ -1469,8 +1564,7 @@ class Class(DBC):
 
         This method is expected to be called only during the translation phase.
         """
-        self._ancestor_id_set = frozenset(id(ancestor) for ancestor in ancestors)
-
+        self._ancestor_id_set = self.__class__._compute_ancestor_id_set(ancestors)
         self._ancestors = ancestors
 
     @require(lambda self, descendants: self not in descendants)
@@ -1480,9 +1574,7 @@ class Class(DBC):
 
         This method is expected to be called only during the translation phase.
         """
-        self._descendant_id_set = frozenset(
-            id(descendant) for descendant in descendants
-        )
+        self._descendant_id_set = self.__class__._compute_descendant_id_set(descendants)
 
         self._descendants = descendants
 
@@ -1492,8 +1584,10 @@ class Class(DBC):
             if isinstance(descendant, ConcreteClass)
         ]
 
-        self._concrete_descendant_id_set = frozenset(
-            id(descendant) for descendant in self._concrete_descendants
+        self._concrete_descendant_id_set = (
+            self.__class__._compute_concrete_descendant_id_set(
+                self._concrete_descendants
+            )
         )
 
     # fmt: off
@@ -1511,7 +1605,7 @@ class Class(DBC):
         """
         self._properties = properties
         self._properties_by_name = {prop.name: prop for prop in properties}
-        self._property_id_set = frozenset(id(prop) for prop in properties)
+        self._property_id_set = self.__class__._compute_property_id_set(properties)
 
     # fmt: off
     @require(
@@ -1528,7 +1622,7 @@ class Class(DBC):
         """
         self._methods = methods
         self._methods_by_name = {method.name: method for method in methods}
-        self._method_id_set = frozenset(id(method) for method in methods)
+        self._method_id_set = self.__class__._compute_method_id_set(methods)
 
     def _set_invariants(self, invariants: Sequence[Invariant]) -> None:
         """
@@ -1537,7 +1631,7 @@ class Class(DBC):
         This method is expected to be called only during the translation phase.
         """
         self._invariants = invariants
-        self._invariant_id_set = frozenset(id(inv) for inv in invariants)
+        self._invariant_id_set = self.__class__._compute_invariant_id_set(invariants)
 
     # fmt: off
     @require(
@@ -1632,6 +1726,40 @@ class Class(DBC):
         self.description = description
         self.parsed = parsed
 
+    @staticmethod
+    def _compute_inheritance_id_set(
+        inheritances: Sequence["ClassUnion"],
+    ) -> FrozenSet[int]:
+        return frozenset(id(inheritance) for inheritance in inheritances)
+
+    @staticmethod
+    def _compute_ancestor_id_set(ancestors: Sequence["ClassUnion"]) -> FrozenSet[int]:
+        return frozenset(id(ancestor) for ancestor in ancestors)
+
+    @staticmethod
+    def _compute_descendant_id_set(
+        descendants: Sequence["ClassUnion"],
+    ) -> FrozenSet[int]:
+        return frozenset(id(descendant) for descendant in descendants)
+
+    @staticmethod
+    def _compute_concrete_descendant_id_set(
+        concrete_descendants: Sequence["ConcreteClass"],
+    ) -> FrozenSet[int]:
+        return frozenset(id(descendant) for descendant in concrete_descendants)
+
+    @staticmethod
+    def _compute_property_id_set(properties: Sequence[Property]) -> FrozenSet[int]:
+        return frozenset(id(prop) for prop in properties)
+
+    @staticmethod
+    def _compute_method_id_set(methods: Sequence["MethodUnion"]) -> FrozenSet[int]:
+        return frozenset(id(method) for method in methods)
+
+    @staticmethod
+    def _compute_invariant_id_set(invariants: Sequence[Invariant]) -> FrozenSet[int]:
+        return frozenset(id(inv) for inv in invariants)
+
     @property
     def inheritances(self) -> Sequence["ClassUnion"]:
         """Return direct parents that this class inherits from."""
@@ -1732,6 +1860,48 @@ class Class(DBC):
         """Collect IDs (with :py:func:`id`) of the invariant objects in a set."""
         return self._invariant_id_set
 
+    def __getstate__(self) -> Dict[str, Any]:
+        state = self.__dict__.copy()
+
+        state.pop("_inheritance_id_set", None)
+        state.pop("_ancestor_id_set", None)
+        state.pop("_descendant_id_set", None)
+        state.pop("_concrete_descendant_id_set", None)
+        state.pop("_property_id_set", None)
+        state.pop("_method_id_set", None)
+        state.pop("_invariant_id_set", None)
+
+        return state
+
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        self.__dict__.update(state)
+
+        setattr(
+            self,
+            "_inheritance_id_set",
+            Class._compute_inheritance_id_set(self._inheritances),
+        )
+        setattr(
+            self, "_ancestor_id_set", Class._compute_ancestor_id_set(self._ancestors)
+        )
+        setattr(
+            self,
+            "_descendant_id_set",
+            Class._compute_descendant_id_set(self._descendants),
+        )
+        setattr(
+            self,
+            "_concrete_descendant_id_set",
+            Class._compute_concrete_descendant_id_set(self._concrete_descendants),
+        )
+        setattr(
+            self, "_property_id_set", Class._compute_property_id_set(self._properties)
+        )
+        setattr(self, "_method_id_set", Class._compute_method_id_set(self._methods))
+        setattr(
+            self, "_invariant_id_set", Class._compute_invariant_id_set(self._invariants)
+        )
+
     @abc.abstractmethod
     def __repr__(self) -> str:
         # Signal that this is a purely abstract class.
@@ -1926,7 +2096,7 @@ class ConstantSetOfPrimitives(Constant):
     parsed: Final[parse.ConstantSet]
 
     #: Set of all the literal values
-    literal_value_set: Final[Set[Union[bool, int, float, str, bytearray]]]
+    literal_value_set: Final[FrozenSet[Union[bool, int, float, str, bytearray]]]
 
     # fmt: off
     # noinspection PyTypeHints
@@ -1972,7 +2142,7 @@ class ConstantSetOfPrimitives(Constant):
         self.subsets = subsets
         self.parsed = parsed
 
-        self.literal_value_set = {literal.value for literal in literals}
+        self.literal_value_set = frozenset(literal.value for literal in literals)
 
     def __repr__(self) -> str:
         """Represent the instance as a string for easier debugging."""
@@ -1997,7 +2167,10 @@ class ConstantSetOfEnumerationLiterals(Constant):
     parsed: Final[parse.ConstantSet]
 
     #: Set of all the IDs (as in Python objects) of the literals
-    literal_id_set: Final[Set[int]]
+    literal_id_set: Final[FrozenSet[int]]
+
+    #: Set of all the literal values
+    literal_value_set: Final[FrozenSet[str]]
 
     # fmt: off
     @require(
@@ -2038,7 +2211,31 @@ class ConstantSetOfEnumerationLiterals(Constant):
         self.subsets = subsets
         self.parsed = parsed
 
-        self.literal_id_set = {id(literal) for literal in self.literals}
+        self.literal_id_set = self.__class__._compute_literal_id_set(self.literals)
+        self.literal_value_set = frozenset(literal.value for literal in self.literals)
+
+    @staticmethod
+    def _compute_literal_id_set(
+        literals: Sequence[EnumerationLiteral],
+    ) -> FrozenSet[int]:
+        return frozenset(id(literal) for literal in literals)
+
+    def __getstate__(self) -> Dict[str, Any]:
+        state = self.__dict__.copy()
+
+        state.pop("literal_id_set", None)
+
+        return state
+
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        self.__dict__.update(state)
+
+        # We rebuild what we did not pickle.
+        setattr(
+            self,
+            "literal_id_set",
+            self.__class__._compute_literal_id_set(self.literals),
+        )
 
     def __repr__(self) -> str:
         """Represent the instance as a string for easier debugging."""
@@ -2383,7 +2580,25 @@ class Interface:
             prop.name: prop for prop in self.properties
         }
 
-        self.property_id_set = frozenset(id(prop) for prop in self.properties)
+        self.property_id_set = self.__class__._compute_property_id_set(self.properties)
+
+    @staticmethod
+    def _compute_property_id_set(properties: Sequence[Property]) -> FrozenSet[int]:
+        return frozenset(id(prop) for prop in properties)
+
+    def __getstate__(self) -> Dict[str, Any]:
+        state = self.__dict__.copy()
+
+        state.pop("property_id_set", None)
+
+        return state
+
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        self.__dict__.update(state)
+
+        setattr(
+            self, "property_id_set", Interface._compute_property_id_set(self.properties)
+        )
 
     def __repr__(self) -> str:
         """Represent the instance as a string for easier debugging."""
@@ -2741,6 +2956,130 @@ class SymbolTable:
 
         return result
 
+    def must_find_constant(self, name: Identifier) -> "ConstantUnion":
+        """
+        Find the constant with the given ``name``.
+
+        :raise: :py:class:`KeyError` if the ``name`` is not in our constants.
+        """
+        result = self.constants_by_name.get(name, None)
+        if result is None:
+            raise KeyError(name)
+
+        return result
+
+    def must_find_constant_primitive(self, name: Identifier) -> ConstantPrimitive:
+        """
+        Find the primitive constant with the given ``name``.
+
+        :raise: :py:class:`KeyError` if the ``name`` is not in the constants.
+        :raise:
+            :py:class:`TypeError` if the ``name`` is in the constants, but it is not
+            a constant primitive.
+        """
+        result = self.constants_by_name.get(name, None)
+        if result is None:
+            raise KeyError(name)
+
+        if not isinstance(result, ConstantPrimitive):
+            raise TypeError(
+                f"Found {name} in the constants; "
+                f"expected an instance of {ConstantPrimitive.__name__},"
+                f"but got {type(result)}: {result}"
+            )
+
+        return result
+
+    def must_find_constant_set_of_primitives(
+        self, name: Identifier
+    ) -> ConstantSetOfPrimitives:
+        """
+        Find the constant set of primitives with the given ``name``.
+
+        :raise: :py:class:`KeyError` if the ``name`` is not in the constants.
+        :raise:
+            :py:class:`TypeError` if the ``name`` is in the constants, but it is not
+            a constant set of primitives.
+        """
+        result = self.constants_by_name.get(name, None)
+        if result is None:
+            raise KeyError(name)
+
+        if not isinstance(result, ConstantSetOfPrimitives):
+            raise TypeError(
+                f"Found {name} in the constants; "
+                f"expected an instance of {ConstantSetOfPrimitives.__name__},"
+                f"but got {type(result)}: {result}"
+            )
+
+        return result
+
+    def must_find_constant_set_of_enumeration_literals(
+        self, name: Identifier
+    ) -> ConstantSetOfEnumerationLiterals:
+        """
+        Find the constant set of enumeration literals with the given ``name``.
+
+        :raise: :py:class:`KeyError` if the ``name`` is not in the constants.
+        :raise:
+            :py:class:`TypeError` if the ``name`` is in the constants, but it is not
+            a constant set of enumeration literals.
+        """
+        result = self.constants_by_name.get(name, None)
+        if result is None:
+            raise KeyError(name)
+
+        if not isinstance(result, ConstantSetOfEnumerationLiterals):
+            raise TypeError(
+                f"Found {name} in the constants; "
+                f"expected an instance of {ConstantSetOfEnumerationLiterals.__name__},"
+                f"but got {type(result)}: {result}"
+            )
+
+        return result
+
+    def is_enumeration_literal_of(
+        self, literal: EnumerationLiteral, enumeration_or_constant_set_name: Identifier
+    ) -> bool:
+        """
+        Check that the given ``literal`` is a member of the enumeration or constant set.
+
+        We assume that the enumeration or the constant set of enumeration literals
+        exists in the symbol table.
+
+        :raises:
+            :py:class:`KeyError` if the ``enumeration_or_constant_set_name`` is neither
+            in our types nor in constants
+
+        :raises:
+             :py:class:`TypeError` if the ``enumeration_or_constant_set_name`` is
+             neither an enumeration nor a constant set of enumeration literals, but
+             exists in our types or in the constants.
+        """
+        our_type = self._name_to_our_type.get(enumeration_or_constant_set_name, None)
+        if our_type is not None:
+            if not isinstance(our_type, Enumeration):
+                raise TypeError(
+                    f"Expected an enumeration "
+                    f"under the name {enumeration_or_constant_set_name!r}, "
+                    f"but got {type(our_type)}: {our_type}"
+                )
+
+            return id(literal) in our_type.literal_id_set
+
+        constant = self.constants_by_name.get(enumeration_or_constant_set_name, None)
+        if constant is not None:
+            if not isinstance(constant, ConstantSetOfEnumerationLiterals):
+                raise TypeError(
+                    f"Expected a constant set of enumeration literals "
+                    f"under the name {enumeration_or_constant_set_name!r}, "
+                    f"but got {type(constant)}: {constant}"
+                )
+
+            return id(literal) in constant.literal_id_set
+
+        raise KeyError(enumeration_or_constant_set_name)
+
 
 def try_primitive_type(type_annotation: TypeAnnotationUnion) -> Optional[PrimitiveType]:
     """
@@ -2817,15 +3156,6 @@ def map_descendability(
     return mapping
 
 
-class _ConstructorArgumentOfClass:
-    """Represent a constructor argument with its corresponding class."""
-
-    def __init__(self, arg: Argument, cls: Class) -> None:
-        """Initialize with the given values."""
-        self.arg = arg
-        self.cls = cls
-
-
 def collect_ids_of_our_types_in_properties(symbol_table: SymbolTable) -> Set[int]:
     """
     Collect the IDs of our types occurring in type annotations of the properties.

aas_core_codegen/python/xmlization/_generate.py

@@ -2117,7 +2117,9 @@ def _write_float_property(
 {II}else:
 {III}self.stream.write('0.0')
 {I}else:
-{II}self.stream.write(str(value))"""
+{II}self.stream.write(str(value))
+
+{I}self._write_end_element(name)"""
         ),
         Stripped(
             f"""\

{aas_core_codegen-0.0.16.dist-info → aas_core_codegen-0.0.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-core-codegen
-Version: 0.0.16
+Version: 0.0.17
 Summary: Generate implementations and schemas based on an AAS meta-model.
 Author-email: Marko Ristin <marko@ristin.ch>, Nico Braunisch <nico.braunisch@tu-dresden.de>
 License: MIT
@@ -17,7 +17,7 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE
 License-File: AUTHORS
 Requires-Dist: asttokens<3,>=2.0.8
-Requires-Dist: icontract<3,>=2.5.2
+Requires-Dist: icontract<3,>=2.7.3
 Requires-Dist: sortedcontainers<3,>=2.4.0
 Requires-Dist: docutils==0.22.3
 Requires-Dist: more-itertools<9,>=8