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

aas_core_codegen/smoke/main.py

@@ -0,0 +1,219 @@
+"""Run a smoke-test as a preliminary test that a meta-model is ready for generation."""
+
+import argparse
+import pathlib
+import sys
+from typing import TextIO, List, MutableMapping
+
+import aas_core_codegen
+import aas_core_codegen.smoke
+from aas_core_codegen import (
+    parse,
+    run,
+    intermediate,
+    infer_for_schema,
+    specific_implementations,
+)
+from aas_core_codegen.common import LinenoColumner, Error, Stripped
+from aas_core_codegen.csharp import common as csharp_common
+from aas_core_codegen.csharp.structure import (
+    _generate as csharp_structure_generate,
+)
+from aas_core_codegen.csharp.verification import (
+    _generate as csharp_verification_generate,
+)
+
+assert __doc__ == aas_core_codegen.smoke.__doc__
+
+
+def _smoke_transpile_to_csharp(symbol_table: intermediate.SymbolTable) -> List[Error]:
+    """Try to transpile to C# what you can without snippets."""
+    # fmt: off
+    verified_symbol_table, structure_verification_errors = (
+        csharp_structure_generate.verify(
+            symbol_table
+        )
+    )
+    # fmt: on
+    if structure_verification_errors is not None:
+        return structure_verification_errors
+
+    assert verified_symbol_table is not None
+
+    errors = []
+
+    spec_impls = (
+        dict()
+    )  # type: MutableMapping[specific_implementations.ImplementationKey, Stripped]
+
+    dummy_implementation = Stripped("DUMMY IMPLEMENTATION")
+
+    for cls in symbol_table.classes:
+        if cls.is_implementation_specific:
+            key = specific_implementations.ImplementationKey(
+                "Types/{our_type.name}/{our_type.name}.cs"
+            )
+            spec_impls[key] = dummy_implementation
+            continue
+
+        for method in cls.methods:
+            if isinstance(method, intermediate.ImplementationSpecificMethod):
+                key = specific_implementations.ImplementationKey(
+                    f"Types/{cls.name}/{method.name}.cs"
+                )
+                spec_impls[key] = dummy_implementation
+
+    for verification in symbol_table.verification_functions:
+        if isinstance(verification, intermediate.ImplementationSpecificVerification):
+            key = specific_implementations.ImplementationKey(
+                f"Verification/{verification.name}.cs"
+            )
+            spec_impls[key] = dummy_implementation
+
+    namespace = csharp_common.NamespaceIdentifier("DummyNamespace")
+
+    _, structure_errors = csharp_structure_generate.generate(
+        symbol_table=verified_symbol_table, namespace=namespace, spec_impls=spec_impls
+    )
+    if structure_errors is not None:
+        errors.extend(structure_errors)
+
+    _, verification_errors = csharp_verification_generate.generate(
+        symbol_table=symbol_table, namespace=namespace, spec_impls=spec_impls
+    )
+    if verification_errors is not None:
+        errors.extend(verification_errors)
+
+    return errors
+
+
+def execute(model_path: pathlib.Path, stderr: TextIO) -> int:
+    """Run the smoke test."""
+    text = model_path.read_text(encoding="utf-8")
+
+    atok, parse_exception = parse.source_to_atok(source=text)
+    if parse_exception:
+        if isinstance(parse_exception, SyntaxError):
+            stderr.write(
+                f"Failed to parse the meta-model {model_path}: "
+                f"invalid syntax at line {parse_exception.lineno}\n"
+            )
+        else:
+            stderr.write(
+                f"Failed to parse the meta-model {model_path}: {parse_exception}\n"
+            )
+
+        return 1
+
+    assert atok is not None
+
+    import_errors = parse.check_expected_imports(atok=atok)
+    if import_errors:
+        run.write_error_report(
+            message="One or more unexpected imports in the meta-model",
+            errors=import_errors,
+            stderr=stderr,
+        )
+
+        return 1
+
+    lineno_columner = LinenoColumner(atok=atok)
+
+    parsed_symbol_table, error = parse.atok_to_symbol_table(atok=atok)
+    if error is not None:
+        run.write_error_report(
+            message=f"Failed to construct the symbol table from {model_path}",
+            errors=[lineno_columner.error_message(error)],
+            stderr=stderr,
+        )
+
+        return 1
+
+    assert parsed_symbol_table is not None
+
+    ir_symbol_table, error = intermediate.translate(
+        parsed_symbol_table=parsed_symbol_table,
+        atok=atok,
+    )
+    if error is not None:
+        run.write_error_report(
+            message=f"Failed to translate the parsed symbol table "
+            f"to intermediate symbol table "
+            f"based on {model_path}",
+            errors=[lineno_columner.error_message(error)],
+            stderr=stderr,
+        )
+
+        return 1
+
+    assert ir_symbol_table is not None
+
+    constraints_by_class, errors = infer_for_schema.infer_constraints_by_class(
+        symbol_table=ir_symbol_table
+    )
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to infer the constraints by class for the schemas "
+            f"based on {model_path}",
+            errors=[lineno_columner.error_message(error) for error in errors],
+            stderr=stderr,
+        )
+
+        return 1
+
+    assert constraints_by_class is not None
+
+    _, error = infer_for_schema.merge_constraints_with_ancestors(
+        symbol_table=ir_symbol_table, constraints_by_class=constraints_by_class
+    )
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to merge the constraints with ancestors for the schemas "
+            f"based on {model_path}",
+            errors=[lineno_columner.error_message(error)],
+            stderr=stderr,
+        )
+
+        return 1
+
+    errors = _smoke_transpile_to_csharp(symbol_table=ir_symbol_table)
+
+    if len(errors) > 0:
+        run.write_error_report(
+            message=f"Failed to smoke-transpile what we could without snippets to C# "
+            f"based on {model_path}",
+            errors=[lineno_columner.error_message(error) for error in errors],
+            stderr=stderr,
+        )
+
+        return 1
+
+    return 0
+
+
+def main(prog: str) -> int:
+    """Execute the main routine."""
+    # NOTE (mristin, 2022-03-28):
+    # The module ``argparse`` is not flexible enough to understand special options such
+    # as ``--version`` so we manually hard-wire.
+    if "--version" in sys.argv and "--help" not in sys.argv:
+        print(aas_core_codegen.__version__)
+        return 0
+
+    parser = argparse.ArgumentParser(prog=prog, description=__doc__)
+    parser.add_argument("--model_path", help="path to the meta-model", required=True)
+    parser.add_argument(
+        "--version", help="show the current version and exit", action="store_true"
+    )
+    args = parser.parse_args()
+
+    return execute(model_path=pathlib.Path(args.model_path), stderr=sys.stderr)
+
+
+def entry_point() -> int:
+    """Provide an entry point for a console script."""
+    return main(prog="aas-core-codegen-smoke")
+
+
+if __name__ == "__main__":
+    sys.exit(main(prog="aas-core-codegen-smoke"))

