interlis2py 0.1.0__py3-none-any.whl

ili2py/mappers/internal/ilismeta16/domain.py

@@ -0,0 +1,29 @@
+def BasketOID(value: str):
+    """
+    Enforces the IlisMeta16.BasketOID Domain definition in the ilismeta16 model.
+
+    Raises:
+        AssertionError when value does not match rules.
+    """
+    assert isinstance(value, str)
+
+
+def MetaElemOID(value: int):
+    """
+    Enforces the IlisMeta16.MetaElemOID Domain definition in the ilismeta16 model.
+
+    Raises:
+        AssertionError when value does not match rules.
+    """
+    assert isinstance(value, str)
+
+
+def LanguageCode(value: str):
+    """
+    Enforces the IlisMeta16.LanguageCode Domain definition in the ilismeta16 model.
+
+    Raises:
+        AssertionError when value does not match rules.
+    """
+    assert isinstance(value, str)
+    assert len(value) <= 5

ili2py/mappers/internal/ilismeta16/model_data/definitions.py

@@ -0,0 +1,401 @@
+from abc import ABC
+from enum import Enum
+from typing import Optional
+
+from ili2py.mappers.internal.ilismeta16.domain import LanguageCode
+from ili2py.mappers.internal.ilismeta16.model_data.domain import Code, LengthRange, MultRange
+
+# MetaElements definition of ilisMeta16.ili
+
+
+class DocText:
+    def __init__(self, text: str, name: str | None = None):
+        self.text = text
+        self.name = name
+
+
+class MetaAttribute:
+    def __init__(self, name: str, value: str, meta_element: Optional["MetaElement"] = None):
+        self.name = name
+        self.value = value
+        self.meta_element = meta_element
+
+
+class MetaElement(ABC):  # noqa: B024 - ABSTRACT in IlisMeta16
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        element_in_package: Optional["Package"] | None = None,
+    ):
+        self.tid = tid
+        self.name = name
+        self.documentation = documentation or []
+        self.meta_attributes = meta_attributes or []
+        # CONTSTRAINT
+        if element_in_package:
+            assert not isinstance(element_in_package, Model)
+        self.element_in_package = element_in_package
+
+
+class ExtendableMe(MetaElement, ABC):
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        abstract: bool,
+        final: bool,
+        generic: bool | None = None,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        element_in_package: Optional["Package"] | None = None,
+        sub: list["ExtendableMe"] | None = None,
+        super_class: Optional["ExtendableMe"] = None,
+    ):
+        super().__init__(
+            tid,
+            name,
+            documentation=documentation,
+            meta_attributes=meta_attributes,
+            element_in_package=element_in_package,
+        )
+        self.abstract = abstract
+        self.final = final
+        self.generic = generic
+        self.sub = sub or []
+        self.super = super_class
+
+
+# Models definition of ilisMeta16.ili
+
+
+class Package(MetaElement, ABC):
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        element_in_package: Optional["Package"] | None = None,
+        imports: list["Package"] | None | None = None,
+    ):
+        super().__init__(
+            tid,
+            name,
+            documentation=documentation,
+            meta_attributes=meta_attributes,
+            element_in_package=element_in_package,
+        )
+        self.imports = imports or []
+
+
+class TidKind(Enum):
+    TID_I16 = "TID_I16"
+    TID_I32 = "TID_I32"
+    TID_ANY = "TID_ANY"
+    TID_EXPLANATION = "TID_EXPLANATION"
+
+
+class Ili1Format:
+    """
+    Structure
+    """
+
+    def __init__(
+        self,
+        is_free: bool,
+        blank_code: int,
+        undefined_code: int,
+        continue_code: int,
+        font: str,
+        tid_kind: TidKind,
+        line_size: int | None = None,
+        tid_size: int | None = None,
+        tid_explantation: str | None = None,
+    ):
+        Code(blank_code)
+        Code(undefined_code)
+        Code(continue_code)
+        if line_size is not None:
+            LengthRange(line_size)
+        if tid_size is not None:
+            LengthRange(tid_size)
+        self.is_free = is_free
+        self.blank_code = blank_code
+        self.undefined_code = undefined_code
+        self.continue_code = continue_code
+        self.font = font
+        self.tid_kind = tid_kind
+        self.line_size = line_size
+        self.tid_size = tid_size
+        self.tid_explantation = tid_explantation
+
+
+class ModelKind(Enum):
+    NORMALM = "NormalM"
+    TYPEM = "TypeM"
+    REFSYSTEMM = "RefSystemM"
+    SYMBOLOGYM = "SymbologyM"
+
+
+class Model(Package):
+    """
+    Represents an INTERLIS Model
+    """
+
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        ili_version: str,
+        kind: ModelKind,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        element_in_package: Optional["Package"] | None = None,
+        contracted: bool | None = None,
+        language: str | None = None,
+        at: str | None = None,
+        version: str | None = None,
+        no_incremental_transfer: bool | None = None,
+        char_set_iana_name: str | None = None,
+        xmlns: str | None = None,
+        ili1_transfer_name: str | None = None,
+        ili1_format: Ili1Format | None = None,
+    ):
+        if language is not None:
+            LanguageCode(language)
+        super().__init__(
+            tid,
+            name,
+            documentation=documentation,
+            meta_attributes=meta_attributes,
+            element_in_package=element_in_package,
+        )
+        self.ili_version = ili_version
+        self.kind = kind
+        self.contracted = contracted
+        self.language = language
+        self.at = at
+        self.version = version
+        self.no_incremental_transfer = no_incremental_transfer
+        self.char_set_iana_name = char_set_iana_name
+        self.xmlns = xmlns
+        self.ili1_transfer = ili1_transfer_name
+        self.ili1_format = ili1_format
+
+
+class SubModel(Package):
+    """
+    Represents an INTERLIS Topic
+    """
+
+
+class Type(ExtendableMe, ABC):
+    pass
+
+
+class Expression(ABC):  # noqa: B024 - ABSTRACT in IlisMeta16
+    pass
+
+
+class Multiplicity:
+    def __init__(self, minimum: int, maximum: int | None = None):
+        MultRange(minimum)
+        if maximum is not None:
+            MultRange(maximum)
+        self.minimum = minimum
+        self.maximum = maximum
+
+
+class Constraint(MetaElement, ABC):
+    pass
+
+
+class DomainType(Type, ABC):
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        abstract: bool,
+        final: bool,
+        mandatory: bool,
+        generic: bool | None = None,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        element_in_package: Package | None | None = None,
+        sub: list[ExtendableMe] | None = None,
+        super_class: ExtendableMe | None = None,
+        constraints: list[Constraint] | None = None,
+    ):
+        super().__init__(
+            tid,
+            name,
+            abstract,
+            final,
+            generic,
+            documentation=documentation,
+            meta_attributes=meta_attributes,
+            element_in_package=element_in_package,
+            sub=sub,
+            super_class=super_class,
+        )
+        self.mandatory = mandatory
+        # association DomainConstraint
+        self.constraints = constraints or []
+
+
+# Classes definition of ilisMeta16.ili
+
+
+class ClassKind(Enum):
+    STRUCTURE = "Structure"
+    CLASS = "Class"
+    VIEW = "View"
+    ASSOCIATION = "Association"
+
+
+class Class(Type):
+    def __init__(
+        self,
+        kind: ClassKind,
+        embedded_role_transfer: bool,
+        attributes: list["AttrOrParam"] | None = None,
+        parameters: list["AttrOrParam"] | None = None,
+        multiplicity: Multiplicity | None = None,
+        ili1_optional_table: bool | None = None,
+        constraints: list[Constraint] | None = None,
+    ):
+        self.kind = kind
+        self.embedded_role_transfer = embedded_role_transfer
+        self.attributes = attributes or []
+        self.parameters = parameters or []
+        # enforce ilismeta16
+        if self.kind == ClassKind.ASSOCIATION:
+            assert multiplicity is not None
+        self.multiplicity = multiplicity
+        self.ili1_optional_table = ili1_optional_table
+        self.constraints = constraints or []
+
+
+class SubdivisionKind(Enum):
+    NOSUBDIV = "NoSubDiv"
+    SUBDIV = "SubDiv"
+    CONTSUBDIV = "ContSubDiv"
+
+
+class AttrOrParam(ExtendableMe):
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        abstract: bool,
+        final: bool,
+        subdivision_kind: SubdivisionKind,
+        attr_type: Type,
+        generic: bool | None = None,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        sub: list["ExtendableMe"] | None = None,
+        super_class: Optional["ExtendableMe"] = None,
+        transient: bool | None = None,
+        derivates: list[Expression] | None = None,
+        local_type: list[Type] | None = None,
+    ):
+        super().__init__(
+            tid,
+            name,
+            abstract,
+            final,
+            generic,
+            documentation=documentation,
+            meta_attributes=meta_attributes,
+            sub=sub,
+            super_class=super_class,
+        )
+        self.subdivision_kind = subdivision_kind
+        self.transient = transient
+        self.derivates = derivates or []
+        self.local_type = local_type or []
+        self.type = attr_type
+
+
+# Types related to other types of ilisMeta16.ili
+
+
+class TypeRelatedType(DomainType, ABC):
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        abstract: bool,
+        final: bool,
+        mandatory: bool,
+        base_type: Type,
+        generic: bool | None = None,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        element_in_package: Package | None | None = None,
+        sub: list[ExtendableMe] | None = None,
+        super_class: ExtendableMe | None = None,
+        type_restrictions: list[Type] | None = None,
+    ):
+        super().__init__(
+            tid,
+            name,
+            abstract,
+            final,
+            mandatory,
+            generic=generic,
+            documentation=documentation,
+            meta_attributes=meta_attributes,
+            element_in_package=element_in_package,
+            sub=sub,
+            super_class=super_class,
+        )
+        self.base_type = base_type
+        # TODO: How to implement external reference? aka what does that mean actually in this
+        #  context? Just, that it can be from another model?
+        self.type_restrictions = type_restrictions or []
+
+
+# Bag type of ilisMeta16.ili
+
+
+class MultiValue(TypeRelatedType):
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        abstract: bool,
+        final: bool,
+        mandatory: bool,
+        base_type: Type,
+        ordered: bool,
+        generic: bool | None = None,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        element_in_package: Package | None | None = None,
+        sub: list[ExtendableMe] | None = None,
+        super_class: ExtendableMe | None = None,
+        type_restrictions: list[Type] | None = None,
+        multiplicity: Multiplicity | None = None,
+    ):
+        super().__init__(
+            tid,
+            name,
+            abstract,
+            final,
+            mandatory,
+            base_type,
+            generic=generic,
+            documentation=documentation,
+            meta_attributes=meta_attributes,
+            element_in_package=element_in_package,
+            sub=sub,
+            super_class=super_class,
+            type_restrictions=type_restrictions,
+        )
+        self.ordered = ordered
+        self.multiplicity = multiplicity

