pystuderxcom 3.5.0__tar.gz → 3.6.1__tar.gz

{pystuderxcom-3.5.0/src/pystuderxcom.egg-info → pystuderxcom-3.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pystuderxcom
-Version: 3.5.0
+Version: 3.6.1
 Summary: Python library to communicate with Studer-Innotec devices on the local network via Xcom protocol
 Author-email: Anko Hanse <anko_hanse@hotmail.com>
 Project-URL: Homepage, https://github.com/ankohanse/pystuderxcom
@@ -95,7 +95,7 @@ To read an infos or param or write to a param:
 ```
 from pystuderxcom import XcomApiTcp, XcomApiTcpMode, XcomDataset, XcomVoltage
 
-dataset = XcomFactory.create_dataset(XcomVoltage.AC240, XcomVoltage.DC48)
+dataset = XcomDataset.get_instance(XcomVoltage.AC240, XcomVoltage.DC48)
 info_3023 = dataset.get_by_nr(3023, "xt")  # the "xt" part is optional but usefull for detecting mistakes
 info_6001 = dataset.get_by_nr(6001, "bsp")
 param_1107 = dataset.get_by_nr(1107, "xt")

{pystuderxcom-3.5.0 → pystuderxcom-3.6.1}/README.md

@@ -71,7 +71,7 @@ To read an infos or param or write to a param:
 ```
 from pystuderxcom import XcomApiTcp, XcomApiTcpMode, XcomDataset, XcomVoltage
 
-dataset = XcomFactory.create_dataset(XcomVoltage.AC240, XcomVoltage.DC48)
+dataset = XcomDataset.get_instance(XcomVoltage.AC240, XcomVoltage.DC48)
 info_3023 = dataset.get_by_nr(3023, "xt")  # the "xt" part is optional but usefull for detecting mistakes
 info_6001 = dataset.get_by_nr(6001, "bsp")
 param_1107 = dataset.get_by_nr(1107, "xt")

{pystuderxcom-3.5.0 → pystuderxcom-3.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pystuderxcom"
-version = "3.5.0"
+version = "3.6.1"
 authors = [
   { name="Anko Hanse", email="anko_hanse@hotmail.com" },
 ]

pystuderxcom-3.6.1/src/pystuderxcom/__init__.py

@@ -0,0 +1,32 @@
+from .shared.studer_types import StuderUserLevel, StuderAccess, StuderTarget, StuderDataType
+from .shared.studer_types import StuderDiscoveredGateway, StuderDiscoveredDevice, StuderDiscoverNotConnected
+from .shared.studer_types import StuderParamException
+from .shared.studer_dataset import StuderDataset, StuderDatapoint, StuderDatapointUnknownException, StuderDatapointSyntaxException, StuderDatapointEnumNotFoundException
+from .shared.studer_families import StuderDeviceFamily, StuderDeviceFamilies, StuderDeviceFamilyUnknownException, StuderDeviceCodeUnknownException, StuderDeviceAddressUnknownException, StuderDeviceSlaveUnknownException
+from .shared.studer_messageset import StuderMessageSet, StuderMessageDef, StuderMessageUnknownException, StuderMessageSyntaxException
+from .shared.studer_interfaces_async import AsyncStuderApi, AsyncStuderDiscover, StuderDiscoverFlags
+from .shared.studer_interfaces_sync import StuderApi, StuderDiscover
+from .shared.studer_valueset import StuderValueSet, StuderValueItem
+
+from .api_tcp import AsyncXcomApiTcp, XcomApiTcp
+from .api_udp import AsyncXcomApiUdp, XcomApiUdp
+from .api_serial import AsyncXcomApiSerial, XcomApiSerial
+
+from .api_base_async import AsyncXcomApiBase
+from .discover_async import AsyncXcomDiscover
+
+from .api_base_sync import XcomApiBase
+from .discover_sync import XcomDiscover
+
+from .const import XcomApiTcpMode, XcomVoltage, XcomAggregationType
+from .const import XcomApiWriteException, XcomApiReadException, XcomApiTimeoutException, XcomApiUnpackException, XcomApiResponseIsError, XcomDiscoverNotConnected, XcomParamException
+from .datapoints import XcomDataset, XcomDatapoint
+from .families import XcomDeviceFamily, XcomDeviceFamilies
+from .messages import XcomMessageSet, XcomMessageDef, XcomMessage
+from .values import XcomValueItem, XcomValueSet
+
+# For unit testing
+from .const import XcomUserLevel, ScomFrameFlag, ScomObjType, ScomObjId, ScomServiceId, ScomServiceFlag, ScomQspId, ScomQspLevel, ScomAddress, ScomErrorCode
+from .data import XcomData, XcomDataMessageRsp, XcomDataMultiInfoReq, XcomDataMultiInfoReqItem, XcomDataMultiInfoRsp, XcomDataMultiInfoRspItem
+from .protocol import XcomHeader, XcomFrame, XcomService, XcomPackage
+

{pystuderxcom-3.5.0 → pystuderxcom-3.6.1}/src/pystuderxcom/api_base_async.py

@@ -2,61 +2,26 @@
 
 import asyncio
 import binascii
+from io import BufferedReader
 import logging
 
 from datetime import datetime, timedelta
-
-from .const import (
-    START_TIMEOUT,
-    STOP_TIMEOUT,
-    REQ_TIMEOUT,
-    REQ_RETRIES,
-    REQ_BURST_PERIOD,
-    ScomAddress,
-    XcomFormat,
-    XcomTarget,
-    XcomCategory,
-    XcomAggregationType,
-    ScomFrameFlag,
-    ScomObjType,
-    ScomObjId,
-    ScomServiceId,
-    ScomQspId,
-    XcomApiReadException,
-    XcomApiWriteException,
-    XcomApiUnpackException,
-    XcomApiTimeoutException,
-    XcomApiResponseIsError,
-    XcomParamException,
-    safe_len,
-)
-from .data import (
-    XcomData,
-    XcomDataMessageRsp,
-    MULTI_INFO_REQ_MAX,
-)
-from .datapoints import (
-    XcomDatapoint,
-)
-from .factory_async import (
-    AsyncXcomFactory,
-)
-from .factory_sync import (
-    XcomFactory,
-)
-from .families import (
-    XcomDeviceFamilies
-)
-from .messages import (
-    XcomMessage,
-)
-from .protocol import (
-    XcomPackage,
-)
-from .values import (
-    XcomValues,
-    XcomValuesItem,
-)
+from typing import Any
+
+from .shared.studer_interfaces_async import AsyncStuderApi
+from .shared.studer_interfaces_sync import StuderApi
+from .shared.studer_types import StuderAccess, StuderDataType, StuderDiscoveredDevice, StuderTarget, StuderUserLevel
+from .shared.studer_dataset import StuderDatapoint
+from .shared.studer_valueset import StuderValueSet, StuderValueItem
+from .const import START_TIMEOUT, STOP_TIMEOUT, REQ_TIMEOUT, REQ_RETRIES, REQ_BURST_PERIOD
+from .const import ScomAddress, XcomAggregationType, ScomFrameFlag, ScomObjType, ScomObjId, ScomServiceId, ScomQspId
+from .const import XcomApiReadException, XcomApiWriteException, XcomApiUnpackException, XcomApiTimeoutException, XcomApiResponseIsError, XcomParamException
+from .const import safe_len
+from .data import AsyncReader, SyncReader, XcomData, XcomDataMessageRsp, MULTI_INFO_REQ_MAX, read_bytes
+from .families import XcomDeviceFamilies
+from .messages import XcomMessage, XcomMessageSet
+from .protocol import XcomFrame, XcomHeader, XcomPackage
+from .values import XcomValueSet, XcomValueItem
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -65,7 +30,7 @@ _LOGGER = logging.getLogger(__name__)
 ##
 ## Base cass abstracting Xcom Api
 ##
-class AsyncXcomApiBase:
+class AsyncXcomApiBase(AsyncStuderApi):
 
     def __init__(self):
         """
@@ -77,6 +42,8 @@ class AsyncXcomApiBase:
         self._request_id = 0
         self._sendRequestLock = asyncio.Lock() # to make sure _sendRequest_inner is never called concurrently
 
+        self._families = XcomDeviceFamilies.get_instance() # singleton instance
+
         # Cached values
         self._msg_set = None
         self._latest_frame_flags: int = None   # most recent received frame flags, used for various status flags
@@ -86,7 +53,7 @@ class AsyncXcomApiBase:
         self._diag_durations = {}
 
 
-    async def start(self, timeout=START_TIMEOUT) -> bool:
+    async def start(self) -> bool:
         """
         Start the Xcom Server and listening to the Xcom client.
         """
@@ -179,14 +146,14 @@ class AsyncXcomApiBase:
         if response is not None:
             # Unpack the response value
             try:
-                return XcomData.unpack(response.frame_data.service_data.property_data, XcomFormat.GUID)
+                return XcomData.unpack(response.frame_data.service_data.property_data, StuderDataType.GUID)
 
             except Exception as e:
                 msg = f"Failed to unpack response package for GUID:{request.header.dst_addr}, data={response.frame_data.service_data.property_data.hex()}: {e}"
                 raise XcomApiUnpackException(msg) from None
 
                                          
-    async def request_value(self, parameter: XcomDatapoint, dstAddr = 100, retries = None, timeout = None, verbose=False):
+    async def request_value(self, parameter: StuderDatapoint, device: StuderDiscoveredDevice|int|str=None, retries = None, timeout = None, verbose=False):
         """
         Request a param or info.
         Returns None if not connected, otherwise returns the requested value
@@ -198,19 +165,24 @@ class AsyncXcomApiBase:
         """
 
         # Sanity check
-        if parameter.target != XcomTarget.STANDARD:
+        if parameter.target != StuderTarget.STANDARD:
             raise XcomParamException(f"Invalid datapoint passed to request_value; must have target STANDARD. Violated by datapoint '{parameter.name}' ({parameter.nr})")
-            
-        # Check/convert input parameters        
-        if type(dstAddr) is str:
-            dstAddr = XcomDeviceFamilies.get_addr_by_code(dstAddr)
 
+        if isinstance(device, StuderDiscoveredDevice):
+            dstAddr = device.address
+        elif isinstance(device, int):
+            dstAddr = device
+        elif isinstance(device, str):  
+            dstAddr = self._families.get_addr_by_code(code=device)
+        else:
+            raise StuderParamException(f"Parameter 'device' must be a XcomDiscoverdDevice, device address or a device code in call to request_value")
+            
         # Compose the request and send it
         request: XcomPackage = XcomPackage.gen_package(
             service_id = ScomServiceId.READ,
-            object_type = ScomObjType.PARAMETER if parameter.category == XcomCategory.PARAMETER else ScomObjType.INFO,
+            object_type = ScomObjType.PARAMETER if parameter.access in [StuderAccess.WRITE, StuderAccess.READ_WRITE] else ScomObjType.INFO,
             object_id = parameter.nr,
-            property_id = ScomQspId.UNSAVED_VALUE if parameter.category == XcomCategory.PARAMETER else ScomQspId.VALUE,
+            property_id = ScomQspId.UNSAVED_VALUE if parameter.access in [StuderAccess.WRITE, StuderAccess.READ_WRITE] else ScomQspId.VALUE,
             property_data = XcomData.NONE,
             dst_addr = dstAddr
         )
@@ -219,14 +191,14 @@ class AsyncXcomApiBase:
         if response is not None:
             # Unpack the response value
             try:
-                return XcomData.unpack(response.frame_data.service_data.property_data, parameter.format)
+                return XcomData.unpack(response.frame_data.service_data.property_data, parameter.data_type)
 
             except Exception as e:
                 msg = f"Failed to unpack response package for {parameter.nr}:{dstAddr}, data={response.frame_data.service_data.property_data.hex()}: {e}"
                 raise XcomApiUnpackException(msg) from None
 
 
-    async def request_virtual(self, parameter: XcomDatapoint, dstAddr = 100, retries = None, timeout = None, verbose=False):
+    async def request_virtual(self, parameter: StuderDatapoint, device: StuderDiscoveredDevice|int|str=None, retries = None, timeout = None, verbose=False):
         """
         Request a virtual param or info.
         Returns None if not connected, otherwise returns the requested value
@@ -240,9 +212,18 @@ class AsyncXcomApiBase:
         if not self.connected:
             return None
 
-        if parameter.target != XcomTarget.VIRTUAL:
+        if parameter.target != StuderTarget.VIRTUAL:
             raise XcomParamException(f"Invalid datapoint passed to request_value; must have target VIRTUAL. Violated by datapoint '{parameter.name}' ({parameter.nr})")
     
+        if isinstance(device, StuderDiscoveredDevice):
+            dstAddr = device.address
+        elif isinstance(device, int):
+            dstAddr = device
+        elif isinstance(device, str):  
+            dstAddr = self._families.get_addr_by_code(code=device)
+        else:
+            raise StuderParamException(f"Parameter 'device' must be a XcomDiscoverdDevice, device address or a device code in call to request_value")
+            
         # Virtual request
         match parameter.nr:
             case 99000:   return self.is_message_pending
@@ -266,7 +247,7 @@ class AsyncXcomApiBase:
         return None
             
                                          
-    async def request_infos(self, request_data: XcomValues, retries = None, timeout = None, verbose=False) -> XcomValues:
+    async def request_infos(self, request_data: XcomValueSet, retries = None, timeout = None, verbose=False) -> XcomValueSet:
         """
         Request multiple infos in one call.
         Per info you can indicate what device to get it from, or to get Average or Sum of multiple devices
@@ -284,10 +265,10 @@ class AsyncXcomApiBase:
 
         # Sanity check
         for item in request_data.items:
-            if item.datapoint.target != XcomTarget.STANDARD:
+            if item.datapoint.target != StuderTarget.STANDARD:
                 raise XcomParamException(f"Invalid datapoint passed to request_infos; must have target STANDARD. Violated by datapoint '{item.datapoint.name}' ({item.datapoint.nr})")
             
-            if item.datapoint.category != XcomCategory.INFO:
+            if item.datapoint.userlevel_r != StuderUserLevel.INFO:
                 raise XcomParamException(f"Invalid datapoint passed to request_infos; must have type INFO. Violated by datapoint '{item.datapoint.name}' ({item.datapoint.nr})")
             
             if item.aggregation_type not in XcomAggregationType:
@@ -307,14 +288,14 @@ class AsyncXcomApiBase:
         if response is not None:
             try:
                 # Unpack the response value
-                return XcomValues.unpack_response(response.frame_data.service_data.property_data, request_data)
+                return XcomValueSet.unpack_response(response.frame_data.service_data.property_data, request_data)
 
             except Exception as e:
                 msg = f"Failed to unpack response package for multi-info request, data={response.frame_data.service_data.property_data.hex()}: {e}"
                 raise XcomApiUnpackException(msg) from None
 
 
-    async def request_values(self, request_data: XcomValues, retries = None, timeout = None, verbose=False) -> XcomValues:
+    async def request_values(self, request_data: StuderValueSet, retries = None, timeout = None, verbose=False) -> StuderValueSet:
         """
         Request multiple infos, params or virtuals in one call.
         Can only retrieve actual device values, NOT the average or sum over multiple devices.
@@ -331,28 +312,33 @@ class AsyncXcomApiBase:
             XcomApiResponseIsError
         """
 
-        # Sort out which XcomValues can be done via multi request_values and which must be done via single request_value
-        req_virtuals: list[XcomValuesItem] = []
-        req_singles: list[XcomValuesItem] = []
-        req_multi_items: list[XcomValuesItem] = []
-        req_multis: list[XcomValues] = []
+        # Sort out which XcomValueSet can be done via multi request_values and which must be done via single request_value
+        req_virtuals: list[XcomValueItem] = []
+        req_singles: list[XcomValueItem] = []
+        req_multi_items: list[XcomValueItem] = []
+        req_multis: list[XcomValueSet] = []
         idx_last = safe_len(request_data.items)-1
 
         for idx,item in enumerate(request_data.items):
+
+            # If needed, cast StuderValueItem into XcomValueItem so that extra fields are resolved
+            if not isinstance(item, XcomValueItem) and isinstance(item, StuderValueItem):
+                item = XcomValueItem(datapoint=item.datapoint, device=item.code or item.address)
             
             match item.datapoint.target:
-                case XcomTarget.VIRTUAL:
+                case StuderTarget.VIRTUAL:
                     if item.address is not None:
                         # Needs to be done via an individual request_virtual call
                         req_virtuals.append(item)
 
                     else:
-                        raise XcomParamException(f"Invalid XcomValuesItem passed to request_values; violated by code='{item.code}', address={item.address}, aggregation_type={item.aggregation_type}")
+                        raise XcomParamException(f"Invalid XcomValueItem passed to request_values; violated by code='{item.code}', address={item.address}, aggregation_type={item.aggregation_type}")
 
-                case XcomTarget.STANDARD:
+                case StuderTarget.STANDARD:
                     # Standard datapoints are handled depending on category and aggregation type
-                    match item.datapoint.category:
-                        case XcomCategory.INFO:
+                    match item.datapoint.access:
+                        case StuderAccess.READ:
+                            # Info
                             if item.aggregation_type is not None and item.aggregation_type in range(XcomAggregationType.DEVICE1, XcomAggregationType.DEVICE15+1):
                                 # Can be combined with other infos in a request_values call
                                 req_multi_items.append(item)
@@ -362,25 +348,26 @@ class AsyncXcomApiBase:
                                 req_singles.append(item)
 
                             else:
-                                raise XcomParamException(f"Invalid XcomValuesItem passed to request_values; violated by code='{item.code}', address={item.address}, aggregation_type={item.aggregation_type}")
+                                raise XcomParamException(f"Invalid XcomValueItem passed to request_values; violated by code='{item.code}', address={item.address}, aggregation_type={item.aggregation_type}")
 
-                        case XcomCategory.PARAMETER:
+                        case StuderAccess.WRITE | StuderAccess.READ_WRITE:
+                            # Parameter
                             if item.address is not None:
                                 # Needs to be done via an individual request_value call
                                 req_singles.append(item)
 
                             else:
-                                raise XcomParamException(f"Invalid XcomValuesItem passed to request_values; violated by code='{item.code}', address={item.address}, aggregation_type={item.aggregation_type}")
+                                raise XcomParamException(f"Invalid XcomValueItem passed to request_values; violated by code='{item.code}', address={item.address}, aggregation_type={item.aggregation_type}")
             
             if (len(req_multi_items) == MULTI_INFO_REQ_MAX) or \
                (len(req_multi_items) > 0 and idx == idx_last):
 
                 # Start a new multi-items if current one if full or on last item of enumerate
-                req_multis.append( XcomValues(items=req_multi_items) )
+                req_multis.append( XcomValueSet(items=req_multi_items) )
                 req_multi_items = []
 
         # Now perform all the multi request_values requests
-        result_items: list[XcomValues] = []
+        result_items: list[XcomValueSet] = []
         burst_start = datetime.now()
 
         for req_multi in req_multis:
@@ -396,7 +383,7 @@ class AsyncXcomApiBase:
                 # Fail; do not retry as single request_value also expected to give timeout
                 value = None
                 error = str(tex)
-                result_items.extend( [XcomValuesItem(req.datapoint, code=req.code, address=req.address, aggregation_type=req.aggregation_type, value=value, error=error) for req in req_multi.items] )
+                result_items.extend( [XcomValueItem(datapoint=req.datapoint, device=req.code, aggregation_type=req.aggregation_type, value=value, error=error) for req in req_multi.items] )
             
             except Exception as ex:
                 _LOGGER.debug(f"Failed to retrieve infos via single call; will retry retrieve one-by-one. {ex}")
@@ -424,10 +411,9 @@ class AsyncXcomApiBase:
                 _LOGGER.debug(f"Failed to retrieve info or param {req_single.datapoint.nr}:{req_single.address}; {error}")
 
             # Add to results
-            rsp_single = XcomValuesItem(
+            rsp_single = XcomValueItem(
                 datapoint = req_single.datapoint, 
-                code = req_single.code,
-                address = req_single.address,
+                device = req_single.code,
                 aggregation_type=req_single.aggregation_type, 
                 value = value,
                 error = error,
@@ -454,10 +440,9 @@ class AsyncXcomApiBase:
                 _LOGGER.debug(f"Failed to retrieve virtual info or param {req_virtual.datapoint.nr}:{req_virtual.address}; {error}")
 
             # Add to results
-            rsp_virtual = XcomValuesItem(
+            rsp_virtual = XcomValueItem(
                 datapoint = req_virtual.datapoint, 
-                code = req_virtual.code,
-                address = req_virtual.address,
+                device = req_virtual.code,
                 aggregation_type=req_virtual.aggregation_type, 
                 value = value,
                 error = error,
@@ -470,11 +455,11 @@ class AsyncXcomApiBase:
                 await asyncio.sleep(1)
                 burst_start = datetime.now()
 
-        # Return all reponse items as one XcomValues object
-        return XcomValues(result_items)
+        # Return all reponse items as one XcomValueSet object
+        return XcomValueSet(result_items)
 
 
-    async def update_value(self, parameter: XcomDatapoint, value, dstAddr = 100, retries = None, timeout = None, verbose=False):
+    async def update_value(self, parameter: StuderDatapoint, value: Any, device: StuderDiscoveredDevice|int|str=None, retries = None, timeout = None, verbose=False):
         """
         Update a param
         Returns None if not connected, otherwise returns True on success
@@ -485,14 +470,20 @@ class AsyncXcomApiBase:
             XcomApiResponseIsError
         """
         # Sanity check: the parameter/datapoint must have category == XcomDatapointType.PARAMETER
-        if parameter.category != XcomCategory.PARAMETER:
-            _LOGGER.warning(f"Ignoring attempt to update readonly infos value {parameter}")
+        if parameter.access not in [StuderAccess.WRITE, StuderAccess.READ_WRITE]:
+            _LOGGER.warning(f"Ignoring attempt to update readonly value {parameter}")
             return None
 
-        if type(dstAddr) is str:
-            dstAddr = XcomDeviceFamilies.get_addr_by_code(dstAddr)
+        if isinstance(device, StuderDiscoveredDevice):
+            dstAddr = device.address
+        elif isinstance(device, int):
+            dstAddr = device
+        elif isinstance(device, str):  
+            dstAddr = self._families.get_addr_by_code(code=device)
+        else:
+            raise StuderParamException(f"Parameter 'device' must be a XcomDiscoverdDevice, device address or a device code in call to request_value")
 
-        _LOGGER.debug(f"Update value {parameter} on addr {dstAddr}")
+        _LOGGER.debug(f"Update value {parameter} on address {dstAddr}")
 
         # Compose the request and send it
         request: XcomPackage = XcomPackage.gen_package(
@@ -500,7 +491,7 @@ class AsyncXcomApiBase:
             object_type = ScomObjType.PARAMETER,
             object_id = parameter.nr,
             property_id = ScomQspId.UNSAVED_VALUE,
-            property_data = XcomData.pack(value, parameter.format),
+            property_data = XcomData.pack(value, parameter.data_type),
             dst_addr = dstAddr
         )
 
@@ -535,7 +526,7 @@ class AsyncXcomApiBase:
 
         # Make sure we have access to the message_set
         if self._msg_set is None:
-            self._msg_set = await AsyncXcomFactory.create_messageset()
+            self._msg_set = await XcomMessageSet.async_get_instance()
 
         # Compose the request and send it
         request: XcomPackage = XcomPackage.gen_package(
@@ -689,6 +680,39 @@ class AsyncXcomApiBase:
         return self._request_id
 
 
+    async def _parse_package(self, f: BufferedReader, timeout:float=REQ_TIMEOUT, verbose=False) -> XcomPackage:
+        # package sometimes starts with 0xff
+        skipped = bytearray(b'')
+        ts_end = datetime.now() + timedelta(seconds=timeout)
+
+        while datetime.now() < ts_end:
+            sb = await read_bytes(f, 1)
+            if sb == XcomPackage.start_byte:
+                break
+
+            skipped.extend(sb)
+
+        if verbose and len(skipped) > 0:
+            _LOGGER.debug(f"skip {len(skipped)} bytes until start-byte ({binascii.hexlify(skipped).decode('ascii')})")
+
+        h_raw = await read_bytes(f, XcomHeader.length)
+        h_chk = await read_bytes(f, 2)
+        assert XcomPackage.checksum(h_raw) == h_chk
+        header = XcomHeader.parse_bytes(h_raw)
+
+        f_raw = await read_bytes(f, header.data_length)
+        f_chk = await read_bytes(f, 2)
+        assert XcomPackage.checksum(f_raw) == f_chk
+        frame = XcomFrame.parse_bytes(f_raw)
+
+        return XcomPackage(header, frame)
+
+
+    async def _parse_package_bytes(self, buf: bytes, timeout:float=REQ_TIMEOUT, verbose=False) -> XcomPackage:
+        reader = AsyncReader(buf)
+        return await self._parse_package(reader, timeout, verbose)
+    
+
     async def _add_diagnostics(self, retries: int = None, duration: timedelta = None):
         if retries is not None:
             if retries not in self._diag_retries: