pystuderxcom 3.4.1__tar.gz → 3.4.2__tar.gz

{pystuderxcom-3.4.1/src/pystuderxcom.egg-info → pystuderxcom-3.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pystuderxcom
-Version: 3.4.1
+Version: 3.4.2
 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

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/pyproject.toml

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

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/src/pystuderxcom/__init__.py

@@ -10,7 +10,7 @@ from .api_base_sync import XcomApiBase
 from .discover_sync import XcomDiscover
 from .factory_sync import XcomFactory
 
-from .const import XcomApiTcpMode, XcomVoltage, XcomLevel, XcomFormat, XcomCategory, XcomAggregationType
+from .const import XcomApiTcpMode, XcomVoltage, XcomLevel, XcomFormat, XcomTarget, XcomCategory, XcomAggregationType
 from .const import XcomApiWriteException, XcomApiReadException, XcomApiTimeoutException, XcomApiUnpackException, XcomApiResponseIsError, XcomDiscoverNotConnected, XcomParamException
 from .data import XcomDiscoveredClient, XcomDiscoveredDevice
 from .datapoints import XcomDataset, XcomDatapoint, XcomDatapointUnknownException

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/src/pystuderxcom/api_base_async.py

@@ -14,6 +14,7 @@ from .const import (
     REQ_BURST_PERIOD,
     ScomAddress,
     XcomFormat,
+    XcomTarget,
     XcomCategory,
     XcomAggregationType,
     ScomFrameFlag,
@@ -196,14 +197,14 @@ class AsyncXcomApiBase:
             XcomApiResponseIsError
         """
 
+        # Sanity check
+        if parameter.target != XcomTarget.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)
 
-        # Check for virtual value request
-        if parameter.category in [XcomCategory.VIRTUAL]:
-            return await self.request_virtual(parameter, dstAddr=dstAddr, retries=retries, timeout=timeout, verbose=verbose)
-
         # Compose the request and send it
         request: XcomPackage = XcomPackage.gen_package(
             service_id = ScomServiceId.READ,
@@ -235,9 +236,12 @@ class AsyncXcomApiBase:
             XcomApiTimeoutException
             XcomApiResponseIsError
         """
-
+        # Sanity check
         if not self.connected:
             return None
+
+        if parameter.target != XcomTarget.VIRTUAL:
+            raise XcomParamException(f"Invalid datapoint passed to request_value; must have target VIRTUAL. Violated by datapoint '{parameter.name}' ({parameter.nr})")
     
         # Virtual request
         match parameter.nr:
@@ -255,6 +259,9 @@ class AsyncXcomApiBase:
                         case 99021: return datetime.fromtimestamp(msg.timestamp)
                         case 99022: return msg.source_address
 
+            case _:
+                raise XcomParamException(f"Invalid datapoint passed to request_virtual; nr not recognized. Violated by datapoint '{parameter.name}' ({parameter.nr})")
+
         return None
             
                                          
@@ -276,6 +283,9 @@ class AsyncXcomApiBase:
 
         # Sanity check
         for item in request_data.items:
+            if item.datapoint.target != XcomTarget.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:
                 raise XcomParamException(f"Invalid datapoint passed to request_infos; must have type INFO. Violated by datapoint '{item.datapoint.name}' ({item.datapoint.nr})")
             
@@ -305,12 +315,12 @@ class AsyncXcomApiBase:
 
     async def request_values(self, request_data: XcomValues, retries = None, timeout = None, verbose=False) -> XcomValues:
         """
-        Request multiple infos and params in one call.
+        Request multiple infos, params or virtuals in one call.
         Can only retrieve actual device values, NOT the average or sum over multiple devices.
 
         The function will try to be as efficient as possible and combine retrieval of multiple infos in one call.
         When the xcom-client does not support multiple-infos in one call, they are retried one by one. 
-        Requested params are always retrieved one by one, so the function can take a while to finish.        
+        Requested params and virtuals are always retrieved one by one, so the function can take a while to finish.        
 
         Returns None if not connected, otherwise returns the list of requested values
         Throws
@@ -321,6 +331,7 @@ class AsyncXcomApiBase:
         """
 
         # 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] = []
@@ -328,26 +339,37 @@ class AsyncXcomApiBase:
 
         for idx,item in enumerate(request_data.items):
             
-            match item.datapoint.category:
-                case XcomCategory.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)
-
-                    elif item.address is not None:
-                        # Any others need to be done via an individual request_value cal
-                        req_singles.append(item)
+            match item.datapoint.target:
+                case XcomTarget.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}")
 
-                case XcomCategory.PARAMETER:
-                    if item.address is not None:
-                        # Needs to be done via an individual request_value call
-                        req_singles.append(item)
+                case XcomTarget.STANDARD:
+                    # Standard datapoints are handled depending on category and aggregation type
+                    match item.datapoint.category:
+                        case XcomCategory.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)
 
-                    else:
-                        raise XcomParamException(f"Invalid XcomValuesItem passed to request_values; violated by code='{item.code}', address={item.address}, aggregation_type={item.aggregation_type}")
+                            elif item.address is not None:
+                                # Any others need to be done via an individual request_value cal
+                                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}")
+
+                        case XcomCategory.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}")
             
             if (len(req_multi_items) == MULTI_INFO_REQ_MAX) or \
                (len(req_multi_items) > 0 and idx == idx_last):
@@ -417,6 +439,36 @@ class AsyncXcomApiBase:
                 await asyncio.sleep(1)
                 burst_start = datetime.now()
 
+        # Finally perform all the virtual request_value requests
+        for req_virtual in req_virtuals:
+            try:
+                error = None
+                value = await self.request_virtual(req_virtual.datapoint, req_virtual.address, retries=retries, timeout=timeout, verbose=verbose)
+            
+            except Exception as ex:
+                value = None
+                error = str(ex)
+
+            if error is not None:
+                _LOGGER.debug(f"Failed to retrieve virtual info or param {req_virtual.datapoint.nr}:{req_virtual.address}; {error}")
+
+            # Add to results
+            rsp_virtual = XcomValuesItem(
+                datapoint = req_virtual.datapoint, 
+                code = req_virtual.code,
+                address = req_virtual.address,
+                aggregation_type=req_virtual.aggregation_type, 
+                value = value,
+                error = error,
+            )
+            result_items.append(rsp_virtual)
+
+            # Periodically wait for a second. This will make sure we do not block Xcom-LAN with
+            # too many requests at once and prevent it from uploading data to the Studer portal.
+            if (datetime.now() - burst_start).total_seconds() > REQ_BURST_PERIOD:
+                await asyncio.sleep(1)
+                burst_start = datetime.now()
+
         # Return all reponse items as one XcomValues object
         return XcomValues(result_items)
 

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/src/pystuderxcom/api_base_sync.py

