interlis2py 0.1.0__py3-none-any.whl

ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/extendable_me.py

@@ -0,0 +1,102 @@
+from dataclasses import dataclass, field
+from enum import StrEnum, auto
+
+from ili2py.interfaces.interlis.interlis_24.ilismeta16 import imd_namespace_map
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.extendable_me.type.expression.expression import (  # noqa: E501
+    Expression,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.meta_element import (
+    MetaElement,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.references import (
+    OrderedRef,
+    Ref,
+)
+
+
+@dataclass(kw_only=True)
+class ExtendableMe(MetaElement):
+    Abstract: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+    Final: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    Super_ref: Ref | None = field(
+        default=None,
+        metadata={"name": "Super", "namespace": imd_namespace_map["IlisMeta16"]},
+    )
+    # Only available in interlis model_data since 2.4
+    # TODO: Find way to create class according to the parsed version in imd
+    Generic: bool | None = field(
+        default=None,
+        metadata={"namespace": imd_namespace_map["IlisMeta16"]},
+    )
+    # TODO: implement association Inheritance super/Subclass
+
+
+@dataclass
+class Unit(ExtendableMe):
+    class KindEnum(StrEnum):
+        BaseU = auto()
+        DerivedU = auto()
+        ComposedU = auto()
+
+    Kind: KindEnum = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+    # TODO: MANDATORY CONSTRAINT ((Kind != #BaseU) == DEFINED(Definition));
+    # TODO: Fix this, currently this fails while parsing the XML...
+    # Definition: Optional[List[Union[CompoundExprElement,UnitFunctionElement]]] = None
+
+
+@dataclass
+class DataUnit(ExtendableMe):
+    name = "BASKET"
+    ViewUnit: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+    DataUnitName: str = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+    # TODO: Implement ASSOCIATION Dependency
+    # TODO: Implement ASSOCIATION AllowedInBasket
+
+
+@dataclass
+class AttrOrParam(ExtendableMe):
+    class SubdivisionKindEnum(StrEnum):
+        NoSubDiv = auto()
+        SubDiv = auto()
+        ContSubDiv = auto()
+
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    Type_ref: Ref = field(
+        metadata={"name": "Type", "namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    SubdivisionKind: SubdivisionKindEnum | None = None
+    Transient: bool | None = None
+    Derivates: list[Expression] | None = field(
+        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    AttrParent_ref: OrderedRef | None = field(
+        default=None,
+        metadata={"name": "AttrParent", "namespace": imd_namespace_map["IlisMeta16"]},
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    ParamParent_ref: OrderedRef | None = field(
+        default=None,
+        metadata={"name": "ParamParent", "namespace": imd_namespace_map["IlisMeta16"]},
+    )
+
+
+@dataclass
+class EnumNode(ExtendableMe):
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    EnumType_ref: OrderedRef | None = field(
+        default=None,
+        metadata={"name": "EnumType", "namespace": imd_namespace_map["IlisMeta16"]},
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    ParentNode_ref: OrderedRef | None = field(
+        default=None,
+        metadata={"name": "ParentNode", "namespace": imd_namespace_map["IlisMeta16"]},
+    )

ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/class_related_type/class_related_type.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass, field
+
+from ili2py.interfaces.interlis.interlis_24.ilismeta16 import imd_namespace_map
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.extendable_me.type.domain_type.domain_type import (  # noqa: E501
+    DomainType,
+)
+
+
+@dataclass
+class ClassRelatedType(DomainType):
+    pass
+
+
+@dataclass
+class ReferenceType(ClassRelatedType):
+    External: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+
+
+@dataclass
+class ObjectType(ClassRelatedType):
+    Multiple: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+
+
+@dataclass
+class ClassRefType(ClassRelatedType):
+    pass

ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/class_related_type/role.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass, field
+from enum import StrEnum, auto
+from typing import Optional
+
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.extendable_me.type.domain_type.class_related_type.class_related_type import (  # noqa: E501
+    ReferenceType,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.references import OrderedRef
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.serialization_elements import (  # noqa: E501
+    MultiplicityElement,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.shared import imd_namespace_map
+
+
+@dataclass
+class Role(ReferenceType):
+    class StrongnessEnum(StrEnum):
+        Assoc = auto()
+        Aggr = auto()
+        Comp = auto()
+
+    @dataclass
+    class _Multiplicity:
+        Multiplicity: MultiplicityElement | None = field(
+            default=None,
+            metadata={
+                "namespace": imd_namespace_map["IlisMeta16"],
+            },
+        )
+
+    Strongness: StrongnessEnum = field(
+        metadata={
+            "namespace": imd_namespace_map["IlisMeta16"],
+        }
+    )
+    Ordered: bool = field(
+        metadata={
+            "namespace": imd_namespace_map["IlisMeta16"],
+        }
+    )
+    EmbeddedTransfer: bool = field(
+        metadata={
+            "namespace": imd_namespace_map["IlisMeta16"],
+        }
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    Association_ref: OrderedRef = field(
+        metadata={"name": "Association", "namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    Multiplicity: Optional["Role._Multiplicity"] = field(
+        default=None,
+        metadata={
+            "namespace": imd_namespace_map["IlisMeta16"],
+        },
+    )

ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py

@@ -0,0 +1,171 @@
+from dataclasses import dataclass, field
+from enum import StrEnum, auto
+from typing import Optional
+
+from ili2py.interfaces.interlis.interlis_24.ilismeta16 import imd_namespace_map
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.extendable_me.type.type_class import (  # noqa: E501
+    Type,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.references import (
+    HasRef,
+    OrderedRef,
+    Ref,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.serialization_elements import (  # noqa: E501
+    MultiplicityElement,
+)
+
+
+@dataclass(kw_only=True)
+class DomainType(Type):
+    Mandatory: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+
+
+@dataclass
+class BlackboxType(DomainType):
+    class KindEnum(StrEnum):
+        Binary = auto()
+        Xml = auto()
+
+    Kind: KindEnum = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+
+
+@dataclass
+class CoordType(DomainType):
+    NullAxis: int | None = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    PiHalfAxis: int | None = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    # Only available in interlis model_data since 2.4
+    Multi: bool | None = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+
+
+@dataclass
+class AxisSpec(HasRef):
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    CoordType_ref: Ref = field(
+        metadata={"name": "CoordType", "namespace": imd_namespace_map["IlisMeta16"]},
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    Axis_ref: OrderedRef = field(
+        metadata={"name": "Axis", "namespace": imd_namespace_map["IlisMeta16"]},
+    )
+
+
+@dataclass
+class LineType(DomainType):
+    class KindEnum(StrEnum):
+        Polyline = auto()
+        DirectedPolyline = auto()
+        Area = auto()
+
+    Kind: KindEnum = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+    # This is originally a string type in ilisMeta16.ili, but all actually
+    #  occuring values are floats, so we assume that this was done to
+    #  prevent limits of float definition in interlis 0.00 .. 1.00 since
+    #  we need a simple arbitrary float value. Thats why we cast the value to
+    #  float here silently
+    MaxOverlap: float | None = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    Multi: bool | None = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    CoordType_ref: Ref | None = field(
+        default=None,
+        metadata={"name": "CoordType", "namespace": imd_namespace_map["IlisMeta16"]},
+    )
+
+
+@dataclass
+class TypeRelatedType(DomainType, HasRef):
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    BaseType_ref: Ref = field(
+        metadata={"name": "BaseType", "namespace": imd_namespace_map["IlisMeta16"]},
+    )
+
+
+@dataclass
+class TextType(DomainType):
+    class KindEnum(StrEnum):
+        MText = auto()
+        Text = auto()
+        Name = auto()
+        Uri = auto()
+
+    Kind: KindEnum = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+
+    MaxLength: int | None = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+
+
+@dataclass(kw_only=True)
+class NumType(DomainType, HasRef):
+    Min: str | None = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    Max: str | None = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    Circular: bool | None = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    Clockwise: bool | None = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    Unit_ref: Ref | None = field(
+        default=None, metadata={"name": "Unit", "namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    # TODO: Implement RefSys attribute as association (called NumsRefSys in
+    # https://models.interlis.ch/core/IlisMeta16.ili)
+
+
+@dataclass(kw_only=True)
+class FormattedType(NumType):
+    Format: str = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    Struct_ref: Ref = field(
+        metadata={"name": "Struct", "namespace": imd_namespace_map["IlisMeta16"]}
+    )
+
+
+@dataclass
+class BooleanType(DomainType):
+    pass
+
+
+@dataclass
+class EnumType(DomainType):
+    class OrderEnum(StrEnum):
+        Unordered = auto()
+        Ordered = auto()
+        Circular = auto()
+
+    Order: OrderEnum = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+
+
+@dataclass
+class MultiValue(TypeRelatedType):
+    @dataclass
+    class _Multiplicity:
+        Multiplicity: MultiplicityElement | None = field(
+            default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+        )
+
+    Ordered: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+    Multiplicity: Optional["MultiValue._Multiplicity"] = field(
+        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
+    )

ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/expression.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass, field
+from enum import StrEnum, auto
+
+from ili2py.interfaces.interlis.interlis_24.ilismeta16 import imd_namespace_map
+
+
+@dataclass(kw_only=True)
+class Expression:
+    pass
+
+
+@dataclass
+class UnaryExpr(Expression):
+    class OperationEnum(StrEnum):
+        Not = auto()
+        Defined = auto()
+
+    Operation: OperationEnum = field(
+        metadata={
+            "namespace": imd_namespace_map["IlisMeta16"],
+        }
+    )
+    SubExpressions: list[Expression] = field(
+        metadata={
+            "namespace": imd_namespace_map["IlisMeta16"],
+        }
+    )
+
+
+@dataclass
+class CompoundExpr(Expression):
+    class OperationEnum(StrEnum):
+        Implication = "Implication"  # 2.4!
+        And = "And"
+        Or = "Or"
+        Mult = "Mult"
+        Div = "Div"
+        Relation_Equal = "Relation.Equal"
+        Relation_NotEqual = "Relation.NotEqual"
+        Relation_LessOrEqual = "Relation.LessOrEqual"
+        Relation_GreaterOrEqual = "Relation.GreaterOrEqual"
+        Relation_Less = "Relation.Less"
+        Relation_Greater = "Relation.Greater"
+
+    Operation: OperationEnum | None = field(
+        default=None,
+        metadata={
+            "namespace": imd_namespace_map["IlisMeta16"],
+        },
+    )
+    # TODO: Fix this, currently this fails while parsing the XML...
+    # SubExpressions: List[Union[Constant, PathOrInspFactor]]

ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/factor/factor.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass, field
+from enum import StrEnum
+
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.extendable_me.type.expression.expression import (  # noqa: E501
+    Expression,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.path_elements import (
+    PathElsElement,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.references import Ref
+
+
+@dataclass(kw_only=True)
+class Factor(Expression):
+    pass
+
+
+@dataclass
+class PathOrInspFactor(Factor):
+    PathEls: PathElsElement
+
+
+@dataclass
+class Constant(Factor):
+    class TypeKind(StrEnum):
+        Undefined = "Undefined"
+        Numeric = "Numeric"
+        Text = "Text"
+        Enumeration = "Enumeration"
+
+    Value: str
+    Type: TypeKind
+
+
+@dataclass
+class UnitRef(Factor):
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    Unit_ref: Ref = field(
+        metadata={"name": "Unit"},
+    )
+
+
+@dataclass
+class UnitFunction(Factor):
+    Explanation: str

ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/type_class.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass, field
+from enum import StrEnum, auto
+from typing import Optional
+
+from ili2py.interfaces.interlis.interlis_24.ilismeta16 import imd_namespace_map
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.extendable_me.extendable_me import (  # noqa: E501
+    ExtendableMe,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.references import HasRef, Ref
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.serialization_elements import (  # noqa: E501
+    MultiplicityElement,
+)
+
+
+@dataclass(kw_only=True)
+class Type(ExtendableMe):
+    LTParent_ref: Ref | None = field(
+        default=None,
+        metadata={"name": "LTParent", "namespace": imd_namespace_map["IlisMeta16"]},
+    )
+
+
+@dataclass
+class Class(Type):
+    class KindEnum(StrEnum):
+        Structure = auto()
+        Class = auto()
+        View = auto()
+        Association = auto()
+
+    @dataclass
+    class _Multiplicity:
+        multiplicity: MultiplicityElement | None = field(
+            default=None,
+            metadata={"name": "LTParent", "namespace": imd_namespace_map["IlisMeta16"]},
+        )
+
+    Kind: KindEnum = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+    EmbeddedRoleTransfer: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
+    ili1OptionalTable: bool | None = field(
+        default=None,
+        metadata={
+            "type": "Attribute",
+            "namespace": imd_namespace_map["IlisMeta16"],
+        },
+    )
+    Multiplicity: Optional["Class._Multiplicity"] = field(
+        default=None,
+        metadata={
+            "type": "Attribute",
+            "namespace": imd_namespace_map["IlisMeta16"],
+        },
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    Oid_ref: Ref | None = field(
+        default=None, metadata={"name": "Oid", "namespace": imd_namespace_map["IlisMeta16"]}
+    )
+
+    # TODO: implement ASSOCIATION ClassConstraint
+    # TODO: implement ASSOCIATION ClassAttr
+    # TODO: implement ASSOCIATION ClassParam
+    # TODO: implement ASSOCIATION BaseClass
+
+
+@dataclass
+class BaseClass(HasRef):
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    CRT_ref: Ref = field(
+        metadata={"name": "CRT", "namespace": imd_namespace_map["IlisMeta16"]}
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    BaseClass_ref: Ref = field(
+        metadata={"name": "BaseClass", "namespace": imd_namespace_map["IlisMeta16"]}
+    )

ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/line_form.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass, field
+
+from ili2py.interfaces.interlis.interlis_24.ilismeta16 import imd_namespace_map
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.meta_element import (
+    MetaElement,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.references import HasRef, Ref
+
+
+@dataclass
+class LineForm(MetaElement):
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    Structure_ref: Ref | None = field(
+        metadata={
+            "name": "Structure",
+            "namespace": imd_namespace_map["IlisMeta16"],
+        }
+    )
+
+
+@dataclass
+class LinesForm(HasRef):
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    LineType_ref: Ref = field(
+        metadata={
+            "name": "LineType",
+            "namespace": imd_namespace_map["IlisMeta16"],
+        }
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    LineForm_ref: Ref = field(
+        metadata={
+            "name": "LineForm",
+            "namespace": imd_namespace_map["IlisMeta16"],
+        }
+    )

ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/meta_element.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass, field
+
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.abstract_element import (
+    AbstractElement,
+    DocTextElement,
+    MetaAttributeElement,
+)
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.model_data.references import HasRef, Ref
+from ili2py.interfaces.interlis.interlis_24.ilismeta16.shared import imd_namespace_map
+
+
+@dataclass(kw_only=True)
+class MetaElement(HasRef, AbstractElement):
+    Name: str = field(
+        metadata={
+            "namespace": imd_namespace_map["IlisMeta16"],
+        }
+    )
+    tid: str = field(metadata={"type": "Attribute", "namespace": imd_namespace_map["ili"]})
+    Documentation: list["MetaElement._Documentation"] | None = field(
+        default_factory=list,
+        metadata={
+            "namespace": imd_namespace_map["IlisMeta16"],
+        },
+    )
+    MetaAttribute: list[MetaAttributeElement] | None = field(
+        default_factory=list,
+        metadata={
+            "namespace": imd_namespace_map["IlisMeta16"],
+        },
+    )
+    # use the metadata.name to fetch the element from XML but store it
+    #   as `*_ref` instance variable to resolve soft reference to actual object
+    ElementInPackage_ref: Ref | None = field(
+        default=None,
+        metadata={"name": "ElementInPackage"},
+    )
+
+    @dataclass
+    class _Documentation:
+        DocText: DocTextElement = field(
+            metadata={
+                "name": "DocText",
+                "type": "Element",
+                "namespace": imd_namespace_map["IlisMeta16"],
+            },
+        )