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

aas_core_codegen/csharp/main.py

@@ -0,0 +1,421 @@
+"""Generate C# 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.csharp import (
+    common as csharp_common,
+    constants as csharp_constants,
+    structure as csharp_structure,
+    visitation as csharp_visitation,
+    verification as csharp_verification,
+    reporting as csharp_reporting,
+    stringification as csharp_stringification,
+    jsonization as csharp_jsonization,
+    xmlization as csharp_xmlization,
+    copying as csharp_copying,
+    enhancing as csharp_enhancing,
+)
+
+
+def execute(context: run.Context, stdout: TextIO, stderr: TextIO) -> int:
+    """Generate the code."""
+    verified_ir_table, errors = csharp_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 C# 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 csharp_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 = csharp_common.NamespaceIdentifier(namespace_text)
+
+    # region Structure
+
+    code, errors = csharp_structure.generate(
+        symbol_table=verified_ir_table,
+        namespace=namespace,
+        spec_impls=context.spec_impls,
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the structures in the C# 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.cs"
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the C# structures to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Visitation
+
+    code, errors = csharp_visitation.generate(
+        symbol_table=context.symbol_table, namespace=namespace
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the C# code for visitation "
+            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 / "visitation.cs"
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the visitation C# code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Constants
+
+    code, errors = csharp_constants.generate(
+        symbol_table=context.symbol_table,
+        namespace=namespace,
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the constants in the C# 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 / "constants.cs"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the constants in the C# code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Verification
+
+    verify_errors = csharp_verification.verify(
+        spec_impls=context.spec_impls,
+        verification_functions=verified_ir_table.verification_functions,
+    )
+
+    if verify_errors is not None:
+        run.write_error_report(
+            message="Failed to verify for generation of C# verification code",
+            errors=verify_errors,
+            stderr=stderr,
+        )
+        return 1
+
+    code, errors = csharp_verification.generate(
+        symbol_table=verified_ir_table,
+        namespace=namespace,
+        spec_impls=context.spec_impls,
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the verification C# 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 / "verification.cs"
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the verification C# code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Reporting
+
+    code = csharp_reporting.generate(namespace=namespace)
+
+    pth = context.output_dir / "reporting.cs"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the reporting C# code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Stringification
+
+    code, errors = csharp_stringification.generate(
+        symbol_table=context.symbol_table, namespace=namespace
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the stringification C# 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 / "stringification.cs"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the stringification C# code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Jsonization
+
+    code, errors = csharp_jsonization.generate(
+        symbol_table=context.symbol_table,
+        namespace=namespace,
+        spec_impls=context.spec_impls,
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the jsonization C# 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 / "jsonization.cs"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the jsonization C# code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Xmlization
+
+    code, errors = csharp_xmlization.generate(
+        symbol_table=context.symbol_table,
+        namespace=namespace,
+        spec_impls=context.spec_impls,
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the xmlization C# 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 / "xmlization.cs"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the xmlization C# code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Copying
+
+    code, errors = csharp_copying.generate(
+        symbol_table=context.symbol_table,
+        namespace=namespace,
+        spec_impls=context.spec_impls,
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the C# code for shallow and deep copying "
+            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 / "copying.cs"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the C# code for shallow and deep copying "
+            f"to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Enhancing
+
+    code, errors = csharp_enhancing.generate(
+        symbol_table=context.symbol_table,
+        namespace=namespace,
+        spec_impls=context.spec_impls,
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the C# code for enhancing "
+            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 / "enhancing.cs"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the C# code for enhancing 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/csharp/naming.py

@@ -0,0 +1,157 @@
+"""Generate C# identifiers based on the identifiers from the meta-model."""
+from typing import Union
+
+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 C# interface name based on its meta-model ``identifier``.
+
+    >>> interface_name(Identifier("something"))
+    'ISomething'
+
+    >>> interface_name(Identifier("URL_to_something"))
+    'IUrlToSomething'
+    """
+    return Identifier(f"I{aas_core_codegen.naming.capitalized_camel_case(identifier)}")
+
+
+def enum_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a C# 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 C# name for an enum literal based on its meta-model ``identifier``.
+
+    >>> enum_literal_name(Identifier("something"))
+    'Something'
+
+    >>> enum_literal_name(Identifier("URL_to_something"))
+    'UrlToSomething'
+    """
+    return aas_core_codegen.naming.capitalized_camel_case(identifier)
+
+
+def class_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a C# 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 C# name for a public property based on its meta-model ``identifier``.
+
+    >>> property_name(Identifier("something"))
+    'Something'
+
+    >>> property_name(Identifier("something_to_URL"))
+    'SomethingToUrl'
+    """
+    return aas_core_codegen.naming.capitalized_camel_case(identifier)
+
+
+def private_property_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a C# name for a private property based on the ``identifier``.
+
+    >>> private_property_name(Identifier("something"))
+    '_something'
+
+    >>> private_property_name(Identifier("something_to_URL"))
+    '_somethingToUrl'
+    """
+    return Identifier(f"_{aas_core_codegen.naming.lower_camel_case(identifier)}")
+
+
+def private_method_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a C# name for a private method based on the ``identifier``.
+
+    >>> private_method_name(Identifier("something"))
+    '_something'
+
+    >>> private_method_name(Identifier("something_to_URL"))
+    '_somethingToUrl'
+    """
+    return Identifier(f"_{aas_core_codegen.naming.lower_camel_case(identifier)}")
+
+
+def method_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a C# name for a member method based on its meta-model ``identifier``.
+
+    >>> method_name(Identifier("do_something"))
+    'DoSomething'
+
+    >>> method_name(Identifier("do_something_to_URL"))
+    'DoSomethingToUrl'
+    """
+    return aas_core_codegen.naming.capitalized_camel_case(identifier)
+
+
+def argument_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a C# name for an argument based on its meta-model ``identifier``.
+
+    >>> argument_name(Identifier("something"))
+    'something'
+
+    >>> argument_name(Identifier("something_to_URL"))
+    'somethingToUrl'
+    """
+    return aas_core_codegen.naming.lower_camel_case(identifier)
+
+
+def variable_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a C# name for a variable based on its meta-model ``identifier``.
+
+    >>> variable_name(Identifier("something"))
+    'something'
+
+    >>> variable_name(Identifier("something_to_URL"))
+    'somethingToUrl'
+    """
+    return aas_core_codegen.naming.lower_camel_case(identifier)

aas_core_codegen/csharp/reporting/__init__.py

@@ -0,0 +1,4 @@
+"""Generate C# code for reporting errors."""
+from aas_core_codegen.csharp.reporting import _generate
+
+generate = _generate.generate