pyetp 0.0.45__py3-none-any.whl → 0.0.46__py3-none-any.whl

pyetp/__init__.py

@@ -1,5 +1,5 @@
 from ._version import __version__
-from .client import ETPClient, ETPError, connect, etp_connect, etp_persistent_connect
+from .client import ETPClient, ETPError, connect, etp_connect
 from .uri import DataObjectURI, DataspaceURI
 
 __all__ = [
@@ -8,7 +8,6 @@ __all__ = [
     "ETPError",
     "connect",
     "etp_connect",
-    "etp_persistent_connect",
     "DataObjectURI",
     "DataspaceURI",
 ]

pyetp/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.45'
-__version_tuple__ = version_tuple = (0, 0, 45)
+__version__ = version = '0.0.46'
+__version_tuple__ = version_tuple = (0, 0, 46)
 
 __commit_id__ = commit_id = None

pyetp/client.py

@@ -2,7 +2,6 @@ import asyncio
 import contextlib
 import datetime
 import logging
-import sys
 import typing as T
 import uuid
 import warnings
@@ -154,40 +153,6 @@ from resqml_objects import parse_resqml_v201_object, serialize_resqml_v201_objec
 
 logger = logging.getLogger(__name__)
 
-try:
-    # for py >3.11, we can raise grouped exceptions
-    from builtins import ExceptionGroup  # type: ignore
-except ImportError:
-    # Python 3.10
-    def ExceptionGroup(msg, errors):
-        return errors[0]
-
-
-try:
-    # Python >= 3.11
-    from asyncio import timeout
-except ImportError:
-    # Python 3.10
-    from contextlib import asynccontextmanager
-
-    import async_timeout
-
-    @asynccontextmanager
-    async def timeout(delay: T.Optional[float]) -> T.Any:
-        try:
-            async with async_timeout.timeout(delay):
-                yield None
-        except asyncio.CancelledError as e:
-            raise asyncio.TimeoutError(f"Timeout ({delay}s)") from e
-
-    TimeoutError = asyncio.TimeoutError
-
-try:
-    # Python >= 3.11
-    from typing import Self
-except ImportError:
-    Self = "ETPClient"
-
 
 class ETPError(Exception):
     def __init__(self, message: str, code: int):
@@ -315,7 +280,7 @@ class ETPClient(ETPConnection):
         for ti in timeout_intervals(self.etp_timeout):
             try:
                 # Wait for an event for `ti` seconds.
-                async with timeout(ti):
+                async with asyncio.timeout(ti):
                     await self._recv_events[correlation_id].wait()
             except TimeoutError:
                 # Check if the receiver task is still running.
@@ -323,11 +288,18 @@ class ETPClient(ETPConnection):
                     # Raise any errors by waiting for the task to finish.
                     await self.__recvtask
 
-                    logger.error(
-                        "Receiver task terminated without errors. This should not happen"
+                    # Check that the receiver task stopped due to a
+                    # (successfully) closed websockets connection.
+                    try:
+                        await self.ws.recv()
+                    except websockets.ConnectionClosedOK:
+                        pass
+
+                    # Terminate client with an error.
+                    raise ReceiveWorkerExited(
+                        "Receiver task terminated prematurely due to a closed "
+                        "websockets connection"
                     )
-
-                    raise ReceiveWorkerExited
             else:
                 # Break out of for-loop, and start processing message.
                 break
@@ -372,13 +344,15 @@ class ETPClient(ETPConnection):
                 errors.extend(body.errors.values())
         return errors
 
-    async def __aexit__(self, *exc_details) -> None:
-        await self.close(reason="Client exiting")
-
-    async def close(self, reason=""):
+    async def __aexit__(
+        self,
+        exc_type: T.Type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
         close_session_sent = False
         try:
-            await self._send(CloseSession(reason=reason))
+            await self._send(CloseSession(reason="Client exiting"))
             close_session_sent = True
         except websockets.ConnectionClosed:
             logger.error(
@@ -419,7 +393,7 @@ class ETPClient(ETPConnection):
             # In some cases the server does not drop the connection after we
             # have sent the `CloseSession`-message. We therefore add a timeout
             # to the reading of possibly lost messages.
-            async with timeout(self.etp_timeout or 10):
+            async with asyncio.timeout(self.etp_timeout or 10):
                 async for msg in self.ws:
                     counter += 1
         except websockets.ConnectionClosed:
@@ -428,7 +402,7 @@ class ETPClient(ETPConnection):
             pass
         except TimeoutError:
             if close_session_sent:
-                logger.error(
+                logger.warning(
                     "Websockets connection was not closed within "
                     f"{self.etp_timeout or 10} seconds after the "
                     "`CloseSession`-message was sent"
@@ -442,17 +416,30 @@ class ETPClient(ETPConnection):
 
         logger.debug("Client closed")
 
+    async def close(self):
+        """Closing method that tears down the ETP-connection via the
+        `ETPClient.__aexit__`-method, and closes the websockets connection.
+        This method should _only_ be used if the user has set up a connection
+        via `etp_client = await connect(...)` or `etp_client = await
+        etp_connect(...)` and will handle the closing of the connection
+        manually.
+        """
+
+        await self.__aexit__(None, None, None)
+        # The websockets connection should be closed from the ETP-server once
+        # it has received a `CloseSession`-message. However, calling close on
+        # the websockets connection does not do anything if it is already
+        # closed.
+        await self.ws.close()
+
     async def __recv(self):
         logger.debug("Starting receiver loop")
 
-        while True:
-            # We use this way of receiving messages, instead of the `async
-            # for`-pattern, in order to raise all
-            # `websockets.exceptions.ConnectionClosed`-errors (including the
-            # `websockets.exceptions.ConnectionClosedOK` error). In the `async
-            # for`-case a closing code of `1000` (normal closing) just exits
-            # the loop.
-            msg_data = await self.ws.recv()
+        # Using `async for` makes the receiver task exit without errors on a
+        # `websockets.exceptions.ConnectionClosedOK`-exception. This ensures a
+        # smoother clean-up in case the main-task errors resulting in a closed
+        # websockets connection down the line.
+        async for msg_data in self.ws:
             msg = Message.decode_binary_message(
                 T.cast(bytes, msg_data), ETPClient.generic_transition_table
             )
@@ -468,11 +455,9 @@ class ETPClient(ETPConnection):
                 # set response on send event
                 self._recv_events[msg.header.correlation_id].set()
 
-    #
-    # session related
-    #
+        logger.info("Websockets connection closed and receiver task stopped")
 
-    async def __aenter__(self) -> Self:
+    async def __aenter__(self) -> T.Self:
         return await self.request_session()
 
     async def request_session(self):
@@ -811,20 +796,19 @@ class ETPClient(ETPConnection):
             "obj must be Grid2DRepresentation"
         )
         sgeo = gri.grid2d_patch.geometry.points.supporting_geometry  # type: ignore
-        if sys.version_info[1] != 10:
-            assert isinstance(
-                gri.grid2d_patch.geometry.points, ro.Point3dZValueArray
-            ), "Points must be Point3dZValueArray"
-            assert isinstance(
-                gri.grid2d_patch.geometry.points.zvalues, ro.DoubleHdf5Array
-            ), "Values must be DoubleHdf5Array"
-            assert isinstance(
-                gri.grid2d_patch.geometry.points.supporting_geometry,
-                ro.Point3dLatticeArray,
-            ), "Points support_geo must be Point3dLatticeArray"
-            assert isinstance(sgeo, ro.Point3dLatticeArray), (
-                "supporting_geometry must be Point3dLatticeArray"
-            )
+        assert isinstance(gri.grid2d_patch.geometry.points, ro.Point3dZValueArray), (
+            "Points must be Point3dZValueArray"
+        )
+        assert isinstance(
+            gri.grid2d_patch.geometry.points.zvalues, ro.DoubleHdf5Array
+        ), "Values must be DoubleHdf5Array"
+        assert isinstance(
+            gri.grid2d_patch.geometry.points.supporting_geometry,
+            ro.Point3dLatticeArray,
+        ), "Points support_geo must be Point3dLatticeArray"
+        assert isinstance(sgeo, ro.Point3dLatticeArray), (
+            "supporting_geometry must be Point3dLatticeArray"
+        )
         assert isinstance(
             gri.grid2d_patch.geometry.points.zvalues.values, ro.Hdf5Dataset
         ), "Values must be Hdf5Dataset"
@@ -1407,6 +1391,7 @@ class connect:
     # ... = await connect(...)
 
     def __await__(self):
+        # The caller is response for calling `close()` on the client.
         return self.__aenter__().__await__()
 
     # async with connect(...) as ...:
@@ -1420,7 +1405,7 @@ class connect:
         if self.data_partition is not None:
             headers["data-partition-id"] = self.data_partition
 
-        self.ws = await websockets.connect(
+        ws = await websockets.connect(
             self.server_url,
             subprotocols=[ETPClient.SUB_PROTOCOL],  # type: ignore
             additional_headers=headers,
@@ -1430,7 +1415,7 @@ class connect:
         )
 
         self.client = ETPClient(
-            self.ws,
+            ws=ws,
             etp_timeout=self.timeout,
             max_message_size=SETTINGS.MaxWebSocketMessagePayloadSize,
             application_name=SETTINGS.application_name,
@@ -1448,67 +1433,156 @@ class connect:
 
     # exit the async context manager
     async def __aexit__(self, exc_type, exc: Exception, tb: TracebackType):
+        # The `ETPClient.close`-method also closes the websockets connection.
         await self.client.close()
-        await self.ws.close()
 
 
-@contextlib.asynccontextmanager
-async def etp_connect(
-    uri: str,
-    data_partition_id: str | None = None,
-    authorization: str | None = None,
-    etp_timeout: float = 10.0,
-    max_message_size: float = 2**20,
-) -> ETPClient:
-    additional_headers = {}
-
-    if authorization is not None:
-        additional_headers["Authorization"] = authorization
-    if data_partition_id is not None:
-        additional_headers["data-partition-id"] = data_partition_id
-
-    subprotocols = ["etp12.energistics.org"]
-
-    async with (
-        websockets.connect(
-            uri=uri,
-            subprotocols=subprotocols,
-            max_size=max_message_size,
-            additional_headers=additional_headers,
-        ) as ws,
-        ETPClient(
-            ws=ws,
-            etp_timeout=etp_timeout,
-            max_message_size=max_message_size,
-        ) as etp_client,
-    ):
-        yield etp_client
-
-
-async def etp_persistent_connect(
-    uri: str,
-    data_partition_id: str | None = None,
-    authorization: str | None = None,
-    etp_timeout: float = 10.0,
-    max_message_size: float = 2**20,
-) -> AsyncGenerator[ETPClient]:
-    additional_headers = {}
-
-    if authorization is not None:
-        additional_headers["Authorization"] = authorization
-    if data_partition_id is not None:
-        additional_headers["data-partition-id"] = data_partition_id
-
-    subprotocols = ["etp12.energistics.org"]
-    async for ws in websockets.connect(
-        uri=uri,
-        subprotocols=subprotocols,
-        max_size=max_message_size,
-        additional_headers=additional_headers,
-    ):
-        async with ETPClient(
-            ws=ws,
-            etp_timeout=etp_timeout,
-            max_message_size=max_message_size,
-        ) as etp_client:
-            yield etp_client
+class etp_connect:
+    """
+    Connect to an ETP server via websockets.
+
+    This class can act as:
+
+    1. A context manager handling setup and tear-down of the connection.
+    2. An asynchronous iterator which can be used to persistently retry to
+    connect if the websockets connection drops.
+    3. An awaitable connection that must be manually closed by the user.
+
+    See below for examples of all three cases.
+
+    Parameters
+    ----------
+    uri: str
+        The uri to the ETP server. This should be the uri to a websockets
+        endpoint.
+    data_partition_id: str | None
+        The data partition id used when connecting to the OSDU open-etp-server
+        in multi-partition mode. Default is `None`.
+    authorization: str | SecretStr | None
+        Bearer token used for authenticating to the ETP server. This token
+        should be on the form `"Bearer 1234..."`. Default is `None`.
+    etp_timeout: float | None
+        The timeout in seconds for when to stop waiting for a message from the
+        ETP server. Setting it to `None` will persist the connection
+        indefinetly. Default is `None`.
+    max_message_size: float
+        The maximum number of bytes for a single websockets message. Default is
+        `2**20` corresponding to `1` MiB.
+
+
+    Examples
+    --------
+    An example of connecting to the ETP server using :func:`etp_connect` as a
+    context manager is:
+
+        async with etp_connect(...) as etp_client:
+            ...
+
+    In this case the closing message and the websockets connection is closed
+    once the program exits the context manager.
+
+
+    To persist a connection if the websockets connection is dropped (for any
+    reason), use :func:`etp_connect` as an asynchronous generator, viz.:
+
+        import websockets
+
+        async for etp_client in etp_connect(...):
+            try:
+                ...
+            except websockets.ConnectionClosed:
+                continue
+
+            # Include `break` to avoid re-running the whole block if the
+            # iteration runs without any errors.
+            break
+
+    Note that in this case the whole program under the `try`-block is re-run
+    from the start if the iteration completes normally, or if the websockets
+    connection is dropped. Therefore, make sure to include a `break` at the end
+    of the `try`-block (as in the example above).
+
+
+    The third option is to set up a connection via `await` and then manually
+    close the connection once done:
+
+        etp_client = await etp_connect(...)
+        ...
+        await etp_client.close()
+    """
+
+    def __init__(
+        self,
+        uri: str,
+        data_partition_id: str | None = None,
+        authorization: str | SecretStr | None = None,
+        etp_timeout: float | None = None,
+        max_message_size: float = 2**20,
+    ) -> None:
+        self.uri = uri
+        self.data_partition_id = data_partition_id
+        self.authorization = SecretStr(authorization)
+        self.etp_timeout = etp_timeout
+        self.max_message_size = max_message_size
+        self.subprotocols = ["etp12.energistics.org"]
+
+    def __await__(self) -> ETPClient:
+        # The caller is responsible for calling `close()` on the client.
+        return self.__aenter__().__await__()
+
+    def get_additional_headers(self) -> dict[str, str]:
+        additional_headers = {}
+
+        if self.authorization.get_secret_value() is not None:
+            additional_headers["Authorization"] = self.authorization.get_secret_value()
+
+        if self.data_partition_id is not None:
+            additional_headers["data-partition-id"] = self.data_partition_id
+
+        return additional_headers
+
+    async def __aenter__(self) -> ETPClient:
+        self.stack = contextlib.AsyncExitStack()
+        try:
+            ws = await self.stack.enter_async_context(
+                websockets.connect(
+                    uri=self.uri,
+                    subprotocols=self.subprotocols,
+                    max_size=self.max_message_size,
+                    additional_headers=self.get_additional_headers(),
+                )
+            )
+            etp_client = await self.stack.enter_async_context(
+                ETPClient(
+                    ws=ws,
+                    etp_timeout=self.etp_timeout,
+                    max_message_size=self.max_message_size,
+                )
+            )
+        except BaseException:
+            await self.stack.aclose()
+            raise
+
+        return etp_client
+
+    async def __aexit__(
+        self,
+        exc_type: T.Type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        return await self.stack.aclose()
+
+    async def __aiter__(self) -> AsyncGenerator[ETPClient]:
+        async for ws in websockets.connect(
+            uri=self.uri,
+            subprotocols=self.subprotocols,
+            max_size=self.max_message_size,
+            additional_headers=self.get_additional_headers(),
+        ):
+            async with ETPClient(
+                ws=ws,
+                etp_timeout=self.etp_timeout,
+                max_message_size=self.max_message_size,
+            ) as etp_client:
+                yield etp_client

pyetp/uri.py

@@ -83,7 +83,9 @@ class DataObjectURI(_DataObjectURI, _Mixin):
                 obj.Meta, "target_namespace"
             )
             namespace = namespace.lower()
-            # TODO: we can rather look at citation.format - which could be used for xmlformat ? - however to be backward capatiable we check namespaces instead
+            # TODO: we can rather look at citation.format - which could be used
+            # for xmlformat ? - however to be backward capatiable we check
+            # namespaces instead
             if namespace.endswith("resqmlv2"):
                 domain = "resqml20"
             elif namespace.endswith("data/commonv2"):

pyetp/utils_arrays.py

@@ -1,4 +1,3 @@
-import sys
 import typing as T
 
 import numpy as np
@@ -50,12 +49,7 @@ _ANY_LOGICAL_ARRAY_TYPE_MAP: dict[npt.DTypeLike, AnyLogicalArrayType] = {
 }
 
 valid_logical_array_dtypes = list(_ANY_LOGICAL_ARRAY_TYPE_MAP)
-if (sys.version_info.major, sys.version_info.minor) == (3, 10):
-    LogicalArrayDTypes: T.TypeAlias = T.Union[
-        tuple(v.type for v in valid_logical_array_dtypes)
-    ]
-else:
-    LogicalArrayDTypes: T.TypeAlias = T.Union[tuple(valid_logical_array_dtypes)]
+LogicalArrayDTypes: T.TypeAlias = T.Union[tuple(valid_logical_array_dtypes)]
 
 _INV_ANY_LOGICAL_ARRAY_TYPE_MAP: dict[AnyLogicalArrayType, npt.DTypeLike] = {
     v: k for k, v in _ANY_LOGICAL_ARRAY_TYPE_MAP.items()

pyetp/utils_xml.py

@@ -118,13 +118,8 @@ def instantiate_resqml_grid(
         grid2d_patch=ro.Grid2dPatch(
             # TODO: Perhaps we can use this for tiling?
             patch_index=0,
-            # NumPy-arrays are C-ordered, meaning that the last index is
-            # the index that changes most rapidly. However, xtgeo uses nrow for
-            # axis 1 in the array, and ncol for axis 0. This means that
-            # surf.nrow is the fastest changing axis, and surf.ncol the slowest
-            # changing axis (as surf.values.shape == (surf.ncol, surf.nrow))
-            fastest_axis_count=ny,
             slowest_axis_count=nx,
+            fastest_axis_count=ny,
             geometry=ro.PointGeometry(
                 local_crs=get_data_object_reference(crs),
                 points=ro.Point3dZValueArray(

{pyetp-0.0.45.dist-info → pyetp-0.0.46.dist-info}/METADATA

@@ -1,16 +1,15 @@
 Metadata-Version: 2.4
 Name: pyetp
-Version: 0.0.45
+Version: 0.0.46
 Summary: Interface with OSDU RDDMS using ETP protocol
 Author-email: Adam Cheng <52572642+adamchengtkc@users.noreply.github.com>
 License-Expression: Apache-2.0
 Project-URL: homepage, https://github.com/equinor/pyetp
 Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: numpy>=1.26.0
@@ -29,6 +28,12 @@ Dynamic: license-file
 [![PyPI version](https://badge.fury.io/py/pyetp.svg)](https://badge.fury.io/py/pyetp)
 ![License](https://img.shields.io/github/license/equinor/pyetp)
 
+Pyetp is a library implementing an ETP v1.2 client with utilities and support
+for working with RESQML v2.0.1 models.
+
+> The following Energistics (c) products were used in the creation of this work:
+> Energistics Transfer Protocol (ETP) v1.2 and RESQML v2.0.1
+
 # Installing the library
 This package is published to PyPI, and can be installed via:
 ```bash

pyetp-0.0.46.dist-info/RECORD

@@ -0,0 +1,22 @@
+pyetp/__init__.py,sha256=nh-eVYEWMMxqx4YZLzN7fV7NXwbutr1soD_ot48860U,283
+pyetp/_version.py,sha256=Zfksky0dIFN2RZprnAMflcd2YbMf3D0JpTlHasmdh24,706
+pyetp/client.py,sha256=7cCDUURjWRBcmR94hbnwrLfzQoiAUV4KO0qIptQ0Hx4,57935
+pyetp/config.py,sha256=uGEx6n-YF7Rtgwckf0ovRKNOKgCUsiQx4IA0Tyiqafk,870
+pyetp/resqml_objects.py,sha256=j00e8scSh-yYv4Lpp9WjzLiaKqJWd5Cs7ROcJcxxFVw,50721
+pyetp/types.py,sha256=zOfUzEQcgBvveWJyM6dD7U3xJ4SCkWElewNL0Ml-PPY,6761
+pyetp/uri.py,sha256=zbwAeyqLgRqgN-xAbOYmiTtHtVJwfveaMbjl7yc2ifU,3143
+pyetp/utils_arrays.py,sha256=P9F_FWxf9IkqMI1CDdoRjKqD1bWB5DCOJWdHrT7UHfQ,13251
+pyetp/utils_xml.py,sha256=qETAMooFWXBvV_SIMGv1TEG2tLWCbgPraARkftqblKw,6444
+pyetp-0.0.46.dist-info/licenses/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+resqml_objects/__init__.py,sha256=ilimTrQScFryxHrfZwZURVpW0li19bVnayUcHR7S_Fs,183
+resqml_objects/epc_readers.py,sha256=-k2GGK8VgVoqX3-ThyLjs_5OlgNHu1Sd4LZAq6YSF18,3306
+resqml_objects/parsers.py,sha256=aX7W4sP68NlEp8bFB88A8mXWpBHmr79ahpvgD04vCdY,724
+resqml_objects/serializers.py,sha256=wgWhO7ynn51cWRvt5BKdLvxZRqWuopoHFQn0tX8d2NA,1155
+resqml_objects/surface_helpers.py,sha256=-x9DqCliI0dUP4ierTypVFWx7eOH_0j6iDdLxzpGPtk,11207
+resqml_objects/v201/__init__.py,sha256=yL3jWgkyGAzr-wt_WJDV_eARE75NoA6SPEKBrKM4Crk,51630
+resqml_objects/v201/generated.py,sha256=vr9fRNen5GmU75g7PlX1hgusJ4vD_K1nMueV-XgTMis,789217
+resqml_objects/v201/utils.py,sha256=WiywauiJRBWhdjUvbKhpltRjoBX3qWd7qQ0_FAmIzUc,1442
+pyetp-0.0.46.dist-info/METADATA,sha256=xuiA72Cwtb83H1kpdhdRlCY1MiwE23K9YweoYfqDFaI,3096
+pyetp-0.0.46.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+pyetp-0.0.46.dist-info/top_level.txt,sha256=NrdXbidkT5QR4NjH6nv2Frixknqse3jZq7bnqNdVb5k,21
+pyetp-0.0.46.dist-info/RECORD,,

{pyetp-0.0.45.dist-info → pyetp-0.0.46.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

resqml_objects/epc_readers.py

@@ -1,11 +1,11 @@
 import logging
 import pathlib
-import sys
 import zipfile
 
 import h5py
 import numpy as np
 import numpy.typing as npt
+from xsdata.exceptions import ParserError
 
 import resqml_objects.v201 as ro_201
 
@@ -46,12 +46,6 @@ def get_resqml_v201_objects(
     get_arrays_and_paths_in_hdf_file
     """
 
-    if sys.version_info.major == 3 and sys.version_info.minor == 10:
-        raise NotImplementedError(
-            "The epc-reader 'get_resqml_v201_objects'-function does not work for "
-            "Python 3.10. Consider switching to Python 3.11 or up."
-        )
-
     robjs = []
     fail = {}
 
@@ -64,6 +58,8 @@ def get_resqml_v201_objects(
                     robjs.append(parse_resqml_v201_object(c))
                 except AttributeError as e:
                     fail[zi.filename] = e
+                except ParserError as e:
+                    fail[zi.filename] = e
 
     if log_failed_objects:
         logger.info(f"Failed to parse: {fail}")

resqml_objects/parsers.py

@@ -1,12 +1,25 @@
 from lxml import etree
-from xsdata.formats.dataclass.context import XmlContext
+from xsdata.formats.dataclass.models.generics import DerivedElement
 from xsdata.formats.dataclass.parsers import XmlParser
 
 import resqml_objects.v201 as ro_201
 
+xsi_type_key = "{http://www.w3.org/2001/XMLSchema-instance}type"
 
-def parse_resqml_v201_object(raw_data: bytes) -> ro_201.AbstractObject:
-    parser = XmlParser(context=XmlContext())
 
-    obj_name = etree.QName(etree.fromstring(raw_data).tag).localname
-    return parser.from_bytes(raw_data, getattr(ro_201, obj_name))
+def parse_resqml_v201_object(
+    raw_data: bytes,
+) -> ro_201.AbstractObject:
+    parser = XmlParser()
+
+    xml_obj = etree.fromstring(raw_data)
+    obj_type = xml_obj.get(xsi_type_key) or etree.QName(xml_obj.tag).localname
+
+    if ":" in obj_type:
+        obj_type = obj_type.split(":")[1]
+
+    parsed_obj = parser.from_bytes(raw_data, getattr(ro_201, obj_type))
+
+    return (
+        parsed_obj if not isinstance(parsed_obj, DerivedElement) else parsed_obj.value
+    )