interlis2py 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,26 @@
+{%- for definition in domain_types %}
+class {{ definition['name'] }}({{ definition['reference'] }}):
+
+    @property
+    def metadata(self) -> dict:
+        return {
+            "interlis": {
+                "oid": "{{ definition['oid'] }}",
+                "meta_attributes": {},
+                "type_restrictions": {{ definition['restrictions'] }}
+            }
+        }
+
+    @property
+    def existence_constraints(self) -> list:
+        return {{ definition['existence_constraints'] }}
+    @property
+    def set_constraints(self) -> list:
+        return {{ definition['set_constraints'] }}
+    @property
+    def simple_constraints(self) -> list:
+        return {{ definition['simple_constraints'] }}
+    @property
+    def unique_constraints(self) -> list:
+        return {{ definition['unique_constraints'] }}
+{%- endfor %}

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

@@ -0,0 +1,27 @@
+{%- for enumeration in enumerations %}
+class {{ enumeration.name }}(str, Enum):
+    {%- if enumeration.doc %}
+    """
+    {{ "\n".join(enumeration.doc) }}
+    """
+    {%- endif -%}
+{% for value in enumeration.values %}
+    {{ value.upper().replace('.', '_') }} = "{{ value }}"
+{%- endfor %}
+    @property
+    def metadata(self) -> dict:
+        return {
+            "ili2py": {
+
+            },
+            "interlis": {
+                "oid": "{{ enumeration.identifier }}",
+                "kind": "Enumeration",
+                "meta_attributes": {
+                    {%- for item in enumeration.meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                }
+            }
+        }
+{% endfor -%}

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

@@ -0,0 +1,5 @@
+{%- if library.doc %}
+"""
+{{ "\n".join(library.doc) }}
+"""
+{%- endif %}

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

@@ -0,0 +1,31 @@
+
+@dataclass
+class {{ class_name }}:
+    class Meta:
+        namespace = "{{ namespace }}"
+
+    {%- if doc %}
+    """
+    {{ "\n".join(doc) }}
+    """
+    {%- endif %}
+    {%- set namespace=namespace %}
+    {%- set coord_type_name=coord_type_name %}
+    {%- set segment_class_name="Segment" %}
+    {% macro render_line_type_segment() %}{% include "line_type_segment.jinja2" %}{% endmacro %}
+    {{ render_line_type_segment() | indent(4, true) }}
+
+    polyline: {{ segment_class_name }} | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "namespace": "{{ namespace }}",
+            "interlis": {
+                "meta_attributes": {
+                    {%- for item in meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                }
+            }
+        }
+    )

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

@@ -0,0 +1,49 @@
+
+@dataclass
+class {{ class_name }}:
+    class Meta:
+        namespace = "{{ namespace }}"
+
+    {%- if doc %}
+    """
+    {{ "\n".join(doc) }}
+    """
+    {%- endif %}
+    @dataclass
+    class Polylines:
+        class Meta:
+            namespace = "{{ namespace }}"
+
+        {%- set doc=[] %}
+        {%- set coord_type_name=coord_type_name %}
+        {%- set segment_class_name="Segment" %}
+        {% macro render_line_type_segment() %}{% include "line_type_segment.jinja2" %}{% endmacro %}
+        {{ render_line_type_segment() | indent(8, true) }}
+
+        parts: list[{{ segment_class_name }}] = field(
+            default_factory=list,
+            metadata={
+                "type": "Elements",
+                "choices": [{
+                    "type": {{ segment_class_name }},
+                    "name": "surface",
+                    "namespace": "{{ namespace }}"
+                }],
+                "interlis": {}
+            }
+        )
+
+    multipolyline: Polylines = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "namespace": "{{ namespace }}",
+            "interlis": {
+                "meta_attributes": {
+                    {%- for item in meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                }
+            }
+        }
+    )

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

