aas_core3.xmlization

Read and write AAS models as XML.

For reading, we provide different reading functions, each handling a different kind of input. All the reading functions operate in one pass, i.e., the source is read incrementally and the complete XML is not held in memory.

We provide the following four reading functions (where X represents the name of the class):

X_from_iterparse reads from a stream of (event, element) tuples coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]. If you do not trust the source, please consider using defusedxml.ElementTree.
X_from_stream reads from the given text stream.
X_from_file reads from a file on disk.
X_from_str reads from the given string.

The functions X_from_stream, X_from_file and X_from_str provide an extra parameter, has_iterparse, which allows you to use a parsing library different from xml.etree.ElementTree. For example, you can pass in defusedxml.ElementTree.

All XML elements are expected to live in the NAMESPACE.

For writing, use the function aas_core3.xmlization.write() which translates the instance of the model into an XML document and writes it in one pass to the stream.

Here is an example usage how to de-serialize from a file:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.read_extension_from_file(
    path
)

# Do something with the ``instance``

Here is another code example where we serialize the instance:

import pathlib

import aas_core3.types as aas_types
import aas_core3.xmlization as aas_xmlization

instance = Extension(
   ... # some constructor arguments
)

pth = pathlib.Path(...)
with pth.open("wt") as fid:
    aas_xmlization.write(instance, fid)

aas_core3.xmlization.NAMESPACE = 'https://admin-shell.io/aas/3/0': XML namespace in which all the elements are expected to reside

class aas_core3.xmlization.Element(*args, **kwargs)[source]

Behave like xml.etree.ElementTree.Element().

property attrib: Optional[Mapping[str, str]]: Attributes of the element

property text: Optional[str]: Text content of the element

property tail: Optional[str]: Tail text of the element

property tag: str: Tag of the element; with a namespace provided as a {...} prefix

clear() → None[source]: Behave like xml.etree.ElementTree.Element.clear().

__init__(*args, **kwargs)

class aas_core3.xmlization.HasIterparse(*args, **kwargs)[source]

Parse an XML document incrementally.

iterparse(source: TextIO, events: Optional[Sequence[str]] = None) → Iterator[Tuple[str, Element]][source]: Behave like xml.etree.ElementTree.iterparse().

__init__(*args, **kwargs)

class aas_core3.xmlization.ElementSegment(element: Element)[source]

Represent an element on a path to the erroneous value.

__init__(element: Element) → None[source]: Initialize with the given values.

element: Final[Element]: Erroneous element

__str__() → str[source]

Render the segment as a tag without the namespace.

We deliberately omit the namespace in the tag names. If you want to actually query with the resulting XPath, you have to insert the namespaces manually. We did not know how to include the namespace in a meaningful way, as XPath assumes namespace prefixes to be defined outside of the document. At least the path thus rendered is informative, and you should be able to descend it manually.

class aas_core3.xmlization.IndexSegment(element: Element, index: int)[source]

Represent an element in a sequence on a path to the erroneous value.

__init__(element: Element, index: int) → None[source]: Initialize with the given values.

element: Final[Element]: Erroneous element

index: Final[int]: Index of the element in the sequence

__str__() → str[source]: Render the segment as an element wildcard with the index.

class aas_core3.xmlization.Path[source]

Represent the relative path to the erroneous element.

__init__() → None[source]: Initialize as an empty path.

property segments: Sequence[Union[ElementSegment, IndexSegment]]: Get the segments of the path.

__str__() → str[source]

Render the path as a relative XPath.

We omit the leading / so that you can easily prefix it as you need.

exception aas_core3.xmlization.DeserializationException(cause: str)[source]

Signal that the XML de-serialization could not be performed.

__init__(cause: str) → None[source]: Initialize with the given cause and an empty path.

cause: Final[str]: Human-readable explanation of the exception’s cause

path: Final[Path]: Relative path to the erroneous value

aas_core3.xmlization.has_semantics_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → HasSemantics[source]

Read an instance of types.HasSemantics from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.has_semantics_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.HasSemantics read from iterator

aas_core3.xmlization.has_semantics_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasSemantics[source]

Read an instance of types.HasSemantics from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.has_semantics_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.HasSemantics in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasSemantics read from stream

aas_core3.xmlization.has_semantics_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasSemantics[source]

Read an instance of types.HasSemantics from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.has_semantics_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.HasSemantics in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasSemantics read from path

aas_core3.xmlization.has_semantics_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasSemantics[source]

Read an instance of types.HasSemantics from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.has_semantics_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.HasSemantics in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasSemantics read from text

aas_core3.xmlization.extension_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Extension[source]

Read an instance of types.Extension from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.extension_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Extension read from iterator

aas_core3.xmlization.extension_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Extension[source]

Read an instance of types.Extension from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.extension_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Extension in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Extension read from stream

aas_core3.xmlization.extension_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Extension[source]

Read an instance of types.Extension from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.extension_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Extension in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Extension read from path

aas_core3.xmlization.extension_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Extension[source]

Read an instance of types.Extension from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.extension_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Extension in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Extension read from text

aas_core3.xmlization.has_extensions_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → HasExtensions[source]

Read an instance of types.HasExtensions from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.has_extensions_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.HasExtensions read from iterator

aas_core3.xmlization.has_extensions_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasExtensions[source]

Read an instance of types.HasExtensions from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.has_extensions_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.HasExtensions in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasExtensions read from stream

aas_core3.xmlization.has_extensions_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasExtensions[source]

Read an instance of types.HasExtensions from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.has_extensions_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.HasExtensions in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasExtensions read from path

aas_core3.xmlization.has_extensions_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasExtensions[source]

Read an instance of types.HasExtensions from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.has_extensions_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.HasExtensions in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasExtensions read from text

aas_core3.xmlization.referable_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Referable[source]

Read an instance of types.Referable from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.referable_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Referable read from iterator

aas_core3.xmlization.referable_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Referable[source]

Read an instance of types.Referable from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.referable_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Referable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Referable read from stream

aas_core3.xmlization.referable_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Referable[source]

Read an instance of types.Referable from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.referable_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Referable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Referable read from path

aas_core3.xmlization.referable_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Referable[source]

Read an instance of types.Referable from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.referable_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Referable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Referable read from text

aas_core3.xmlization.identifiable_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Identifiable[source]

Read an instance of types.Identifiable from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.identifiable_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Identifiable read from iterator

aas_core3.xmlization.identifiable_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Identifiable[source]

Read an instance of types.Identifiable from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.identifiable_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Identifiable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Identifiable read from stream

aas_core3.xmlization.identifiable_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Identifiable[source]

Read an instance of types.Identifiable from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.identifiable_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Identifiable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Identifiable read from path

aas_core3.xmlization.identifiable_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Identifiable[source]

Read an instance of types.Identifiable from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.identifiable_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Identifiable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Identifiable read from text

aas_core3.xmlization.has_kind_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → HasKind[source]

Read an instance of types.HasKind from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.has_kind_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.HasKind read from iterator

aas_core3.xmlization.has_kind_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasKind[source]

Read an instance of types.HasKind from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.has_kind_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.HasKind in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasKind read from stream

aas_core3.xmlization.has_kind_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasKind[source]

Read an instance of types.HasKind from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.has_kind_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.HasKind in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasKind read from path

aas_core3.xmlization.has_kind_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasKind[source]

Read an instance of types.HasKind from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.has_kind_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.HasKind in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasKind read from text

aas_core3.xmlization.has_data_specification_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → HasDataSpecification[source]

Read an instance of types.HasDataSpecification from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.has_data_specification_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.HasDataSpecification read from iterator

aas_core3.xmlization.has_data_specification_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasDataSpecification[source]

Read an instance of types.HasDataSpecification from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.has_data_specification_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.HasDataSpecification in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasDataSpecification read from stream

aas_core3.xmlization.has_data_specification_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasDataSpecification[source]

Read an instance of types.HasDataSpecification from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.has_data_specification_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.HasDataSpecification in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasDataSpecification read from path

aas_core3.xmlization.has_data_specification_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → HasDataSpecification[source]

Read an instance of types.HasDataSpecification from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.has_data_specification_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.HasDataSpecification in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.HasDataSpecification read from text

aas_core3.xmlization.administrative_information_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → AdministrativeInformation[source]

Read an instance of types.AdministrativeInformation from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.administrative_information_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.AdministrativeInformation read from iterator

aas_core3.xmlization.administrative_information_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AdministrativeInformation[source]

Read an instance of types.AdministrativeInformation from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.administrative_information_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.AdministrativeInformation in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AdministrativeInformation read from stream

aas_core3.xmlization.administrative_information_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AdministrativeInformation[source]

Read an instance of types.AdministrativeInformation from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.administrative_information_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.AdministrativeInformation in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AdministrativeInformation read from path

aas_core3.xmlization.administrative_information_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AdministrativeInformation[source]

Read an instance of types.AdministrativeInformation from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.administrative_information_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.AdministrativeInformation in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AdministrativeInformation read from text

aas_core3.xmlization.qualifiable_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Qualifiable[source]

Read an instance of types.Qualifiable from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.qualifiable_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Qualifiable read from iterator

aas_core3.xmlization.qualifiable_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Qualifiable[source]

Read an instance of types.Qualifiable from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.qualifiable_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Qualifiable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Qualifiable read from stream

aas_core3.xmlization.qualifiable_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Qualifiable[source]

Read an instance of types.Qualifiable from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.qualifiable_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Qualifiable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Qualifiable read from path

aas_core3.xmlization.qualifiable_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Qualifiable[source]

Read an instance of types.Qualifiable from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.qualifiable_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Qualifiable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Qualifiable read from text

aas_core3.xmlization.qualifier_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Qualifier[source]

Read an instance of types.Qualifier from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.qualifier_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Qualifier read from iterator

aas_core3.xmlization.qualifier_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Qualifier[source]

Read an instance of types.Qualifier from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.qualifier_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Qualifier in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Qualifier read from stream

aas_core3.xmlization.qualifier_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Qualifier[source]

Read an instance of types.Qualifier from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.qualifier_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Qualifier in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Qualifier read from path

aas_core3.xmlization.qualifier_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Qualifier[source]

Read an instance of types.Qualifier from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.qualifier_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Qualifier in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Qualifier read from text

aas_core3.xmlization.asset_administration_shell_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → AssetAdministrationShell[source]

Read an instance of types.AssetAdministrationShell from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.asset_administration_shell_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.AssetAdministrationShell read from iterator

aas_core3.xmlization.asset_administration_shell_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AssetAdministrationShell[source]

Read an instance of types.AssetAdministrationShell from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.asset_administration_shell_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.AssetAdministrationShell in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AssetAdministrationShell read from stream

