aas-core-codegen 0.0.24__tar.gz → 0.0.26__tar.gz

{aas_core_codegen-0.0.24/aas_core_codegen.egg-info → aas_core_codegen-0.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-core-codegen
-Version: 0.0.24
+Version: 0.0.26
 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
@@ -8,11 +8,10 @@ Project-URL: Homepage, https://github.com/aas-core-works/aas-core-codegen
 Keywords: asset administration shell,code generation,industry 4.0,industrie 4.0,i4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 License-File: AUTHORS

{aas_core_codegen-0.0.24 → aas_core_codegen-0.0.26}/aas_core_codegen/__init__.py

@@ -1,6 +1,6 @@
 """Generate implementations and schemas based on an AAS meta-model."""
 
-__version__ = "0.0.24"
+__version__ = "0.0.26"
 __author__ = "Marko Ristin, Nico Braunisch"
 __license__ = "License :: OSI Approved :: MIT License"
 __status__ = "Production/Stable"

{aas_core_codegen-0.0.24 → aas_core_codegen-0.0.26}/aas_core_codegen/cpp/common.py

@@ -492,12 +492,33 @@ def is_referencable(type_annotation: intermediate.TypeAnnotationUnion) -> bool:
     if primitive_type is not None:
         return primitive_type_is_referencable(primitive_type)
 
-    if isinstance(type_annotation, intermediate.OurTypeAnnotation) and isinstance(
-        type_annotation.our_type, intermediate.Enumeration
-    ):
-        return False
+    else:
+        if isinstance(type_annotation, intermediate.PrimitiveTypeAnnotation):
+            raise AssertionError("Expected to handle this case before")
+
+        elif isinstance(type_annotation, intermediate.OurTypeAnnotation):
+            if isinstance(type_annotation.our_type, intermediate.Enumeration):
+                return False
+
+            elif isinstance(
+                type_annotation.our_type, intermediate.ConstrainedPrimitive
+            ):
+                raise AssertionError("Expected to handle this case before")
+
+            elif isinstance(
+                type_annotation.our_type,
+                (intermediate.AbstractClass, intermediate.ConcreteClass),
+            ):
+                return True
 
-    return True
+            else:
+                assert_never(type_annotation.our_type)
+
+        elif isinstance(type_annotation, intermediate.ListTypeAnnotation):
+            return True
+
+        else:
+            assert_never(type_annotation)
 
 
 def generate_type_with_const_ref_if_applicable(

{aas_core_codegen-0.0.24 → aas_core_codegen-0.0.26}/aas_core_codegen/cpp/lib/_generate_constants.py

@@ -147,7 +147,7 @@ const std::wstring {constant_name} = (
         )
 
     elif constant.a_type is intermediate.PrimitiveType.BYTEARRAY:
-        assert isinstance(constant.value, bytearray)
+        assert isinstance(constant.value, bytes)
 
         literal, _ = cpp_common.bytes_literal(value=constant.value)
 
@@ -275,7 +275,7 @@ std::unordered_set<
         )
 
         for literal in constant.literals:
-            assert isinstance(literal.value, bytearray)
+            assert isinstance(literal.value, bytes)
             literal_code, _ = cpp_common.bytes_literal(literal.value)
             literal_codes.append(literal_code)
 

{aas_core_codegen-0.0.24 → aas_core_codegen-0.0.26}/aas_core_codegen/cpp/lib/_generate_enhancing.py

@@ -379,32 +379,47 @@ that->{setter_name}(
         else:
             # noinspection PyTypeChecker
             assert_never(type_anno.our_type)
+
     elif isinstance(type_anno, intermediate.ListTypeAnnotation):
-        assert isinstance(
-            type_anno.items, intermediate.OurTypeAnnotation
-        ) and isinstance(
-            type_anno.items.our_type,
-            (intermediate.AbstractClass, intermediate.ConcreteClass),
-        ), (
-            f"NOTE (mristin): We expect only lists of classes "
-            f"at the moment, but you specified {type_anno}. "
-            f"Please contact the developers if you need this feature."
-        )
+        if isinstance(type_anno.items, intermediate.PrimitiveTypeAnnotation):
+            # Nothing to recurse into.
+            return Stripped("")
 
-        getter_name = cpp_naming.getter_name(prop.name)
-        const_ref_prop_type = cpp_common.generate_type_with_const_ref_if_applicable(
-            type_annotation=type_anno, types_namespace=Identifier("types")
-        )
-        prop_type = cpp_common.generate_type(
-            type_annotation=type_anno, types_namespace=cpp_common.TYPES_NAMESPACE
-        )
+        elif isinstance(type_anno.items, intermediate.OurTypeAnnotation):
+            if isinstance(type_anno.items.our_type, intermediate.Enumeration):
+                # Nothing to recurse into.
+                return Stripped("")
+
+            elif isinstance(
+                type_anno.items.our_type, intermediate.ConstrainedPrimitive
+            ):
+                # Nothing to recurse into.
+                return Stripped("")
+
+            elif isinstance(
+                type_anno.items.our_type,
+                (intermediate.AbstractClass, intermediate.ConcreteClass),
+            ):
+                getter_name = cpp_naming.getter_name(prop.name)
+
+                const_ref_prop_type = (
+                    cpp_common.generate_type_with_const_ref_if_applicable(
+                        type_annotation=type_anno, types_namespace=Identifier("types")
+                    )
+                )
 
-        item_type = cpp_common.generate_type_with_const_ref_if_applicable(
-            type_annotation=type_anno.items, types_namespace=cpp_common.TYPES_NAMESPACE
-        )
+                prop_type = cpp_common.generate_type(
+                    type_annotation=type_anno,
+                    types_namespace=cpp_common.TYPES_NAMESPACE,
+                )
 
-        return Stripped(
-            f"""\
+                item_type = cpp_common.generate_type_with_const_ref_if_applicable(
+                    type_annotation=type_anno.items,
+                    types_namespace=cpp_common.TYPES_NAMESPACE,
+                )
+
+                return Stripped(
+                    f"""\
 {{
 {I}{indent_but_first_line(const_ref_prop_type, I)} value(
 {II}that->{getter_name}()
@@ -430,7 +445,30 @@ that->{setter_name}(
 {II}std::move(wrapped)
 {I});
 }}"""
-        )
+                )
+
+            else:
+                assert_never(type_anno.items.our_type)
+
+        elif isinstance(type_anno.items, intermediate.OptionalTypeAnnotation):
+            raise NotImplementedError(
+                f"NOTE (mristin, 2026-05-09): We do not currently support "
+                f"the generation of enhancing code for lists of optionals, "
+                f"but you specified {type_anno}. Please contact the developers if "
+                f"you need this feature."
+            )
+
+        elif isinstance(type_anno.items, intermediate.ListTypeAnnotation):
+            raise NotImplementedError(
+                f"NOTE (mristin, 2026-05-09): We do not currently support "
+                f"the generation of enhancing code for lists of lists, "
+                f"but you specified {type_anno}. Please contact the developers if "
+                f"you need this feature."
+            )
+
+        else:
+            assert_never(type_anno.items)
+
     else:
         # noinspection PyTypeChecker
         assert_never(type_anno)

{aas_core_codegen-0.0.24 → aas_core_codegen-0.0.26}/aas_core_codegen/cpp/lib/_generate_iteration.py

@@ -775,30 +775,59 @@ class IteratorQualities:
         for prop in cls.properties:
             type_anno = intermediate.beneath_optional(prop.type_annotation)
 
-            if isinstance(type_anno, intermediate.OurTypeAnnotation) and isinstance(
-                type_anno.our_type,
-                (intermediate.AbstractClass, intermediate.ConcreteClass),
-            ):
-                relevant_properties.append(prop)
+            if isinstance(type_anno, intermediate.PrimitiveTypeAnnotation):
+                pass
 
-            elif isinstance(type_anno, intermediate.ListTypeAnnotation):
-                assert isinstance(
-                    type_anno.items, intermediate.OurTypeAnnotation
-                ) and isinstance(
-                    type_anno.items.our_type,
+            elif isinstance(type_anno, intermediate.OurTypeAnnotation):
+                if isinstance(type_anno.our_type, intermediate.Enumeration):
+                    pass
+
+                elif isinstance(type_anno.our_type, intermediate.ConstrainedPrimitive):
+                    pass
+
+                elif isinstance(
+                    type_anno.our_type,
                     (intermediate.AbstractClass, intermediate.ConcreteClass),
-                ), (
-                    f"NOTE (mristin): We expect only lists of classes "
-                    f"at the moment, but you specified {prop.type_annotation} "
-                    f"in class {cls.name!r} and property {prop.name!r}. "
-                    f"Please contact the developers if you need this feature."
-                )
+                ):
+                    relevant_properties.append(prop)
 
-                cls_contains_a_list_property = True
+                else:
+                    assert_never(type_anno.our_type)
+
+            elif isinstance(type_anno, intermediate.ListTypeAnnotation):
+                if isinstance(type_anno.items, intermediate.PrimitiveTypeAnnotation):
+                    pass
+
+                elif isinstance(type_anno.items, intermediate.OurTypeAnnotation):
+                    if isinstance(type_anno.items.our_type, intermediate.Enumeration):
+                        pass
+
+                    elif isinstance(
+                        type_anno.items.our_type, intermediate.ConstrainedPrimitive
+                    ):
+                        pass
+
+                    elif isinstance(
+                        type_anno.items.our_type,
+                        (intermediate.AbstractClass, intermediate.ConcreteClass),
+                    ):
+                        cls_contains_a_list_property = True
+
+                        relevant_properties.append(prop)
+
+                    else:
+                        assert_never(type_anno.items.our_type)
+
+                else:
+                    raise NotImplementedError(
+                        f"NOTE (mristin): We expect only lists of atomic values "
+                        f"at the moment, but you specified {prop.type_annotation} "
+                        f"in class {cls.name!r} and property {prop.name!r}. "
+                        f"Please contact the developers if you need this feature."
+                    )
 
-                relevant_properties.append(prop)
             else:
-                pass
+                assert_never(type_anno)
 
         self.cls = cls
         self.relevant_properties = relevant_properties