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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aas-core-codegen
-Version: 0.0.23
+Version: 0.0.24
 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

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

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

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/python/lib/_generate_jsonization.py

@@ -1001,13 +1001,21 @@ jsonable[{key_literal}] = (
                 access_expression=Stripped("item"), type_anno=type_anno.items
             )
 
-            block = Stripped(
-                f"""\
+            # NOTE (mristin):
+            # We optimize here to avoid unnecessary comprehension.
+            if transformation_expression == "item":
+                block = Stripped(
+                    f"""\
+jsonable[{key_literal}] = list(that.{prop_name})"""
+                )
+            else:
+                block = Stripped(
+                    f"""\
 jsonable[{key_literal}] = [
 {I}{transformation_expression}
 {I}for item in that.{prop_name}
 ]"""
-            )
+                )
 
         else:
             assert_never(type_anno)

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/python/lib/_generate_xmlization.py

@@ -964,7 +964,7 @@ self.{prop_name} = {read_prop_cls_as_sequence}(
                 read_item_cls_as_element = Identifier(
                     _READ_FUNCTION_BY_PRIMITIVE_TYPE[type_anno.items.a_type]
                 )
-                items_type = Stripped(str(type_anno.items.a_type))
+                items_type = python_common.PRIMITIVE_TYPE_MAP[type_anno.items.a_type]
             else:
                 raise AssertionError(
                     "(mristin, 2022-10-09) We handle only lists of classes and primitive types"

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/python/tests/_generate_common.py

@@ -55,7 +55,7 @@ import {qualified_module_name}.types as aas_types"""
         ),
         Stripped(
             """\
-_REPO_ROOT = pathlib.Path(os.path.realpath(__file__)).parent.parent"""
+_REPO_ROOT = pathlib.Path(os.path.realpath(__file__)).parent.parent.parent"""
         ),
         Stripped(
             '''\

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/python/tests/_generate_test_descend_and_pass_through_visitor.py

@@ -51,6 +51,7 @@ import {qualified_module_name}.types as aas_types"""
         ),
         Stripped(
             """\
+import tests.common
 import tests.common_xmlization"""
         ),
         Stripped(

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/python/tests/_generate_test_for_over_x_or_empty.py

@@ -133,6 +133,7 @@ import {qualified_module_name}.types as aas_types"""
         ),
         Stripped(
             """\
+import tests.common
 import tests.common_xmlization"""
         ),
     ]

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/python/tests/_generate_test_for_x_or_default.py

@@ -127,6 +127,7 @@ import {qualified_module_name}.types as aas_types"""
         ),
         Stripped(
             """\
+import tests.common
 import tests.common_xmlization"""
         ),
     ]

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/python/tests/_generate_test_jsonization_of_classes_with_descendants.py

@@ -124,6 +124,7 @@ import {qualified_module_name}.jsonization as aas_jsonization"""
         ),
         Stripped(
             """\
+import tests.common
 import tests.common_jsonization"""
         ),
         _generate_test_case(symbol_table=symbol_table),

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/python/tests/_generate_test_jsonization_of_concrete_classes.py

@@ -105,6 +105,7 @@ import {qualified_module_name}.jsonization as aas_jsonization"""
         ),
         Stripped(
             """\
+import tests.common
 import tests.common_jsonization"""
         ),
         _generate_test_case(symbol_table=symbol_table),

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/python/tests/_generate_test_xmlization_of_classes_with_descendants.py

@@ -149,6 +149,7 @@ import {qualified_module_name}.xmlization as aas_xmlization"""
         ),
         Stripped(
             """\
+import tests.common
 import tests.common_xmlization"""
         ),
         _generate_test_case(symbol_table=symbol_table),

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/python/tests/_generate_test_xmlization_of_concrete_classes.py

@@ -151,6 +151,7 @@ import {qualified_module_name}.xmlization as aas_xmlization"""
         ),
         Stripped(
             """\
+import tests.common
 import tests.common_xmlization"""
         ),
         _generate_test_case(symbol_table=symbol_table),

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/typescript/lib/_generate_xmlization.py

@@ -38,6 +38,113 @@ _PARSE_FUNCTION_BY_PRIMITIVE_TYPE = {
 }
 
 
