Skip to content

DataSection dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/__init__.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
@dataclass(kw_only=True)
class DataSection:

    ModelData: list["Imd_ModelData"] = field(
        default_factory=list,
        metadata={
            "type": "Elements",
            "choices": (
                {
                    "name": "ModelData",
                    "type": Imd_ModelData,
                    "namespace": imd_namespace_map["IlisMeta16"],
                },
            ),
        },
    )
    ModelTranslation: list["Imd_ModelTranslation"] = field(
        default_factory=list,
        metadata={
            "type": "Elements",
            "choices": (
                {
                    "name": "ModelTranslation",
                    "type": Imd_ModelTranslation,
                    "namespace": imd_namespace_map["IlisMeta16"],
                },
            ),
        },
    )

ModelData = field(default_factory=list, metadata={'type': 'Elements', 'choices': ({'name': 'ModelData', 'type': Imd_ModelData, 'namespace': imd_namespace_map['IlisMeta16']})}) class-attribute instance-attribute

ModelTranslation = field(default_factory=list, metadata={'type': 'Elements', 'choices': ({'name': 'ModelTranslation', 'type': Imd_ModelTranslation, 'namespace': imd_namespace_map['IlisMeta16']})}) class-attribute instance-attribute

__init__(*, ModelData=list(), ModelTranslation=list())

ImdTransfer dataclass

Bases: Transfer

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/__init__.py 
44
45
46
47
@dataclass(kw_only=True)
class ImdTransfer(Transfer):

    datasection: DataSection = field(metadata={"namespace": imd_namespace_map["ili"]})

datasection = field(metadata={'namespace': imd_namespace_map['ili']}) class-attribute instance-attribute

__init__(headersection, *, datasection)

helper

index_modeldata(transfer)

Little helper method to perform the indexing of the metamodel information in an easy-to-use one dimensional tree. Args: transfer: The full metamodel tree of dataclass objects which should be indexed.

Returns: The index containing the already resolved references between the dataclass objects.

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/helper.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
def index_modeldata(transfer: ImdTransfer) -> dict:
    """
    Little helper method to perform the indexing of the metamodel information in an
    easy-to-use one dimensional tree.
    Args:
        transfer: The full metamodel tree of dataclass objects which should be indexed.

    Returns: The index containing the already resolved references between the dataclass objects.
    """

    index = {}
    for item in transfer.datasection.ModelData:
        unwrap_tree(item, index)

    resolve_references(index)
    return index

resolve_references(index)

Little helper method to resolve references in the index based on the REF elements.

Parameters:

Name Type Description Default
index dict

The index with all the elements identifiable by their unique key.

 required
Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/helper.py 
34
35
36
37
38
39
40
41
42
43
def resolve_references(index: dict):
    """
    Little helper method to resolve references in the index based on the REF elements.

    Args:
        index: The index with all the elements identifiable by their unique key.
    """
    for key in index:
        if isinstance(index[key], HasRef):
            index[key].resolve_refs(index)

unwrap_tree(element, index)

A little helper method to assemble a one dimensional index with the elements unique identifiers tid as the key.

Parameters:

Name Type Description Default
index dict

the dictionary which should be filled with the elements.

 required
Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/helper.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
def unwrap_tree(element: object, index: dict):
    """
    A little helper method to assemble a one dimensional index with the elements unique
    identifiers *tid* as the key.

    Args:
        index: the dictionary which should be filled with the elements.
    """
    if hasattr(element, "__annotations__"):
        if hasattr(element, "tid"):
            # the element has already a unique identifier. we can use this in the index
            if element.tid in index:
                raise LookupError(f"Element {element.tid} was already in tree. Thats not allowed!")
        else:
            # the element does not have a unique idendtifier (usually relations) we will set up a runtime
            # one to make linking possible
            setattr(element, "tid", f"{element.__class__.__name__}.{str(uuid4())}")
        index[element.tid] = element
        for attribute in element.__annotations__:
            member = element.__getattribute__(attribute)
            if isinstance(member, list):
                for item in member:
                    unwrap_tree(item, index)
            else:
                unwrap_tree(member, index)

model_data

abstract_element

AbstractElement dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/abstract_element.py 
 9
10
11
@dataclass
class AbstractElement:
    pass
__init__()

DocTextElement dataclass