@@ -0,0 +1,27 @@
+
+@dataclass
+class {{ segment_class_name }}:
+    class Meta:
+        namespace = "{{ namespace }}"
+    {%- if coord_type_name == 'Any' %}
+    vertices: "list[{{ coord_type_name }}]" = field(
+    {%- else %}
+    vertices: "list[{{ coord_type_name }}Type | {{ coord_type_name }}ARCType]" = field(
+    {%- endif %}
+        default_factory=list,
+        metadata={
+            "type": "Elements",
+            "choices": ({
+                "name": "coord",
+                "type": {%- if coord_type_name == 'Any' %}Any{% else %}{{ coord_type_name }}Type{% endif %},
+                "namespace": "{{ namespace }}",
+            },{
+                "name": "arc",
+                "type": {%- if coord_type_name == 'Any' %}Any{% else %}{{ coord_type_name }}ARCType{% endif %},
+                "namespace": "{{ namespace }}",
+            } ),
+            "interlis": {
+                "meta_attributes": {}
+            }
+        }
+    )

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

@@ -0,0 +1,31 @@
+{% set surface_class_name=class_name %}
+@dataclass
+class {{ surface_class_name }}:
+    class Meta:
+        namespace = "{{ namespace }}"
+
+    """
+    {%- if doc %}
+    {{ "\n".join(doc) }}
+    {%- endif  %}
+    """
+
+    {%- set doc=[] %}
+    {% set boundary_class_name=class_name + "Boundary" %}
+    {% macro render_line_type_surface_boundary() %}{% include "line_type_surface_boundary.jinja2" %}{% endmacro %}
+    {{ render_line_type_surface_boundary() | indent(4, true) }}
+
+    surface: {{ boundary_class_name }} | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "namespace": "{{ namespace }}",
+            "interlis": {
+                "meta_attributes": {
+                    {%- for item in meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                }
+            }
+        }
+    )

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

@@ -0,0 +1,40 @@
+{% set surface_class_name=class_name %}
+@dataclass
+class {{ boundary_class_name }}:
+    class Meta:
+        namespace = "{{ namespace }}"
+
+    {%- set class_name=surface_class_name + "Polyline" %}
+    {%- set doc=[] %}
+    {% macro render_line_type_polyline() %}{% include "line_type_polyline.jinja2" %}{% endmacro %}
+    {{ render_line_type_polyline() | indent(4, true) }}
+
+
+    @dataclass
+    class {{ surface_class_name }}PolylineInterior({{ class_name }}):
+        pass
+
+
+    @dataclass
+    class {{ surface_class_name }}PolylineExterior({{ class_name }}):
+        pass
+
+
+    boundaries: list[{{ class_name }}] = field(
+        default_factory=list,
+        metadata={
+            "type": "Elements",
+            "choices": ({
+                "type": {{ surface_class_name }}PolylineExterior,
+                "name": "exterior",
+                "namespace": "{{ namespace }}"
+            },{
+                "type": {{ surface_class_name }}PolylineInterior,
+                "name": "interior",
+                "namespace": "{{ namespace }}"
+            }),
+            "interlis": {
+                "meta_attributes": {}
+            }
+        }
+    )

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

@@ -0,0 +1,50 @@
+
+@dataclass
+class {{ class_name }}:
+    class Meta:
+        namespace = "{{ namespace }}"
+
+    {%- if doc %}
+    """
+    {{ "\n".join(doc) }}
+    """
+    {%- endif %}
+
+
+    @dataclass
+    class Surfaces:
+        class Meta:
+            namespace = "{{ namespace }}"
+
+        {%- set doc=[] %}
+        {% set boundary_class_name=class_name + "Boundary" %}
+        {% macro render_line_type_surface_boundary() %}{% include "line_type_surface_boundary.jinja2" %}{% endmacro %}
+        {{ render_line_type_surface_boundary() | indent(8, true) }}
+
+        parts: list[{{ boundary_class_name }}] = field(
+            default_factory=list,
+            metadata={
+                "type": "Elements",
+                "choices": [{
+                    "type": {{ boundary_class_name }},
+                    "name": "surface",
+                    "namespace": "{{ namespace }}"
+                }],
+                "interlis": {}
+            }
+        )
+
+    multisurface: Surfaces = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "namespace": "{{ namespace }}",
+            "interlis": {
+                "meta_attributes": {
+                    {%- for item in meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                }
+            }
+        }
+    )

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

