interlis2py 0.1.0__py3-none-any.whl

ili2py/writers/py/interlis23/templates/module.jinja2

@@ -0,0 +1,89 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from abc import ABC
+from typing import Any, Union, Tuple
+from {{ module.library }} import INTERLIS
+from {{ module.library }}.references import Ref, XmlBlBoxType, BinBlBoxType
+{% for item in  module.imported_packages %}
+from {{ module.library }} import {{ item }}
+{% endfor %}
+{%- for module_path, class_item, alias in module.related_class_imports %}
+{%- if class_item and alias  %}
+from {{ module.library }}.{{ module_path }} import {{ class_item }} as {{ alias }}
+{%- elif class_item and not alias %}
+from {{ module.library }}.{{ module_path }} import {{ class_item }}
+{%- elif not class_item and not alias %}
+import {{ module.library }}.{{ module_path }}
+{%- endif %}
+{%- endfor %}
+{%- if module.doc %}
+"""
+{{ "\n".join(module.doc) }}
+"""
+{%- endif %}
+
+metadata: dict = {
+    "interlis": {
+        "meta_attributes": {
+            {% for item in module.meta_attributes %}
+                "{{ item.name }}": "{{ item.value }}",
+            {% endfor %}
+        }
+    }
+}
+
+{%- set domain_types=module.type_definitions %}
+{%- include "domain_types.jinja2" %}
+
+{%- set enumerations=module.enumerations %}
+{%- include "enumerations.jinja2" %}
+
+{%- set coord_types=module.coord_types %}
+{%- include "coord_types.jinja2" %}
+{%- if module.line_types  %}
+{%- endif %}
+{%- set line_types=module.line_types %}
+{%- include "line_types.jinja2" %}
+
+{%- set classes=module.classes %}
+{%- include "classes.jinja2" %}
+{% if module.basket.choices %}
+@dataclass
+class {{ module.name }}TOPIC:
+    class Meta:
+        name = "{{ module.identifier }}"
+
+    elements: list[Union[
+        {% for choice in module.basket.choices %}
+        {{choice.type_reference}},
+        {% endfor %}
+    ]]  = field(
+        default_factory=list,
+        metadata={
+            "type": "Elements",
+            "choices": (
+            {%- for choice in module.basket.choices %}
+                {
+                    "name": "{{ choice.identifier }}",
+                    "type": {{ choice.type_reference }},
+                    "namespace": "{{ render_config['namespace_map']['ili'] }}",
+                },
+            {%- endfor %}
+            )
+        }
+    )
+    bid: str|None = field(
+        default=None,
+        metadata={
+            "type": "Attribute",
+            "name": "BID"
+        },
+    )
+    kind: str|None = field(
+        default=None,
+        metadata={
+            "type": "Attribute",
+            "name": "KIND"
+        },
+    )
+{% endif %}

ili2py/writers/py/interlis23/templates/package_init.jinja2

@@ -0,0 +1,56 @@
+from typing import Union
+from enum import Enum
+from abc import ABC
+from typing import Any, Union, Tuple
+from dataclasses import dataclass, field
+from {{ package.library }}.references import Ref, XmlBlBoxType, BinBlBoxType
+{%- if package.name != 'INTERLIS' %}
+from {{ package.library }} import INTERLIS
+{%- endif %}
+{% for item in  package.imported_packages %}
+from {{ package.library }} import {{ item }}
+{% endfor %}
+{% for module_path, class_item, alias in package.related_class_imports %}
+{%- if class_item and alias  %}
+from {{ package.library }}.{{ module_path }} import {{ class_item }} as {{ alias }}
+{%- elif class_item and not alias %}
+from {{ package.library }}.{{ module_path }} import {{ class_item }}
+{%- elif not class_item and not alias %}
+import {{ package.library }}.{{ module_path }}
+{%- endif %}
+{% endfor %}
+{%- if package.doc %}
+"""
+{{ "\n".join(package.doc) }}
+"""
+{%- endif %}
+
+
+VERSION={% if package.version %}"{{ package.version }}"{% else %}{{ package.version }}{% endif %}
+ILI_VERSION="{{ package.ili_version }}"
+
+metadata: dict = {
+    "interlis": {
+        "meta_attributes": {
+            {% for item in package.meta_attributes %}
+                "{{ item.name }}": "{{ item.value }}",
+            {% endfor %}
+        }
+    }
+}
+
+{%- set domain_types=package.type_definitions %}
+{%- include "domain_types.jinja2" %}
+
+{%- set enumerations=package.enumerations %}
+{%- include "enumerations.jinja2" %}
+
+{%- set coord_types=package.coord_types %}
+{%- include "coord_types.jinja2" %}
+{%- if package.line_types  %}
+{%- endif %}
+{%- set line_types=package.line_types %}
+{%- include "line_types.jinja2" %}
+
+{%- set classes=package.classes %}
+{%- include "classes.jinja2" %}