aas_core3.xmlization.asset_administration_shell_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AssetAdministrationShell[source]

Read an instance of types.AssetAdministrationShell from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.asset_administration_shell_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.AssetAdministrationShell in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AssetAdministrationShell read from path

aas_core3.xmlization.asset_administration_shell_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AssetAdministrationShell[source]

Read an instance of types.AssetAdministrationShell from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.asset_administration_shell_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.AssetAdministrationShell in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AssetAdministrationShell read from text

aas_core3.xmlization.asset_information_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → AssetInformation[source]

Read an instance of types.AssetInformation from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.asset_information_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.AssetInformation read from iterator

aas_core3.xmlization.asset_information_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AssetInformation[source]

Read an instance of types.AssetInformation from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.asset_information_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.AssetInformation in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AssetInformation read from stream

aas_core3.xmlization.asset_information_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AssetInformation[source]

Read an instance of types.AssetInformation from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.asset_information_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.AssetInformation in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AssetInformation read from path

aas_core3.xmlization.asset_information_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AssetInformation[source]

Read an instance of types.AssetInformation from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.asset_information_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.AssetInformation in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AssetInformation read from text

aas_core3.xmlization.resource_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Resource[source]

Read an instance of types.Resource from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.resource_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Resource read from iterator

aas_core3.xmlization.resource_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Resource[source]

Read an instance of types.Resource from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.resource_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Resource in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Resource read from stream

aas_core3.xmlization.resource_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Resource[source]

Read an instance of types.Resource from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.resource_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Resource in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Resource read from path

aas_core3.xmlization.resource_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Resource[source]

Read an instance of types.Resource from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.resource_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Resource in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Resource read from text

aas_core3.xmlization.specific_asset_id_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → SpecificAssetID[source]

Read an instance of types.SpecificAssetID from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.specific_asset_id_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.SpecificAssetID read from iterator

aas_core3.xmlization.specific_asset_id_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SpecificAssetID[source]

Read an instance of types.SpecificAssetID from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.specific_asset_id_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.SpecificAssetID in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SpecificAssetID read from stream

aas_core3.xmlization.specific_asset_id_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SpecificAssetID[source]

Read an instance of types.SpecificAssetID from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.specific_asset_id_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.SpecificAssetID in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SpecificAssetID read from path

aas_core3.xmlization.specific_asset_id_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SpecificAssetID[source]

Read an instance of types.SpecificAssetID from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.specific_asset_id_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.SpecificAssetID in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SpecificAssetID read from text

aas_core3.xmlization.submodel_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Submodel[source]

Read an instance of types.Submodel from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.submodel_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Submodel read from iterator

aas_core3.xmlization.submodel_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Submodel[source]

Read an instance of types.Submodel from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.submodel_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Submodel in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Submodel read from stream

aas_core3.xmlization.submodel_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Submodel[source]

Read an instance of types.Submodel from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.submodel_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Submodel in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Submodel read from path

aas_core3.xmlization.submodel_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Submodel[source]

Read an instance of types.Submodel from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.submodel_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Submodel in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Submodel read from text

aas_core3.xmlization.submodel_element_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → SubmodelElement[source]

Read an instance of types.SubmodelElement from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.submodel_element_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.SubmodelElement read from iterator

aas_core3.xmlization.submodel_element_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SubmodelElement[source]

Read an instance of types.SubmodelElement from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.submodel_element_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.SubmodelElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SubmodelElement read from stream

aas_core3.xmlization.submodel_element_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SubmodelElement[source]

Read an instance of types.SubmodelElement from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.submodel_element_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.SubmodelElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SubmodelElement read from path

aas_core3.xmlization.submodel_element_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SubmodelElement[source]

Read an instance of types.SubmodelElement from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.submodel_element_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.SubmodelElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SubmodelElement read from text

aas_core3.xmlization.relationship_element_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → RelationshipElement[source]

Read an instance of types.RelationshipElement from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.relationship_element_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.RelationshipElement read from iterator

aas_core3.xmlization.relationship_element_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → RelationshipElement[source]

Read an instance of types.RelationshipElement from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.relationship_element_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.RelationshipElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.RelationshipElement read from stream

aas_core3.xmlization.relationship_element_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → RelationshipElement[source]

Read an instance of types.RelationshipElement from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.relationship_element_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.RelationshipElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.RelationshipElement read from path

aas_core3.xmlization.relationship_element_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → RelationshipElement[source]

Read an instance of types.RelationshipElement from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.relationship_element_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.RelationshipElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.RelationshipElement read from text

aas_core3.xmlization.submodel_element_list_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → SubmodelElementList[source]

Read an instance of types.SubmodelElementList from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.submodel_element_list_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.SubmodelElementList read from iterator

aas_core3.xmlization.submodel_element_list_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SubmodelElementList[source]

Read an instance of types.SubmodelElementList from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.submodel_element_list_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.SubmodelElementList in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SubmodelElementList read from stream

aas_core3.xmlization.submodel_element_list_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SubmodelElementList[source]

Read an instance of types.SubmodelElementList from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.submodel_element_list_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.SubmodelElementList in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SubmodelElementList read from path

aas_core3.xmlization.submodel_element_list_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SubmodelElementList[source]

Read an instance of types.SubmodelElementList from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.submodel_element_list_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.SubmodelElementList in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SubmodelElementList read from text