@@ -16,6 +16,7 @@ from .const import (
     REQ_BURST_PERIOD,
     ScomAddress,
     XcomFormat,
+    XcomTarget,
     XcomCategory,
     XcomAggregationType,
     ScomFrameFlag,
@@ -58,8 +59,8 @@ from .values import (
     XcomValues,
     XcomValuesItem,
 )
-import time
 import threading
+import time
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -200,14 +201,14 @@ class XcomApiBase:
             XcomApiResponseIsError
         """
 
+        # Sanity check
+        if parameter.target != XcomTarget.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)
 
-        # Check for virtual value request
-        if parameter.category in [XcomCategory.VIRTUAL]:
-            return self.request_virtual(parameter, dstAddr=dstAddr, retries=retries, timeout=timeout, verbose=verbose)
-
         # Compose the request and send it
         request: XcomPackage = XcomPackage.gen_package(
             service_id = ScomServiceId.READ,
@@ -239,9 +240,12 @@ class XcomApiBase:
             XcomApiTimeoutException
             XcomApiResponseIsError
         """
-
+        # Sanity check
         if not self.connected:
             return None
+
+        if parameter.target != XcomTarget.VIRTUAL:
+            raise XcomParamException(f"Invalid datapoint passed to request_value; must have target VIRTUAL. Violated by datapoint '{parameter.name}' ({parameter.nr})")
     
         # Virtual request
         match parameter.nr:
@@ -259,6 +263,9 @@ class XcomApiBase:
                         case 99021: return datetime.fromtimestamp(msg.timestamp)
                         case 99022: return msg.source_address
 
+            case _:
+                raise XcomParamException(f"Invalid datapoint passed to request_virtual; nr not recognized. Violated by datapoint '{parameter.name}' ({parameter.nr})")
+
         return None
             
                                          
@@ -280,6 +287,9 @@ class XcomApiBase:
 
         # Sanity check
         for item in request_data.items:
+            if item.datapoint.target != XcomTarget.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:
                 raise XcomParamException(f"Invalid datapoint passed to request_infos; must have type INFO. Violated by datapoint '{item.datapoint.name}' ({item.datapoint.nr})")
             
@@ -309,12 +319,12 @@ class XcomApiBase:
 
     def request_values(self, request_data: XcomValues, retries = None, timeout = None, verbose=False) -> XcomValues:
         """
-        Request multiple infos and params in one call.
+        Request multiple infos, params or virtuals in one call.
         Can only retrieve actual device values, NOT the average or sum over multiple devices.
 
         The function will try to be as efficient as possible and combine retrieval of multiple infos in one call.
         When the xcom-client does not support multiple-infos in one call, they are retried one by one. 
-        Requested params are always retrieved one by one, so the function can take a while to finish.        
+        Requested params and virtuals are always retrieved one by one, so the function can take a while to finish.        
 
         Returns None if not connected, otherwise returns the list of requested values
         Throws
@@ -325,6 +335,7 @@ class XcomApiBase:
         """
 
         # 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] = []
@@ -332,26 +343,37 @@ class XcomApiBase:
 
         for idx,item in enumerate(request_data.items):
             
-            match item.datapoint.category:
-                case XcomCategory.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)
-
-                    elif item.address is not None:
-                        # Any others need to be done via an individual request_value cal
-                        req_singles.append(item)
+            match item.datapoint.target:
+                case XcomTarget.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}")
 
-                case XcomCategory.PARAMETER:
-                    if item.address is not None:
-                        # Needs to be done via an individual request_value call
-                        req_singles.append(item)
+                case XcomTarget.STANDARD:
+                    # Standard datapoints are handled depending on category and aggregation type
+                    match item.datapoint.category:
+                        case XcomCategory.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)
 
-                    else:
-                        raise XcomParamException(f"Invalid XcomValuesItem passed to request_values; violated by code='{item.code}', address={item.address}, aggregation_type={item.aggregation_type}")
+                            elif item.address is not None:
+                                # Any others need to be done via an individual request_value cal
+                                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}")
+
+                        case XcomCategory.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}")
             
             if (len(req_multi_items) == MULTI_INFO_REQ_MAX) or \
                (len(req_multi_items) > 0 and idx == idx_last):
@@ -421,6 +443,36 @@ class XcomApiBase:
                 time.sleep(1)
                 burst_start = datetime.now()
 
+        # Finally perform all the virtual request_value requests
+        for req_virtual in req_virtuals:
+            try:
+                error = None
+                value = self.request_virtual(req_virtual.datapoint, req_virtual.address, retries=retries, timeout=timeout, verbose=verbose)
+            
+            except Exception as ex:
+                value = None
+                error = str(ex)
+
+            if error is not None:
+                _LOGGER.debug(f"Failed to retrieve virtual info or param {req_virtual.datapoint.nr}:{req_virtual.address}; {error}")
+
+            # Add to results
+            rsp_virtual = XcomValuesItem(
+                datapoint = req_virtual.datapoint, 
+                code = req_virtual.code,
+                address = req_virtual.address,
+                aggregation_type=req_virtual.aggregation_type, 
+                value = value,
+                error = error,
+            )
+            result_items.append(rsp_virtual)
+
+            # Periodically wait for a second. This will make sure we do not block Xcom-LAN with
+            # too many requests at once and prevent it from uploading data to the Studer portal.
+            if (datetime.now() - burst_start).total_seconds() > REQ_BURST_PERIOD:
+                time.sleep(1)
+                burst_start = datetime.now()
+
         # Return all reponse items as one XcomValues object
         return XcomValues(result_items)
 

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/src/pystuderxcom/const.py

@@ -37,6 +37,9 @@ REQ_TIMEOUT = 3
 REQ_RETRIES = 3
 REQ_BURST_PERIOD = 5 # do burst of requests for 5 seconds, then wait a second, then the next burst
 
+NR_VIRTUAL_START = 98000
+NR_VIRTUAL_END = 99999
+
 
 class XcomApiTcpMode(StrEnum):
     SERVER = "server"