+def _generate_parse_text_for_primitive_type(
+    primitive_type: intermediate.PrimitiveType,
+) -> Stripped:
+    """Generate parser for a primitive XML text representation."""
+    if primitive_type is intermediate.PrimitiveType.BOOL:
+        return Stripped(
+            f"""\
+function parseBooleanText(
+{I}text: string
+): AasCommon.Either<boolean, DeserializationError> {{
+{I}if (text === "true" || text === "1") {{
+{II}return new AasCommon.Either<boolean, DeserializationError>(true, null);
+{I}}}
+{I}if (text === "false" || text === "0") {{
+{II}return new AasCommon.Either<boolean, DeserializationError>(false, null);
+{I}}}
+
+{I}return newDeserializationError<boolean>(
+{II}`Expected xs:boolean text, but got: ${{text}}`
+{I});
+}}"""
+        )
+
+    elif primitive_type is intermediate.PrimitiveType.INT:
+        return Stripped(
+            f"""\
+function parseIntegerText(
+{I}text: string
+): AasCommon.Either<number, DeserializationError> {{
+{I}if (!/^[+-]?\\d+$/.test(text)) {{
+{II}return newDeserializationError<number>(
+{III}`Expected integer text, but got: ${{text}}`
+{II});
+{I}}}
+
+{I}const value = Number(text);
+{I}if (!Number.isInteger(value)) {{
+{II}return newDeserializationError<number>(
+{III}`Expected integer text, but got: ${{text}}`
+{II});
+{I}}}
+
+{I}return new AasCommon.Either<number, DeserializationError>(value, null);
+}}"""
+        )
+
+    elif primitive_type is intermediate.PrimitiveType.FLOAT:
+        return Stripped(
+            f"""\
+function parseFloatText(
+{I}text: string
+): AasCommon.Either<number, DeserializationError> {{
+{I}if (text === "INF") {{
+{II}return new AasCommon.Either<number, DeserializationError>(Infinity, null);
+{I}}}
+{I}if (text === "-INF") {{
+{II}return new AasCommon.Either<number, DeserializationError>(-Infinity, null);
+{I}}}
+{I}if (text === "NaN") {{
+{II}return new AasCommon.Either<number, DeserializationError>(NaN, null);
+{I}}}
+
+{I}const value = Number(text);
+{I}if (Number.isNaN(value)) {{
+{II}return newDeserializationError<number>(
+{III}`Expected xs:double text, but got: ${{text}}`
+{II});
+{I}}}
+
+{I}return new AasCommon.Either<number, DeserializationError>(value, null);
+}}"""
+        )
+
+    elif primitive_type is intermediate.PrimitiveType.STR:
+        return Stripped(
+            f"""\
+function parseStringText(
+{I}text: string
+): AasCommon.Either<string, DeserializationError> {{
+{I}return new AasCommon.Either<string, DeserializationError>(text, null);
+}}"""
+        )
+
+    elif primitive_type is intermediate.PrimitiveType.BYTEARRAY:
+        return Stripped(
+            f"""\
+function parseBase64EncodedBytesText(
+{I}text: string
+): AasCommon.Either<Uint8Array, DeserializationError> {{
+{I}const decodedOrError = AasCommon.base64Decode(text);
+{I}if (decodedOrError.error !== null) {{
+{II}return newDeserializationError<Uint8Array>(
+{III}decodedOrError.error
+{II});
+{I}}}
+
+{I}return new AasCommon.Either<Uint8Array, DeserializationError>(
+{II}decodedOrError.mustValue(),
+{II}null
+{I});
+}}"""
+        )
+
+    else:
+        assert_never(primitive_type)
+
+
 def _parse_function_for_atomic_type(
     type_annotation: intermediate.AtomicTypeAnnotation,
 ) -> Identifier:
@@ -242,6 +349,7 @@ const parsedItems = new Array<{list_items_type}>();
 let itemIndex = 0;
 
 cursor.skipIgnorable();
