interlis2py 0.1.0__py3-none-any.whl

ili2py/__init__.py

@@ -0,0 +1,3 @@
+from ili2py._version import __version__, version
+
+__all__ = ["__version__", "version"]

ili2py/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

ili2py/cli.py

@@ -0,0 +1,229 @@
+"""Main `ili2py` CLI."""
+
+import logging
+import os
+import sys
+from typing import Any
+
+import click
+from rich.logging import RichHandler
+
+from ili2py import version
+from ili2py.mappers.helpers import Index
+from ili2py.readers.interlis_24.ilismeta16.xsdata import Imd16Reader
+from ili2py.writers.diagram import create_uml_diagram
+from ili2py.writers.diagram.interlis import Diagram, tool_settings
+from ili2py.writers.py.python_structure import Library
+from ili2py.writers.py.render import create_python_classes, library_storage_name
+
+
+def version_msg():
+    """ili2py version, location and Python version.
+
+    Get message about ili2py version, location
+    and Python version.
+    """
+    python_version = sys.version[:6]
+    message = f"ili2py {version} from {sys.argv[0]} (Python {python_version})"
+    return message
+
+
+def flavour_options(setting: str) -> str:
+    """Lists the allowed values of a tool setting per flavour, e.g. for help texts."""
+    return ", ".join(
+        [f"{key}: {getattr(tool_settings[key], setting)}" for key in tool_settings]
+    )
+
+
+@click.group()
+@click.option("-v", "--verbose", is_flag=True, help="Print debug information", default=False)
+@click.version_option(version, "-V", "--version", message=version_msg())
+def cli(verbose):
+    level = logging.DEBUG if verbose else logging.INFO
+    handlers = []
+    # we recognize if we run in tty -> colorlogging is enabled with rich logging else we use
+    # the default stream handler (this avoids awkward output when it's piped to a file).
+    if sys.stdout.isatty():
+        handlers.append(RichHandler())
+    else:
+        handlers.append(logging.StreamHandler(sys.stdout))
+    logging.basicConfig(
+        level=level, format="%(levelname)s: %(message)s", datefmt="[%X]", handlers=handlers
+    )
+    logging.info("Starting ili2py CLI")
+    logging.info(version_msg())
+
+
+@cli.command(
+    help="""Parses an arbitrary IMD16 and creates a diagram of selected flavour
+    representing the selected models.""",
+    context_settings=dict(help_option_names=["-h", "--help"], show_default=True),
+)
+@click.option("-i", "--imd", is_flag=False, required=True, help="full path to IMD16 file")
+@click.option(
+    "-o",
+    "--output_folder",
+    is_flag=False,
+    required=True,
+    help="""Path to the folder where the diagram should be written to.
+    The folder will be created if not existing.""",
+)
+@click.option(
+    "-f",
+    "--flavour",
+    is_flag=False,
+    default=list(tool_settings.keys())[0],
+    help=f"the desired flavour (one of {', '.join(tool_settings.keys())})",
+)
+@click.option(
+    "-d",
+    "--direction",
+    is_flag=False,
+    default=None,
+    help="the desired direction, depending on the selected flavour "
+    f"(one of {flavour_options('directions')})",
+)
+@click.option(
+    "-l",
+    "--linetype",
+    is_flag=False,
+    default=None,
+    help="the desired linetype, depending on the selected flavour "
+    f"(one of {flavour_options('linetype')})",
+)
+@click.option(
+    "-n",
+    "--file_name",
+    is_flag=False,
+    default="diagram",
+    help="The name of the output diagram. The postfix (md, puml, etc. is added automatically "
+    "due to selected flavour).",
+)
+@click.option(
+    "-m",
+    "--models",
+    is_flag=False,
+    required=False,
+    help="""Model names separated by comma. This is used to filter the content of the
+    resulting diagram.
+    If not provided, the full tree will be drawn.
+    NOTE: This works in conjunction with the depth parameter
+    """,
+)
+@click.option(
+    "-s",
+    "--spacing-line-length",
+    is_flag=False,
+    default=2,
+    required=False,
+    help="""The length of the drawn connectors between the diagram nodes.
+    NOTE: Currently this only influences plantuml diagrams!
+    """,
+)
+@click.option(
+    "--depth",
+    is_flag=False,
+    default=None,
+    type=int,
+    required=False,
+    help="""The depth how the diagram should be drawn in reference to the level of imports.
+    0 is the model itself, 1 the model itself and all models its importing and so on.
+    NOTE: This can be used in conjunction to the model names to add arbitrary models to the
+    diagram.
+    """,
+)
+@click.pass_context
+def diagram(ctx: click.Context, **kwargs: Any):
+    """
+    parse an arbitrary imd and creates a UML diagram of selected flavour
+    """
+    logging.info("Creating diagram")
+    metamodel_path = kwargs.pop("imd")
+    model_names = kwargs.pop("models")
+    output_path = kwargs.pop("output_folder")
+    direction = kwargs.pop("direction")
+    linetype = kwargs.pop("linetype")
+    file_name = kwargs.pop("file_name")
+    multiplier = kwargs.pop("spacing_line_length")
+    depth = kwargs.pop("depth")
+    model_names = model_names.split(",") if model_names else []
+    flavour = kwargs.pop("flavour")
+    if flavour not in tool_settings:
+        click.echo(
+            f"The output {flavour} is not allowed. "
+            f"It has to be one of {', '.join(tool_settings.keys())}"
+        )
+        sys.exit(2)
+    try:
+        metamodel = Imd16Reader().read(metamodel_path)
+        index = Index(metamodel.datasection)
+        diagram = Diagram.from_imd(index)
+        assembled_file_name = f"{file_name or flavour}.{tool_settings[flavour].postfix}"
+        logging.info(
+            f"""Diagram ({flavour}) is generated with:
+            path:                   {os.path.join(output_path, assembled_file_name)}
+            direction:              {direction if direction else "DEFAULT"}
+            linetype:               {linetype if linetype else "DEFAULT"}
+            spacing line length:    {multiplier}
+            depth:                  {depth}
+        """
+        )
+        create_uml_diagram(
+            diagram,
+            index,
+            model_names,
+            flavour,
+            assembled_file_name,
+            output_path=output_path,
+            direction=direction,
+            linetype=linetype,
+            multiplier=multiplier,
+            depth=depth,
+        )
+    except Exception as error:
+        click.echo(error)
+        sys.exit(1)
+
+
+@cli.command(
+    help="""Parses an arbitrary imd and creates a library of python classes which
+    represents a typed interface to the complete construction.""",
+    context_settings=dict(help_option_names=["-h", "--help"]),
+)
+@click.option("-i", "--imd", is_flag=False, required=True, help="full path to imd file")
+@click.option(
+    "-o",
+    "--output_folder",
+    is_flag=False,
+    required=True,
+    help="Path to where the python package should be written",
+)
+@click.option(
+    "-l",
+    "--library_name",
+    is_flag=False,
+    required=True,
+    help="Library name which will be used to assemble all python structures in.",
+)
+def python_classes(**kwargs: Any):
+    logging.info("Creating python-classes")
+    metamodel_path = kwargs.pop("imd")
+    output_path = kwargs.pop("output_folder")
+    library_name = kwargs.pop("library_name")
+    try:
+        metamodel = Imd16Reader().read(metamodel_path)
+        index = Index(metamodel.datasection)
+        library = Library.from_imd(metamodel.datasection.ModelData, index, library_name)
+        logging.info(
+            f"""Classes are generated with:
+            path:       {os.path.join(output_path, library_storage_name(library_name))}
+        """
+        )
+        create_python_classes(library, index, output_path)
+    except Exception as error:
+        click.echo(error)
+        sys.exit(1)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    cli()