@@ -187,9 +190,13 @@ class XcomMultiInfoFlags(IntEnum):
     VT_PRESENT  = 0x00000080,
     VS_PRESENT  = 0x00000100,
 
+### values for target
+class XcomTarget(StrEnum):
+    STANDARD    = "standard"
+    VIRTUAL     = "virtual"
+
 ### values for category
 class XcomCategory:
-    VIRTUAL    = 0x0000
     INFO       = 0x0001
     PARAMETER  = 0x0002
 
@@ -208,7 +215,6 @@ class ScomObjType:
     def __repr__(self):
         return self.name
 
-    @staticmethod
     @staticmethod
     def from_str(s: str, default: int|None = None):
         for e in XcomAggregationType:

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/src/pystuderxcom/datapoints.py

@@ -9,9 +9,15 @@ import logging
 from dataclasses import dataclass
 
 from .const import (
+    NR_VIRTUAL_END,
+    NR_VIRTUAL_START,
     XcomLevel,
     XcomFormat,
     XcomCategory,
+    XcomTarget,
+)
+from .families import (
+    XcomDeviceFamilies,
 )
 
 
@@ -82,9 +88,6 @@ class XcomDatapoint:
         
     @property
     def category(self) -> XcomCategory:
-        if self.nr >= 99000:
-            return XcomCategory.VIRTUAL
-        
         if self.level in [XcomLevel.INFO]:
             return XcomCategory.INFO
 
@@ -94,6 +97,13 @@ class XcomDatapoint:
         _LOGGER.debug(f"Unknown category for datapoint {self.nr} with level {self.level} and format {self.format}")
         return XcomCategory.INFO
     
+    @property
+    def target(self) -> XcomTarget:
+        if NR_VIRTUAL_START <= self.nr <= NR_VIRTUAL_END:
+            return XcomTarget.VIRTUAL
+        else:
+            return XcomTarget.STANDARD
+    
     def enum_value(self, key):
         if self.format not in [XcomFormat.LONG_ENUM, XcomFormat.SHORT_ENUM]:
             return None

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/src/pystuderxcom/datapoints_xcom.json

@@ -1,6 +1,9 @@
 [
     {  "_rem": "Extra 'virtual' Xcom datapoints"},
 
+    {  "_rem": "These are not included in 'Studer Technical Specification - Xtender serial protocol appendix'"},
+    {  "_rem": "But are defined by us based on other parameters exposed by the Xcom protocol"},
+
     {  "_rem": "Column descriptions:"},
     {  "_rem": "  fam  = Device Family"},
     {  "_rem": "  lvl  = User level required to access the param or info"},

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/src/pystuderxcom/discover_async.py

@@ -17,6 +17,7 @@ from .api_base_sync import (
 )
 from .const import (
     XcomDiscoverNotConnected,
+    XcomTarget,
 )
 from .data import (
     XcomDiscoveredDevice,
@@ -86,7 +87,10 @@ class AsyncXcomDiscover:
                     param = self._dataset.get_by_nr(nr, family.id_for_nr)
 
                     _LOGGER.info(f"Trying device {device_code} on {device_addr} for nr {nr}")
-                    value = await self._api.request_value(param, device_addr, verbose=verbose)
+                    match param.target:
+                        case XcomTarget.STANDARD: value = await self._api.request_value(param, device_addr, verbose=verbose)
+                        case XcomTarget.VIRTUAL : value = await self._api.request_virtual(param, device_addr, verbose=verbose)
+                        
                     if value is not None:
                         _LOGGER.info(f"  Found device {device_code} via {nr}:{device_addr}")
 

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/src/pystuderxcom/discover_sync.py

@@ -19,6 +19,7 @@ from .api_base_sync import (
 )
 from .const import (
     XcomDiscoverNotConnected,
+    XcomTarget,
 )
 from .data import (
     XcomDiscoveredDevice,
@@ -89,7 +90,10 @@ class XcomDiscover:
                     param = self._dataset.get_by_nr(nr, family.id_for_nr)
 
                     _LOGGER.info(f"Trying device {device_code} on {device_addr} for nr {nr}")
-                    value = self._api.request_value(param, device_addr, verbose=verbose)
+                    match param.target:
+                        case XcomTarget.STANDARD: value = self._api.request_value(param, device_addr, verbose=verbose)
+                        case XcomTarget.VIRTUAL : value = self._api.request_virtual(param, device_addr, verbose=verbose)
+                        
                     if value is not None:
                         _LOGGER.info(f"  Found device {device_code} via {nr}:{device_addr}")
 

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/src/pystuderxcom/families.py

@@ -139,10 +139,10 @@ class XcomDeviceFamilies:
     )
     XCOM = XcomDeviceFamily(    
         "xcom", "xcom",        # virtual device to expose additional values in a uniform way
-        "Xcom", 
+        "Xcom-LAN/232i", 
         990,                   # addr multicast to all devices (write only)
         990, 990,              # addr devices,  start to end
-        0, 0,                  # nr for params, start to end
+        98000, 98999,          # nr for params, start to end
         99000, 99999,          # nr for infos,  start to end 
         99000,                 # nr for discovery
     )

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2/src/pystuderxcom.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pystuderxcom
-Version: 3.4.1
+Version: 3.4.2
 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

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/tests/test_api_base_async.py

@@ -9,8 +9,9 @@ from pystuderxcom import AsyncXcomFactory, XcomFactory
 from pystuderxcom import XcomApiTimeoutException, XcomApiResponseIsError, XcomParamException
 from pystuderxcom import XcomDataset, XcomData, XcomPackage
 from pystuderxcom import XcomValues, XcomValuesItem
-from pystuderxcom import XcomVoltage, XcomFormat, XcomAggregationType, ScomServiceId, ScomServiceFlag, ScomFrameFlag, ScomObjType, ScomObjId, ScomQspId, ScomAddress, ScomErrorCode
+from pystuderxcom import XcomVoltage, XcomFormat, XcomAggregationType, XcomTarget, ScomServiceId, ScomServiceFlag, ScomFrameFlag, ScomObjType, ScomObjId, ScomQspId, ScomAddress, ScomErrorCode
 from pystuderxcom import XcomDataMessageRsp
+
 from . import AsyncTestApi, TestApi
 from . import AsyncTaskHelper, TaskHelper
 
@@ -63,6 +64,7 @@ async def data_message():
 @pytest.mark.parametrize(
     "name, test_nr, test_dest, rsp_frm_flags, rsp_data, exp_value, exp_except",
     [
+        ("request virtual err",                 3000,  100, 0x00,                                     None, None,  XcomParamException),
         ("request virtual false",               99000, 990, 0x00,                                     None, False, None),
         ("request virtual is_message_pending",  99000, 990, ScomFrameFlag.IS_MESSAGE_PENDING,         None, True,  None),
         ("request virtual was_rcc_reseted",     99001, 990, ScomFrameFlag.WAS_RCC_RESETED,            None, True,  None),
@@ -99,7 +101,6 @@ async def test_request_virtual(name, test_nr, test_dest, rsp_frm_flags, rsp_data
 
     if exp_except == None:
         value = await api.request_virtual(param, test_dest, retries=1, timeout=5)
-
         assert value == exp_value
     else:
         with pytest.raises(exp_except):
@@ -162,6 +163,7 @@ async def test_request_guid(name, exp_dst_addr, exp_svc_id, exp_obj_type, exp_ob
         ("request info timeout", 3000, 100, 100, ScomServiceId.READ, ScomObjType.INFO, 3000, ScomQspId.VALUE, 0x00, XcomData.pack(1234.0, XcomFormat.FLOAT), None, XcomApiTimeoutException),
         ("request param ok",     1107, 100, 100, ScomServiceId.READ, ScomObjType.PARAMETER, 1107, ScomQspId.UNSAVED_VALUE, 0x02, XcomData.pack(1234.0, XcomFormat.FLOAT), 1234.0, None),
         ("request param vo",     5012, 501, 501, ScomServiceId.READ, ScomObjType.PARAMETER, 5012, ScomQspId.UNSAVED_VALUE, 0x02, XcomData.pack(32, XcomFormat.INT32), 32, None),
+        ("request virtual err", 99003, 990, 990, ScomServiceId.READ, ScomObjType.INFO, 3000, ScomQspId.VALUE, 0x02, XcomData.pack(1234.0, XcomFormat.FLOAT), None, XcomParamException),
     ]
 )
 async def test_request_value(name, test_nr, test_dest, exp_dst_addr, exp_svc_id, exp_obj_type, exp_obj_id, exp_prop_id, rsp_flags, rsp_data, exp_value, exp_except, request):
@@ -173,6 +175,7 @@ async def test_request_value(name, test_nr, test_dest, exp_dst_addr, exp_svc_id,
         """Helper to turn a request into a response"""
         api.response_package = copy.deepcopy(api.request_package)
 
+        api.response_package.header.frame_flags = ScomFrameFlag.IS_MESSAGE_PENDING
         api.response_package.frame_data.service_flags = rsp_flags
         api.response_package.frame_data.service_data.property_data = rsp_data
         api.response_package.header.data_length = len(api.response_package.frame_data)
@@ -281,9 +284,12 @@ async def data_infos_dev(dataset):
             XcomValuesItem(info_3023, aggregation_type=XcomAggregationType.DEVICE1, value=78.9),
         ]
     )
-    rsp_single_val = None
-    
-    yield req_data, rsp_multi, rsp_single_val
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[]
+    )
+    yield req_data, rsp_multi, rsp_single
 
 @pytest_asyncio.fixture
 async def data_infos_aggr(dataset):
@@ -305,9 +311,12 @@ async def data_infos_aggr(dataset):
             XcomValuesItem(info_3023, aggregation_type=XcomAggregationType.SUM, value=78.9),
         ]
     )
