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

aas_core_codegen/infer_for_schema/_stringify.py

@@ -0,0 +1,201 @@
+"""Represent inferred constraints as strings."""
+import collections
+from typing import Union, Optional
+
+from aas_core_codegen import stringify, intermediate
+from aas_core_codegen.infer_for_schema._types import (
+    LenConstraint,
+    PatternConstraint,
+    ConstraintsByProperty,
+    SetOfPrimitivesConstraint,
+    SetOfEnumerationLiteralsConstraint,
+)
+
+
+def _stringify_len_constraint(
+    that: LenConstraint,
+) -> stringify.Entity:
+    result = stringify.Entity(
+        name=that.__class__.__name__,
+        properties=[
+            stringify.Property("min_value", that.min_value),
+            stringify.Property("max_value", that.max_value),
+        ],
+    )
+
+    return result
+
+
+def _stringify_pattern_constraint(
+    that: PatternConstraint,
+) -> stringify.Entity:
+    result = stringify.Entity(
+        name=that.__class__.__name__,
+        properties=[
+            stringify.Property("pattern", that.pattern),
+        ],
+    )
+
+    return result
+
+
+def _stringify_set_of_primitives_constraint(
+    that: SetOfPrimitivesConstraint,
+) -> stringify.Entity:
+    result = stringify.Entity(
+        name=that.__class__.__name__,
+        properties=[
+            stringify.Property("a_type", that.a_type.name),
+            stringify.Property(
+                "literals", list(map(intermediate.stringify, that.literals))
+            ),
+        ],
+    )
+
+    return result
+
+
+def _stringify_set_of_enumeration_literals_constraint(
+    that: SetOfEnumerationLiteralsConstraint,
+) -> stringify.Entity:
+    result = stringify.Entity(
+        name=that.__class__.__name__,
+        properties=[
+            stringify.Property(
+                "enumeration",
+                f"Reference to {that.enumeration.__class__.__name__} "
+                f"{that.enumeration.name}",
+            ),
+            stringify.Property(
+                "literals",
+                [
+                    f"Reference to {literal.__class__.__name__} {literal.name}"
+                    for literal in that.literals
+                ],
+            ),
+        ],
+    )
+
+    return result
+
+
+def _stringify_constraints_by_property(that: ConstraintsByProperty) -> stringify.Entity:
+    result = stringify.Entity(
+        name=that.__class__.__name__,
+        properties=[
+            stringify.Property(
+                "len_constraints_by_property",
+                # fmt: off
+                collections.OrderedDict(
+                    [
+                        # NOTE (mristin, 2022-05-18):
+                        # Mypy could not infer that an identifier is also a string.
+                        # Hence, we need to explicitly convert to a str here.
+                        (str(prop.name), _stringify_len_constraint(len_constraint))
+                        for prop, len_constraint in
+                        that.len_constraints_by_property.items()
+                    ]
+                ),
+                # fmt: on
+            ),
+            stringify.Property(
+                "patterns_by_property",
+                # fmt: off
+                collections.OrderedDict(
+                    [
+                        (
+                            # NOTE (mristin, 2022-05-18):
+                            # Mypy could not infer that an identifier is also a string.
+                            # Hence, we need to explicitly convert to a str here.
+                            str(prop.name),
+                            [_stringify(pattern) for pattern in patterns],
+                        )
+                        for prop, patterns in that.patterns_by_property.items()
+                    ]
+                ),
+                # fmt: on
+            ),
+            stringify.Property(
+                "set_of_primitives_by_property",
+                # fmt: off
+                collections.OrderedDict(
+                    [
+                        # NOTE (mristin, 2022-07-08):
+                        # Mypy could not infer that an identifier is also a string.
+                        # Hence, we need to explicitly convert to a str here.
+                        (str(prop.name), _stringify(set_of_primitives))
+                        for prop, set_of_primitives in
+                        that.set_of_primitives_by_property.items()
+                    ]
+                ),
+                # fmt: on
+            ),
+            stringify.Property(
+                "set_of_enumeration_literals_by_property",
+                # fmt: off
+                collections.OrderedDict(
+                    [
+                        # NOTE (mristin, 2022-07-08):
+                        # Mypy could not infer that an identifier is also a string.
+                        # Hence, we need to explicitly convert to a str here.
+                        (str(prop.name), _stringify(set_of_enum_literals))
+                        for prop, set_of_enum_literals in
+                        that.set_of_enumeration_literals_by_property.items()
+                    ]
+                ),
+                # fmt: on
+            ),
+        ],
+    )
+
+    return result
+
+
+Dumpable = Union[
+    LenConstraint,
+    PatternConstraint,
+    SetOfPrimitivesConstraint,
+    SetOfEnumerationLiteralsConstraint,
+    ConstraintsByProperty,
+]
+
+_DISPATCH = {
+    LenConstraint: _stringify_len_constraint,
+    PatternConstraint: _stringify_pattern_constraint,
+    SetOfPrimitivesConstraint: _stringify_set_of_primitives_constraint,
+    # fmt: off
+    SetOfEnumerationLiteralsConstraint: (
+        _stringify_set_of_enumeration_literals_constraint
+    ),
+    # fmt: on
+    ConstraintsByProperty: _stringify_constraints_by_property,
+}
+
+stringify.assert_dispatch_exhaustive(dispatch=_DISPATCH, dumpable=Dumpable)
+
+
+def _stringify(that: Optional[Dumpable]) -> Optional[stringify.Entity]:
+    """Dispatch to the correct ``_stringify_*`` method."""
+    if that is None:
+        return None
+
+    stringify_func = _DISPATCH.get(that.__class__, None)
+    if stringify_func is None:
+        raise AssertionError(
+            f"No stringify function could be found for the class {that.__class__}"
+        )
+
+    stringified = stringify_func(that)  # type: ignore
+    assert isinstance(stringified, stringify.Entity)
+    stringify.assert_compares_against_dict(stringified, that)
+
+    return stringified
+
+
+def dump(that: Optional[Dumpable]) -> str:
+    """Produce a string representation of the ``dumpable`` for testing or debugging."""
+    if that is None:
+        return repr(None)
+
+    stringified = _stringify(that)
+    return stringify.dump(stringified)

aas_core_codegen/infer_for_schema/_types.py

@@ -0,0 +1,135 @@
+"""Provide data structures for the constraint inferences."""
+from typing import Mapping, Sequence, Optional
+
+from icontract import require
+
+from aas_core_codegen import intermediate
+
+
+class LenConstraint:
+    """
+    Represent the inferred constraint on the ``len`` of something.
+
+    Both bounds are inclusive: ``min_value ≤ len ≤ max_value``.
+    """
+
+    # fmt: off
+    @require(
+        lambda min_value, max_value:
+        not (min_value is not None and max_value is not None)
+        or 0 < min_value <= max_value
+    )
+    # fmt: on
+    def __init__(self, min_value: Optional[int], max_value: Optional[int]) -> None:
+        """Initialize with the given values."""
+        self.min_value = min_value
+        self.max_value = max_value
+
+    def copy(self) -> "LenConstraint":
+        """Create a copy of the self."""
+        return LenConstraint(min_value=self.min_value, max_value=self.max_value)
+
+    def __str__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"min_value={self.min_value!r}, max_value={self.max_value!r})"
+        )
+
+
+class PatternConstraint:
+    """Constrain a string to comply to a regular expression."""
+
+    def __init__(self, pattern: str) -> None:
+        """Initialize with the given values."""
+        self.pattern = pattern
+
+    def __repr__(self) -> str:
+        """Represent the constraint with the pattern."""
+        return (
+            f"<{self.__class__.__name__} at 0x{id(self):x} "
+            f"with pattern={self.pattern!r}>"
+        )
+
+
+class SetOfPrimitivesConstraint:
+    """Constrain a primitive value to be a member of a pre-defined set of values."""
+
+    # fmt: off
+    @require(
+        lambda a_type, literals:
+        all(
+            literal.a_type is a_type
+            for literal in literals
+        )
+    )
+    # fmt: on
+    def __init__(
+        self,
+        a_type: intermediate.PrimitiveType,
+        literals: Sequence[intermediate.PrimitiveSetLiteral],
+    ) -> None:
+        """Initialize with the given values."""
+        self.a_type = a_type
+        self.literals = literals
+
+    def __repr__(self) -> str:
+        """Represent the constraint with the pattern."""
+        return f"<{self.__class__.__name__} at 0x{id(self):x}>"
+
+
+class SetOfEnumerationLiteralsConstraint:
+    """Constrain a value to be a member of a pre-defined set of values."""
+
+    # fmt: off
+    @require(
+        lambda enumeration, literals:
+        all(
+            id(literal) in enumeration.literal_id_set
+            for literal in literals
+        )
+    )
+    # fmt: on
+    def __init__(
+        self,
+        enumeration: intermediate.Enumeration,
+        literals: Sequence[intermediate.EnumerationLiteral],
+    ) -> None:
+        """Initialize with the given values."""
+        self.enumeration = enumeration
+        self.literals = literals
+
+    def __repr__(self) -> str:
+        """Represent the constraint with the pattern."""
+        return f"<{self.__class__.__name__} at 0x{id(self):x}>"
+
+
+class ConstraintsByProperty:
+    """
+    Represent all the inferred property constraints of one of our types.
+
+    The constraints coming from the constrained primitives are in-lined and hence also
+    included in this representation.
+    """
+
+    def __init__(
+        self,
+        len_constraints_by_property: Mapping[intermediate.Property, LenConstraint],
+        patterns_by_property: Mapping[
+            intermediate.Property, Sequence[PatternConstraint]
+        ],
+        set_of_primitives_by_property: Mapping[
+            intermediate.Property, SetOfPrimitivesConstraint
+        ],
+        set_of_enumeration_literals_by_property: Mapping[
+            intermediate.Property, SetOfEnumerationLiteralsConstraint
+        ],
+    ) -> None:
+        """Initialize with the given values."""
+        self.len_constraints_by_property = len_constraints_by_property
+        self.patterns_by_property = patterns_by_property
+        self.set_of_primitives_by_property = set_of_primitives_by_property
+        # fmt: off
+        self.set_of_enumeration_literals_by_property = (
+            set_of_enumeration_literals_by_property
+        )
+        # fmt: on

