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

aas_core_codegen/protobuf/main.py

@@ -0,0 +1,115 @@
+"""Generate ProtoBuf code to handle asset administration shells based on the meta-model."""
+
+from typing import TextIO
+
+from aas_core_codegen import specific_implementations, run, intermediate
+from aas_core_codegen.protobuf import (
+    common as proto_common,
+    structure as proto_structure,
+)
+
+
+def execute(context: run.Context, stdout: TextIO, stderr: TextIO) -> int:
+    """Generate the code."""
+    verified_ir_table, errors = proto_structure.verify(
+        symbol_table=context.symbol_table
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to verify the intermediate symbol table "
+            f"for generation of ProtoBuf code"
+            f"based on {context.model_path}",
+            errors=[context.lineno_columner.error_message(error) for error in errors],
+            stderr=stderr,
+        )
+        return 1
+
+    assert verified_ir_table is not None
+
+    unsupported_contracts_errors = (
+        intermediate.errors_if_contracts_for_functions_or_methods_defined(
+            verified_ir_table
+        )
+    )
+    if unsupported_contracts_errors is not None:
+        run.write_error_report(
+            message=f"We do not support pre and post-conditions and snapshots "
+            f"at the moment. Please notify the developers if you need this "
+            f"feature (based on meta-model {context.model_path})",
+            errors=[
+                context.lineno_columner.error_message(error)
+                for error in unsupported_contracts_errors
+            ],
+            stderr=stderr,
+        )
+        return 1
+
+    unsupported_methods_errors = (
+        intermediate.errors_if_non_implementation_specific_methods(verified_ir_table)
+    )
+    if unsupported_methods_errors is not None:
+        run.write_error_report(
+            message=f"We added some support for understood methods already and keep "
+            f"maintaining it as it is only a matter of time when we will "
+            f"introduce their transpilation. Introducing them after the fact "
+            f"would have been much more difficult.\n"
+            f"\n"
+            f"At the given moment, however, we deliberately focus only on "
+            f"implementation-specific methods. "
+            f"(based on meta-model {context.model_path})",
+            errors=[
+                context.lineno_columner.error_message(error)
+                for error in unsupported_methods_errors
+            ],
+            stderr=stderr,
+        )
+        return 1
+
+    namespace_key = specific_implementations.ImplementationKey("namespace.txt")
+    namespace_text = context.spec_impls.get(namespace_key, None)
+    if namespace_text is None:
+        stderr.write(f"The namespace snippet is missing: {namespace_key}\n")
+        return 1
+
+    if not proto_common.NAMESPACE_IDENTIFIER_RE.fullmatch(namespace_text):
+        stderr.write(
+            f"The text from the snippet {namespace_key} "
+            f"is not a valid namespace identifier: {namespace_text!r}\n"
+        )
+        return 1
+
+    namespace = proto_common.NamespaceIdentifier(namespace_text)
+
+    # region Structure
+
+    code, errors = proto_structure.generate(
+        symbol_table=verified_ir_table, namespace=namespace
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the structures in the ProtoBuf code "
+            f"based on {context.model_path}",
+            errors=[context.lineno_columner.error_message(error) for error in errors],
+            stderr=stderr,
+        )
+        return 1
+
+    assert code is not None
+
+    pth = context.output_dir / "types.proto"
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the ProtoBuf structures to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    stdout.write(f"Code generated to: {context.output_dir}\n")
+    return 0

aas_core_codegen/protobuf/naming.py

@@ -0,0 +1,143 @@
+"""Generate ProtoBuf identifiers based on the identifiers from the meta-model."""
+
+from typing import Union
+
+from icontract import ensure
+
+import aas_core_codegen.naming
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import Identifier, assert_never
+
+
+def interface_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a ProtoBuf name for an interface based on its meta-model ``identifier``.
+
+    This method is not to be used because proto3 does not support interfaces.
+    """
+    raise NotImplementedError("Interfaces are not supported by proto3.")
+
+
+def enum_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a ProtoBuf name for an enum based on its meta-model ``identifier``.
+
+    >>> enum_name(Identifier("something"))
+    'Something'
+
+    >>> enum_name(Identifier("URL_to_something"))
+    'UrlToSomething'
+    """
+    return aas_core_codegen.naming.capitalized_camel_case(identifier)
+
+
+def enum_literal_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a Protobuf name for an enum literal based on its meta-model ``identifier``.
+
+    >>> enum_literal_name(Identifier("something"))
+    'SOMETHING'
+
+    >>> enum_literal_name(Identifier("URL_to_something"))
+    'URL_TO_SOMETHING'
+    """
+    return aas_core_codegen.naming.upper_snake_case(identifier)
+
+
+@ensure(
+    lambda result: "_" not in result,
+    "No underscode allowed so that we can attached our own suffixes such as ``_choice``",
+)
+def class_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a ProtoBuf name for a class based on its meta-model ``identifier``.
+
+    >>> class_name(Identifier("something"))
+    'Something'
+
+    >>> class_name(Identifier("URL_to_something"))
+    'UrlToSomething'
+    """
+    return aas_core_codegen.naming.capitalized_camel_case(identifier)
+
+
+def name_of(
+    something: Union[
+        intermediate.Enumeration, intermediate.ConcreteClass, intermediate.Interface
+    ]
+) -> Identifier:
+    """Dispatch to the appropriate naming function."""
+    if isinstance(something, intermediate.Enumeration):
+        return enum_name(something.name)
+
+    elif isinstance(something, intermediate.ConcreteClass):
+        return class_name(something.name)
+
+    elif isinstance(something, intermediate.Interface):
+        return interface_name(something.name)
+
+    else:
+        assert_never(something)
+
+    raise AssertionError("Should not have gotten here")
+
+
+def property_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a ProtoBuf name for a public property based on its meta-model ``identifier``.
+
+    >>> property_name(Identifier("something"))
+    'something'
+
+    >>> property_name(Identifier("something_to_URL"))
+    'something_to_url'
+    """
+    return aas_core_codegen.naming.lower_snake_case(identifier)
+
+
+def private_property_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a ProtoBuf name for a private property.
+
+    This method is not to be used because proto3 does not support private properties.
+    """
+    raise NotImplementedError(
+        "Private properties are not supported by proto3 Messages."
+    )
+
+
+def private_method_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a ProtoBuf name for a private method.
+
+    This method is not to be used because proto3 does not support private methods.
+    """
+    raise NotImplementedError("Methods are not supported by proto3 Messages.")
+
+
+def method_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a ProtoBuf name for a method.
+
+    This method is not to be used because proto3 does not support methods.
+    """
+    raise NotImplementedError("Methods are not supported by proto3 Messages.")
+
+
+def argument_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a ProtoBuf name for an argument.
+
+    This method is not to be used because proto3 does not support methods and
+    thus no arguments.
+    """
+    raise NotImplementedError("Arguments are not supported by proto3 Messages.")
+
+
+def variable_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a ProtoBuf name for a variable.
+
+    This method is not to be used because proto3 does not support variables.
+    """
+    raise NotImplementedError("Variables are not supported by proto3 Messages.")

aas_core_codegen/protobuf/structure/__init__.py

@@ -0,0 +1,6 @@
+"""Generate C# data structures to represent an AAS."""
+
+from aas_core_codegen.protobuf.structure import _generate
+
+verify = _generate.verify
+generate = _generate.generate