-    rsp_single_val = None
-    
-    yield req_data, rsp_multi, rsp_single_val
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[]
+    )
+    yield req_data, rsp_multi, rsp_single
 
 @pytest_asyncio.fixture
 async def data_infos_params_dev(dataset):
@@ -328,9 +337,14 @@ async def data_infos_params_dev(dataset):
             XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.DEVICE1, value=45.6),
         ]
     )
-    rsp_single_val = 1234.0
-
-    yield req_data, rsp_multi, rsp_single_val
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(param_1107, aggregation_type=XcomAggregationType.DEVICE1, value=1234.0),
+        ]
+    )
+    yield req_data, rsp_multi, rsp_single
 
 
 @pytest_asyncio.fixture
@@ -352,13 +366,82 @@ async def data_infos_params_aggr(dataset):
             XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.AVERAGE, value=45.6),
         ]
     )
-    rsp_single_val = 1234.0
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(param_1107, aggregation_type=XcomAggregationType.DEVICE1, value=1234.0),
+        ]
+    )
+    yield req_data, rsp_multi, rsp_single
+
+
+@pytest_asyncio.fixture
+async def data_infos_virt_dev(dataset):
+    info_3021 = dataset.get_by_nr(3021)
+    info_3022 = dataset.get_by_nr(3022)
+    param_1107 = dataset.get_by_nr(1107)
+    info_99003 = dataset.get_by_nr(99003)
+
+    req_data = XcomValues([
+        XcomValuesItem(info_3021, code="XT1"),
+        XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.DEVICE1),
+        XcomValuesItem(param_1107, address=101),
+        XcomValuesItem(info_99003, code="XCOM"), # Make sure to have another single request prior to virtual
+    ])
+    rsp_multi = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(info_3021, aggregation_type=XcomAggregationType.MASTER, value=12.3),
+            XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.DEVICE1, value=45.6),
+        ]
+    )
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(param_1107, aggregation_type=XcomAggregationType.DEVICE1, value=1234.0),
+            XcomValuesItem(info_99003, aggregation_type=XcomAggregationType.DEVICE1, value=True),
+        ]
+    )
+    yield req_data, rsp_multi, rsp_single
+
 
-    yield req_data, rsp_multi, rsp_single_val
+@pytest_asyncio.fixture
+async def data_infos_virt_aggr(dataset):
+    info_3021 = dataset.get_by_nr(3021)
+    info_3022 = dataset.get_by_nr(3022)
+    param_1107 = dataset.get_by_nr(1107)
+    info_99003 = dataset.get_by_nr(99003)
+
+    req_data = XcomValues([
+        XcomValuesItem(info_3021, aggregation_type=XcomAggregationType.MASTER),
+        XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.AVERAGE),
+        XcomValuesItem(param_1107, address=101),
+        XcomValuesItem(info_99003, code="XCOM"), # Make sure to have another single request prior to virtual
+    ])
+    rsp_multi = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(info_3021, aggregation_type=XcomAggregationType.MASTER, value=12.3),
+            XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.AVERAGE, value=45.6),
+        ]
+    )
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(param_1107, aggregation_type=XcomAggregationType.DEVICE1, value=1234.0),
+            XcomValuesItem(info_99003, aggregation_type=XcomAggregationType.DEVICE1, value=True),
+        ]
+    )
+    yield req_data, rsp_multi, rsp_single
 
 
 @pytest.mark.asyncio
-@pytest.mark.usefixtures("dataset", "data_infos_dev", "data_infos_aggr", "data_infos_params_dev", "data_infos_params_aggr")
+@pytest.mark.usefixtures("dataset", "data_infos_dev", "data_infos_aggr", "data_infos_params_dev", "data_infos_params_aggr", "data_infos_virt_dev", "data_infos_virt_aggr")
 @pytest.mark.parametrize(
     "name, values_fixture, run_receive, exp_src_addr, exp_dst_addr, exp_svc_id, exp_obj_type, exp_obj_id, exp_prop_id, rsp_flags, exp_except",
     [
@@ -370,6 +453,8 @@ async def data_infos_params_aggr(dataset):
         ("request infos aggr timeout", "data_infos_aggr",        False, ScomAddress.SOURCE, 501, ScomServiceId.READ, ScomObjType.MULTI_INFO, ScomObjId.MULTI_INFO, ScomQspId.MULTI_INFO, 0x02, XcomApiTimeoutException),
         ("request infos params err",   "data_infos_params_dev",  False, ScomAddress.SOURCE, 501, ScomServiceId.READ, ScomObjType.MULTI_INFO, ScomObjId.MULTI_INFO, ScomQspId.MULTI_INFO, 0x03, XcomParamException),
         ("request infos params aggr",  "data_infos_params_aggr", False, ScomAddress.SOURCE, 501, ScomServiceId.READ, ScomObjType.MULTI_INFO, ScomObjId.MULTI_INFO, ScomQspId.MULTI_INFO, 0x03, XcomParamException),
+        ("request infos virt err",     "data_infos_virt_dev",    False, ScomAddress.SOURCE, 501, ScomServiceId.READ, ScomObjType.MULTI_INFO, ScomObjId.MULTI_INFO, ScomQspId.MULTI_INFO, 0x03, XcomParamException),
+        ("request infos virt aggr",    "data_infos_virt_aggr",   False, ScomAddress.SOURCE, 501, ScomServiceId.READ, ScomObjType.MULTI_INFO, ScomObjId.MULTI_INFO, ScomQspId.MULTI_INFO, 0x02, XcomParamException),
     ]
 )
 async def test_request_infos(name, values_fixture, run_receive, exp_src_addr, exp_dst_addr, exp_svc_id, exp_obj_type, exp_obj_id, exp_prop_id, rsp_flags, exp_except, request):