ili2py/interfaces/interlis/interlis_23/__init__.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+
+# the common name space used in an INTERLIS 2.3 XTF
+namespace_map = {"ili": "http://www.interlis.ch/INTERLIS2.3"}
+
+
+class ILI_META_BASE:
+    namespace = namespace_map["ili"]
+
+
+@dataclass(kw_only=True)
+class MODEL:
+    class Meta(ILI_META_BASE):
+        pass
+
+    NAME: str
+    VERSION: str
+    URI: str
+
+
+@dataclass
+class HeaderSection:
+    class Meta(ILI_META_BASE):
+        pass
+
+    MODELS: list[MODEL]
+    SENDER: str
+    VERSION: str
+
+
+@dataclass
+class TRANSFER:
+    class Meta(ILI_META_BASE):
+        pass
+
+    HEADERSECTION: HeaderSection

ili2py/interfaces/interlis/interlis_23/generator.py

@@ -0,0 +1,146 @@
+from dataclasses import field, make_dataclass
+from typing import Optional
+
+from ili2py.interfaces.interlis.interlis_23 import TRANSFER
+from ili2py.interfaces.interlis.interlis_24.ilismeta16 import ImdTransfer
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.model_data import ModelData
+
+
+class DataClassGenerator:
+    def __init__(self, meta_model: ImdTransfer):
+        self.meta_model = meta_model
+
+    def find_model_by_name(self, model_name: str) -> ModelData:
+        for model_data in self.meta_model.datasection.ModelData:
+            if model_name == model_data.Model.Name:
+                return model_data
+        raise LookupError(f"No model with name {model_name} could be found.")
+
+    def generate(self, model_name: str):
+        """
+        This is a factory method which produces dataclasses at runtime `make_dataclass`. The
+        construction plan of the dataclasses is derived from the tree of dataclass objects
+        which has to be created to be first.
+
+        TODO: currently this makes no big sense since we usually want to read all models which
+            can be in an XTF.
+
+        Args:
+            model_name: The name of the desired model name which the XTF is constructed from.
+
+        Returns: The tree of dataclasses representing the structure of the XTF. This can be
+            used to generate readers out of it.
+        """
+        model_data = self.find_model_by_name(model_name)
+        topic_fields = []
+        for topic_item in model_data.SubModel:
+            class_fields = [("bid", str, field(metadata={"name": "BID", "type": "Attribute"}))]
+            # find all classes inside sub_model[ili:TOPIC]
+            for class_item in model_data.Class:
+                if (
+                    class_item.element_in_package.ref == topic_item.tid
+                    and class_item.kind == "Class"
+                ):
+                    attr_or_param_fields = [
+                        (
+                            "tid",
+                            Optional[str],  # noqa: UP045 - runtime type for xsdata
+                            field(default=None, metadata={"name": "TID", "type": "Attribute"}),
+                        )
+                    ]
+                    # find all attributes related to class
+                    for attr_or_param_item in model_data.AttrOrParam:
+                        if attr_or_param_item.AttrParent_ref.ref == class_item.tid:
+                            # find type definition for attribute (currently we have implemented
+                            # [ili:TextType]
+                            for type_item in model_data.TextType:
+                                if type_item.tid == attr_or_param_item.Type_ref.ref:
+                                    attr_or_param_field = (
+                                        attr_or_param_item.Name.lower(),
+                                        str if type_item.mandatory else Optional[str],  # noqa: UP045
+                                        (
+                                            field(
+                                                metadata={
+                                                    "name": attr_or_param_item.Name,
+                                                    "type": "Element",
+                                                    "required": type_item.mandatory,
+                                                }
+                                            )
+                                            if type_item.mandatory
+                                            else field(
+                                                default=None,
+                                                metadata={
+                                                    "name": attr_or_param_item.Name,
+                                                    "type": "Element",
+                                                    "required": type_item.mandatory,
+                                                },
+                                            )
+                                        ),
+                                    )
+                                    # dataclasses have kwargs and args. We need to ensure, that
+                                    # the stay in correct order (args first)
+                                    if type_item.mandatory:
+                                        attr_or_param_fields.insert(0, attr_or_param_field)
+                                    else:
+                                        attr_or_param_fields.append(attr_or_param_field)
+                            # find type definition for attribute (currently we have implemented
+                            # [ili:NumType]
+                            for type_item in model_data.NumType:
+                                if type_item.tid == attr_or_param_item.Type_ref.ref:
+                                    attr_or_param_field = (
+                                        attr_or_param_item.Name.lower(),
+                                        int if type_item.mandatory else Optional[int],  # noqa: UP045
+                                        (
+                                            field(
+                                                metadata={
+                                                    "name": attr_or_param_item.Name,
+                                                    "type": "Element",
+                                                    "required": type_item.mandatory,
+                                                }
+                                            )
+                                            if type_item.mandatory
+                                            else field(
+                                                default=None,
+                                                metadata={
+                                                    "name": attr_or_param_item.Name,
+                                                    "type": "Element",
+                                                    "required": type_item.mandatory,
+                                                },
+                                            )
+                                        ),
+                                    )
+                                    # dataclasses have kwargs and args. We need to ensure, that
+                                    # the stay in correct order (args first)
+                                    if type_item.mandatory:
+                                        attr_or_param_fields.insert(0, attr_or_param_field)
+                                    else:
+                                        attr_or_param_fields.append(attr_or_param_field)
+
+                    class_fields.append(
+                        (
+                            class_item.name.lower(),
+                            list[make_dataclass(class_item.name, attr_or_param_fields)],
+                            field(
+                                default=None,
+                                metadata={
+                                    "name": class_item.tid,
+                                    "type": "Element",
+                                    "default": None,
+                                },
+                            ),
+                        )
+                    )
+            topic_fields.append(
+                (
+                    topic_item.Name.lower(),
+                    make_dataclass(topic_item.Name, class_fields),
+                    field(
+                        metadata={"name": topic_item.tid, "type": "Element", "default": None}
+                    ),
+                )
+            )
+
+        class XtfTransfer(TRANSFER):
+            DATASECTION: make_dataclass("DATASECTION", fields=topic_fields)
+
+        return XtfTransfer