aas_core3.xmlization.submodel_element_collection_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → SubmodelElementCollection[source]

Read an instance of types.SubmodelElementCollection from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.submodel_element_collection_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.SubmodelElementCollection read from iterator

aas_core3.xmlization.submodel_element_collection_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SubmodelElementCollection[source]

Read an instance of types.SubmodelElementCollection from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.submodel_element_collection_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.SubmodelElementCollection in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SubmodelElementCollection read from stream

aas_core3.xmlization.submodel_element_collection_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SubmodelElementCollection[source]

Read an instance of types.SubmodelElementCollection from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.submodel_element_collection_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.SubmodelElementCollection in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SubmodelElementCollection read from path

aas_core3.xmlization.submodel_element_collection_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → SubmodelElementCollection[source]

Read an instance of types.SubmodelElementCollection from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.submodel_element_collection_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.SubmodelElementCollection in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.SubmodelElementCollection read from text

aas_core3.xmlization.data_element_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → DataElement[source]

Read an instance of types.DataElement from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.data_element_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.DataElement read from iterator

aas_core3.xmlization.data_element_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → DataElement[source]

Read an instance of types.DataElement from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.data_element_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.DataElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.DataElement read from stream

aas_core3.xmlization.data_element_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → DataElement[source]

Read an instance of types.DataElement from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.data_element_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.DataElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.DataElement read from path

aas_core3.xmlization.data_element_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → DataElement[source]

Read an instance of types.DataElement from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.data_element_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.DataElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.DataElement read from text

aas_core3.xmlization.property_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Property[source]

Read an instance of types.Property from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.property_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Property read from iterator

aas_core3.xmlization.property_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Property[source]

Read an instance of types.Property from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.property_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Property in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Property read from stream

aas_core3.xmlization.property_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Property[source]

Read an instance of types.Property from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.property_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Property in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Property read from path

aas_core3.xmlization.property_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Property[source]

Read an instance of types.Property from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.property_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Property in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Property read from text

aas_core3.xmlization.multi_language_property_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → MultiLanguageProperty[source]

Read an instance of types.MultiLanguageProperty from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.multi_language_property_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.MultiLanguageProperty read from iterator

aas_core3.xmlization.multi_language_property_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → MultiLanguageProperty[source]

Read an instance of types.MultiLanguageProperty from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.multi_language_property_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.MultiLanguageProperty in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.MultiLanguageProperty read from stream

aas_core3.xmlization.multi_language_property_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → MultiLanguageProperty[source]

Read an instance of types.MultiLanguageProperty from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.multi_language_property_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.MultiLanguageProperty in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.MultiLanguageProperty read from path

aas_core3.xmlization.multi_language_property_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → MultiLanguageProperty[source]

Read an instance of types.MultiLanguageProperty from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.multi_language_property_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.MultiLanguageProperty in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.MultiLanguageProperty read from text

aas_core3.xmlization.range_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Range[source]

Read an instance of types.Range from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.range_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Range read from iterator

aas_core3.xmlization.range_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Range[source]

Read an instance of types.Range from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.range_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Range in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Range read from stream

aas_core3.xmlization.range_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Range[source]

Read an instance of types.Range from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.range_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Range in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Range read from path

aas_core3.xmlization.range_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Range[source]

Read an instance of types.Range from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.range_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Range in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Range read from text

aas_core3.xmlization.reference_element_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → ReferenceElement[source]

Read an instance of types.ReferenceElement from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.reference_element_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.ReferenceElement read from iterator

aas_core3.xmlization.reference_element_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ReferenceElement[source]

Read an instance of types.ReferenceElement from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.reference_element_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.ReferenceElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ReferenceElement read from stream

aas_core3.xmlization.reference_element_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ReferenceElement[source]

Read an instance of types.ReferenceElement from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.reference_element_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.ReferenceElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ReferenceElement read from path

aas_core3.xmlization.reference_element_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ReferenceElement[source]

Read an instance of types.ReferenceElement from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.reference_element_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.ReferenceElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ReferenceElement read from text

aas_core3.xmlization.blob_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Blob[source]

Read an instance of types.Blob from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.blob_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Blob read from iterator

aas_core3.xmlization.blob_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Blob[source]

Read an instance of types.Blob from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.blob_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Blob in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Blob read from stream

aas_core3.xmlization.blob_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Blob[source]

Read an instance of types.Blob from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.blob_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Blob in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Blob read from path

aas_core3.xmlization.blob_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Blob[source]

Read an instance of types.Blob from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.blob_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Blob in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Blob read from text

aas_core3.xmlization.file_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → File[source]

Read an instance of types.File from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.file_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.File read from iterator

aas_core3.xmlization.file_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → File[source]

Read an instance of types.File from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.file_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.File in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.File read from stream

aas_core3.xmlization.file_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → File[source]

Read an instance of types.File from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.file_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.File in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.File read from path

aas_core3.xmlization.file_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → File[source]

Read an instance of types.File from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.file_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.File in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.File read from text

aas_core3.xmlization.annotated_relationship_element_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → AnnotatedRelationshipElement[source]

Read an instance of types.AnnotatedRelationshipElement from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.annotated_relationship_element_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.AnnotatedRelationshipElement read from iterator

aas_core3.xmlization.annotated_relationship_element_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AnnotatedRelationshipElement[source]

Read an instance of types.AnnotatedRelationshipElement from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.annotated_relationship_element_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.AnnotatedRelationshipElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AnnotatedRelationshipElement read from stream

aas_core3.xmlization.annotated_relationship_element_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AnnotatedRelationshipElement[source]

Read an instance of types.AnnotatedRelationshipElement from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.annotated_relationship_element_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.AnnotatedRelationshipElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AnnotatedRelationshipElement read from path

aas_core3.xmlization.annotated_relationship_element_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AnnotatedRelationshipElement[source]

Read an instance of types.AnnotatedRelationshipElement from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.annotated_relationship_element_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.AnnotatedRelationshipElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AnnotatedRelationshipElement read from text

aas_core3.xmlization.entity_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Entity[source]

Read an instance of types.Entity from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.entity_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Entity read from iterator

aas_core3.xmlization.entity_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Entity[source]

Read an instance of types.Entity from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.entity_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Entity in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Entity read from stream

aas_core3.xmlization.entity_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Entity[source]

Read an instance of types.Entity from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.entity_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Entity in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Entity read from path

aas_core3.xmlization.entity_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Entity[source]

Read an instance of types.Entity from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.entity_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Entity in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Entity read from text

aas_core3.xmlization.event_payload_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → EventPayload[source]

Read an instance of types.EventPayload from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.event_payload_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.EventPayload read from iterator

aas_core3.xmlization.event_payload_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → EventPayload[source]

Read an instance of types.EventPayload from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.event_payload_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.EventPayload in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.EventPayload read from stream

aas_core3.xmlization.event_payload_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → EventPayload[source]

Read an instance of types.EventPayload from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.event_payload_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.EventPayload in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.EventPayload read from path

aas_core3.xmlization.event_payload_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → EventPayload[source]

Read an instance of types.EventPayload from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.event_payload_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.EventPayload in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.EventPayload read from text

aas_core3.xmlization.event_element_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → EventElement[source]

Read an instance of types.EventElement from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.event_element_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.EventElement read from iterator

aas_core3.xmlization.event_element_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → EventElement[source]

Read an instance of types.EventElement from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.event_element_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.EventElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.EventElement read from stream

aas_core3.xmlization.event_element_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → EventElement[source]

Read an instance of types.EventElement from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.event_element_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.EventElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.EventElement read from path

aas_core3.xmlization.event_element_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → EventElement[source]

Read an instance of types.EventElement from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.event_element_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.EventElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.EventElement read from text

aas_core3.xmlization.basic_event_element_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → BasicEventElement[source]

Read an instance of types.BasicEventElement from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.basic_event_element_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.BasicEventElement read from iterator

aas_core3.xmlization.basic_event_element_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → BasicEventElement[source]

Read an instance of types.BasicEventElement from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.basic_event_element_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.BasicEventElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.BasicEventElement read from stream

aas_core3.xmlization.basic_event_element_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → BasicEventElement[source]

Read an instance of types.BasicEventElement from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.basic_event_element_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.BasicEventElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.BasicEventElement read from path

aas_core3.xmlization.basic_event_element_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → BasicEventElement[source]

Read an instance of types.BasicEventElement from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.basic_event_element_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.BasicEventElement in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.BasicEventElement read from text

aas_core3.xmlization.operation_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Operation[source]

Read an instance of types.Operation from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.operation_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Operation read from iterator

aas_core3.xmlization.operation_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Operation[source]

Read an instance of types.Operation from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.operation_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Operation in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Operation read from stream

aas_core3.xmlization.operation_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Operation[source]

Read an instance of types.Operation from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.operation_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Operation in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Operation read from path

aas_core3.xmlization.operation_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Operation[source]

Read an instance of types.Operation from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.operation_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Operation in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Operation read from text

aas_core3.xmlization.operation_variable_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → OperationVariable[source]

Read an instance of types.OperationVariable from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.operation_variable_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.OperationVariable read from iterator

aas_core3.xmlization.operation_variable_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → OperationVariable[source]

Read an instance of types.OperationVariable from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.operation_variable_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.OperationVariable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.OperationVariable read from stream

aas_core3.xmlization.operation_variable_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → OperationVariable[source]

Read an instance of types.OperationVariable from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.operation_variable_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.OperationVariable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.OperationVariable read from path

aas_core3.xmlization.operation_variable_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → OperationVariable[source]

Read an instance of types.OperationVariable from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.operation_variable_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.OperationVariable in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.OperationVariable read from text

aas_core3.xmlization.capability_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Capability[source]

Read an instance of types.Capability from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.capability_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Capability read from iterator

aas_core3.xmlization.capability_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Capability[source]

Read an instance of types.Capability from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.capability_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Capability in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Capability read from stream

aas_core3.xmlization.capability_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Capability[source]

Read an instance of types.Capability from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.capability_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Capability in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Capability read from path

aas_core3.xmlization.capability_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Capability[source]

Read an instance of types.Capability from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.capability_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Capability in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Capability read from text

aas_core3.xmlization.concept_description_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → ConceptDescription[source]

Read an instance of types.ConceptDescription from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.concept_description_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.ConceptDescription read from iterator

aas_core3.xmlization.concept_description_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ConceptDescription[source]

Read an instance of types.ConceptDescription from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.concept_description_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.ConceptDescription in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ConceptDescription read from stream