@@ -0,0 +1,41 @@
+{%- for line_type in line_types %}
+{%- set doc=line_type.doc %}
+{%- set class_name=line_type.name %}
+{%- set attribute_name=line_type.attribute.name.lower() %}
+{%- set coord_type_name=line_type.attribute.types[0] %}
+{%- set namespace=render_config['namespace_map']['geom'] %}
+{%- set meta_attributes=line_type.attribute.meta_attributes %}
+{% if attribute_name in ["polyline", "directedpolyline"]  %}
+{% if line_type.multi %}
+{% macro render_line_type_polyline_multi() %}{% include "line_type_polyline_multi.jinja2" %}{% endmacro %}
+{{ render_line_type_polyline_multi() }}
+{% else %}
+{% macro render_line_type_polyline() %}{% include "line_type_polyline.jinja2" %}{% endmacro %}
+{{ render_line_type_polyline() }}
+{% endif %}
+{%- elif attribute_name in ["surface", "area"] %}
+{% if line_type.multi %}
+{% macro render_line_type_surface_multi() %}{% include "line_type_surface_multi.jinja2" %}{% endmacro %}
+{{ render_line_type_surface_multi() }}
+{% else %}
+{% macro render_line_type_surface() %}{% include "line_type_surface.jinja2" %}{% endmacro %}
+{{ render_line_type_surface() }}
+{% endif %}
+{%- endif  %}
+    @property
+    def metadata(self) -> dict:
+        return {
+            "interlis": {
+                "oid": "{{ line_type.identifier }}",
+                "kind": "LineType",
+                "meta_attributes": {
+                    {%- for item in line_type.meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                },
+                "max_overlap": {{ line_type.max_overlap }},
+                "straights": {{ line_type.straights }},
+                "arcs": {{ line_type.arcs }}
+            }
+        }
+{%- endfor %}

ili2py/writers/py/interlis24/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.name }}"
+
+    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.name }}",
+                    "type": {{ choice.type_reference }},
+                    "namespace": "{{ render_config['base_url'] }}/{{ choice.model_name }}",
+                },
+            {%- endfor %}
+            )
+        }
+    )
+    bid: str|None = field(
+        default=None,
+        metadata={
+            "type": "Attribute",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+        },
+    )
+    kind: str|None = field(
+        default=None,
+        metadata={
+            "type": "Attribute",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+        },
+    )
+{% endif %}

ili2py/writers/py/interlis24/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/interlis24/templates/references.jinja2

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

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

@@ -0,0 +1,120 @@
+
+{%- 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.name }}",
+                    "type": {{ choice.type_reference }},
+                    "namespace": "{{ render_config['base_url'] }}/{{ choice.model_name }}",
+                },
+            {%- 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={"type": "Text"})
+    @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={"type": "Element", "namespace": "{{ render_config['namespace_map']['ili'] }}"})
+    version: str | None = field(default=None, metadata={"type": "Element", "namespace": "{{ render_config['namespace_map']['ili'] }}"})
+    comment: str | None = field(default=None, metadata={"type": "Element", "namespace": "{{ render_config['namespace_map']['ili'] }}"})
+    @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={"type": "Element", "namespace": "{{ render_config['namespace_map']['ili'] }}"}
+    )
+    datasection: DataSection = field(
+        metadata={"type": "Element", "namespace": "{{ render_config['namespace_map']['ili'] }}"}
+    )
+    @property
+    def metadata(self) -> dict:
+        return {
+            "interlis": {
+                "oid": "transfer",
+                "kind": None,
+                "meta_attributes": {}
+            }
+        }