@@ -383,6 +468,7 @@ async def test_request_infos(name, values_fixture, run_receive, exp_src_addr, ex
         else:
             api.response_package = copy.deepcopy(api.request_package)
 
+            api.response_package.header.frame_flags = 0x1F
             api.response_package.frame_data.service_flags = rsp_flags
             if rsp_flags & 0x01:
                 api.response_package.frame_data.service_data.property_data = XcomData.pack(ScomErrorCode.READ_PROPERTY_FAILED, XcomFormat.ERROR)
@@ -435,7 +521,7 @@ async def test_request_infos(name, values_fixture, run_receive, exp_src_addr, ex
 
 
 @pytest.mark.asyncio
-@pytest.mark.usefixtures("dataset", "data_infos_dev", "data_infos_aggr", "data_infos_params_dev", "data_infos_params_aggr")
+@pytest.mark.usefixtures("dataset", "data_infos_dev", "data_infos_aggr", "data_infos_params_dev", "data_infos_params_aggr", "data_infos_virt_dev", "data_infos_virt_aggr")
 @pytest.mark.parametrize(
     "name, values_fixture, run_receive, rsp_flags, exp_value, exp_error, exp_except",
     [
@@ -445,11 +531,13 @@ async def test_request_infos(name, values_fixture, run_receive, exp_src_addr, ex
         ("request values infos aggr",     "data_infos_aggr",        False, 0x02, False, False, XcomParamException),
         ("request values params ok",      "data_infos_params_dev",  True,  0x02, True,  False, None),
         ("request values params aggr",    "data_infos_params_aggr", False, 0x02, False, False, XcomParamException),
+        ("request values virt ok",        "data_infos_virt_dev",    True,  0x02, True,  False, None),
+        ("request values virt aggr",      "data_infos_virt_aggr",   False, 0x02, False, False, XcomParamException),
     ]
 )
 async def test_request_values(name, values_fixture, run_receive, rsp_flags, exp_value, exp_error, exp_except, request):
     
-    req_data, exp_rsp_multi, exp_rsp_single_val = request.getfixturevalue(values_fixture)
+    req_data, exp_rsp_multi, exp_rsp_single = request.getfixturevalue(values_fixture)
 
     async def on_receive(api: AsyncTestApi):
         """Helper to turn a request into a response"""
@@ -457,6 +545,7 @@ async def test_request_values(name, values_fixture, run_receive, rsp_flags, exp_
             api.response_package = None
         else:
             api.response_package = copy.deepcopy(api.request_package)
+            api.response_package.header.frame_flags = 0x1F
             api.response_package.frame_data.service_flags = rsp_flags
 
             if rsp_flags & 0x01:
@@ -466,7 +555,8 @@ async def test_request_values(name, values_fixture, run_receive, rsp_flags, exp_
                 api.response_package.frame_data.service_data.property_data = exp_rsp_multi.pack_response()
 
             else:
-                api.response_package.frame_data.service_data.property_data = XcomData.pack(exp_rsp_single_val, XcomFormat.FLOAT)
+                item = next( (i for i in exp_rsp_single.items if i.datapoint.nr == api.request_package.frame_data.service_data.object_id), None)
+                api.response_package.frame_data.service_data.property_data = XcomData.pack(item.value, XcomFormat.FLOAT)
 
             api.response_package.header.data_length = len(api.response_package.frame_data)
 
@@ -494,7 +584,11 @@ async def test_request_values(name, values_fixture, run_receive, rsp_flags, exp_
                 if exp_item is not None:
                     exp_val = exp_item.value
                 else:
-                    exp_val = exp_rsp_single_val
+                    exp_item = next((i for i in exp_rsp_single.items if i.datapoint.nr==item.datapoint.nr and i.aggregation_type==item.aggregation_type), None)
+                    if exp_item is not None:
+                        exp_val = exp_item.value
+                    else:
+                        exp_val = None
 
                 match item.datapoint.format:
                     case XcomFormat.FLOAT:

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/tests/test_api_base_sync.py

@@ -11,8 +11,9 @@ from pystuderxcom import AsyncXcomFactory, XcomFactory
 from pystuderxcom import XcomApiTimeoutException, XcomApiResponseIsError, XcomParamException
 from pystuderxcom import XcomDataset, XcomData, XcomPackage
 from pystuderxcom import XcomValues, XcomValuesItem
-from pystuderxcom import XcomVoltage, XcomFormat, XcomAggregationType, ScomServiceId, ScomServiceFlag, ScomFrameFlag, ScomObjType, ScomObjId, ScomQspId, ScomAddress, ScomErrorCode
+from pystuderxcom import XcomVoltage, XcomFormat, XcomAggregationType, XcomTarget, ScomServiceId, ScomServiceFlag, ScomFrameFlag, ScomObjType, ScomObjId, ScomQspId, ScomAddress, ScomErrorCode
 from pystuderxcom import XcomDataMessageRsp
+
 from . import AsyncTestApi, TestApi
 from . import AsyncTaskHelper, TaskHelper
 
@@ -65,6 +66,7 @@ def data_message():
 @pytest.mark.parametrize(
     "name, test_nr, test_dest, rsp_frm_flags, rsp_data, exp_value, exp_except",
     [
+        ("request virtual err",                 3000,  100, 0x00,                                     None, None,  XcomParamException),
         ("request virtual false",               99000, 990, 0x00,                                     None, False, None),
         ("request virtual is_message_pending",  99000, 990, ScomFrameFlag.IS_MESSAGE_PENDING,         None, True,  None),
         ("request virtual was_rcc_reseted",     99001, 990, ScomFrameFlag.WAS_RCC_RESETED,            None, True,  None),
@@ -101,7 +103,6 @@ def test_request_virtual(name, test_nr, test_dest, rsp_frm_flags, rsp_data,exp_v
 
     if exp_except == None:
         value = api.request_virtual(param, test_dest, retries=1, timeout=5)
-
         assert value == exp_value
     else:
         with pytest.raises(exp_except):
@@ -164,6 +165,7 @@ def test_request_guid(name, exp_dst_addr, exp_svc_id, exp_obj_type, exp_obj_id,
         ("request info timeout", 3000, 100, 100, ScomServiceId.READ, ScomObjType.INFO, 3000, ScomQspId.VALUE, 0x00, XcomData.pack(1234.0, XcomFormat.FLOAT), None, XcomApiTimeoutException),
         ("request param ok",     1107, 100, 100, ScomServiceId.READ, ScomObjType.PARAMETER, 1107, ScomQspId.UNSAVED_VALUE, 0x02, XcomData.pack(1234.0, XcomFormat.FLOAT), 1234.0, None),
         ("request param vo",     5012, 501, 501, ScomServiceId.READ, ScomObjType.PARAMETER, 5012, ScomQspId.UNSAVED_VALUE, 0x02, XcomData.pack(32, XcomFormat.INT32), 32, None),
+        ("request virtual err", 99003, 990, 990, ScomServiceId.READ, ScomObjType.INFO, 3000, ScomQspId.VALUE, 0x02, XcomData.pack(1234.0, XcomFormat.FLOAT), None, XcomParamException),
     ]
 )
 def test_request_value(name, test_nr, test_dest, exp_dst_addr, exp_svc_id, exp_obj_type, exp_obj_id, exp_prop_id, rsp_flags, rsp_data, exp_value, exp_except, request):
@@ -175,6 +177,7 @@ def test_request_value(name, test_nr, test_dest, exp_dst_addr, exp_svc_id, exp_o
         """Helper to turn a request into a response"""
         api.response_package = copy.deepcopy(api.request_package)
 
+        api.response_package.header.frame_flags = ScomFrameFlag.IS_MESSAGE_PENDING
         api.response_package.frame_data.service_flags = rsp_flags
         api.response_package.frame_data.service_data.property_data = rsp_data
         api.response_package.header.data_length = len(api.response_package.frame_data)
@@ -283,9 +286,12 @@ def data_infos_dev(dataset):
             XcomValuesItem(info_3023, aggregation_type=XcomAggregationType.DEVICE1, value=78.9),
         ]
     )
-    rsp_single_val = None
-    
-    yield req_data, rsp_multi, rsp_single_val
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[]
+    )
+    yield req_data, rsp_multi, rsp_single
 
 @pytest.fixture
 def data_infos_aggr(dataset):
@@ -307,9 +313,12 @@ def data_infos_aggr(dataset):
             XcomValuesItem(info_3023, aggregation_type=XcomAggregationType.SUM, value=78.9),
         ]
     )
-    rsp_single_val = None
-    
-    yield req_data, rsp_multi, rsp_single_val
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[]
+    )
+    yield req_data, rsp_multi, rsp_single
 
 @pytest.fixture
 def data_infos_params_dev(dataset):
@@ -330,9 +339,14 @@ def data_infos_params_dev(dataset):
             XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.DEVICE1, value=45.6),
         ]
     )
-    rsp_single_val = 1234.0
-
-    yield req_data, rsp_multi, rsp_single_val
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(param_1107, aggregation_type=XcomAggregationType.DEVICE1, value=1234.0),
+        ]
+    )
+    yield req_data, rsp_multi, rsp_single
 
 
 @pytest.fixture
@@ -354,13 +368,82 @@ def data_infos_params_aggr(dataset):
             XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.AVERAGE, value=45.6),
         ]
     )
-    rsp_single_val = 1234.0
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(param_1107, aggregation_type=XcomAggregationType.DEVICE1, value=1234.0),
+        ]
+    )
+    yield req_data, rsp_multi, rsp_single
+
+
+@pytest.fixture
+def data_infos_virt_dev(dataset):
+    info_3021 = dataset.get_by_nr(3021)
+    info_3022 = dataset.get_by_nr(3022)
+    param_1107 = dataset.get_by_nr(1107)
+    info_99003 = dataset.get_by_nr(99003)
+
+    req_data = XcomValues([
+        XcomValuesItem(info_3021, code="XT1"),
+        XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.DEVICE1),
+        XcomValuesItem(param_1107, address=101),
+        XcomValuesItem(info_99003, code="XCOM"), # Make sure to have another single request prior to virtual
+    ])
+    rsp_multi = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(info_3021, aggregation_type=XcomAggregationType.MASTER, value=12.3),
+            XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.DEVICE1, value=45.6),
+        ]
+    )
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(param_1107, aggregation_type=XcomAggregationType.DEVICE1, value=1234.0),
+            XcomValuesItem(info_99003, aggregation_type=XcomAggregationType.DEVICE1, value=True),
+        ]
+    )
+    yield req_data, rsp_multi, rsp_single
+
 
-    yield req_data, rsp_multi, rsp_single_val
+@pytest.fixture
+def data_infos_virt_aggr(dataset):
+    info_3021 = dataset.get_by_nr(3021)
+    info_3022 = dataset.get_by_nr(3022)
+    param_1107 = dataset.get_by_nr(1107)
+    info_99003 = dataset.get_by_nr(99003)
+
+    req_data = XcomValues([
+        XcomValuesItem(info_3021, aggregation_type=XcomAggregationType.MASTER),
+        XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.AVERAGE),
+        XcomValuesItem(param_1107, address=101),
+        XcomValuesItem(info_99003, code="XCOM"), # Make sure to have another single request prior to virtual
+    ])
+    rsp_multi = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(info_3021, aggregation_type=XcomAggregationType.MASTER, value=12.3),
+            XcomValuesItem(info_3022, aggregation_type=XcomAggregationType.AVERAGE, value=45.6),
+        ]
+    )
+    rsp_single = XcomValues(
+        flags = 0x00, 
+        datetime = 0, 
+        items=[
+            XcomValuesItem(param_1107, aggregation_type=XcomAggregationType.DEVICE1, value=1234.0),
+            XcomValuesItem(info_99003, aggregation_type=XcomAggregationType.DEVICE1, value=True),
+        ]
+    )
+    yield req_data, rsp_multi, rsp_single
 
 
 @pytest.mark.asyncio
-@pytest.mark.usefixtures("dataset", "data_infos_dev", "data_infos_aggr", "data_infos_params_dev", "data_infos_params_aggr")
+@pytest.mark.usefixtures("dataset", "data_infos_dev", "data_infos_aggr", "data_infos_params_dev", "data_infos_params_aggr", "data_infos_virt_dev", "data_infos_virt_aggr")
 @pytest.mark.parametrize(
     "name, values_fixture, run_receive, exp_src_addr, exp_dst_addr, exp_svc_id, exp_obj_type, exp_obj_id, exp_prop_id, rsp_flags, exp_except",
     [
@@ -372,6 +455,8 @@ def data_infos_params_aggr(dataset):
         ("request infos aggr timeout", "data_infos_aggr",        False, ScomAddress.SOURCE, 501, ScomServiceId.READ, ScomObjType.MULTI_INFO, ScomObjId.MULTI_INFO, ScomQspId.MULTI_INFO, 0x02, XcomApiTimeoutException),
         ("request infos params err",   "data_infos_params_dev",  False, ScomAddress.SOURCE, 501, ScomServiceId.READ, ScomObjType.MULTI_INFO, ScomObjId.MULTI_INFO, ScomQspId.MULTI_INFO, 0x03, XcomParamException),
         ("request infos params aggr",  "data_infos_params_aggr", False, ScomAddress.SOURCE, 501, ScomServiceId.READ, ScomObjType.MULTI_INFO, ScomObjId.MULTI_INFO, ScomQspId.MULTI_INFO, 0x03, XcomParamException),
+        ("request infos virt err",     "data_infos_virt_dev",    False, ScomAddress.SOURCE, 501, ScomServiceId.READ, ScomObjType.MULTI_INFO, ScomObjId.MULTI_INFO, ScomQspId.MULTI_INFO, 0x03, XcomParamException),
+        ("request infos virt aggr",    "data_infos_virt_aggr",   False, ScomAddress.SOURCE, 501, ScomServiceId.READ, ScomObjType.MULTI_INFO, ScomObjId.MULTI_INFO, ScomQspId.MULTI_INFO, 0x02, XcomParamException),
     ]
 )
 def test_request_infos(name, values_fixture, run_receive, exp_src_addr, exp_dst_addr, exp_svc_id, exp_obj_type, exp_obj_id, exp_prop_id, rsp_flags, exp_except, request):