ili2py/interfaces/interlis/interlis_24/__init__.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+
+namespace_map = {
+    "ili": "http://www.interlis.ch/xtf/2.4/INTERLIS",
+    "geom": "http://www.interlis.ch/geometry/1.0",
+    "xsi": "http://www.w3.org/2001/XMLSchema-instance",
+}
+
+
+@dataclass
+class Model:
+    model: str = field(metadata={"namespace": namespace_map["ili"]})
+
+
+@dataclass
+class Models:
+    elements: list[Model] = field(
+        default_factory=list,
+        metadata={
+            "type": "Elements",
+            "choices": ({"name": "model", "type": Model, "namespace": namespace_map["ili"]},),
+        },
+    )
+
+
+@dataclass
+class HeaderSection:
+    models: Models = field(metadata={"namespace": namespace_map["ili"]})
+    sender: str | None = field(
+        default=None,
+        metadata={"namespace": namespace_map["ili"]},
+    )
+
+
+@dataclass
+class Transfer:
+    headersection: HeaderSection = field(metadata={"namespace": namespace_map["ili"]})

ili2py/interfaces/interlis/interlis_24/ilismeta/README.md

@@ -0,0 +1,21 @@
+
+xsdata version: 25.7
+
+```shell
+xsdata generate -p ilismeta -r --unnest-classes -ss clusters --compound-fields ../../../../../../tests/data/ilismeta16/IlisMeta16.imd
+```
+
+xsdata created a file `class_ref_type_ref1.py` which was not correct. It inherited from nothing
+and therefore missed alot of attributes which come from inheritance. It is still
+unclear, why xsdata creates such construction because it also creates the almost
+correct one. But this lacked the `ref` attribute. The solution was to add the
+`ref` attribute from `class_ref_type_ref1.ClassRefTypeRef1` to the
+`class_ref_type_ref.ClassRefTypeRef` and repoint all references too. After that, `class_ref_type_ref1.py`
+was deleted.
+
+while generating classes from xsd with xsdata another problem occurred in
+[choice definition](ilismeta16_2022_10_10/actual_argument_type.py#L350). This was falsely
+generated as a single object choice, but had to be a list of choices, actually. It had to be
+corrected manually by making it an optional list of union... and in the field definition the
+`default=None` had to be changed to `default_factory=list`. After that fix all expressions could
+be parsed from IMD16 files in the tests.