+// eslint-disable-next-line no-constant-condition
 while (true) {{
 {I}const itemOrClose = cursor.current();
 {I}if (itemOrClose === null) {{
@@ -332,6 +440,7 @@ const parsedItems = new Array<{list_items_type}>();
 let itemIndex = 0;
 
 cursor.skipIgnorable();
+// eslint-disable-next-line no-constant-condition
 while (true) {{
 {I}const itemOrClose = cursor.current();
 {I}if (itemOrClose === null) {{
@@ -537,6 +646,7 @@ function {function_name}(
 {I}{indent_but_first_line(declarations, I)}
 
 {I}cursor.skipIgnorable();
+{I}// eslint-disable-next-line no-constant-condition
 {I}while (true) {{
 {II}const token = cursor.current();
 {II}if (token === null) {{
@@ -674,6 +784,68 @@ function {serialize_function_name}(
     )
 
 
+def _generate_serialize_text_for_primitive_type(
+    primitive_type: intermediate.PrimitiveType,
+) -> Stripped:
+    """Generate serializer for a primitive XML text representation."""
+    if primitive_type is intermediate.PrimitiveType.BOOL:
+        return Stripped(
+            f"""\
+function serializeBooleanText(value: boolean): string {{
+{I}return value ? "true" : "false";
+}}"""
+        )
+
+    elif primitive_type is intermediate.PrimitiveType.INT:
+        return Stripped(
+            f"""\
+function serializeIntegerText(value: number): string {{
+{I}if (!Number.isInteger(value)) {{
+{II}throw new Error(`Expected an integer, but got: ${{value}}`);
+{I}}}
+
+{I}return `${{value}}`;
+}}"""
+        )
+
+    elif primitive_type is intermediate.PrimitiveType.FLOAT:
+        return Stripped(
+            f"""\
+function serializeFloatText(value: number): string {{
+{I}if (Number.isNaN(value)) {{
+{II}return "NaN";
+{I}}}
+{I}if (value === Infinity) {{
+{II}return "INF";
+{I}}}
+{I}if (value === -Infinity) {{
+{II}return "-INF";
+{I}}}
+
+{I}return `${{value}}`;
+}}"""
+        )
+
+    elif primitive_type is intermediate.PrimitiveType.STR:
+        return Stripped(
+            f"""\
+function serializeStringText(value: string): string {{
+{I}return escapeXmlText(value);
+}}"""
+        )
+
+    elif primitive_type is intermediate.PrimitiveType.BYTEARRAY:
+        return Stripped(
+            f"""\
+function serializeBase64EncodedBytesText(value: Uint8Array): string {{
+{I}return escapeXmlText(AasCommon.base64Encode(value));
+}}"""
+        )
+
+    else:
+        assert_never(primitive_type)
+
+
 def _generate_serialize_block_for_property(
     cls: intermediate.ConcreteClass,
     prop: intermediate.Property,
@@ -1183,6 +1355,7 @@ class XmlCursor {{
 {I}}}
 
 {I}skipIgnorable(): void {{
+{II}// eslint-disable-next-line no-constant-condition
 {II}while (true) {{
 {III}const token = this.current();
 {III}if (token === null) {{
@@ -1306,85 +1479,6 @@ function readTextContentAndConsumeEndTag(
 {I});
 }}
 
-function parseBooleanText(
-{I}text: string
-): AasCommon.Either<boolean, DeserializationError> {{
-{I}if (text === "true" || text === "1") {{
-{II}return new AasCommon.Either<boolean, DeserializationError>(true, null);
-{I}}}
-{I}if (text === "false" || text === "0") {{
-{II}return new AasCommon.Either<boolean, DeserializationError>(false, null);
-{I}}}
-
-{I}return newDeserializationError<boolean>(
-{II}`Expected xs:boolean text, but got: ${{text}}`
-{I});
-}}
-
-function parseIntegerText(
-{I}text: string
-): AasCommon.Either<number, DeserializationError> {{
-{I}if (!/^[+-]?\\d+$/.test(text)) {{
-{II}return newDeserializationError<number>(
-{III}`Expected integer text, but got: ${{text}}`
-{II});
-{I}}}
-
-{I}const value = Number(text);
-{I}if (!Number.isInteger(value)) {{
-{II}return newDeserializationError<number>(
-{III}`Expected integer text, but got: ${{text}}`
-{II});
-{I}}}
-
-{I}return new AasCommon.Either<number, DeserializationError>(value, null);
-}}
-
-function parseFloatText(
-{I}text: string
-): AasCommon.Either<number, DeserializationError> {{
-{I}if (text === "INF") {{
-{II}return new AasCommon.Either<number, DeserializationError>(Infinity, null);
-{I}}}
-{I}if (text === "-INF") {{
-{II}return new AasCommon.Either<number, DeserializationError>(-Infinity, null);
-{I}}}
-{I}if (text === "NaN") {{
-{II}return new AasCommon.Either<number, DeserializationError>(NaN, null);
-{I}}}
-
-{I}const value = Number(text);
-{I}if (Number.isNaN(value)) {{
-{II}return newDeserializationError<number>(
-{III}`Expected xs:double text, but got: ${{text}}`
-{II});
-{I}}}
-
-{I}return new AasCommon.Either<number, DeserializationError>(value, null);
-}}
-
-function parseStringText(
-{I}text: string
-): AasCommon.Either<string, DeserializationError> {{
-{I}return new AasCommon.Either<string, DeserializationError>(text, null);
-}}
-
-function parseBase64EncodedBytesText(
-{I}text: string
-): AasCommon.Either<Uint8Array, DeserializationError> {{
-{I}const decodedOrError = AasCommon.base64Decode(text);
-{I}if (decodedOrError.error !== null) {{
-{II}return newDeserializationError<Uint8Array>(
-{III}decodedOrError.error
-{II});
-{I}}}
-
-{I}return new AasCommon.Either<Uint8Array, DeserializationError>(
-{II}decodedOrError.mustValue(),
-{II}null
-{I});
-}}
-
 function parsePropertyAsClassInstance(
 {I}cursor: XmlCursor,
 {I}propertyStartTag: OpenTagToken
@@ -1449,6 +1543,9 @@ function parsePropertyAsClassInstance(
         ),
     ]  # type: List[Stripped]
 
+    for primitive_type in intermediate.PrimitiveType:
+        blocks.append(_generate_parse_text_for_primitive_type(primitive_type))
+
     for enumeration in symbol_table.enumerations:
         blocks.append(_generate_parse_text_as_enumeration(enumeration))
 
@@ -1572,42 +1669,16 @@ function escapeXmlText(text: string): string {{
 {II}.replace(/>/g, "&gt;")
 {II}.replace(/\"/g, "&quot;")
 {II}.replace(/'/g, "&apos;");
-}}
-
-function serializeBooleanText(value: boolean): string {{
-{I}return value ? "true" : "false";
-}}
-
-function serializeIntegerText(value: number): string {{
-{I}if (!Number.isInteger(value)) {{
-{II}throw new Error(`Expected an integer, but got: ${{value}}`);
-{I}}}
-
-{I}return `${{value}}`;
-}}
-
-function serializeFloatText(value: number): string {{
-{I}if (Number.isNaN(value)) {{
-{II}return "NaN";
-{I}}}
-{I}if (value === Infinity) {{
-{II}return "INF";
-{I}}}
-{I}if (value === -Infinity) {{
-{II}return "-INF";
-{I}}}
-
-{I}return `${{value}}`;
-}}
-
-function serializeStringText(value: string): string {{
-{I}return escapeXmlText(value);
-}}
-
-function serializeBase64EncodedBytesText(value: Uint8Array): string {{
-{I}return escapeXmlText(AasCommon.base64Encode(value));
 }}"""
             ),
+        ]
+    )
+
+    for primitive_type in intermediate.PrimitiveType:
+        blocks.append(_generate_serialize_text_for_primitive_type(primitive_type))
+
+    blocks.extend(
+        [
             _generate_serializer(symbol_table=symbol_table),
             Stripped("const SERIALIZER = new Serializer();"),
             Stripped(
@@ -1644,4 +1715,5 @@ export function toXmlString(that: AasTypes.Class): string {{
 
 
 assert generate.__doc__ is not None
+assert __doc__ is not None
 assert generate.__doc__.strip().startswith(__doc__.strip())

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/typescript/main.py

@@ -209,6 +209,15 @@ def execute(context: run.Context, stdout: TextIO, stderr: TextIO) -> int:
                 None,
             ),
         ),
+        (
+            test_rel_path / "xmlization.common.spec.ts",
+            lambda: (
+                typescript_tests.generate_xmlization_common_spec(
+                    symbol_table=verified_ir_table,
+                ),
+                None,
+            ),
+        ),
         (
             test_rel_path / "xmlization.enums.spec.ts",
             lambda: (
@@ -227,6 +236,15 @@ def execute(context: run.Context, stdout: TextIO, stderr: TextIO) -> int:
                 None,
             ),
         ),
+        (
+            test_rel_path / "xmlization.negative.spec.ts",
+            lambda: (
+                typescript_tests.generate_xmlization_negative_spec(
+                    symbol_table=verified_ir_table,
+                ),
+                None,
+            ),
+        ),
         (
             test_rel_path / "types.casts.spec.ts",
             lambda: (

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/typescript/tests/__init__.py

@@ -10,8 +10,10 @@ from aas_core_codegen.typescript.tests import (
     _generate_jsonization_enums_spec,
     _generate_jsonization_interfaces_spec,
     _generate_xmlization_concrete_classes_spec,
+    _generate_xmlization_common_spec,
     _generate_xmlization_enums_spec,
     _generate_xmlization_interfaces_spec,
+    _generate_xmlization_negative_spec,
     _generate_types_casts_spec,
     _generate_types_descend_and_pass_through_visitor_spec,
     _generate_types_descend_once_spec,
@@ -35,8 +37,10 @@ generate_jsonization_interfaces_spec = _generate_jsonization_interfaces_spec.gen
 generate_xmlization_concrete_classes_spec = (
     _generate_xmlization_concrete_classes_spec.generate
 )
+generate_xmlization_common_spec = _generate_xmlization_common_spec.generate
 generate_xmlization_enums_spec = _generate_xmlization_enums_spec.generate
 generate_xmlization_interfaces_spec = _generate_xmlization_interfaces_spec.generate
+generate_xmlization_negative_spec = _generate_xmlization_negative_spec.generate
 generate_types_casts_spec = _generate_types_casts_spec.generate
 generate_types_descend_and_pass_through_visitor_spec = (
     _generate_types_descend_and_pass_through_visitor_spec.generate

{aas_core_codegen-0.0.23 → aas_core_codegen-0.0.24}/aas_core_codegen/typescript/tests/_generate_common_xmlization.py

@@ -151,4 +151,5 @@ export function {load_minimal_name}(
 
 
 assert generate.__doc__ is not None
+assert __doc__ is not None
 assert generate.__doc__.strip().startswith(__doc__.strip())

aas_core_codegen-0.0.24/aas_core_codegen/typescript/tests/_generate_xmlization_common_spec.py

@@ -0,0 +1,76 @@
+"""Generate code to execute all common XMLization loader functions once."""
+
+import io
+from typing import List
+
+from icontract import ensure
+
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import Stripped, Identifier
+from aas_core_codegen.typescript import (
+    common as typescript_common,
+    naming as typescript_naming,
+)
+from aas_core_codegen.typescript.common import (
+    INDENT as I,
+)
+
+
+# fmt: off
+@ensure(
+    lambda result: result.endswith('\n'),
+    "Trailing newline mandatory for valid end-of-files"
+)
+# fmt: on
+def generate(symbol_table: intermediate.SymbolTable) -> str:
+    """Generate code to execute all common XMLization loader functions once."""
+    blocks = [
+        Stripped(
+            """\
+/**
+ * Execute all common XMLization loader helpers once.
+ */"""
+        ),
+        typescript_common.WARNING,
+        Stripped(
+            """\
+import * as TestCommonXmlization from "./commonXmlization";"""
+        ),
+    ]  # type: List[Stripped]
+
+    for concrete_cls in symbol_table.concrete_classes:
+        load_maximal_name = typescript_naming.function_name(
+            Identifier(f"load_maximal_{concrete_cls.name}")
+        )
+        load_minimal_name = typescript_naming.function_name(
+            Identifier(f"load_minimal_{concrete_cls.name}")
+        )
+        cls_name_typescript = typescript_naming.class_name(concrete_cls.name)
+
+        blocks.append(
+            Stripped(
+                f"""\
+test("commonXmlization loaders for {cls_name_typescript}", () => {{
+{I}expect(TestCommonXmlization.{load_minimal_name}()).not.toBeNull();
+{I}expect(TestCommonXmlization.{load_maximal_name}()).not.toBeNull();
+}});"""
+            )
+        )
+
+    blocks.append(typescript_common.WARNING)
+
+    writer = io.StringIO()
+    for i, block in enumerate(blocks):
+        if i > 0:
+            writer.write("\n\n")
+
+        writer.write(block)
+
+    writer.write("\n")
+
+    return writer.getvalue()
+
+
+assert generate.__doc__ is not None
+assert __doc__ is not None
+assert generate.__doc__.strip().startswith(__doc__.strip())