pystuderxcom 3.4.0__tar.gz → 3.4.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pystuderxcom
-Version: 3.4.0
+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.0 → pystuderxcom-3.4.2}/pyproject.toml

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

{pystuderxcom-3.4.0 → 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.0 → 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,6 +197,10 @@ 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)
@@ -220,6 +225,45 @@ class AsyncXcomApiBase:
                 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):
+        """
+        Request a virtual param or info.
+        Returns None if not connected, otherwise returns the requested value
+        Throws
+            XcomApiWriteException
+            XcomApiReadException
+            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:
+            case 99000:   return self.is_message_pending
+            case 99001:   return self.was_rcc_reseted
+            case 99002:   return self.is_sd_card_present
+            case 99003:   return self.is_sd_card_full
+            case 99004:   return self.is_new_datalogger_file_present
+
+            case 99020 | 99021 | 99022:
+                msg = await self.request_message(index=0, retries=retries, timeout=timeout, verbose=verbose)
+                if msg:
+                    match parameter.nr:
+                        case 99020: return msg.message_string
+                        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
+            
                                          
     async def request_infos(self, request_data: XcomValues, retries = None, timeout = None, verbose=False) -> XcomValues:
         """
@@ -239,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})")
             
@@ -268,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
@@ -284,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] = []
@@ -291,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):
@@ -380,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.0 → 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,6 +201,10 @@ 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)
@@ -224,6 +229,45 @@ class XcomApiBase:
                 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
 
+
+    def request_virtual(self, parameter: XcomDatapoint, dstAddr = 100, retries = None, timeout = None, verbose=False):
+        """
+        Request a virtual param or info.
+        Returns None if not connected, otherwise returns the requested value
+        Throws
+            XcomApiWriteException
+            XcomApiReadException
+            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:
+            case 99000:   return self.is_message_pending
+            case 99001:   return self.was_rcc_reseted
+            case 99002:   return self.is_sd_card_present
+            case 99003:   return self.is_sd_card_full
+            case 99004:   return self.is_new_datalogger_file_present
+
+            case 99020 | 99021 | 99022:
+                msg = self.request_message(index=0, retries=retries, timeout=timeout, verbose=verbose)
+                if msg:
+                    match parameter.nr:
+                        case 99020: return msg.message_string
+                        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
+            
                                          
     def request_infos(self, request_data: XcomValues, retries = None, timeout = None, verbose=False) -> XcomValues:
         """
@@ -243,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})")
             
@@ -272,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
@@ -288,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] = []
@@ -295,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):
@@ -384,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.0 → 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,6 +190,11 @@ class XcomMultiInfoFlags(IntEnum):
     VT_PRESENT  = 0x00000080,
     VS_PRESENT  = 0x00000100,
 
+### values for target
+class XcomTarget(StrEnum):
+    STANDARD    = "standard"
+    VIRTUAL     = "virtual"
+
 ### values for category
 class XcomCategory:
     INFO       = 0x0001
@@ -207,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.0 → 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,
 )
 
 
@@ -91,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
@@ -117,6 +130,7 @@ class XcomDataset:
 
     PATH_120V = __file__.replace('.py', '_120v.json')
     PATH_240V = __file__.replace('.py', '_240v.json')
+    PATH_XCOM = __file__.replace('.py', '_xcom.json')
 
     def __init__(self, datapoints: list[XcomDatapoint] | None = None):
         self._datapoints = datapoints

pystuderxcom-3.4.2/src/pystuderxcom/datapoints_xcom.json