aas_core_codegen/infer_for_schema/match.py

@@ -0,0 +1,122 @@
+"""
+Provide matching functions for different algorithms for inference of the constraints.
+
+The constraints are inferred based on the invariants, so the properties in this context
+refer to member access in form of ``self.some_property``.
+
+.. note::
+
+    This module is not only used by aas-core-codegen, but also by downstream clients
+    or continuous integrations of other packages, *e.g.*, aas-core-meta.
+"""
+from typing import Optional, Union
+
+from aas_core_codegen.common import Identifier
+
+from aas_core_codegen.parse import tree as parse_tree
+
+
+def try_property(node: parse_tree.Node) -> Optional[Identifier]:
+    """
+    Match access to a property.
+
+    For example, matching ``self.something`` will be a ``"something"``.
+    """
+    if (
+        isinstance(node, parse_tree.Member)
+        and isinstance(node.instance, parse_tree.Name)
+        and node.instance.identifier == "self"
+    ):
+        return node.name
+
+    return None
+
+
+class SingleArgFunctionOnMemberOrName:
+    """
+    Match a call of a function with a single argument on a member or a variable.
+
+    Mind that we only match arguments, but ignore keyword arguments. This is due to
+    simplicity of the implementation and this behavior might change in the future.
+    """
+
+    def __init__(
+        self,
+        function_name: Identifier,
+        member_or_name: Union[parse_tree.Member, parse_tree.Name],
+    ) -> None:
+        """Initialize with the given values."""
+        self.function_name = function_name
+        self.member_or_name = member_or_name
+
+
+def try_single_arg_function_on_member_or_name(
+    node: parse_tree.Node,
+) -> Optional[SingleArgFunctionOnMemberOrName]:
+    """
+    Match a call of a function with a single argument on a member or a variable.
+
+    For example, something like ``len(self.some_property)`` or ``is_MIME_type(self)``.
+
+    Mind that we only match arguments, but ignore keyword arguments. This is due to
+    simplicity of the implementation and this behavior might change in the future.
+    """
+    if not isinstance(node, parse_tree.FunctionCall):
+        return None
+
+    if len(node.args) != 1:
+        return None
+
+    if not isinstance(node.args[0], (parse_tree.Name, parse_tree.Member)):
+        return None
+
+    # noinspection PyTypeChecker
+    return SingleArgFunctionOnMemberOrName(
+        function_name=node.name.identifier, member_or_name=node.args[0]
+    )
+
+
+class ConditionalOnProp:
+    """Represent an invariant conditioned on an optional property."""
+
+    def __init__(
+        self, prop_name: Identifier, consequent: parse_tree.Expression
+    ) -> None:
+        """Initialize with the given values."""
+        self.prop_name = prop_name
+        self.consequent = consequent
+
+
+def try_conditional_on_prop(node: parse_tree.Node) -> Optional[ConditionalOnProp]:
+    """
+    Match an invariant conditioned on an optional property.
+
+    For example, ``not (self.some_prop is not None) or ...`` or
+    ``self.some_prop is None or ...``.
+    """
+    if isinstance(node, parse_tree.Implication):
+        if not isinstance(node.antecedent, parse_tree.IsNotNone):
+            return None
+
+        prop_name = try_property(node.antecedent.value)
+        if prop_name is None:
+            return None
+
+        return ConditionalOnProp(prop_name=prop_name, consequent=node.consequent)
+
+    elif isinstance(node, parse_tree.Or):
+        if len(node.values) != 2:
+            return None
+
+        if not isinstance(node.values[0], parse_tree.IsNone):
+            return None
+
+        # noinspection PyUnresolvedReferences
+        prop_name = try_property(node.values[0].value)
+        if prop_name is None:
+            return None
+
+        return ConditionalOnProp(prop_name=prop_name, consequent=node.values[1])
+
+    else:
+        return None

aas_core_codegen/intermediate/__init__.py

@@ -0,0 +1,78 @@
+"""Provide the intermediate representation of the meta-model."""
+
+from aas_core_codegen.intermediate import _types, _translate, _stringify
+
+TypeAnnotation = _types.TypeAnnotation
+TypeAnnotationUnion = _types.TypeAnnotationUnion
+AtomicTypeAnnotation = _types.AtomicTypeAnnotation
+PrimitiveType = _types.PrimitiveType
+PrimitiveTypeAnnotation = _types.PrimitiveTypeAnnotation
+OurTypeAnnotation = _types.OurTypeAnnotation
+ListTypeAnnotation = _types.ListTypeAnnotation
+OptionalTypeAnnotation = _types.OptionalTypeAnnotation
+SummaryRemarksDescription = _types.SummaryRemarksDescription
+SummaryRemarksConstraintsDescription = _types.SummaryRemarksConstraintsDescription
+DescriptionOfMetaModel = _types.DescriptionOfMetaModel
+DescriptionOfOurType = _types.DescriptionOfOurType
+DescriptionOfProperty = _types.DescriptionOfProperty
+DescriptionOfEnumerationLiteral = _types.DescriptionOfEnumerationLiteral
+DescriptionOfSignature = _types.DescriptionOfSignature
+DescriptionOfConstant = _types.DescriptionOfConstant
+DescriptionUnion = _types.DescriptionUnion
+Property = _types.Property
+Default = _types.Default
+DefaultPrimitive = _types.DefaultPrimitive
+DefaultEnumerationLiteral = _types.DefaultEnumerationLiteral
+Argument = _types.Argument
+OurType = _types.OurType
+OurTypeExceptEnumeration = _types.OurTypeExceptEnumeration
+Invariant = _types.Invariant
+Contract = _types.Contract
+Snapshot = _types.Snapshot
+Contracts = _types.Contracts
+Method = _types.Method
+ImplementationSpecificMethod = _types.ImplementationSpecificMethod
+UnderstoodMethod = _types.UnderstoodMethod
+MethodUnion = _types.MethodUnion
+Constructor = _types.Constructor
+Serialization = _types.Serialization
+EnumerationLiteral = _types.EnumerationLiteral
+Enumeration = _types.Enumeration
+ConstrainedPrimitive = _types.ConstrainedPrimitive
+Class = _types.Class
+ClassUnion = _types.ClassUnion
+ConcreteClass = _types.ConcreteClass
+AbstractClass = _types.AbstractClass
+ConstantPrimitive = _types.ConstantPrimitive
+PrimitiveSetLiteral = _types.PrimitiveSetLiteral
+Constant = _types.Constant
+ConstantSetOfPrimitives = _types.ConstantSetOfPrimitives
+ConstantSetOfEnumerationLiterals = _types.ConstantSetOfEnumerationLiterals
+ConstantSetUnion = _types.ConstantSetUnion
+ConstantUnion = _types.ConstantUnion
+Verification = _types.Verification
+ImplementationSpecificVerification = _types.ImplementationSpecificVerification
+PatternVerification = _types.PatternVerification
+TranspilableVerification = _types.TranspilableVerification
+VerificationUnion = _types.VerificationUnion
+Signature = _types.Signature
+Interface = _types.Interface
+SymbolTable = _types.SymbolTable
+
+type_annotations_equal = _types.type_annotations_equal
+beneath_optional = _types.beneath_optional
+TypeAnnotationExceptOptional = _types.TypeAnnotationExceptOptional
+try_primitive_type = _types.try_primitive_type
+map_descendability = _types.map_descendability
+collect_ids_of_our_types_in_properties = _types.collect_ids_of_our_types_in_properties
+
+translate = _translate.translate
+errors_if_contracts_for_functions_or_methods_defined = (
+    _translate.errors_if_contracts_for_functions_or_methods_defined
+)
+errors_if_non_implementation_specific_methods = (
+    _translate.errors_if_non_implementation_specific_methods
+)
+
+dump = _stringify.dump
+stringify = _stringify.stringify