aas_core3.xmlization.concept_description_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ConceptDescription[source]

Read an instance of types.ConceptDescription from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.concept_description_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.ConceptDescription in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ConceptDescription read from path

aas_core3.xmlization.concept_description_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ConceptDescription[source]

Read an instance of types.ConceptDescription from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.concept_description_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.ConceptDescription in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ConceptDescription read from text

aas_core3.xmlization.reference_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Reference[source]

Read an instance of types.Reference from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.reference_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Reference read from iterator

aas_core3.xmlization.reference_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Reference[source]

Read an instance of types.Reference from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.reference_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Reference in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Reference read from stream

aas_core3.xmlization.reference_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Reference[source]

Read an instance of types.Reference from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.reference_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Reference in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Reference read from path

aas_core3.xmlization.reference_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Reference[source]

Read an instance of types.Reference from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.reference_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Reference in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Reference read from text

aas_core3.xmlization.key_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Key[source]

Read an instance of types.Key from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.key_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Key read from iterator

aas_core3.xmlization.key_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Key[source]

Read an instance of types.Key from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.key_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Key in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Key read from stream

aas_core3.xmlization.key_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Key[source]

Read an instance of types.Key from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.key_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Key in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Key read from path

aas_core3.xmlization.key_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Key[source]

Read an instance of types.Key from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.key_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Key in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Key read from text

aas_core3.xmlization.abstract_lang_string_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → AbstractLangString[source]

Read an instance of types.AbstractLangString from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.abstract_lang_string_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.AbstractLangString read from iterator

aas_core3.xmlization.abstract_lang_string_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AbstractLangString[source]

Read an instance of types.AbstractLangString from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.abstract_lang_string_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.AbstractLangString in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AbstractLangString read from stream

aas_core3.xmlization.abstract_lang_string_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AbstractLangString[source]

Read an instance of types.AbstractLangString from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.abstract_lang_string_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.AbstractLangString in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AbstractLangString read from path

aas_core3.xmlization.abstract_lang_string_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → AbstractLangString[source]

Read an instance of types.AbstractLangString from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.abstract_lang_string_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.AbstractLangString in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.AbstractLangString read from text

aas_core3.xmlization.lang_string_name_type_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → LangStringNameType[source]

Read an instance of types.LangStringNameType from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.lang_string_name_type_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.LangStringNameType read from iterator

aas_core3.xmlization.lang_string_name_type_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringNameType[source]

Read an instance of types.LangStringNameType from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.lang_string_name_type_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.LangStringNameType in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringNameType read from stream

aas_core3.xmlization.lang_string_name_type_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringNameType[source]

Read an instance of types.LangStringNameType from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.lang_string_name_type_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.LangStringNameType in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringNameType read from path

aas_core3.xmlization.lang_string_name_type_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringNameType[source]

Read an instance of types.LangStringNameType from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.lang_string_name_type_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.LangStringNameType in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringNameType read from text

aas_core3.xmlization.lang_string_text_type_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → LangStringTextType[source]

Read an instance of types.LangStringTextType from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.lang_string_text_type_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.LangStringTextType read from iterator

aas_core3.xmlization.lang_string_text_type_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringTextType[source]

Read an instance of types.LangStringTextType from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.lang_string_text_type_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.LangStringTextType in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringTextType read from stream

aas_core3.xmlization.lang_string_text_type_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringTextType[source]

Read an instance of types.LangStringTextType from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.lang_string_text_type_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.LangStringTextType in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringTextType read from path

aas_core3.xmlization.lang_string_text_type_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringTextType[source]

Read an instance of types.LangStringTextType from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.lang_string_text_type_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.LangStringTextType in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringTextType read from text

aas_core3.xmlization.environment_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Environment[source]

Read an instance of types.Environment from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.environment_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Environment read from iterator

aas_core3.xmlization.environment_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Environment[source]

Read an instance of types.Environment from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.environment_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.Environment in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Environment read from stream

aas_core3.xmlization.environment_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Environment[source]

Read an instance of types.Environment from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.environment_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.Environment in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Environment read from path

aas_core3.xmlization.environment_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Environment[source]

Read an instance of types.Environment from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.environment_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.Environment in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.Environment read from text

aas_core3.xmlization.data_specification_content_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → DataSpecificationContent[source]

Read an instance of types.DataSpecificationContent from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.data_specification_content_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.DataSpecificationContent read from iterator

aas_core3.xmlization.data_specification_content_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → DataSpecificationContent[source]

Read an instance of types.DataSpecificationContent from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.data_specification_content_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.DataSpecificationContent in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.DataSpecificationContent read from stream

aas_core3.xmlization.data_specification_content_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → DataSpecificationContent[source]

Read an instance of types.DataSpecificationContent from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.data_specification_content_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.DataSpecificationContent in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.DataSpecificationContent read from path

aas_core3.xmlization.data_specification_content_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → DataSpecificationContent[source]

Read an instance of types.DataSpecificationContent from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.data_specification_content_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.DataSpecificationContent in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.DataSpecificationContent read from text

aas_core3.xmlization.embedded_data_specification_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → EmbeddedDataSpecification[source]

Read an instance of types.EmbeddedDataSpecification from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.embedded_data_specification_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.EmbeddedDataSpecification read from iterator

aas_core3.xmlization.embedded_data_specification_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → EmbeddedDataSpecification[source]

Read an instance of types.EmbeddedDataSpecification from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.embedded_data_specification_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.EmbeddedDataSpecification in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.EmbeddedDataSpecification read from stream

aas_core3.xmlization.embedded_data_specification_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → EmbeddedDataSpecification[source]

Read an instance of types.EmbeddedDataSpecification from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.embedded_data_specification_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.EmbeddedDataSpecification in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.EmbeddedDataSpecification read from path

aas_core3.xmlization.embedded_data_specification_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → EmbeddedDataSpecification[source]

Read an instance of types.EmbeddedDataSpecification from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.embedded_data_specification_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.EmbeddedDataSpecification in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.EmbeddedDataSpecification read from text

aas_core3.xmlization.level_type_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → LevelType[source]

Read an instance of types.LevelType from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.level_type_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.LevelType read from iterator

aas_core3.xmlization.level_type_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LevelType[source]

Read an instance of types.LevelType from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.level_type_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.LevelType in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LevelType read from stream

aas_core3.xmlization.level_type_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LevelType[source]

Read an instance of types.LevelType from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.level_type_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.LevelType in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LevelType read from path

aas_core3.xmlization.level_type_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LevelType[source]

Read an instance of types.LevelType from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.level_type_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.LevelType in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LevelType read from text

aas_core3.xmlization.value_reference_pair_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → ValueReferencePair[source]

Read an instance of types.ValueReferencePair from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.value_reference_pair_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.ValueReferencePair read from iterator

aas_core3.xmlization.value_reference_pair_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ValueReferencePair[source]

Read an instance of types.ValueReferencePair from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.value_reference_pair_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.ValueReferencePair in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ValueReferencePair read from stream

aas_core3.xmlization.value_reference_pair_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ValueReferencePair[source]

Read an instance of types.ValueReferencePair from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.value_reference_pair_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.ValueReferencePair in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ValueReferencePair read from path

aas_core3.xmlization.value_reference_pair_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ValueReferencePair[source]

Read an instance of types.ValueReferencePair from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.value_reference_pair_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.ValueReferencePair in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ValueReferencePair read from text

aas_core3.xmlization.value_list_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → ValueList[source]

Read an instance of types.ValueList from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.value_list_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.ValueList read from iterator

aas_core3.xmlization.value_list_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ValueList[source]

Read an instance of types.ValueList from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.value_list_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.ValueList in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ValueList read from stream

aas_core3.xmlization.value_list_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ValueList[source]

Read an instance of types.ValueList from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.value_list_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.ValueList in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ValueList read from path

aas_core3.xmlization.value_list_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → ValueList[source]

Read an instance of types.ValueList from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.value_list_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.ValueList in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.ValueList read from text

aas_core3.xmlization.lang_string_preferred_name_type_iec_61360_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → LangStringPreferredNameTypeIEC61360[source]

Read an instance of types.LangStringPreferredNameTypeIEC61360 from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.lang_string_preferred_name_type_iec_61360_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.LangStringPreferredNameTypeIEC61360 read from iterator

aas_core3.xmlization.lang_string_preferred_name_type_iec_61360_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringPreferredNameTypeIEC61360[source]

Read an instance of types.LangStringPreferredNameTypeIEC61360 from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.lang_string_preferred_name_type_iec_61360_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.LangStringPreferredNameTypeIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringPreferredNameTypeIEC61360 read from stream

aas_core3.xmlization.lang_string_preferred_name_type_iec_61360_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringPreferredNameTypeIEC61360[source]

Read an instance of types.LangStringPreferredNameTypeIEC61360 from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.lang_string_preferred_name_type_iec_61360_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.LangStringPreferredNameTypeIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringPreferredNameTypeIEC61360 read from path

aas_core3.xmlization.lang_string_preferred_name_type_iec_61360_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringPreferredNameTypeIEC61360[source]

Read an instance of types.LangStringPreferredNameTypeIEC61360 from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.lang_string_preferred_name_type_iec_61360_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.LangStringPreferredNameTypeIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringPreferredNameTypeIEC61360 read from text

aas_core3.xmlization.lang_string_short_name_type_iec_61360_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → LangStringShortNameTypeIEC61360[source]

Read an instance of types.LangStringShortNameTypeIEC61360 from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.lang_string_short_name_type_iec_61360_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.LangStringShortNameTypeIEC61360 read from iterator

aas_core3.xmlization.lang_string_short_name_type_iec_61360_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringShortNameTypeIEC61360[source]

Read an instance of types.LangStringShortNameTypeIEC61360 from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.lang_string_short_name_type_iec_61360_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.LangStringShortNameTypeIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringShortNameTypeIEC61360 read from stream

aas_core3.xmlization.lang_string_short_name_type_iec_61360_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringShortNameTypeIEC61360[source]

Read an instance of types.LangStringShortNameTypeIEC61360 from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.lang_string_short_name_type_iec_61360_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.LangStringShortNameTypeIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringShortNameTypeIEC61360 read from path

aas_core3.xmlization.lang_string_short_name_type_iec_61360_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringShortNameTypeIEC61360[source]

Read an instance of types.LangStringShortNameTypeIEC61360 from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.lang_string_short_name_type_iec_61360_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.LangStringShortNameTypeIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringShortNameTypeIEC61360 read from text