ili2py/mappers/internal/ilismeta16/model_data/domain.py

@@ -0,0 +1,31 @@
+def Code(value: int):
+    """
+    Enforces the IlisMeta16.ModelData.Code Domain definition in the ilismeta16 model.
+
+    Raises:
+        AssertionError when value does not match rules.
+    """
+    assert isinstance(value, int)
+    assert 0 <= value <= 255
+
+
+def MultRange(value: int):
+    """
+    Enforces the IlisMeta16.ModelData.MultRange Domain definition in the ilismeta16 model.
+
+    Raises:
+        AssertionError when value does not match rules.
+    """
+    assert isinstance(value, int)
+    assert 0 <= value <= 2147483647
+
+
+def LengthRange(value: int):
+    """
+    Enforces the IlisMeta16.ModelData.LengthRange Domain definition in the ilismeta16 model.
+
+    Raises:
+        AssertionError when value does not match rules.
+    """
+    assert isinstance(value, int)
+    assert 1 <= value <= 2147483647

ili2py/mappers/internal/ilismeta16/model_data/types.py

@@ -0,0 +1,94 @@
+from enum import Enum
+
+from ili2py.mappers.internal.ilismeta16.model_data.definitions import (
+    DocText,
+    DomainType,
+    ExtendableMe,
+    MetaAttribute,
+    Package,
+)
+from ili2py.mappers.internal.ilismeta16.model_data.domain import LengthRange
+from ili2py.mappers.internal.ilismeta16.model_data.units import Unit
+
+
+class TextTypeKind(Enum):
+    MTEXT = "MText"
+    TEXT = "Text"
+    NAME = "Name"
+    URI = "URI"
+
+
+class TextType(DomainType):
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        abstract: bool,
+        final: bool,
+        mandatory: bool,
+        kind: TextTypeKind,
+        generic: bool | None = None,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        element_in_package: Package | None | None = None,
+        sub: list[ExtendableMe] | None = None,
+        super_class: ExtendableMe | None = None,
+        max_length: int | None = None,
+    ):
+        if max_length is not None:
+            LengthRange(max_length)
+        super().__init__(
+            tid,
+            name,
+            abstract,
+            final,
+            mandatory,
+            generic,
+            documentation=documentation,
+            meta_attributes=meta_attributes,
+            element_in_package=element_in_package,
+            sub=sub,
+            super_class=super_class,
+        )
+        self.kind = kind
+        self.max_length = max_length
+
+
+class NumType(DomainType):
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        abstract: bool,
+        final: bool,
+        mandatory: bool,
+        generic: bool | None = None,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        element_in_package: Package | None | None = None,
+        sub: list[ExtendableMe] | None = None,
+        super_class: ExtendableMe | None = None,
+        min: str | None = None,
+        max: str | None = None,
+        circular: bool | None = None,
+        clockwise: bool | None = None,
+        unit: Unit | None | None = None,
+    ):
+        super().__init__(
+            tid,
+            name,
+            abstract,
+            final,
+            mandatory,
+            generic,
+            documentation=documentation,
+            meta_attributes=meta_attributes,
+            element_in_package=element_in_package,
+            sub=sub,
+            super_class=super_class,
+        )
+        self.min = min
+        self.max = max
+        self.circular = circular
+        self.clockwise = clockwise
+        self.unit = unit