aas_core_codegen/specific_implementations.py

@@ -0,0 +1,72 @@
+"""Handle implementation snippets regardless for all implementation languages."""
+
+import pathlib
+import re
+from typing import cast, Mapping, Tuple, Optional, List
+
+from icontract import require, ensure
+
+from aas_core_codegen.common import Stripped
+
+# noinspection RegExpSimplifiable
+IMPLEMENTATION_KEY_RE = re.compile("[a-zA-Z_][a-zA-Z_0-9.]*(/[a-zA-Z_][a-zA-Z_0-9.]*)*")
+
+
+class ImplementationKey(str):
+    """Represent a key in the map of specific implementations."""
+
+    @require(lambda key: IMPLEMENTATION_KEY_RE.fullmatch(key))
+    def __new__(cls, key: str) -> "ImplementationKey":
+        return cast(ImplementationKey, key)
+
+
+SpecificImplementations = Mapping[ImplementationKey, Stripped]
+
+
+@ensure(lambda result: (result[0] is not None) ^ (result[1] is not None))
+def read_from_directory(
+    snippets_dir: pathlib.Path,
+) -> Tuple[Optional[SpecificImplementations], Optional[List[str]]]:
+    """
+    Read all the implementation-specific code snippets from the ``snippets_dir``.
+
+    :return: either the map of the implementations, or the errors
+    """
+    mapping = dict()  # pylint: disable=use-dict-literal
+
+    errors = []  # type: List[str]
+    for pth in snippets_dir.glob("**/*"):
+        # NOTE (mristin, 2022-08-25):
+        # Ignore hidden or special files. In particular, we do not want Git-related
+        # files such as ``.gitignore`` to be included as snippets.
+        if pth.name.startswith("."):
+            continue
+
+        if pth.is_dir():
+            continue
+
+        maybe_key = (pth.relative_to(snippets_dir).parent / pth.name).as_posix()
+        if IMPLEMENTATION_KEY_RE.fullmatch(maybe_key) is None:
+            errors.append(
+                f"The snippet key is not valid "
+                f"according to {IMPLEMENTATION_KEY_RE.pattern}: {maybe_key}"
+            )
+            continue
+
+        key = ImplementationKey(maybe_key)
+
+        try:
+            value = Stripped(pth.read_text(encoding="utf-8").strip())
+        except UnicodeDecodeError as error:
+            errors.append(
+                f"The snippet file is not a valid UTF-8: {pth}. "
+                f"This was the decoding error: {error}"
+            )
+            continue
+
+        mapping[key] = value
+
+    if errors:
+        return None, errors
+
+    return mapping, None