@@ -385,6 +470,7 @@ def test_request_infos(name, values_fixture, run_receive, exp_src_addr, exp_dst_
         else:
             api.response_package = copy.deepcopy(api.request_package)
 
+            api.response_package.header.frame_flags = 0x1F
             api.response_package.frame_data.service_flags = rsp_flags
             if rsp_flags & 0x01:
                 api.response_package.frame_data.service_data.property_data = XcomData.pack(ScomErrorCode.READ_PROPERTY_FAILED, XcomFormat.ERROR)
@@ -437,7 +523,7 @@ def test_request_infos(name, values_fixture, run_receive, exp_src_addr, exp_dst_
 
 
 @pytest.mark.asyncio
-@pytest.mark.usefixtures("dataset", "data_infos_dev", "data_infos_aggr", "data_infos_params_dev", "data_infos_params_aggr")
+@pytest.mark.usefixtures("dataset", "data_infos_dev", "data_infos_aggr", "data_infos_params_dev", "data_infos_params_aggr", "data_infos_virt_dev", "data_infos_virt_aggr")
 @pytest.mark.parametrize(
     "name, values_fixture, run_receive, rsp_flags, exp_value, exp_error, exp_except",
     [
@@ -447,11 +533,13 @@ def test_request_infos(name, values_fixture, run_receive, exp_src_addr, exp_dst_
         ("request values infos aggr",     "data_infos_aggr",        False, 0x02, False, False, XcomParamException),
         ("request values params ok",      "data_infos_params_dev",  True,  0x02, True,  False, None),
         ("request values params aggr",    "data_infos_params_aggr", False, 0x02, False, False, XcomParamException),
+        ("request values virt ok",        "data_infos_virt_dev",    True,  0x02, True,  False, None),
+        ("request values virt aggr",      "data_infos_virt_aggr",   False, 0x02, False, False, XcomParamException),
     ]
 )
 def test_request_values(name, values_fixture, run_receive, rsp_flags, exp_value, exp_error, exp_except, request):
     
-    req_data, exp_rsp_multi, exp_rsp_single_val = request.getfixturevalue(values_fixture)
+    req_data, exp_rsp_multi, exp_rsp_single = request.getfixturevalue(values_fixture)
 
     def on_receive(api: TestApi):
         """Helper to turn a request into a response"""
@@ -459,6 +547,7 @@ def test_request_values(name, values_fixture, run_receive, rsp_flags, exp_value,
             api.response_package = None
         else:
             api.response_package = copy.deepcopy(api.request_package)
+            api.response_package.header.frame_flags = 0x1F
             api.response_package.frame_data.service_flags = rsp_flags
 
             if rsp_flags & 0x01:
@@ -468,7 +557,8 @@ def test_request_values(name, values_fixture, run_receive, rsp_flags, exp_value,
                 api.response_package.frame_data.service_data.property_data = exp_rsp_multi.pack_response()
 
             else:
-                api.response_package.frame_data.service_data.property_data = XcomData.pack(exp_rsp_single_val, XcomFormat.FLOAT)
+                item = next( (i for i in exp_rsp_single.items if i.datapoint.nr == api.request_package.frame_data.service_data.object_id), None)
+                api.response_package.frame_data.service_data.property_data = XcomData.pack(item.value, XcomFormat.FLOAT)
 
             api.response_package.header.data_length = len(api.response_package.frame_data)
 
@@ -496,7 +586,11 @@ def test_request_values(name, values_fixture, run_receive, rsp_flags, exp_value,
                 if exp_item is not None:
                     exp_val = exp_item.value
                 else:
-                    exp_val = exp_rsp_single_val
+                    exp_item = next((i for i in exp_rsp_single.items if i.datapoint.nr==item.datapoint.nr and i.aggregation_type==item.aggregation_type), None)
+                    if exp_item is not None:
+                        exp_val = exp_item.value
+                    else:
+                        exp_val = None
 
                 match item.datapoint.format:
                     case XcomFormat.FLOAT:

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/tests/test_datapoints_async.py

@@ -6,6 +6,7 @@ from pystuderxcom import (
     XcomVoltage, 
     XcomFormat, 
     XcomCategory, 
+    XcomTarget,
     XcomDatapointUnknownException,
     AsyncXcomFactory,
     XcomFactory,
@@ -39,6 +40,7 @@ async def test_nr():
     assert param.nr == 1107
     assert param.format == XcomFormat.FLOAT
     assert param.category == XcomCategory.PARAMETER
+    assert param.target == XcomTarget.STANDARD
 
     param = dataset.get_by_nr(1552)
     assert param.family_id == "xt"
@@ -48,18 +50,21 @@ async def test_nr():
     assert param.options != None
     assert type(param.options) is dict
     assert len(param.options) == 3
+    assert param.target == XcomTarget.STANDARD
 
     param = dataset.get_by_nr(3000)
     assert param.family_id == "xt"
     assert param.nr == 3000
     assert param.format == XcomFormat.FLOAT
     assert param.category == XcomCategory.INFO
+    assert param.target == XcomTarget.STANDARD
 
     param = dataset.get_by_nr(3000, "xt")
     assert param.family_id == "xt"
     assert param.nr == 3000
     assert param.format == XcomFormat.FLOAT
     assert param.category == XcomCategory.INFO
+    assert param.target == XcomTarget.STANDARD
 
     param = dataset.get_by_nr(5012, "rcc")
     assert param.family_id == "rcc"
@@ -68,12 +73,14 @@ async def test_nr():
     assert param.category == XcomCategory.PARAMETER
     assert param.options != None
     assert type(param.options) is dict
+    assert param.target == XcomTarget.STANDARD
 
     param = dataset.get_by_nr(99000)
     assert param.family_id == "xcom"
     assert param.nr == 99000
     assert param.format == XcomFormat.BOOL
-    assert param.category == XcomCategory.VIRTUAL
+    assert param.category == XcomCategory.INFO
+    assert param.target == XcomTarget.VIRTUAL
 
     with pytest.raises(XcomDatapointUnknownException):
         param = dataset.get_by_nr(9999)

{pystuderxcom-3.4.1 → pystuderxcom-3.4.2}/tests/test_datapoints_sync.py

@@ -8,6 +8,7 @@ from pystuderxcom import (
     XcomVoltage, 
     XcomFormat, 
     XcomCategory, 
+    XcomTarget,
     XcomDatapointUnknownException,
     AsyncXcomFactory,
     XcomFactory,
@@ -41,6 +42,7 @@ def test_nr():
     assert param.nr == 1107
     assert param.format == XcomFormat.FLOAT
     assert param.category == XcomCategory.PARAMETER
+    assert param.target == XcomTarget.STANDARD
 
     param = dataset.get_by_nr(1552)
     assert param.family_id == "xt"
@@ -50,18 +52,21 @@ def test_nr():
     assert param.options != None
     assert type(param.options) is dict
     assert len(param.options) == 3
+    assert param.target == XcomTarget.STANDARD
 
     param = dataset.get_by_nr(3000)
     assert param.family_id == "xt"
     assert param.nr == 3000
     assert param.format == XcomFormat.FLOAT
     assert param.category == XcomCategory.INFO
+    assert param.target == XcomTarget.STANDARD
 
     param = dataset.get_by_nr(3000, "xt")
     assert param.family_id == "xt"
     assert param.nr == 3000
     assert param.format == XcomFormat.FLOAT
     assert param.category == XcomCategory.INFO
+    assert param.target == XcomTarget.STANDARD
 
     param = dataset.get_by_nr(5012, "rcc")
     assert param.family_id == "rcc"
@@ -70,12 +75,14 @@ def test_nr():
     assert param.category == XcomCategory.PARAMETER
     assert param.options != None
     assert type(param.options) is dict
+    assert param.target == XcomTarget.STANDARD
 
     param = dataset.get_by_nr(99000)
     assert param.family_id == "xcom"
     assert param.nr == 99000
     assert param.format == XcomFormat.BOOL
-    assert param.category == XcomCategory.VIRTUAL
+    assert param.category == XcomCategory.INFO
+    assert param.target == XcomTarget.VIRTUAL
 
     with pytest.raises(XcomDatapointUnknownException):
         param = dataset.get_by_nr(9999)