ili2py/mappers/internal/ilismeta16/model_data/units.py

@@ -0,0 +1,49 @@
+from enum import Enum
+from typing import Optional
+
+from ili2py.mappers.internal.ilismeta16.model_data.definitions import (
+    DocText,
+    Expression,
+    ExtendableMe,
+    MetaAttribute,
+)
+
+
+class UnitKind(Enum):
+    BASEU = "BaseU"
+    DERIVEDU = "DerivedU"
+    COMPOSEDU = "ComposedU"
+
+
+class Unit(ExtendableMe):
+    def __init__(
+        self,
+        tid: str,
+        name: str,
+        abstract: bool,
+        final: bool,
+        kind: UnitKind,
+        generic: bool | None = None,
+        documentation: list[DocText] | None = None,
+        meta_attributes: list[MetaAttribute] | None = None,
+        sub: list["ExtendableMe"] | None = None,
+        super_class: Optional["ExtendableMe"] = None,
+        definition: Expression | None = None,
+    ):
+        super().__init__(
+            tid,
+            name,
+            abstract,
+            final,
+            generic,
+            documentation=documentation,
+            meta_attributes=meta_attributes,
+            sub=sub,
+            super_class=super_class,
+        )
+        self.kind = kind
+        self.definition = definition
+        self.constraint()
+
+    def constraint(self):
+        assert self.kind != UnitKind.BASEU and self.definition is not None