aas_core_codegen/stringify.py

@@ -0,0 +1,333 @@
+"""Represent general entities as strings for testing or debugging."""
+
+import collections.abc
+import enum
+import inspect
+import io
+import re
+import textwrap
+from typing import Sequence, Union, Any, Mapping, List, Tuple, Set
+
+from icontract import require
+
+from aas_core_codegen.common import assert_never, indent_but_first_line
+
+# We have to separate Stringifiable and Sequence[Stringifiable] since recursive types
+# are not supported in mypy, see https://github.com/python/mypy/issues/731.
+PrimitiveStringifiable = Union[
+    bool, int, float, str, "Entity", "Property", "PropertyEllipsis", None
+]
+
+Stringifiable = Union[
+    PrimitiveStringifiable,
+    Sequence[PrimitiveStringifiable],
+    Sequence[Sequence[PrimitiveStringifiable]],
+    Mapping[str, PrimitiveStringifiable],
+    Mapping[str, Sequence[PrimitiveStringifiable]],
+]
+
+
+class Property:
+    """Represent a property of an entity to be stringified."""
+
+    def __init__(self, name: str, value: Stringifiable) -> None:
+        self.name = name
+        self.value = value
+
+    def __repr__(self) -> str:
+        return dump(self)
+
+
+class PropertyEllipsis:
+    """Represent a property whose value is not displayed."""
+
+    def __init__(self, name: str, ignored_value: Any) -> None:
+        """Initialize with the given values."""
+        self.name = name
+
+        # The ignored value is usually not used. However, it instructs mypy and
+        # other static checkers to raise a warning if its value can not be accessed
+        # (*e.g.*, as can happen in a refactoring).
+        self.ignored_value = ignored_value
+
+    def __repr__(self) -> str:
+        return dump(self)
+
+
+class Entity:
+    """Represent a stringifiable entity which is defined by its properties.
+
+    Think of a dictionary with assigned type identifier.
+    """
+
+    def __init__(
+        self, name: str, properties: Sequence[Union[Property, PropertyEllipsis]]
+    ) -> None:
+        """Initialize with the given values."""
+        self.name = name
+        self.properties = properties
+
+    def __repr__(self) -> str:
+        return dump(self)
+
+
+def dump(stringifiable: Stringifiable) -> str:
+    """Produce a string representation of ``stringifiable`` for debugging or testing."""
+    if isinstance(stringifiable, (bool, int, float)):
+        return repr(stringifiable)
+
+    elif isinstance(stringifiable, str):
+        if "\n" not in stringifiable or "\r" in stringifiable or '"""' in stringifiable:
+            return repr(stringifiable)
+
+        # NOTE (mristin, 2022-05-18):
+        # A multi-line string literal is much more readable when it comes to diffing.
+
+        escaped = stringifiable.replace("\\", "\\\\")
+
+        indented = "\n".join(f"  {line}" for line in escaped.splitlines())
+
+        return f'textwrap.dedent("""\\\n{indented}""")'
+
+    elif isinstance(stringifiable, Entity):
+        if len(stringifiable.properties) == 0:
+            return f"{stringifiable.name}()"
+
+        writer = io.StringIO()
+        writer.write(f"{stringifiable.name}(\n")
+
+        for i, prop in enumerate(stringifiable.properties):
+            if isinstance(prop, Property):
+                value_str = dump(prop.value)
+                indention = "  "
+                writer.write(
+                    f"  {prop.name}={indent_but_first_line(value_str, indention)}"
+                )
+            elif isinstance(prop, PropertyEllipsis):
+                value_str = "None" if prop.ignored_value is None else "..."
+                writer.write(f"  {prop.name}={value_str}")
+            else:
+                assert_never(prop)
+
+            if i == len(stringifiable.properties) - 1:
+                writer.write(")")
+            else:
+                writer.write(",\n")
+
+        return writer.getvalue()
+
+    elif isinstance(stringifiable, collections.abc.Sequence):
+        if len(stringifiable) == 0:
+            return "[]"
+        else:
+            writer = io.StringIO()
+            writer.write("[\n")
+            for i, value in enumerate(stringifiable):
+                value_str = dump(value)
+                writer.write(textwrap.indent(value_str, "  "))
+
+                if i == len(stringifiable) - 1:
+                    writer.write("]")
+                else:
+                    writer.write(",\n")
+
+            return writer.getvalue()
+
+    elif isinstance(stringifiable, collections.abc.Mapping):
+        if len(stringifiable) == 0:
+            return "{}"
+        else:
+            writer = io.StringIO()
+            writer.write("{\n")
+            for i, (key, value) in enumerate(stringifiable.items()):
+                key_str = dump(key)
+
+                value_str = dump(value)
+                writer.write(textwrap.indent(f"{key_str}: {value_str}", "  "))
+
+                if i == len(stringifiable) - 1:
+                    writer.write("}")
+                else:
+                    writer.write(",\n")
+
+            return writer.getvalue()
+
+    elif stringifiable is None:
+        return repr(None)
+
+    elif isinstance(stringifiable, Property):
+        value_str = dump(stringifiable.value)
+        indention = ""
+        return (
+            f"Property("
+            f"{stringifiable.name}={indent_but_first_line(value_str, indention)}"
+            f")"
+        )
+
+    elif isinstance(stringifiable, PropertyEllipsis):
+        value_str = "None" if stringifiable.ignored_value is None else "..."
+        return f"PropertyEllipsis({stringifiable.name}={value_str})"
+
+    else:
+        assert_never(stringifiable)
+
+    raise AssertionError("Should not have gotten here")
+
+
+def compares_against_dict(entity: Entity, obj: object) -> bool:
+    """
+    Compare that the properties in the ``entity`` and ``obj.__dict__`` match.
+
+    Mind that the dunders and "protected" properties are excluded.
+    """
+    entity_property_set = {prop.name for prop in entity.properties}
+
+    obj_property_set = {key for key in obj.__dict__.keys() if not key.startswith("_")}
+
+    return entity_property_set == obj_property_set
+
+
+@require(lambda obj: hasattr(obj, "__dict__"), error=ValueError)
+def assert_compares_against_dict(entity: Entity, obj: object) -> None:
+    """
+    Compare that the properties in the ``entity`` and ``obj.__dict__`` match.
+
+    Mind that the dunders and "protected" properties are excluded.
+    """
+    entity_property_set = {prop.name for prop in entity.properties}
+
+    obj_property_set = {
+        attr
+        for attr in dir(obj)
+        if not attr.startswith("_") and not inspect.ismethod(getattr(obj, attr))
+    }
+
+    if entity_property_set != obj_property_set:
+        diff_in_entity = sorted(entity_property_set.difference(obj_property_set))
+
+        diff_in_obj = sorted(obj_property_set.difference(entity_property_set))
+
+        prefix = (
+            f"Expected the stringified properties "
+            f"of {obj.__class__.__name__!r} to match the object properties, "
+            f"but they do not.\n\n"
+        )
+
+        if len(diff_in_entity) > 0 and len(diff_in_obj) == 0:
+            raise AssertionError(
+                f"{prefix}"
+                f"The following properties were found in the stringified entity, "
+                f"but not in the object: {diff_in_entity}"
+            )
+
+        elif len(diff_in_obj) > 0 and len(diff_in_entity) == 0:
+            raise AssertionError(
+                f"{prefix}"
+                f"The following properties were found in the object, "
+                f"but not in the stringified entity: {diff_in_obj}"
+            )
+
+        else:
+            raise AssertionError(
+                f"{prefix}"
+                f"The following properties were found in the stringified entity, "
+                f"but not in the object: {diff_in_entity}\n\n"
+                f"The following properties were found in the object, "
+                f"but not in the stringified entity: {diff_in_obj}"
+            )
+
+
+def assert_all_public_types_listed_as_dumpables(
+    dumpable: Any, types_module: Any
+) -> None:
+    """Make sure that all classes in ``types_modules`` are listed as dumpables."""
+
+    dumpable_set = set()  # type: Set[str]
+
+    for dumpable_cls in dumpable.__args__:
+        dumpable_set.add(dumpable_cls.__name__)
+
+    module_set = set()  # type: Set[str]
+
+    for identifier, cls in inspect.getmembers(types_module, inspect.isclass):
+        module_name = getattr(cls, "__module__", None)
+        if module_name is None:
+            continue
+
+        if module_name != types_module.__name__:
+            continue
+
+        if identifier.startswith("_"):
+            continue
+
+        if issubclass(cls, enum.Enum):
+            continue
+
+        if inspect.isabstract(cls):
+            continue
+
+        if cls.__module__ == types_module.__name__:
+            module_set.add(identifier)
+
+    if dumpable_set != module_set:
+        dumpable_diff = dumpable_set.difference(module_set)
+        module_diff = module_set.difference(dumpable_set)
+
+        raise AssertionError(
+            f"The following classes were defined as dumpable, "
+            f"but not found as concrete classes "
+            f"in the module ``_types``: {sorted(dumpable_diff)}\n\n"
+            f"The following classes were defined in the module ``_types``, "
+            f"but not found in dumpables: {sorted(module_diff)}"
+        )
+
+
+def assert_dispatch_exhaustive(dispatch: Mapping[Any, Any], dumpable: Any) -> None:
+    """
+    Make sure that ``dispatch_map`` is exhaustive over all the concrete dumpables.
+
+    We need to dispatch a class to its corresponding ``_stringify_*`` function. This is
+    mapped in ``dispatch_map``. At the same time, we have to make a union type over all
+    the types that can be converted to a stringified entity.
+    """
+    dumpable_map = {
+        id(cls): cls for cls in dumpable.__args__ if not inspect.isabstract(cls)
+    }
+
+    dispatch_map = {id(cls): cls for cls in dispatch}
+
+    dumpable_set = set(dumpable_map.keys())
+    dispatch_set = set(dispatch_map.keys())
+
+    if dumpable_set != dispatch_set:
+        dumpable_diff = dumpable_set.difference(dispatch_set)
+        dispatch_diff = dispatch_set.difference(dumpable_set)
+
+        dumpable_diff_names = [
+            dumpable_map[cls_id].__name__ for cls_id in dumpable_diff
+        ]
+
+        dispatch_diff_names = [
+            dispatch_map[cls_id].__name__ for cls_id in dispatch_diff
+        ]
+
+        raise AssertionError(
+            f"The following concrete classes are found in Dumpable, "
+            f"but not in _DISPATCH: {dumpable_diff_names}.\n\n"
+            f"The following concrete classes are found in _DISPATCH, "
+            f"but not in Dumpable: {dispatch_diff_names}"
+        )
+
+    unexpected_function_names = []  # type: List[Tuple[str, str]]
+    for cls, func in dispatch.items():
+        cls_snake_case = re.sub(r"(?<!^)(?=[A-Z])", "_", cls.__name__).lower()
+        expected_func_name = f"_stringify_{cls_snake_case}"
+
+        if func.__name__ != expected_func_name:
+            unexpected_function_names.append((cls.__name__, func.__name__))
+
+    if len(unexpected_function_names):
+        raise AssertionError(
+            f"The following dispatch functions had unexpected names "
+            f"(as a list of (class, function name)): {unexpected_function_names}"
+        )

aas_core_codegen/typescript/__init__.py

@@ -0,0 +1 @@
+"""Generate TypeScript code based on the intermediate meta-model."""

aas_core_codegen/typescript/aas_common/__init__.py

@@ -0,0 +1,4 @@
+"""Generate TypeScript code for common functions."""
+from aas_core_codegen.typescript.aas_common import _generate
+
+generate = _generate.generate