@@ -0,0 +1,44 @@
+[
+    {  "_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"},
+    {  "_rem": "  pnr  = Parent number in menu structure"},
+    {  "_rem": "  nr   = Number of the param or info"},
+    {  "_rem": "  name = Friendly name of the param or info"},
+    {  "_rem": "  urcc = Data unit of measurement as displayed on RCC"},
+    {  "_rem": "  unit = Data unit of measurement"},
+    {  "_rem": "  def  = Default value"},
+    {  "_rem": "  min  = Minimum value"},
+    {  "_rem": "  max  = Maximum value"},
+    {  "_rem": "  fmt  = Data format"},
+    {  "_rem": "  inc  = Increment step"},
+    {  "_rem": "  opt  = Options for selection in Enums"},
+    {  "_rem": "  rem  = Remarks"},
+    
+
+    {  "_rem": "###"},
+    {  "_rem": "### Root Menu"},
+    {  "_rem": "###"},
+    {   "fam": "xcom",  "lvl": "Info",    "pnr": 0,       "nr": 990,     "name": "Xcom infos",   "fmt": "ONLY LEVEL",   "inc": "Menu" },
+
+    {  "_rem": "###"},
+    {  "_rem": "### Xcom specific params."},
+    {  "_rem": "###"},
+    {   "fam": "xcom",  "lvl": "Info",    "pnr": 990,     "nr": 99000,   "name": "Is message pending",             "short": "",   "urcc": "",   "unit": "",   "fmt": "BOOL" },
+    {   "fam": "xcom",  "lvl": "Info",    "pnr": 990,     "nr": 99001,   "name": "Was RCC reseted",                "short": "",   "urcc": "",   "unit": "",   "fmt": "BOOL" },
+    {   "fam": "xcom",  "lvl": "Info",    "pnr": 990,     "nr": 99002,   "name": "Is sd-card present",             "short": "",   "urcc": "",   "unit": "",   "fmt": "BOOL" },
+    {   "fam": "xcom",  "lvl": "Info",    "pnr": 990,     "nr": 99003,   "name": "Is sd-card full",                "short": "",   "urcc": "",   "unit": "",   "fmt": "BOOL" },
+    {   "fam": "xcom",  "lvl": "Info",    "pnr": 990,     "nr": 99004,   "name": "Is new datalogger file present", "short": "",   "urcc": "",   "unit": "",   "fmt": "BOOL" },
+    {   "fam": "xcom",  "lvl": "Info",    "pnr": 990,     "nr": 99020,   "name": "Latest message",                 "short": "",   "urcc": "",   "unit": "",   "fmt": "BOOL" },
+    {   "fam": "xcom",  "lvl": "Info",    "pnr": 990,     "nr": 99021,   "name": "Latest message time",            "short": "",   "urcc": "",   "unit": "",   "fmt": "BOOL" },
+    {   "fam": "xcom",  "lvl": "Info",    "pnr": 990,     "nr": 99022,   "name": "Latest message source",          "short": "",   "urcc": "",   "unit": "",   "fmt": "BOOL" },
+  
+    { "_rem": "###"},
+    { "_rem": "### End of file"},
+    { "_rem": "###"}    
+]

{pystuderxcom-3.4.0 → 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.0 → 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.0 → pystuderxcom-3.4.2}/src/pystuderxcom/factory_async.py

@@ -54,15 +54,19 @@ class AsyncXcomFactory:
             text_120vac = await file_120vac.read()
         async with aiofiles_open(XcomDataset.PATH_240V, "r", encoding="UTF-8") as file_240vac:
             text_240vac = await file_240vac.read()
+        async with aiofiles_open(XcomDataset.PATH_XCOM, "r", encoding="UTF-8") as file_xcom:
+            text_xcom = await file_xcom.read()
         
         values_120vac = orjson.loads(text_120vac)
         values_240vac = orjson.loads(text_240vac)
+        values_xcom   = orjson.loads(text_xcom)
 
         datapoints_120vac = list(filter(None, [XcomDatapoint.from_dict(val) for val in values_120vac]))
         datapoints_240vac = list(filter(None, [XcomDatapoint.from_dict(val) for val in values_240vac]))
+        datapoints_xcom   = list(filter(None, [XcomDatapoint.from_dict(val) for val in values_xcom]))
 
-        # start with the 240v list as base
-        datapoints = datapoints_240vac
+        # start with the merged 240v + xcom lists as base
+        datapoints = datapoints_240vac + datapoints_xcom
 
         match voltageAC:
             case XcomVoltage.AC240:

{pystuderxcom-3.4.0 → pystuderxcom-3.4.2}/src/pystuderxcom/factory_sync.py

@@ -56,15 +56,19 @@ class XcomFactory:
             text_120vac = file_120vac.read()
         with open(XcomDataset.PATH_240V, "r", encoding="UTF-8") as file_240vac:
             text_240vac = file_240vac.read()
+        with open(XcomDataset.PATH_XCOM, "r", encoding="UTF-8") as file_xcom:
+            text_xcom = file_xcom.read()
         
         values_120vac = orjson.loads(text_120vac)
         values_240vac = orjson.loads(text_240vac)
+        values_xcom   = orjson.loads(text_xcom)
 
         datapoints_120vac = list(filter(None, [XcomDatapoint.from_dict(val) for val in values_120vac]))
         datapoints_240vac = list(filter(None, [XcomDatapoint.from_dict(val) for val in values_240vac]))
+        datapoints_xcom   = list(filter(None, [XcomDatapoint.from_dict(val) for val in values_xcom]))
 
-        # start with the 240v list as base
-        datapoints = datapoints_240vac
+        # start with the merged 240v + xcom lists as base
+        datapoints = datapoints_240vac + datapoints_xcom
 
         match voltageAC:
             case XcomVoltage.AC240:

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pystuderxcom
-Version: 3.4.0
+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.0 → pystuderxcom-3.4.2}/src/pystuderxcom.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/pystuderxcom/data.py
 src/pystuderxcom/datapoints.py
 src/pystuderxcom/datapoints_120v.json
 src/pystuderxcom/datapoints_240v.json
+src/pystuderxcom/datapoints_xcom.json
 src/pystuderxcom/discover_async.py
 src/pystuderxcom/discover_sync.py
 src/pystuderxcom/factory_async.py