ili2py/readers/interlis_23/xtf/xsdata.py

@@ -0,0 +1,38 @@
+from typing import IO, AnyStr
+
+from xsdata.formats.dataclass.parsers import XmlParser
+from xsdata.formats.dataclass.parsers.config import ParserConfig
+
+from ili2py.interfaces.interlis.interlis_23 import TRANSFER
+from ili2py.interfaces.interlis.interlis_23.generator import DataClassGenerator
+from ili2py.interfaces.interlis.interlis_24.ilismeta16 import ImdTransfer
+
+
+class Reader:
+    def __init__(
+        self,
+        meta_model: ImdTransfer,
+        fail_on_unknown_properties: bool = False,
+        namespace_map: dict | None = None,
+    ):
+        self.parser = XmlParser()
+        self.parser.config = ParserConfig()
+        self.parser.config.fail_on_unknown_properties = fail_on_unknown_properties
+        self.namespace_map = namespace_map or {}
+        self.parser.ns_map = self.namespace_map
+        self.meta_model = meta_model
+
+    def read(self, input_xtf: str | IO[AnyStr]):
+        """
+        Parses an XTF XML file into the dataclass objects for further usage.
+
+        Args:
+            input_xtf: The path or the file object to read the imd16 from
+        """
+        # we preparse the XTF to find out what model we are handling
+        pre_xtf = self.parser.parse(input_xtf, TRANSFER)
+        xtf_data = {}
+        for model in pre_xtf.HEADERSECTION.MODELS:
+            generated_dataclasses = DataClassGenerator(self.meta_model).generate(model.NAME)
+            xtf_data[model.NAME] = self.parser.parse(input_xtf, generated_dataclasses)
+        return xtf_data

ili2py/readers/interlis_24/ilismeta16/xsdata.py

@@ -0,0 +1,40 @@
+from abc import ABC
+from typing import IO, AnyStr, ClassVar
+
+from xsdata.formats.dataclass.parsers import XmlParser
+from xsdata.formats.dataclass.parsers.config import ParserConfig
+
+from ili2py.interfaces.interlis.interlis_24.ilismeta16 import ImdTransfer
+
+
+class Reader(ABC):  # noqa: B024 - subclasses set _reader_class
+    _reader_class: ClassVar[type[ImdTransfer]]
+
+    def __init__(
+        self,
+        fail_on_unknown_properties: bool = False,
+        fail_on_unknown_attributes: bool = False,
+        namespace_map: dict | None = None,
+    ):
+        self.parser_config = ParserConfig(
+            fail_on_unknown_properties=fail_on_unknown_properties,
+            fail_on_unknown_attributes=fail_on_unknown_attributes,
+        )
+        self.parser = XmlParser(self.parser_config)
+        self.namespace_map = namespace_map or {}
+        self.parser.ns_map = self.namespace_map
+
+    def read(self, input_xtf: str | IO[AnyStr] | bytes) -> ImdTransfer:
+        """
+        Parses an IMD16 XML file into the dataclass objects for further usage.
+
+        Args:
+            input_xtf: The path or the file object to read the imd16 from
+        Returns:
+            The tree of IMD16 definitions.
+        """
+        return self.parser.parse(input_xtf, self._reader_class)
+
+
+class Imd16Reader(Reader):
+    _reader_class = ImdTransfer