aas_core3.xmlization.lang_string_definition_type_iec_61360_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → LangStringDefinitionTypeIEC61360[source]

Read an instance of types.LangStringDefinitionTypeIEC61360 from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.lang_string_definition_type_iec_61360_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.LangStringDefinitionTypeIEC61360 read from iterator

aas_core3.xmlization.lang_string_definition_type_iec_61360_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringDefinitionTypeIEC61360[source]

Read an instance of types.LangStringDefinitionTypeIEC61360 from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.lang_string_definition_type_iec_61360_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.LangStringDefinitionTypeIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringDefinitionTypeIEC61360 read from stream

aas_core3.xmlization.lang_string_definition_type_iec_61360_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringDefinitionTypeIEC61360[source]

Read an instance of types.LangStringDefinitionTypeIEC61360 from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.lang_string_definition_type_iec_61360_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.LangStringDefinitionTypeIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringDefinitionTypeIEC61360 read from path

aas_core3.xmlization.lang_string_definition_type_iec_61360_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → LangStringDefinitionTypeIEC61360[source]

Read an instance of types.LangStringDefinitionTypeIEC61360 from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.lang_string_definition_type_iec_61360_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.LangStringDefinitionTypeIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.LangStringDefinitionTypeIEC61360 read from text

aas_core3.xmlization.data_specification_iec_61360_from_iterparse(iterator: Iterator[Tuple[str, Element]]) → DataSpecificationIEC61360[source]

Read an instance of types.DataSpecificationIEC61360 from the iterator.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.data_specification_iec_61360_from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.DataSpecificationIEC61360 read from iterator

aas_core3.xmlization.data_specification_iec_61360_from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → DataSpecificationIEC61360[source]

Read an instance of types.DataSpecificationIEC61360 from the stream.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.data_specification_iec_61360_from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance of types.DataSpecificationIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.DataSpecificationIEC61360 read from stream

aas_core3.xmlization.data_specification_iec_61360_from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → DataSpecificationIEC61360[source]

Read an instance of types.DataSpecificationIEC61360 from the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.data_specification_iec_61360_from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance of types.DataSpecificationIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.DataSpecificationIEC61360 read from path

aas_core3.xmlization.data_specification_iec_61360_from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → DataSpecificationIEC61360[source]

Read an instance of types.DataSpecificationIEC61360 from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.data_specification_iec_61360_from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance of types.DataSpecificationIEC61360 in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance of types.DataSpecificationIEC61360 read from text

aas_core3.xmlization.from_iterparse(iterator: Iterator[Tuple[str, Element]]) → Class[source]

Read an instance from the iterator.

The type of the instance is determined by the very first start element.

Example usage:

import pathlib
import xml.etree.ElementTree as ET

import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
with path.open("rt") as fid:
    iterator = ET.iterparse(
        source=fid,
        events=['start', 'end']
    )
    instance = aas_xmlization.from_iterparse(
        iterator
    )

# Do something with the ``instance``

Parameters: iterator¶ – Input stream of (event, element) coming from xml.etree.ElementTree.iterparse() with the argument events=["start", "end"]
Raise: DeserializationException if unexpected input
Returns: Instance of types.Class read from the iterator

aas_core3.xmlization.from_stream(stream: ~typing.TextIO, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Class[source]

Read an instance from the stream.

The type of the instance is determined by the very first start element.

Example usage:

import aas_core3.xmlization as aas_xmlization

with open_some_stream_over_network(...) as stream:
    instance = aas_xmlization.from_stream(
        stream
    )

# Do something with the ``instance``

Parameters

stream¶ – representing an instance in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance read from stream

aas_core3.xmlization.from_file(path: ~os.PathLike, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Class[source]

Read an instance from the file at the path.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

path = pathlib.Path(...)
instance = aas_xmlization.from_file(
    path
)

# Do something with the ``instance``

Parameters

path¶ – to the file representing an instance in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance read from the file at path

aas_core3.xmlization.from_str(text: str, has_iterparse: ~aas_core3.xmlization.HasIterparse = <module 'xml.etree.ElementTree' from '/home/docs/.asdf/installs/python/3.8.20/lib/python3.8/xml/etree/ElementTree.py'>) → Class[source]

Read an instance from the text.

Example usage:

import pathlib
import aas_core3.xmlization as aas_xmlization

text = "<...>...</...>"
instance = aas_xmlization.from_str(
    text
)

# Do something with the ``instance``

Parameters

text¶ – representing an instance in XML
has_iterparse¶ –
Module containing iterparse function.

Default is to use xml.etree.ElementTree from the standard library. If you have to deal with malicious input, consider using a library such as defusedxml.ElementTree.

Raise

DeserializationException if unexpected input

Returns

Instance read from text

aas_core3.xmlization.write(instance: Class, stream: TextIO) → None[source]

Write the XML representation of instance to stream.

Example usage:

import pathlib

import aas_core3.types as aas_types
import aas_core3.xmlization as aas_xmlization

instance = Extension(
   ... # some constructor arguments
)

pth = pathlib.Path(...)
with pth.open("wt") as fid:
    aas_xmlization.write(instance, fid)

Parameters

instance¶ – to be serialized
stream¶ – to write to

aas_core3.xmlization.to_str(that: Class) → str[source]

Serialize that to an XML-encoded text.

Parameters: that¶ – instance to be serialized
Returns: that serialized to XML serialized to text