ili2py/writers/py/interlis23/templates/references.jinja2

@@ -0,0 +1,26 @@
+from dataclasses import dataclass, field
+
+@dataclass
+class Ref:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['ili'] }}"
+        name = "REF"
+    ref: str | None = field(default=None, metadata={"type": "Attribute", "name": "REF"})
+
+class BinBlBox(bytes):
+    pass
+
+@dataclass
+class BinBlBoxType:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['ili'] }}"
+    BINBLBOX: BinBlBox = field(
+        metadata={
+            "type": "Element",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+        }
+    )
+
+
+class XmlBlBoxType(str):
+    pass

ili2py/writers/py/interlis23/templates/xtf_opening.jinja2

@@ -0,0 +1,126 @@
+
+{%- for module_path, class_item, alias in library.related_class_imports %}
+{%- if class_item and alias  %}
+from {{ library.name }}.{{ module_path }} import {{ class_item }} as {{ alias }}
+{%- elif class_item and not alias %}
+from {{ library.name }}.{{ module_path }} import {{ class_item }}
+{%- elif not class_item and not alias %}
+import {{ library.name }}.{{ module_path }}
+{%- endif %}
+{%- endfor %}
+from dataclasses import dataclass, field
+
+
+@dataclass
+class DataSection:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['ili'] }}"
+
+    baskets: list[
+        {{library.topic_choices|map(attribute='type_reference')|join('|') }}
+    ] = field(
+        default_factory=list,
+        metadata={
+            "type": "Elements",
+            "choices": (
+            {%- for choice in library.topic_choices %}
+                {
+                    "name": "{{ choice.identifier }}",
+                    "type": {{ choice.type_reference }},
+                    "namespace": "{{ render_config['namespace_map']['ili'] }}",
+                },
+            {%- endfor %}
+            )
+        }
+    )
+    @property
+    def metadata(self) -> dict:
+        return {
+            "interlis": {
+                "oid": "DATASECTION",
+                "kind": None,
+                "meta_attributes": {}
+            }
+        }
+
+
+@dataclass
+class Model:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['ili'] }}"
+
+    name: str | None = field(default=None, metadata={"name": "NAME", "type": "Attribute"})
+    version: str | None = field(default=None, metadata={"name": "VERSION", "type": "Attribute"})
+    uri: str | None = field(default=None, metadata={"name": "URI", "type": "Attribute"})
+
+    @property
+    def metadata(self) -> dict:
+        return {
+            "interlis": {
+                "oid": "MODEL",
+                "kind": None,
+                "meta_attributes": {}
+            }
+        }
+
+
+@dataclass
+class ModelsType:
+    choice: list[Model] = field(
+        default_factory=list,
+        metadata={
+            "type": "Elements",
+            "choices": (
+                {"name": "MODEL", "type": Model, "namespace": "{{ render_config['namespace_map']['ili'] }}"},
+            )
+        }
+    )
+
+
+@dataclass
+class HeaderSection:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['ili'] }}"
+    models: ModelsType = field(
+        metadata={
+            "name": "MODELS",
+            "type": "Element",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}"
+        }
+    )
+    sender: str|None = field(default=None, metadata={"name": "SENDER", "type": "Attribute"})
+    version: str|None = field(default=None, metadata={"name": "VERSION", "type": "Attribute"})
+
+    @property
+    def metadata(self) -> dict:
+        return {
+            "interlis": {
+                "oid": "HEADERSECTION",
+                "kind": None,
+                "meta_attributes": {}
+            }
+        }
+
+
+@dataclass
+class Transfer:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['ili'] }}"
+        name = "TRANSFER"
+
+    headersection: HeaderSection = field(
+        metadata={"name": "HEADERSECTION", "type": "Element", "namespace": "{{ render_config['namespace_map']['ili'] }}"}
+    )
+    datasection: DataSection = field(
+        metadata={"name": "DATASECTION", "type": "Element", "namespace": "{{ render_config['namespace_map']['ili'] }}"}
+    )
+
+    @property
+    def metadata(self) -> dict:
+        return {
+            "interlis": {
+                "oid": "TRANSFER",
+                "kind": None,
+                "meta_attributes": {}
+            }
+        }

