interlis2py 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,218 @@
+{%- 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:
+        name = "{{ class_definition.identifier }}"
+        namespace = "{{ render_config['namespace_map']['ili'] }}"
+
+    {%- 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",
+            "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",
+            "name": "TID",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": None
+            }
+        }
+    )
+{%- endif %}
+{%- endif %}
+{% for attribute in class_definition.attributes %}
+    {{ attribute.name }}: "{% 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={
+            "type": "Element",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            {%- if attribute.type_restrictions['type_related_type'] %}
+            "name": "{{ attribute.identifier.replace('ili2py.', '') }}",
+            {%- 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/interlis23/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/interlis23/templates/coord_types.jinja2

@@ -0,0 +1,126 @@
+{%- 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",
+            "name": "{{ attribute.name }}",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            "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']['ili'] }}"
+    {%- if coord_type.doc %}
+    """
+    {{ "\n".join(coord_type.doc) }}
+    """
+    {%- endif %}
+    coord: {{ coord_type.name }}Type | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "name": "COORD",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            "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']['ili'] }}"
+    """
+    This is an intermediate class which simplifies parsing of XTF later.
+    """
+    a1: float | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "name": "A1",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": {}
+            }
+        }
+    )
+    a2: float | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "name": "A2",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": {}
+            }
+        }
+    )
+    r: float | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "name": "R",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": {}
+            }
+        }
+    )
+
+
+@dataclass
+class {{ coord_type.name }}ARC:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['ili'] }}"
+    """
+    This is an intermediate class which simplifies parsing of XTF later.
+    """
+    arc: {{ coord_type.name }}ARCType | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "name": "ARC",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            "interlis": {
+                "meta_attributes": {},
+                "type_restrictions": {}
+            }
+        }
+    )
+
+{% endfor -%}

ili2py/writers/py/interlis23/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/interlis23/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/interlis23/templates/library_init.jinja2

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

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

@@ -0,0 +1,162 @@
+{%- for line_type in line_types %}
+@dataclass
+{%- if line_type.attribute.name in ["POLYLINE", "DIRECTEDPOLYLINE"]  %}
+class {{ line_type.name }}:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['ili'] }}"
+
+    {%- if line_type.doc %}
+    """
+    {{ "\n".join(line_type.doc) }}
+    """
+    {%- endif %}
+    @dataclass
+    class Segment:
+        class Meta:
+            namespace = "{{ render_config['namespace_map']['ili'] }}"
+        {%- if line_type.attribute.types[0] == 'Any' %}
+        vertices: "list[{{ line_type.attribute.types[0] }}]" = field(
+        {%- else %}
+        vertices: "list[{{ line_type.attribute.types[0] }}Type | {{ line_type.attribute.types[0] }}ARCType]" = field(
+        {%- endif %}
+            default_factory=list,
+            metadata={
+                "type": "Elements",
+                "choices": ({
+                    "name": "COORD",
+                    "type": {%- if line_type.attribute.types[0] == 'Any' %}Any{% else %}{{ line_type.attribute.types[0] }}Type{% endif %},
+                    "namespace": "{{ render_config['namespace_map']['ili'] }}",
+                },{
+                    "name": "ARC",
+                    "type": {%- if line_type.attribute.types[0] == 'Any' %}Any{% else %}{{ line_type.attribute.types[0] }}ARCType{% endif %},
+                    "namespace": "{{ render_config['namespace_map']['ili'] }}",
+                } ),
+                "interlis": {
+                    "meta_attributes": {
+
+                    }
+                }
+            }
+        )
+    polyline: Segment | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "name": "POLYLINE",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            "interlis": {
+                "meta_attributes": {
+                    {%- for item in line_type.attribute.meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                }
+            }
+        }
+    )
+{%- elif line_type.attribute.name in ["SURFACE", "AREA"] %}
+class {{ line_type.name }}:
+    class Meta:
+        namespace = "{{ render_config['namespace_map']['ili'] }}"
+
+    """
+    {%- if line_type.doc %}
+    {{ "\n".join(line_type.doc) }}
+    {%- endif  %}
+    """
+
+    @dataclass
+    class {{ line_type.name }}BOUNDARY:
+        class Meta:
+            namespace = "{{ render_config['namespace_map']['ili'] }}"
+            name = "SURFACE"
+
+        @dataclass
+        class {{ line_type.name }}POLYLINE:
+            class Meta:
+                namespace = "{{ render_config['namespace_map']['ili'] }}"
+
+            @dataclass
+            class Segment:
+                class Meta:
+                    namespace = "{{ render_config['namespace_map']['ili'] }}"
+
+                vertices: "list[{{ line_type.attribute.types[0] }}Type | {{ line_type.attribute.types[0] }}ARCType]" = field(
+                    default_factory=list,
+                    metadata={
+                        "type": "Elements",
+                        "choices": ({
+                            "name": "COORD",
+                            "type": {{ line_type.attribute.types[0] }}Type,
+                            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+                        },{
+                            "name": "ARC",
+                            "type": {{ line_type.attribute.types[0] }}ARCType,
+                            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+                        } ),
+                        "interlis": {
+                            "meta_attributes": {
+
+                            }
+                        }
+                    }
+                )
+            polyline: Segment | None = field(
+                default=None,
+                metadata={
+                    "type": "Element",
+                    "name": "POLYLINE",
+                    "namespace": "{{ render_config['namespace_map']['ili'] }}",
+                    "interlis": {"meta_attributes": {}},
+                },
+            )
+
+        boundaries: list[{{ line_type.name }}POLYLINE] = field(
+            default_factory=list,
+            metadata={
+                "type": "Elements",
+                "choices": ({
+                    "type": {{ line_type.name }}POLYLINE,
+                    "name": "BOUNDARY",
+                    "namespace": "{{ render_config['namespace_map']['ili'] }}"
+                },),
+                "interlis": {
+                    "meta_attributes": {
+
+                    }
+                }
+            }
+        )
+
+    surface: {{ line_type.name }}BOUNDARY | None = field(
+        default=None,
+        metadata={
+            "type": "Element",
+            "name": "SURFACE",
+            "namespace": "{{ render_config['namespace_map']['ili'] }}",
+            "interlis": {
+                "meta_attributes": {
+                    {%- for item in line_type.attribute.meta_attributes %}
+                        "{{ item.name }}": "{{ item.value }}",
+                    {%- endfor %}
+                }
+            }
+        }
+    )
+{%- 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 %}