Bases: AbstractElement

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/abstract_element.py 
52
53
54
55
56
57
58
59
60
61
62
63
64
65
@dataclass
class DocTextElement(AbstractElement):

    Text: str = field(
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    Name: Optional[str] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
Name = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Text = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(Text, Name=None)

Ili1FormatElement dataclass

Bases: AbstractElement

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/abstract_element.py 
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
@dataclass
class Ili1FormatElement(AbstractElement):

    class TidKind(StrEnum):
        TID_I16 = auto()
        TID_I32 = auto()
        TID_ANY = auto()
        TID_EXPLANATION = auto()

    isFree: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
    blankCode: int = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
    undefinedCode: int = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
    continueCode: int = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
    Font: str = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
    tidKind: TidKind = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
    LineSize: Optional[int] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    tidSize: Optional[int] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    tidExplanation: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
Font = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
LineSize = field(default=None, metadata={'type': 'Attribute', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
blankCode = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
continueCode = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
isFree = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
tidExplanation = field(default=None, metadata={'type': 'Attribute', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
tidKind = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
tidSize = field(default=None, metadata={'type': 'Attribute', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
undefinedCode = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
TidKind

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/abstract_element.py 
17
18
19
20
21
class TidKind(StrEnum):
    TID_I16 = auto()
    TID_I32 = auto()
    TID_ANY = auto()
    TID_EXPLANATION = auto()
TID_ANY = auto() class-attribute instance-attribute
TID_EXPLANATION = auto() class-attribute instance-attribute
TID_I16 = auto() class-attribute instance-attribute
TID_I32 = auto() class-attribute instance-attribute
__init__(isFree, blankCode, undefinedCode, continueCode, Font, tidKind, LineSize=None, tidSize=None, tidExplanation=None)

MetaAttributeElement dataclass

Bases: HasRef, AbstractElement

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/abstract_element.py 
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
@dataclass
class MetaAttributeElement(HasRef, AbstractElement):

    Name: str = field(
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    Value: str = field(
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    tid: str = field(metadata={"type": "Attribute", "namespace": imd_namespace_map["ili"]})
    # use the metadata.name to fetch the element from XML but store it
    #   as `*_ref` instance variable to resolve soft reference to actual object
    MetaElement_ref: Ref = field(
        metadata={
            "name": "MetaElement",
            "namespace": imd_namespace_map["IlisMeta16"],
        }
    )
MetaElement_ref = field(metadata={'name': 'MetaElement', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Name = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Value = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
tid = field(metadata={'type': 'Attribute', 'namespace': imd_namespace_map['ili']}) class-attribute instance-attribute
__init__(Name, Value, tid, MetaElement_ref)

constraints

Constraint dataclass

Bases: MetaElement

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/constraints.py 
13
14
15
16
17
18
19
20
21
22
@dataclass
class Constraint(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
    ToClass_ref: Ref = field(
        metadata={
            "name": "ToClass",
            "namespace": imd_namespace_map["IlisMeta16"],
        }
    )
ToClass_ref = field(metadata={'name': 'ToClass', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(ToClass_ref, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None)

SimpleConstraint dataclass

Bases: Constraint

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/constraints.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@dataclass
class SimpleConstraint(Constraint):
    class KindEnum(StrEnum):
        MandC = auto()
        LowPercC = auto()
        HighPercC = auto()

    Kind: KindEnum = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    LogicalExpression: CompoundExprElement = field(
        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    Percentage: Optional[float] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
Kind = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
LogicalExpression = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Percentage = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
KindEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/constraints.py 
27
28
29
30
class KindEnum(StrEnum):
    MandC = auto()
    LowPercC = auto()
    HighPercC = auto()
HighPercC = auto() class-attribute instance-attribute
LowPercC = auto() class-attribute instance-attribute
MandC = auto() class-attribute instance-attribute
__init__(ToClass_ref, Kind=None, LogicalExpression=None, Percentage=None, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None)

extendable_me

extendable_me

AttrOrParam dataclass

Bases: ExtendableMe

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/extendable_me.py 
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
@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
    Transient: Optional[bool] = None
    Derivates: Optional[List[Expression]] = 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: Optional[OrderedRef] = 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: Optional[OrderedRef] = field(
        default=None,
        metadata={"name": "ParamParent", "namespace": imd_namespace_map["IlisMeta16"]},
    )
AttrParent_ref = field(default=None, metadata={'name': 'AttrParent', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Derivates = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
ParamParent_ref = field(default=None, metadata={'name': 'ParamParent', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
SubdivisionKind = None class-attribute instance-attribute
Transient = None class-attribute instance-attribute
Type_ref = field(metadata={'name': 'Type', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
SubdivisionKindEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/extendable_me.py 
59
60
61
62
class SubdivisionKindEnum(StrEnum):
    NoSubDiv = auto()
    SubDiv = auto()
    ContSubDiv = auto()
ContSubDiv = auto() class-attribute instance-attribute
NoSubDiv = auto() class-attribute instance-attribute
SubDiv = auto() class-attribute instance-attribute
__init__(Type_ref, SubdivisionKind=None, Transient=None, Derivates=list(), AttrParent_ref=None, ParamParent_ref=None, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None)
DataUnit dataclass

Bases: ExtendableMe

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/extendable_me.py 
47
48
49
50
51
@dataclass
class DataUnit(ExtendableMe):
    name = "BASKET"
    ViewUnit: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
    DataUnitName: str = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
DataUnitName = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
ViewUnit = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
name = 'BASKET' class-attribute instance-attribute
__init__(ViewUnit, DataUnitName, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None)
EnumNode dataclass

Bases: ExtendableMe

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/extendable_me.py 
86
87
88
89
90
91
92
93
94
95
96
97
98
@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: Optional[OrderedRef] = 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: Optional[OrderedRef] = field(
        default=None, metadata={"name": "ParentNode", "namespace": imd_namespace_map["IlisMeta16"]}
    )
EnumType_ref = field(default=None, metadata={'name': 'EnumType', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
ParentNode_ref = field(default=None, metadata={'name': 'ParentNode', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(EnumType_ref=None, ParentNode_ref=None, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None)
ExtendableMe dataclass

Bases: MetaElement

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/extendable_me.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@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: Optional[Ref] = 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 = field(
        default=None,
        metadata={"namespace": imd_namespace_map["IlisMeta16"]},
    )
Abstract = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Final = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Generic = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Super_ref = field(default=None, metadata={'name': 'Super', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None)
Unit dataclass

Bases: ExtendableMe

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/extendable_me.py 
33
34
35
36
37
38
39
40
41
@dataclass
class Unit(ExtendableMe):

    class KindEnum(StrEnum):
        BaseU = auto()
        DerivedU = auto()
        ComposedU = auto()

    Kind: KindEnum = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
Kind = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
KindEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/extendable_me.py 
36
37
38
39
class KindEnum(StrEnum):
    BaseU = auto()
    DerivedU = auto()
    ComposedU = auto()
BaseU = auto() class-attribute instance-attribute
ComposedU = auto() class-attribute instance-attribute
DerivedU = auto() class-attribute instance-attribute
__init__(Kind, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None)

type

domain_type
class_related_type
ClassRefType dataclass

Bases: ClassRelatedType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/class_related_type/class_related_type.py 
24
25
26
@dataclass
class ClassRefType(ClassRelatedType):
    pass
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
ClassRelatedType dataclass

Bases: DomainType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/class_related_type/class_related_type.py 
 9
10
11
@dataclass
class ClassRelatedType(DomainType):
    pass
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
ObjectType dataclass

Bases: ClassRelatedType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/class_related_type/class_related_type.py 
19
20
21
@dataclass
class ObjectType(ClassRelatedType):
    Multiple: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
Multiple = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(Multiple, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
ReferenceType dataclass

Bases: ClassRelatedType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/class_related_type/class_related_type.py 
14
15
16
@dataclass
class ReferenceType(ClassRelatedType):
    External: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
External = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(External, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
role
Role dataclass

Bases: ReferenceType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/class_related_type/role.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
@dataclass
class Role(ReferenceType):

    class StrongnessEnum(StrEnum):
        Assoc = auto()
        Aggr = auto()
        Comp = auto()

    @dataclass
    class _Multiplicity:
        Multiplicity: Optional[MultiplicityElement] = 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"],
        },
    )
Association_ref = field(metadata={'name': 'Association', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
EmbeddedTransfer = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Multiplicity = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Ordered = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Strongness = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
StrongnessEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/class_related_type/role.py 
18
19
20
21
class StrongnessEnum(StrEnum):
    Assoc = auto()
    Aggr = auto()
    Comp = auto()
Aggr = auto() class-attribute instance-attribute
Assoc = auto() class-attribute instance-attribute
Comp = auto() class-attribute instance-attribute
_Multiplicity dataclass
Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/class_related_type/role.py 
23
24
25
26
27
28
29
30
@dataclass
class _Multiplicity:
    Multiplicity: Optional[MultiplicityElement] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
Multiplicity = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(Multiplicity=None)
__init__(External, Strongness, Ordered, EmbeddedTransfer, Association_ref, Multiplicity=None, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
domain_type
AxisSpec dataclass

Bases: HasRef

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
48
49
50
51
52
53
54
55
56
57
58
59
@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"]},
    )
Axis_ref = field(metadata={'name': 'Axis', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
CoordType_ref = field(metadata={'name': 'CoordType', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(CoordType_ref, Axis_ref)
BlackboxType dataclass

Bases: DomainType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
24
25
26
27
28
29
30
@dataclass
class BlackboxType(DomainType):
    class KindEnum(StrEnum):
        Binary = auto()
        Xml = auto()

    Kind: KindEnum = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
Kind = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
KindEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
26
27
28
class KindEnum(StrEnum):
    Binary = auto()
    Xml = auto()
Binary = auto() class-attribute instance-attribute
Xml = auto() class-attribute instance-attribute
__init__(Kind, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
BooleanType dataclass

Bases: DomainType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
146
147
148
@dataclass
class BooleanType(DomainType):
    pass
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
CoordType dataclass

Bases: DomainType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
@dataclass
class CoordType(DomainType):

    NullAxis: Optional[int] = field(
        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    PiHalfAxis: Optional[int] = field(
        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    # Only available in interlis model_data since 2.4
    Multi: Optional[bool] = field(
        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
Multi = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
NullAxis = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
PiHalfAxis = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(NullAxis=None, PiHalfAxis=None, Multi=None, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
DomainType dataclass

Bases: Type

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
19
20
21
@dataclass(kw_only=True)
class DomainType(Type):
    Mandatory: bool = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
Mandatory = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
EnumType dataclass

Bases: DomainType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
151
152
153
154
155
156
157
158
159
@dataclass
class EnumType(DomainType):

    class OrderEnum(StrEnum):
        Unordered = auto()
        Ordered = auto()
        Circular = auto()

    Order: OrderEnum = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
Order = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
OrderEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
154
155
156
157
class OrderEnum(StrEnum):
    Unordered = auto()
    Ordered = auto()
    Circular = auto()
Circular = auto() class-attribute instance-attribute
Ordered = auto() class-attribute instance-attribute
Unordered = auto() class-attribute instance-attribute
__init__(Order, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
FormattedType dataclass

Bases: NumType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
135
136
137
138
139
140
141
142
143
@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"]}
    )
Format = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Struct_ref = field(metadata={'name': 'Struct', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory, Min=None, Max=None, Circular=None, Clockwise=None, Unit_ref=None, Format, Struct_ref)
LineType dataclass

Bases: DomainType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
@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: Optional[float] = field(
        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    Multi: Optional[bool] = 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: Optional[Ref] = field(
        default=None,
        metadata={"name": "CoordType", "namespace": imd_namespace_map["IlisMeta16"]},
    )
CoordType_ref = field(default=None, metadata={'name': 'CoordType', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Kind = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
MaxOverlap = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Multi = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
KindEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
64
65
66
67
class KindEnum(StrEnum):
    Polyline = auto()
    DirectedPolyline = auto()
    Area = auto()
Area = auto() class-attribute instance-attribute
DirectedPolyline = auto() class-attribute instance-attribute
Polyline = auto() class-attribute instance-attribute
__init__(Kind, MaxOverlap=None, Multi=None, CoordType_ref=None, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
MultiValue dataclass

Bases: TypeRelatedType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
@dataclass
class MultiValue(TypeRelatedType):

    @dataclass
    class _Multiplicity:
        Multiplicity: MultiplicityElement = 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"]}
    )
Multiplicity = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Ordered = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
_Multiplicity dataclass
Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
165
166
167
168
169
@dataclass
class _Multiplicity:
    Multiplicity: MultiplicityElement = field(
        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
Multiplicity = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(Multiplicity=None)
__init__(BaseType_ref, Ordered, Multiplicity=None, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
NumType dataclass

Bases: DomainType, HasRef

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
@dataclass(kw_only=True)
class NumType(DomainType, HasRef):
    Min: Optional[str] = field(
        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    Max: Optional[str] = field(
        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    Circular: Optional[bool] = field(
        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    Clockwise: Optional[bool] = 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: Optional[Ref] = field(
        default=None, metadata={"name": "Unit", "namespace": imd_namespace_map["IlisMeta16"]}
    )
Circular = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Clockwise = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Max = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Min = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Unit_ref = field(default=None, metadata={'name': 'Unit', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory, Min=None, Max=None, Circular=None, Clockwise=None, Unit_ref=None)
TextType dataclass

Bases: DomainType

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
 98
 99
100
101
102
103
104
105
106
107
108
109
110
@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: Optional[int] = field(
        default=None, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
Kind = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
MaxLength = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
KindEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
100
101
102
103
104
class KindEnum(StrEnum):
    MText = auto()
    Text = auto()
    Name = auto()
    Uri = auto()
MText = auto() class-attribute instance-attribute
Name = auto() class-attribute instance-attribute
Text = auto() class-attribute instance-attribute
Uri = auto() class-attribute instance-attribute
__init__(Kind, MaxLength=None, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
TypeRelatedType dataclass

Bases: DomainType, HasRef

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/domain_type/domain_type.py 
89
90
91
92
93
94
95
@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"]},
    )
BaseType_ref = field(metadata={'name': 'BaseType', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(BaseType_ref, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None, Mandatory)
expression
expression
CompoundExpr dataclass

Bases: Expression

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/expression.py 
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
@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: Optional[OperationEnum] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
Operation = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
OperationEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/expression.py 
33
34
35
36
37
38
39
40
41
42
43
44
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"
And = 'And' class-attribute instance-attribute
Div = 'Div' class-attribute instance-attribute
Implication = 'Implication' class-attribute instance-attribute
Mult = 'Mult' class-attribute instance-attribute
Or = 'Or' class-attribute instance-attribute
Relation_Equal = 'Relation.Equal' class-attribute instance-attribute
Relation_Greater = 'Relation.Greater' class-attribute instance-attribute
Relation_GreaterOrEqual = 'Relation.GreaterOrEqual' class-attribute instance-attribute
Relation_Less = 'Relation.Less' class-attribute instance-attribute
Relation_LessOrEqual = 'Relation.LessOrEqual' class-attribute instance-attribute
Relation_NotEqual = 'Relation.NotEqual' class-attribute instance-attribute
__init__(Operation=None)
Expression dataclass
Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/expression.py 
 8
 9
10
@dataclass(kw_only=True)
class Expression:
    pass
__init__()
UnaryExpr dataclass

Bases: Expression

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/expression.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@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"],
        }
    )
Operation = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
SubExpressions = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
OperationEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/expression.py 
15
16
17
class OperationEnum(StrEnum):
    Not = auto()
    Defined = auto()
Defined = auto() class-attribute instance-attribute
Not = auto() class-attribute instance-attribute
__init__(Operation, SubExpressions)
factor
factor
Constant dataclass

Bases: Factor

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/factor/factor.py 
24
25
26
27
28
29
30
31
32
33
@dataclass
class Constant(Factor):
    class TypeKind(StrEnum):
        Undefined = "Undefined"
        Numeric = "Numeric"
        Text = "Text"
        Enumeration = "Enumeration"

    Value: str
    Type: TypeKind
Type instance-attribute
Value instance-attribute
TypeKind

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/factor/factor.py 
26
27
28
29
30
class TypeKind(StrEnum):
    Undefined = "Undefined"
    Numeric = "Numeric"
    Text = "Text"
    Enumeration = "Enumeration"
Enumeration = 'Enumeration' class-attribute instance-attribute
Numeric = 'Numeric' class-attribute instance-attribute
Text = 'Text' class-attribute instance-attribute
Undefined = 'Undefined' class-attribute instance-attribute
__init__(Value, Type)
Factor dataclass

Bases: Expression

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/factor/factor.py 
13
14
15
@dataclass(kw_only=True)
class Factor(Expression):
    pass
__init__()
PathOrInspFactor dataclass

Bases: Factor

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/factor/factor.py 
18
19
20
21
@dataclass
class PathOrInspFactor(Factor):

    PathEls: PathElsElement
PathEls instance-attribute
__init__(PathEls)
UnitFunction dataclass

Bases: Factor

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/factor/factor.py 
45
46
47
48
@dataclass
class UnitFunction(Factor):

    Explanation: str
Explanation instance-attribute
__init__(Explanation)
UnitRef dataclass

Bases: Factor

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/expression/factor/factor.py 
36
37
38
39
40
41
42
@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"},
    )
Unit_ref = field(metadata={'name': 'Unit'}) class-attribute instance-attribute
__init__(Unit_ref)
type_class
BaseClass dataclass

Bases: HasRef

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/type_class.py 
67
68
69
70
71
72
73
74
75
76
77
@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"]}
    )
BaseClass_ref = field(metadata={'name': 'BaseClass', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
CRT_ref = field(metadata={'name': 'CRT', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(CRT_ref, BaseClass_ref)
Class dataclass

Bases: Type

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/type_class.py 
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
@dataclass
class Class(Type):

    class KindEnum(StrEnum):
        Structure = auto()
        Class = auto()
        View = auto()
        Association = auto()

    @dataclass
    class _Multiplicity:
        multiplicity: Optional[MultiplicityElement] = 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: Optional[bool] = 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: Optional[Ref] = field(
        default=None, metadata={"name": "Oid", "namespace": imd_namespace_map["IlisMeta16"]}
    )
EmbeddedRoleTransfer = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Kind = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Multiplicity = field(default=None, metadata={'type': 'Attribute', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Oid_ref = field(default=None, metadata={'name': 'Oid', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
ili1OptionalTable = field(default=None, metadata={'type': 'Attribute', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
KindEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/type_class.py 
26
27
28
29
30
class KindEnum(StrEnum):
    Structure = auto()
    Class = auto()
    View = auto()
    Association = auto()
Association = auto() class-attribute instance-attribute
Class = auto() class-attribute instance-attribute
Structure = auto() class-attribute instance-attribute
View = auto() class-attribute instance-attribute
_Multiplicity dataclass
Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/type_class.py 
32
33
34
35
36
37
@dataclass
class _Multiplicity:
    multiplicity: Optional[MultiplicityElement] = field(
        default=None,
        metadata={"name": "LTParent", "namespace": imd_namespace_map["IlisMeta16"]},
    )
multiplicity = field(default=None, metadata={'name': 'LTParent', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(multiplicity=None)
__init__(Kind, EmbeddedRoleTransfer, ili1OptionalTable=None, Multiplicity=None, Oid_ref=None, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None)
Type dataclass

Bases: ExtendableMe

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/extendable_me/type/type_class.py 
15
16
17
18
19
20
@dataclass(kw_only=True)
class Type(ExtendableMe):
    LTParent_ref: Optional[Ref] = field(
        default=None,
        metadata={"name": "LTParent", "namespace": imd_namespace_map["IlisMeta16"]},
    )
LTParent_ref = field(default=None, metadata={'name': 'LTParent', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None, Abstract, Final, Super_ref=None, Generic=None, LTParent_ref=None)

line_form

LineForm dataclass

Bases: MetaElement

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/line_form.py 
 9
10
11
12
13
14
15
16
17
18
@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: Optional[Ref] = field(
        metadata={
            "name": "Structure",
            "namespace": imd_namespace_map["IlisMeta16"],
        }
    )
Structure_ref = field(metadata={'name': 'Structure', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(Structure_ref, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None)

LinesForm dataclass

Bases: HasRef

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/line_form.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
@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"],
        }
    )
LineForm_ref = field(metadata={'name': 'LineForm', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
LineType_ref = field(metadata={'name': 'LineType', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(LineType_ref, LineForm_ref)

meta_element

MetaElement dataclass

Bases: HasRef, AbstractElement

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/meta_element.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@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: Optional[List["MetaElement._Documentation"]] = field(
        default_factory=list,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    MetaAttribute: Optional[List[MetaAttributeElement]] = 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: Optional[Ref] = field(
        default=None,
        metadata={"name": "ElementInPackage"},
    )

    @dataclass
    class _Documentation:
        DocText: DocTextElement = field(
            metadata={
                "name": "DocText",
                "type": "Element",
                "namespace": imd_namespace_map["IlisMeta16"],
            },
        )
Documentation = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
ElementInPackage_ref = field(default=None, metadata={'name': 'ElementInPackage'}) class-attribute instance-attribute
MetaAttribute = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Name = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
tid = field(metadata={'type': 'Attribute', 'namespace': imd_namespace_map['ili']}) class-attribute instance-attribute
_Documentation dataclass
Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/meta_element.py 
42
43
44
45
46
47
48
49
50
@dataclass
class _Documentation:
    DocText: DocTextElement = field(
        metadata={
            "name": "DocText",
            "type": "Element",
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
DocText = field(metadata={'name': 'DocText', 'type': 'Element', 'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(DocText)
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None)

model_data

ModelDataType dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/model_data.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
@dataclass
class ModelDataType:

    bid: str = field(metadata={"type": "Attribute", "namespace": imd_namespace_map["ili"]})
    Model: "Model" = field(metadata={"namespace": imd_namespace_map["IlisMeta16"]})
    # TODO: Keep an eye on requested list length (as of meta model docs list of sub_model has to
    #  be at least 1)
    SubModel: List["SubModel"] = field(default_factory=list)
    DataUnit: List["DataUnit"] = None
    MetaAttribute: Optional[List[MetaAttributeElement]] = field(default_factory=list)
    consistency: Optional[str] = field(
        default=None,
        metadata={
            "type": "Attribute",
            "namespace": imd_namespace_map["ili"],
        },
    )
    Class: Optional[List["Class"]] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    AttrOrParam: List["AttrOrParam"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    TextType: Optional[List["TextType"]] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    EnumNode: List["EnumNode"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    EnumType: List["EnumType"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    NumType: Optional[List["NumType"]] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    AxisSpec: List["AxisSpec"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    CoordType: List["CoordType"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    BaseClass: List["BaseClass"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    ObjectType: List["ObjectType"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    ClassRefType: List["ClassRefType"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    MultiValue: Optional[List["MultiValue"]] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    BooleanType: List["BooleanType"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    FormattedType: List["FormattedType"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    LinesForm: List["LinesForm"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    LineType: List["LineType"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    LineForm: List["LineForm"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    Role: List["Role"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    SimpleConstraint: List["SimpleConstraint"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    ReferenceType: List["ReferenceType"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    BlackboxType: Optional[List["BlackboxType"]] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
    Unit: List["Unit"] = field(
        default_factory=list, metadata={"namespace": imd_namespace_map["IlisMeta16"]}
    )
AttrOrParam = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
AxisSpec = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
BaseClass = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
BlackboxType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
BooleanType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Class = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
ClassRefType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
CoordType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
DataUnit = None class-attribute instance-attribute
EnumNode = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
EnumType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
FormattedType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
LineForm = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
LineType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
LinesForm = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
MetaAttribute = field(default_factory=list) class-attribute instance-attribute
Model = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
MultiValue = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
NumType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
ObjectType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
ReferenceType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Role = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
SimpleConstraint = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
SubModel = field(default_factory=list) class-attribute instance-attribute
TextType = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Unit = field(default_factory=list, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
bid = field(metadata={'type': 'Attribute', 'namespace': imd_namespace_map['ili']}) class-attribute instance-attribute
consistency = field(default=None, metadata={'type': 'Attribute', 'namespace': imd_namespace_map['ili']}) class-attribute instance-attribute
__init__(bid, Model, SubModel=list(), DataUnit=None, MetaAttribute=list(), consistency=None, Class=list(), AttrOrParam=list(), TextType=list(), EnumNode=list(), EnumType=list(), NumType=list(), AxisSpec=list(), CoordType=list(), BaseClass=list(), ObjectType=list(), ClassRefType=list(), MultiValue=list(), BooleanType=list(), FormattedType=list(), LinesForm=list(), LineType=list(), LineForm=list(), Role=list(), SimpleConstraint=list(), ReferenceType=list(), BlackboxType=list(), Unit=list())

package

package

Model dataclass

Bases: Package

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/package/package.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
@dataclass
class Model(Package):
    class KindEnum(StrEnum):
        NormalM = auto()
        TypeM = auto()
        RefSystemM = auto()
        SymbologyM = auto()

    iliVersion: str = field(
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        }
    )
    Kind: KindEnum = field(
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        }
    )
    Contracted: Optional[bool] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    Language: Optional[str] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    At: Optional[str] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    Version: Optional[str] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    NoIncrementalTransfer: Optional[bool] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    CharSetIANAName: Optional[str] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    xmlns: Optional[str] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    ili1Transfername: Optional[str] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    ili1Format: Optional["Model._Ili1Format"] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )

    @dataclass
    class _Ili1Format:
        Ili1Format: Optional[Ili1FormatElement] = None
At = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
CharSetIANAName = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Contracted = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Kind = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Language = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
NoIncrementalTransfer = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Version = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
ili1Format = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
ili1Transfername = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
iliVersion = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
xmlns = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
KindEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/package/package.py 
19
20
21
22
23
class KindEnum(StrEnum):
    NormalM = auto()
    TypeM = auto()
    RefSystemM = auto()
    SymbologyM = auto()
NormalM = auto() class-attribute instance-attribute
RefSystemM = auto() class-attribute instance-attribute
SymbologyM = auto() class-attribute instance-attribute
TypeM = auto() class-attribute instance-attribute
_Ili1Format dataclass
Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/package/package.py 
90
91
92
@dataclass
class _Ili1Format:
    Ili1Format: Optional[Ili1FormatElement] = None
Ili1Format = None class-attribute instance-attribute
__init__(Ili1Format=None)
__init__(iliVersion, Kind, Contracted=None, Language=None, At=None, Version=None, NoIncrementalTransfer=None, CharSetIANAName=None, xmlns=None, ili1Transfername=None, ili1Format=None, *, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None)
Package dataclass

Bases: MetaElement

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/package/package.py 
12
13
14
@dataclass(kw_only=True)
class Package(MetaElement):
    pass
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None)
SubModel dataclass

Bases: Package

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/package/package.py 
95
96
97
@dataclass
class SubModel(Package):
    pass
__init__(*, Name, tid, Documentation=list(), MetaAttribute=list(), ElementInPackage_ref=None)

path_elements

PathElElement dataclass

Bases: HasRef

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/path_elements.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@dataclass
class PathElElement(HasRef):
    # TODO: MANDATORY CONSTRAINT (Kind >= #ReferenceAttr) == DEFINED(Ref);
    class KindEnum(StrEnum):
        This = auto()
        ThisArea = auto()
        ThatArea = auto()
        Parent = auto()
        ReferenceAttr = auto()
        AssocPath = auto()
        Role = auto()
        ViewBase = auto()
        Attribute = auto()
        MetaObject = auto()

    Kind: KindEnum
    NumIndex: Optional[int] = None
    # use the metadata.name to fetch the element from XML but store it
    #   as `*_ref` instance variable to resolve soft reference to actual object
    Ref_ref: Optional[Ref] = field(
        default=None,
        metadata={"name": "Ref"},
    )
Kind instance-attribute
NumIndex = None class-attribute instance-attribute
Ref_ref = field(default=None, metadata={'name': 'Ref'}) class-attribute instance-attribute
KindEnum

Bases: StrEnum

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/path_elements.py 
12
13
14
15
16
17
18
19
20
21
22
class KindEnum(StrEnum):
    This = auto()
    ThisArea = auto()
    ThatArea = auto()
    Parent = auto()
    ReferenceAttr = auto()
    AssocPath = auto()
    Role = auto()
    ViewBase = auto()
    Attribute = auto()
    MetaObject = auto()
AssocPath = auto() class-attribute instance-attribute
Attribute = auto() class-attribute instance-attribute
MetaObject = auto() class-attribute instance-attribute
Parent = auto() class-attribute instance-attribute
ReferenceAttr = auto() class-attribute instance-attribute
Role = auto() class-attribute instance-attribute
ThatArea = auto() class-attribute instance-attribute
This = auto() class-attribute instance-attribute
ThisArea = auto() class-attribute instance-attribute
ViewBase = auto() class-attribute instance-attribute
__init__(Kind, NumIndex=None, Ref_ref=None)

PathElsElement dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/path_elements.py 
34
35
36
@dataclass
class PathElsElement:
    PathEl: List[PathElElement] = field(default_factory=list)
PathEl = field(default_factory=list) class-attribute instance-attribute
__init__(PathEl=list())

PathOrInspFactorElement dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/path_elements.py 
39
40
41
42
43
44
45
@dataclass
class PathOrInspFactorElement:
    PathOrInspFactor: "PathOrInspFactor" = field(
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        }
    )
PathOrInspFactor = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(PathOrInspFactor)

references

log = logging.getLogger(__name__) module-attribute

HasRef

Abstract base class which is used to implement decent behaviour on desired subclasses.

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/references.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
class HasRef:
    """
    Abstract base class which is used to implement decent behaviour on desired subclasses.
    """

    def resolve_refs(self, index: dict):
        """
        References the actual object based on the unique identifier in the index. It is based currently
        on a naming pattern. The attribute to be referenced has to be of type `Ref` and its name has to
        end with *_ref*. Lets assume the attribute name is *Type_ref*. This method then installs a new
        runtime attribute *Type* at `self`. In addition it installs a new runtime attribute at the referenced
        object in our example that would be *Type_backref*. If this attribute does not exists already.
        This is currently always a list which is filled with the back referenced objects.

        TODO: handle multilevel references (currently we go only one level deep)
        TODO: handle multiplicity m:n, 1:1, 1:n, etc

        Args:
            index: The index containing all potential referencable objects.
        """
        for attribute_name in self.__dir__():
            if isinstance(getattr(self, attribute_name), Ref):
                reference = getattr(self, attribute_name).ref
                if not index.get(reference, False):
                    log.info(
                        f"Element with tid <{reference}> was not found in index. It is highly possible that it is not implemented yet"
                    )
                else:
                    referenced_element = index[reference]
                    new_attribute_name = attribute_name.replace("_ref", "")
                    setattr(self, new_attribute_name, referenced_element)
                    backref_name = f"{new_attribute_name}_backref"
                    if not hasattr(referenced_element, backref_name):
                        setattr(referenced_element, backref_name, [])
                    getattr(referenced_element, backref_name).append(self)
resolve_refs(index)

References the actual object based on the unique identifier in the index. It is based currently on a naming pattern. The attribute to be referenced has to be of type Ref and its name has to end with _ref. Lets assume the attribute name is Type_ref. This method then installs a new runtime attribute Type at self. In addition it installs a new runtime attribute at the referenced object in our example that would be Type_backref. If this attribute does not exists already. This is currently always a list which is filled with the back referenced objects.

TODO: handle multilevel references (currently we go only one level deep) TODO: handle multiplicity m:n, 1:1, 1:n, etc

Parameters:

Name Type Description Default
index dict

The index containing all potential referencable objects.

 required
Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/references.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def resolve_refs(self, index: dict):
    """
    References the actual object based on the unique identifier in the index. It is based currently
    on a naming pattern. The attribute to be referenced has to be of type `Ref` and its name has to
    end with *_ref*. Lets assume the attribute name is *Type_ref*. This method then installs a new
    runtime attribute *Type* at `self`. In addition it installs a new runtime attribute at the referenced
    object in our example that would be *Type_backref*. If this attribute does not exists already.
    This is currently always a list which is filled with the back referenced objects.

    TODO: handle multilevel references (currently we go only one level deep)
    TODO: handle multiplicity m:n, 1:1, 1:n, etc

    Args:
        index: The index containing all potential referencable objects.
    """
    for attribute_name in self.__dir__():
        if isinstance(getattr(self, attribute_name), Ref):
            reference = getattr(self, attribute_name).ref
            if not index.get(reference, False):
                log.info(
                    f"Element with tid <{reference}> was not found in index. It is highly possible that it is not implemented yet"
                )
            else:
                referenced_element = index[reference]
                new_attribute_name = attribute_name.replace("_ref", "")
                setattr(self, new_attribute_name, referenced_element)
                backref_name = f"{new_attribute_name}_backref"
                if not hasattr(referenced_element, backref_name):
                    setattr(referenced_element, backref_name, [])
                getattr(referenced_element, backref_name).append(self)

OrderedRef dataclass

Bases: Ref

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/references.py 
15
16
17
@dataclass
class OrderedRef(Ref):
    order_pos: str = field(metadata={"type": "Attribute", "namespace": imd_namespace_map["ili"]})
order_pos = field(metadata={'type': 'Attribute', 'namespace': imd_namespace_map['ili']}) class-attribute instance-attribute
__init__(ref, order_pos)

Ref dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/references.py 
 9
10
11
12
@dataclass
class Ref:

    ref: str = field(metadata={"type": "Attribute", "namespace": imd_namespace_map["ili"]})
ref = field(metadata={'type': 'Attribute', 'namespace': imd_namespace_map['ili']}) class-attribute instance-attribute
__init__(ref)

serialization_elements

CompoundExprElement dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/serialization_elements.py 
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@dataclass
class CompoundExprElement:
    CompoundExpr: "CompoundExpr" = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    UnaryExpression: "UnaryExpr" = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
CompoundExpr = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
UnaryExpression = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(CompoundExpr=None, UnaryExpression=None)

ConstantElement dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/serialization_elements.py 
10
11
12
13
14
15
16
@dataclass
class ConstantElement:
    Constant: "Constant" = field(
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        }
    )
Constant = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(Constant)

MultiplicityElement dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/serialization_elements.py 
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
@dataclass
class MultiplicityElement:

    # TODO: *Optional* seems to be wrong regarding to ilismeta model
    Min: Optional[int] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
    Max: Optional[int] = field(
        default=None,
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        },
    )
Max = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
Min = field(default=None, metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(Min=None, Max=None)

UnaryExprElement dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/serialization_elements.py 
19
20
21
22
23
24
25
@dataclass
class UnaryExprElement:
    UnaryExpr: "UnaryExpr" = field(
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        }
    )
UnaryExpr = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(UnaryExpr)

UnitFunctionElement dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/serialization_elements.py 
53
54
55
56
57
58
59
@dataclass
class UnitFunctionElement:
    UnitFunction: "UnitFunction" = field(
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        }
    )
UnitFunction = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(UnitFunction)

UnitRefElement dataclass

Source code in .venv/lib/python3.13/site-packages/ili2py/interfaces/interlis/interlis_24/ilismeta16/model_data/serialization_elements.py 
28
29
30
31
32
33
34
@dataclass
class UnitRefElement:
    UnitRef: "UnitRef" = field(
        metadata={
            "namespace": imd_namespace_map["IlisMeta16"],
        }
    )
UnitRef = field(metadata={'namespace': imd_namespace_map['IlisMeta16']}) class-attribute instance-attribute
__init__(UnitRef)

model_translation

shared

imd_namespace_map = dict(namespace_map) module-attribute