ili2py/writers/py/interlis24/templates/classes.jinja2

@@ -0,0 +1,225 @@
+{%- for class_definition in classes %}
+
+@dataclass
+{%- if class_definition.super_class %}
+class {{ class_definition.name }}({{ class_definition.super_class }}):
+{%- elif class_definition.abstract %}
+class {{ class_definition.name }}(ABC):
+{%- else %}
+class {{ class_definition.name }}:
+{%- endif %}
+
+    class Meta:
+        namespace = "{{ render_config['base_url'] }}/{{ package.name }}"
+
+    {%- if class_definition.doc %}
+    """
+    {{ " ".join(class_definition.doc) }}
+    {% if class_definition.attributes %}
+    Args:
+    {%- for attribute in class_definition.attributes %}
+        {{ attribute.name }}: {{ " ".join(attribute.doc) }}
+    {%- endfor %}
+    {%- endif %}
+    """
+    {%- endif -%}
+
+
+{%- for attribute in class_definition.attributes %}
+{%- if attribute.enumeration %}
+    {%- set enumerations=[attribute.enumeration] %}
+    {%- macro render_enumerations() %}{% include "enumerations.jinja2" %}{% endmacro %}
+    {{ render_enumerations() | indent(4, true) }}
+{%- endif %}
+{%- if attribute.line_type %}
+    {%- set line_types=[attribute.line_type] %}
+    {%- macro render_line_types() %}{% include "line_types.jinja2" %}{% endmacro %}
+    {{ render_line_types() | indent(4, true) }}
+{%- endif %}
+{%- if attribute.type_related_type_class %}
+    {%- set classes=[attribute.type_related_type_class] %}
+    {%- macro render_type_related_classes() %}{% include "classes.jinja2" %}{% endmacro %}
+    {{ render_type_related_classes() | indent(4, true) }}
+{%- endif %}
+{%- endfor %}
+{%-if class_definition.oid  %}
+    {{ class_definition.oid.name }}: "{{ class_definition.oid.types|join(' | ') }} | None" = field(
+        default=None,
+        metadata={
+            "type": "Attribute",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            "name": "tid",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": {{ class_definition.oid.type_restrictions }}
+            }
+        }
+    )
+{%- else %}
+{%- if class_definition.kind == 'Class' and not class_definition.oid %}
+    tid: str | None = field(
+        default=None,
+        metadata={
+            "type": "Attribute",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            "name": "tid",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": None
+            }
+        }
+    )
+{%- endif %}
+{%- endif %}
+{% for attribute in class_definition.attributes %}
+    {% if attribute.name not in reserved_python_key_words %}{{ attribute.name }}{% else %}{{ attribute.name }}_{% endif %}: "{% if attribute.is_list_type %}list[{{ attribute.types|join(" | ") }}]{% else %}{{ attribute.types|join(" | ") }} | None{% endif %}" = field(
+        {%- if attribute.is_list_type %}
+        default_factory=list,
+        {%- else %}
+        default=None,
+        {%- endif %}
+        metadata={
+            {%- if attribute.kind == "MVT" %}
+            "type": "Text",
+            {%- else %}
+            "type": "Element",
+            {%- endif %}
+            "namespace": "{{ render_config['base_url'] }}/{{ attribute.namespace_package }}",
+            {%- if attribute.type_restrictions['type_related_type'] %}
+            "name": "{{ attribute.identifier.split('.')[-1] }}",
+            {%- else %}
+            "name": "{{ attribute.name }}",
+            {%- endif %}
+            "interlis": {
+                "oid": "{{ attribute.identifier }}",
+                {%- if attribute.reference_targets %}
+                "reference_targets": {{ attribute.reference_targets }},
+                {%- endif %}
+                "meta_attributes": {
+                    {%- for item in attribute.meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                },
+                "type_restrictions": {{ attribute.type_restrictions }}
+            },
+            "geometric": {
+                "is_geometric": {{ attribute.geometric }},
+                "multi": {{ attribute.geometric_multi }},
+                "point_like": {{ attribute.geometric_is_point_like }},
+                "line_like": {{ attribute.geometric_is_line_like }},
+                "polygon_like": {{ attribute.geometric_is_polygon_like }},
+            }
+        }
+    )
+{%- endfor %}
+
+    @property
+    def metadata(self) -> dict:
+        return {
+            "interlis": {
+                "oid": "{{ class_definition.identifier }}",
+                "kind": "{{ class_definition.kind }}",
+                "meta_attributes": {
+                    {%- for item in class_definition.meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                }
+            }
+        }
+
+    @property
+    def existence_constraints(self) -> list:
+        """
+        Delivers the existence constraints applying to this object.
+
+        Returns:
+            The list of constraints as dict. They can be deserialized with the
+            corresponding classes.
+        """
+        return {{ class_definition['existence_constraints'] }}
+    @property
+    def set_constraints(self) -> list:
+        """
+        Delivers the set constraints applying to this object.
+
+        Returns:
+            The list of constraints as dict. They can be deserialized with the
+            corresponding classes.
+        """
+        return {{ class_definition['set_constraints'] }}
+    @property
+    def simple_constraints(self) -> list:
+        """
+        Delivers the simple constraints applying to this object.
+
+        Returns:
+            The list of constraints as dict. They can be deserialized with the
+            corresponding classes.
+        """
+        return {{ class_definition['simple_constraints'] }}
+    @property
+    def unique_constraints(self) -> list:
+        """
+        Delivers the unique constraints applying to this object.
+
+        Returns:
+            The list of constraints as dict. They can be deserialized with the
+            corresponding classes.
+        """
+        return {{ class_definition['unique_constraints'] }}
+    @property
+    def geom_point_like_attribute_values(self) -> list[Tuple[str, Any]]:
+        """
+        Gives back a list of tuples which contain the name of the attribute and
+        the corresponding value for point like geometries.
+
+        Returns:
+            Tuple, first element is the attribute name, second the geometry value.
+        """
+        return [
+        {%- for attribute in class_definition.geom_point_like_attributes %}
+            ("{{ attribute.name }}", self.{{ attribute.name }}){% if not loop.last %},{% endif %}
+        {%- endfor %}
+        ]
+    @property
+    def geom_line_like_attribute_values(self) -> list[Tuple[str, Any]]:
+        """
+        Gives back a list of tuples which contain the name of the attribute and
+        the corresponding value for line like geometries.
+
+        Returns:
+            Tuple, first element is the attribute name, second the geometry value.
+        """
+        return [
+        {%- for attribute in class_definition.geom_line_like_attributes %}
+            ("{{ attribute.name }}", self.{{ attribute.name }}){% if not loop.last %},{% endif %}
+        {%- endfor %}
+        ]
+    @property
+    def geom_polygon_like_attribute_values(self) -> list[Tuple[str, Any]]:
+        """
+        Gives back a list of tuples which contain the name of the attribute and
+        the corresponding value for polygon like geometries.
+
+        Returns:
+            Tuple, first element is the attribute name, second the geometry value.
+        """
+        return [
+        {%- for attribute in class_definition.geom_polygon_like_attributes %}
+            ("{{ attribute.name }}", self.{{ attribute.name }}){% if not loop.last %},{% endif %}
+        {%- endfor %}
+        ]
+    @property
+    def geom_attributes(self) -> list[str]:
+        """
+        Delivers a list of attributes names which contain geometric information.
+
+        Returns:
+            The list of geometry attribute names. Empty list when no geometry attributes at this class.
+        """
+        return [
+            {% for attr in class_definition.geom_attributes %}
+                "{{ attr.name }}"{% if not loop.last %}, {% endif %}
+            {% endfor %}
+        ]
+{% endfor -%}

ili2py/writers/py/interlis24/templates/convertable_types.jinja2

@@ -0,0 +1,50 @@
+{% for package in library.packages %}
+{%- for definition in package.type_definitions %}
+from {{ library.name }}.{{ package.name }} import {{ definition['name'] }} as {{ package.name }}_{{ definition['name'] }}
+{% endfor %}
+{% endfor %}
+
+
+def get_special_int_types() -> list:
+    return [
+        {%- for package in library.packages %}
+        {%- for definition in package.type_definitions %}
+        {%- if definition["kind"] == "int" %}
+            {{ package.name }}_{{ definition['name'] }},
+        {%- endif %}
+        {%- endfor %}
+        {%- endfor %}
+    ]
+
+
+def get_special_str_types() -> list:
+    return [
+        {%- for package in library.packages %}
+        {%- for definition in package.type_definitions %}
+        {%- if definition["kind"] == "text" %}
+            {{ package.name }}_{{ definition['name'] }},
+        {%- endif %}
+        {%- endfor %}
+        {%- endfor %}
+    ]
+
+
+def get_special_float_types() -> list:
+    return [
+        {%- for package in library.packages %}
+        {%- for definition in package.type_definitions %}
+        {%- if definition["kind"] == "float" %}
+            {{ package.name }}_{{ definition['name'] }},
+        {%- endif %}
+        {%- endfor %}
+        {%- endfor %}
+    ]
+
+def get_contained_model_names() -> list:
+    return [
+    {%- for package in library.packages %}
+    {%- if package.name != "INTERLIS" %}
+    "{{ package.name }}",
+    {%- endif %}
+    {%- endfor %}
+    ]

ili2py/writers/py/interlis24/templates/coord_types.jinja2

@@ -0,0 +1,120 @@
+{%- for coord_type in coord_types %}
+@dataclass
+class {{ coord_type.name }}Type:
+    {% for attribute in coord_type.attributes %}
+    {%- if attribute.reference_system %}
+    # {{ attribute.reference_system }}
+    {%- endif %}
+    {{ attribute.name.lower() }}: "{{ attribute.types|join(' | ') }} | None" = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "namespace": "{{ render_config['namespace_map']['geom'] }}",
+            "interlis": {
+                "meta_attributes": {
+                    {%- for item in attribute.meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                }{%- if attribute.type_restrictions %},
+                "type_restrictions": {{ attribute.type_restrictions }}
+                {%- endif  %}
+            }
+        }
+    )
+    {%- endfor %}
+
+
+@dataclass
+class {{ coord_type.name }}:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['geom'] }}"
+    {%- if coord_type.doc %}
+    """
+    {{ "\n".join(coord_type.doc) }}
+    """
+    {%- endif %}
+    coord: {{ coord_type.name }}Type | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "namespace": "{{ render_config['namespace_map']['geom'] }}",
+            "interlis": {}
+        }
+    )
+    @property
+    def metadata(self) -> dict:
+        return {
+            "interlis": {
+                "oid": "{{ coord_type.identifier }}",
+                "kind": "Enumeration",
+                "meta_attributes": {
+                    {%- for item in coord_type.meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                }
+            }
+        }
+
+
+@dataclass
+class {{ coord_type.name }}ARCType({{ coord_type.name }}Type):
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['geom'] }}"
+    """
+    This is an intermediate class which simplifies parsing of XTF later.
+    """
+    a1: float | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "namespace": "{{ render_config['namespace_map']['geom'] }}",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": {}
+            }
+        }
+    )
+    a2: float | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "namespace": "{{ render_config['namespace_map']['geom'] }}",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": {}
+            }
+        }
+    )
+    r: float | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "namespace": "{{ render_config['namespace_map']['geom'] }}",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": {}
+            }
+        }
+    )
+
+
+@dataclass
+class {{ coord_type.name }}ARC:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['geom'] }}"
+    """
+    This is an intermediate class which simplifies parsing of XTF later.
+    """
+    arc: {{ coord_type.name }}ARCType | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "namespace": "{{ render_config['namespace_map']['geom'] }}",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": {}
+            }
+        }
+    )
+
+{% endfor -%}