compit-inext-api-beta 0.4.0b10__tar.gz → 0.6.0b7__tar.gz

{compit_inext_api_beta-0.4.0b10 → compit_inext_api_beta-0.6.0b7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compit-inext-api-beta
-Version: 0.4.0b10
+Version: 0.6.0b7
 Summary: Compit Inext API - Python client
 Author: Przemyslaw Grzywa
 License: Apache-2.0

{compit_inext_api_beta-0.4.0b10 → compit_inext_api_beta-0.6.0b7}/compit_inext_api/__init__.py

@@ -5,8 +5,9 @@ from .api import CompitAPI, CannotConnect, InvalidAuth
 from .types.DeviceState import DeviceState, Param, DeviceInstance
 from .types.DeviceDefinitions import DeviceDefinitions, Parameter, ParameterDetails
 from .types.SystemInfo import SystemInfo, Gate, Device
-from .consts import CompitHVACMode, CompitParameter, CompitFanMode, CompitPresetMode
+from .consts import CompitHVACMode, CompitParameter, CompitFanMode, CompitPresetMode, CompitDevice
 from .connector import CompitApiConnector
+from .params_dictionary import PARAMS, PARAM_VALUES
 
 __all__ = [
     "DeviceDefinitionsLoader", 
@@ -22,9 +23,12 @@ __all__ = [
     "Device",
     "InvalidAuth",
     "CannotConnect",
+    "CompitDevice",
     "CompitHVACMode",
     "CompitParameter", 
     "CompitFanMode",
     "CompitPresetMode",
-    "CompitApiConnector"
+    "CompitApiConnector",
+    "PARAMS",
+    "PARAM_VALUES",
 ]

{compit_inext_api_beta-0.4.0b10 → compit_inext_api_beta-0.6.0b7}/compit_inext_api/api.py

@@ -19,7 +19,7 @@ API_URL = "https://inext.compit.pl/mobile/v2/compit"
 class CompitAPI:
     """API client for Compit."""
 
-    def __init__(self, email, password, session: aiohttp.ClientSession) -> None:
+    def __init__(self, email: str, password: str, session: aiohttp.ClientSession) -> None:
         """Initialize the CompitAPI class."""
         self.email = email
         self.password = password
@@ -107,7 +107,7 @@ class CompitAPI:
         try:
             _LOGGER.info("Set %s to %s for device %s", parameter, value, device_id)
 
-            data = {"values": [{"code": parameter.value if isinstance(parameter, CompitParameter) else parameter, "value": value}]}
+            data: dict[str, Any] = {"values": [{"code": parameter.value if isinstance(parameter, CompitParameter) else parameter, "value": value}]}
 
             response = await self._api_wrapper.put(
                 f"{API_URL}/devices/{device_id}/params", data=data, auth=self.token
@@ -157,7 +157,7 @@ class ApiWrapper:
         self._session = session
 
     async def get(
-        self, url: str, headers: dict | None = None, auth: Any = None
+        self, url: str, headers: dict[str, Any] | None = None, auth: Any = None
     ) -> aiohttp.ClientResponse:
         """Run http GET method."""
         if headers is None:
@@ -171,8 +171,8 @@ class ApiWrapper:
     async def post(
         self,
         url: str,
-        data: dict | None = None,
-        headers: dict | None = None,
+        data: dict[str, Any] | None = None,
+        headers: dict[str, Any] | None = None,
         auth: Any = None,
     ) -> aiohttp.ClientResponse:
         """Run http POST method."""
@@ -189,8 +189,8 @@ class ApiWrapper:
     async def put(
         self,
         url: str,
-        data: dict | None = None,
-        headers: dict | None = None,
+        data: dict[str, Any] | None = None,
+        headers: dict[str, Any] | None = None,
         auth: Any = None,
     ) -> aiohttp.ClientResponse:
         """Run http PUT method."""
@@ -206,8 +206,8 @@ class ApiWrapper:
         self,
         method: str,
         url: str,
-        data: dict | None = None,
-        headers: dict | None = None,
+        data: dict[str, Any] | None = None,
+        headers: dict[str, Any] | None = None,
         auth: Any = None,
     ) -> Any:
         """Get information from the API."""

{compit_inext_api_beta-0.4.0b10 → compit_inext_api_beta-0.6.0b7}/compit_inext_api/connector.py

@@ -3,9 +3,9 @@ import logging
 
 from compit_inext_api.api import CompitAPI
 from compit_inext_api.consts import CompitParameter
-from compit_inext_api.params_dictionary import PARAMS
 from compit_inext_api.device_definitions import DeviceDefinitionsLoader
-from compit_inext_api.types.DeviceState import DeviceInstance, DeviceState, GateInstance, Param
+from compit_inext_api.params_dictionary import PARAMS, PARAM_VALUES
+from compit_inext_api.types.DeviceState import DeviceInstance, GateInstance, Param
 
 
 _LOGGER: logging.Logger = logging.getLogger(__package__)
@@ -18,7 +18,7 @@ class CompitApiConnector:
 
     @property
     def all_devices(self) -> dict[int, DeviceInstance]:
-        devices = {}
+        devices: dict[int, DeviceInstance] = {}
         for gate in self.gates.values():
             devices.update(gate.devices)
         return devices
@@ -26,13 +26,23 @@ class CompitApiConnector:
     def __init__(self, session: aiohttp.ClientSession) -> None:
         self.session = session
 
+    def _resolve_parameter_code(self, device_code: int, parameter: CompitParameter) -> str:
+        mapping = PARAMS.get(parameter)
+        if not mapping:
+            return parameter.value
+
+        if device_code in mapping:
+            return mapping[device_code]
+
+        return parameter.value
+
     def get_device(self, device_id: int) -> DeviceInstance | None:
         for gate in self.gates.values():
             if device_id in gate.devices:
                 return gate.devices[device_id]
         return None
 
-    async def init(self, email: str, password: str, lang: str = "en") -> bool:
+    async def init(self, email: str, password: str, lang: str | None = None) -> bool:
         self.api = CompitAPI(email, password, self.session)
         self.systemInfo = await self.api.authenticate()
         if self.systemInfo is None:
@@ -43,7 +53,13 @@ class CompitApiConnector:
             self.gates[gates.id] = GateInstance(gates.id, gates.label)
             for device in gates.devices:
                 try:
-                    self.gates[gates.id].devices[device.id] = DeviceInstance(device.label, await DeviceDefinitionsLoader.get_device_definition(device.type, lang))
+                    self.gates[gates.id].devices[device.id] = DeviceInstance(
+                        device.label,
+                        await DeviceDefinitionsLoader.get_device_definition(
+                            device.type,
+                            lang=lang,
+                        ),
+                    )
                     state = await self.api.get_state(device.id)
                     if state:
                         self.gates[gates.id].devices[device.id].state = state
@@ -71,54 +87,81 @@ class CompitApiConnector:
         else:
             _LOGGER.error("Failed to get state for device %s", device_id)
 
-    def get_current_option(self, device_id: int, parameter: str | CompitParameter) -> str | None:
-        if isinstance(parameter, str):
-            parameter = CompitParameter(parameter)
+    def get_current_option(self, device_id: int, parameter: CompitParameter) -> str | None:
         device = self.get_device(device_id)
         if not device:
             return None
-        val = device.state.get_parameter_value(parameter.value)
-        param = PARAMS.get(parameter, None)
+
+        code = self._resolve_parameter_code(device.definition.code, parameter)
+        val = device.state.get_parameter_value(code)
+        
+        if val is None:
+            return None
+        
+        param = PARAM_VALUES.get(parameter, None)
         if param is None:
             return None
+
         for key, value in param.items():
-            if value == val:
+            if value == val.value:
                 return key
-        return None        
+            
+        return None              
 
-    def get_device_parameter(self, device_id: int, parameter: str | CompitParameter) -> Param | str | None:
+    def get_device_parameter(self, device_id: int, parameter: CompitParameter) -> Param | None:
         device = self.get_device(device_id)
         if not device:
             return None
-        return device.state.get_parameter_value(parameter if isinstance(parameter, str) else parameter.value)
+        code = self._resolve_parameter_code(device.definition.code, parameter)
+        param = device.state.get_parameter_value(code)
+        if param is None:
+            return None
+        
+        if param.value_label is None:
+            return param
+        
+        parameter_values = PARAM_VALUES.get(parameter, None)
 
-    async def select_device_option(self, device_id: int, parameter: str | CompitParameter, value: str) -> bool:
-        if isinstance(parameter, str):
-            parameter = CompitParameter(parameter)
+        if parameter_values is None:
+            return param
 
-        param = PARAMS.get(parameter, None)
-        if param is None:
+        for key, value in parameter_values.items():
+            if value == param.value:
+                param.value = key
+                break
+
+        return param
+
+    async def select_device_option(self, device_id: int, parameter: CompitParameter, value: str) -> bool:
+        device = self.get_device(device_id)
+        if device is None:
                 return False
-        val = param.get(value, None)
+                
+        code = self._resolve_parameter_code(device.definition.code, parameter)
+        
+        val = PARAM_VALUES.get(parameter, None)
         if val is None:
                 return False
-        result = await self.api.update_device_parameter(device_id, parameter, val)
+        
+        mapped_value = val.get(value, None)
+        if mapped_value is None:
+                return False
+        
+        result = await self.api.update_device_parameter(device_id, code, mapped_value)
         if result is None:
                 return False
-            
+        device.state.set_parameter_value(code, mapped_value)
+        return result
+
+    async def set_device_parameter(self, device_id: int, parameter: CompitParameter, value: str | float) -> bool:
         device = self.get_device(device_id)
         if device is None:
                 return False
-            
-        device.state.set_parameter_value(parameter if isinstance(parameter, str) else parameter.value, val)
-        return result
+        
+        code = self._resolve_parameter_code(device.definition.code, parameter)
 
-    async def set_device_parameter(self, device_id: int, parameter: str | CompitParameter, value: str | float) -> bool:
-        result = await self.api.update_device_parameter(device_id, parameter, value)
+        result = await self.api.update_device_parameter(device_id, code, value)
         if result:
-            device = self.get_device(device_id)
-            if device:
-                device.state.set_parameter_value(parameter if isinstance(parameter, str) else parameter.value, value)
-        return result
+            device.state.set_parameter_value(code, value)
 
-        
+        return result

compit_inext_api_beta-0.6.0b7/compit_inext_api/consts.py

@@ -0,0 +1,177 @@
+from enum import Enum
+
+
+class CompitHVACMode(Enum):
+    """Enum for available HVAC modes."""
+
+    HEAT = 0
+    OFF = 1
+    COOL = 2
+
+class CompitParameter(Enum):
+    """Enum for Compit device parameters."""
+    # Climate
+    CURRENT_TEMPERATURE = "CURRENT_TEMPERATURE"
+    SET_TARGET_TEMPERATURE = "SET_TARGET_TEMPERATURE"
+    FAN_MODE = "FAN_MODE"
+    PRESET_MODE = "PRESET_MODE"
+    HVAC_MODE = "HVAC_MODE"
+    TARGET_TEMPERATURE = "TARGET_TEMPERATURE"    
+
+    # Select
+    AEROKONFBYPASS = "__aerokonfbypass"
+    DHW_CIRCULATION_MODE = "__cwucyrkpraca"
+    BIOMAX_HEATING_SOURCE_OF_CORRECTION = "__pracakotla"
+    BIOMAX_MIXER_MODE_ZONE_1 = "__m1praca"
+    BIOMAX_MIXER_MODE_ZONE_2 = "__m2praca"
+    BUFFER_MODE = "__tr_buf"
+    HEATING_SOURCE_OF_CORRECTION = "__comode"
+    LANGUAGE = "_jezyk"
+    NANO_MODE = "__nano_mode"
+    WORK_MODE = "__sezprinst"
+    OPERATING_MODE = "OPERATING_MODE"
+    R470_OPERATING_MODE = "__mode"
+    R480_OPERATING_MODE = "__praca_pc"
+    R490_OPERATING_MODE = "__trprpompyciepla"
+    R900_OPERATING_MODE = "__tr_pracy_pc"    
+    SOLAR_COMP_OPERATING_MODE = "__trybpracy"
+    MIXER_MODE = "__pracamieszacza"
+
+    # Sensor
+    OUTDOOR_TEMPERATURE = "OUTDOOR_TEMPERATURE"
+    CO2_LEVEL = "CO2_LEVEL"
+    HUMIDITY = "HUMIDITY"    
+    PM1_LEVEL = "PM1_LEVEL"
+    PM25_LEVEL = "PM25_LEVEL"
+    PM10_LEVEL = "PM10_LEVEL"
+    PM4_LEVEL = "PM4_LEVEL"
+    DUST_ALERT = "DUST_ALERT"    
+    CO2_ALERT = "CO2_ALERT"
+    TEMPERATURE_ALERT = "TEMPERATURE_ALERT"
+    CO2_PERCENT = "CO2_PERCENT"
+    VENTILATION_ALARM = "VENTILATION_ALARM"
+    VENTILATION_GEAR = "VENTILATION_GEAR"
+    AIRING = "AIRING"
+    MIXER_TEMPERATURE = "MIXER_TEMPERATURE"
+    CIRCUIT_TARGET_TEMPERATURE = "CIRCUIT_TARGET_TEMPERATURE"
+    PROTECTION_TEMPERATURE = "PROTECTION_TEMPERATURE"
+    WEATHER_CURVE = "WEATHER_CURVE"
+    ENERGY_SGREADY_YESTERDAY = "ENERGY_SGREADY_YESTERDAY"
+    DHW_MEASURED_TEMPERATURE = "DHW_MEASURED_TEMPERATURE"
+    CALCULATED_TARGET_TEMPERATURE = "CALCULATED_TARGET_TEMPERATURE"
+    ENERGY_TOTAL = "ENERGY_TOTAL"
+    ENERGY_YESTERDAY = "ENERGY_YESTERDAY"
+    BOILER_TEMPERATURE = "BOILER_TEMPERATURE"
+    FUEL_LEVEL = "FUEL_LEVEL"
+    MIXER1_TEMPERATURE = "MIXER1_TEMPERATURE"
+    MIXER2_TEMPERATURE = "MIXER2_TEMPERATURE"
+    DHW_TEMPERATURE = "DHW_TEMPERATURE"
+    BUFFER_RETURN_TEMPERATURE = "BUFFER_RETURN_TEMPERATURE"
+    BUFFER_MEASURED_TEMPERATURE = "BUFFER_MEASURED_TEMPERATURE"
+    ACTUAL_BUFFER_TEMP = "ACTUAL_BUFFER_TEMP"
+    ACTUAL_DHW_TEMP = "ACTUAL_DHW_TEMP"
+    ACTUAL_UPPER_SOURCE_TEMP = "ACTUAL_UPPER_SOURCE_TEMP"
+    CALCULATED_BUFFER_TEMP = "CALCULATED_BUFFER_TEMP"
+    CALCULATED_DHW_TEMP = "CALCULATED_DHW_TEMP"
+    CALCULATED_UPPER_SOURCE_TEMP = "CALCULATED_UPPER_SOURCE_TEMP"
+    ACTUAL_CO1_TEMPERATURE = "ACTUAL_CO1_TEMPERATURE"
+    ACTUAL_CO2_TEMPERATURE = "ACTUAL_CO2_TEMPERATURE"
+    ACTUAL_CO3_TEMPERATURE = "ACTUAL_CO3_TEMPERATURE"
+    ACTUAL_CO4_TEMPERATURE = "ACTUAL_CO4_TEMPERATURE"
+    HEATING1_TARGET_TEMPERATURE = "HEATING1_TARGET_TEMPERATURE"
+    HEATING2_TARGET_TEMPERATURE = "HEATING2_TARGET_TEMPERATURE"
+    HEATING3_TARGET_TEMPERATURE = "HEATING3_TARGET_TEMPERATURE"
+    HEATING4_TARGET_TEMPERATURE = "HEATING4_TARGET_TEMPERATURE"
+    ALARM_CODE = "ALARM_CODE"
+    BATTERY_LEVEL = "BATTERY_LEVEL"
+    BATTERY_CHARGE_STATUS = "BATTERY_CHARGE_STATUS"
+    CHARGING_POWER = "CHARGING_POWER"
+    PUMP_STATUS = "PUMPE_STATUS"
+    RETURN_CIRCUT_TEMPERATURE = "RETURN_CIRCUT_TEMPERATURE"
+    HAS_BATTERY = "HAS_BATTERY"
+    HAS_EXTERNAL_POWER = "HAS_EXTERNAL_POWER"
+    CALCULATED_HEATING_TEMPERATURE = "CALCULATED_HEATING_TEMPERATURE"
+    TARGET_HEATING_TEMPERATURE = "TARGET_HEATING_TEMPERATURE"
+    CURRENT_HEATING_TEMP = "CURRENT_HEATING_TEMP"
+    RETURN_CIRCUIT_TEMPERATURE = "RETURN_CIRCUIT_TEMPERATURE"
+    COLLECTOR_TEMPERATURE = "COLLECTOR_TEMPERATURE"
+    TANK_BOTTOM_T2_TEMPERATURE = "TANK_BOTTOM_T2_TEMPERATURE"
+    TANK_TOP_T3_TEMPERATURE = "TANK_TOP_T3_TEMPERATURE"
+    COLLECTOR_POWER = "COLLECTOR_POWER"
+    BUFFER_SET_TEMPERATURE = "BUFFER_SET_TEMPERATURE"
+    ENERGY_TODAY = "ENERGY_TODAY"
+    TANK_T4_TEMPERATURE = "TANK_T4_TEMPERATURE"
+    UPPER_SOURCE_TEMPERATURE = "UPPER_SOURCE_TEMPERATURE"
+    LOWER_SOURCE_TEMPERATURE = "LOWER_SOURCE_TEMPERATURE"
+    CO_PUMP_ON_DELAY = "CO_PUMP_ON_DELAY"
+    CO_PUMP_OFF_DELAY = "CO_PUMP_OFF_DELAY"
+    PK1_FUNCTION = "PK1_FUNCTION"
+
+class CompitFanMode(Enum):
+    """Enum for available fan modes."""
+
+    OFF = 0
+    LOW = 1
+    MEDIUM = 2
+    HIGH = 3
+    HOLIDAY = 4
+    AUTO = 5
+
+class CompitPresetMode(Enum):
+    """Enum for available preset modes."""
+    
+    AUTO = 0
+    HOLIDAY = 1
+    MANUAL = 2
+    AWAY = 3
+
+class CompitDevice(Enum):
+    """Enum for Compit devices.
+
+    The enum value is the device `Code`, so you can look up a device by code:
+    `CompitDevice(223) -> CompitDevice.NANO_COLOR_2`.
+
+    Each member also exposes:
+    - `label`: original device name
+    - `device_class`: device class id
+    """
+
+    label: str
+    device_class: int
+
+    def __new__(cls, label: str, code: int, device_class: int):
+        obj = object.__new__(cls)
+        obj._value_ = code
+        obj.label = label
+        obj.device_class = device_class
+        return obj
+
+    AF_1 = ("AF-1", 226, 48)
+    BIOMAX742_2 = ("BioMax742", 36, 15)
+    BIOMAX742 = ("BioMax742", 212, 15)
+    BIOMAX772 = ("BioMax772", 75, 15)
+    BIOMAX775 = ("BioMax775", 201, 15)
+    BWC310 = ("BWC310", 14, 69)
+    COMBO = ("COMBO", 227, 49)
+    COMBO_PRO = ("COMBO PRO", 229, 37)
+    EL750 = ("EL750", 210, 29)
+    L2 = ("L2", 17, 12)
+    NANO_COLOR = ("Nano Color", 12, 10)
+    NANO_COLOR_2 = ("Nano Color 2", 223, 10)
+    NANO_ONE = ("Nano One", 7, 10)
+    R_900 = ("R 900", 224, 47)
+    R350CWU = ("R350.CWU", 53, 36)
+    R350M = ("R350.M", 221, 14)
+    R350_T3 = ("R350 T3", 5, 14)
+    R470 = ("r470", 34, 16)
+    R480 = ("R480", 215, 43)
+    R490 = ("r490", 92, 33)
+    R770RS_R771RS = ("R770RS / R771RS", 91, 25)
+    R810 = ("R810", 3, 14)
+    R810_1 = ("R810", 222, 34)
+    CO2_SHC = ("SHC", 27, 15)
+    SOLARCOMP_951 = ("SolarComp 951", 44, 18)
+    SOLARCOMP971 = ("SolarComp971", 45, 18)
+    SPM_NANO_COLOR = ("SPM - Nano Color", 225, 27)
+    SPM_NANO_COLOR2 = ("SPM - Nano Color2", 0, 46)
+    SPM_NANO_COLOR2_1 = ("SPM - Nano Color2", 78, 46)

{compit_inext_api_beta-0.4.0b10 → compit_inext_api_beta-0.6.0b7}/compit_inext_api/definitions/devices_en.json

@@ -1,6 +1,6 @@
 [
     {
-      "Name": "Nano Color 3",
+      "Name": "Nano Color 2",
       "Parameters": [
         {
           "ParameterCode": "__tpokojowa",
@@ -22104,6 +22104,173 @@
       "Class": 46,
       "ID": ""
     },
+    {
+      "Name": "SPM - Nano Color2",
+      "Parameters": [
+        {
+          "ParameterCode": "__rr_co2",
+          "Label": "Co2",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": "ppm"
+        },
+        {
+          "ParameterCode": "__hig",
+          "Label": "Humidity",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": "%"
+        },
+        {
+          "ParameterCode": "__vocindex",
+          "Label": "Voc index (volatile compounds)",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": null
+        },
+        {
+          "ParameterCode": "__rr_pm1",
+          "Label": "Pm1",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": "ug/m3"
+        },
+        {
+          "ParameterCode": "__rr_pm2_5",
+          "Label": "Pm2.5",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": "ug/m3"
+        },
+        {
+          "ParameterCode": "__rr_pm4",
+          "Label": "Pm4",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": "ug/m3"
+        },
+        {
+          "ParameterCode": "__temp",
+          "Label": "Temperature",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": "C"
+        },
+        {
+          "ParameterCode": "__flaga_pyly",
+          "Label": "Dust",
+          "ReadWrite": "R",
+          "Details": [
+            {
+              "State": 1,
+              "Description": "Normal",
+              "Param": "__nie"
+            },
+            {
+              "State": 0,
+              "Description": "Exceeded",
+              "Param": "__tak"
+            }
+          ],
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": null
+        },
+        {
+          "ParameterCode": "__osuszanie",
+          "Label": "Drying",
+          "ReadWrite": "R",
+          "Details": [
+            {
+              "State": 1,
+              "Description": "Yes",
+              "Param": "__tak"
+            },
+            {
+              "State": 0,
+              "Description": "No",
+              "Param": "__nie"
+            }
+          ],
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": null
+        },
+        {
+          "ParameterCode": "__flaga_co2",
+          "Label": "Co2",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": null
+        },
+        {
+          "ParameterCode": "__rr_pm10",
+          "Label": "Pm10",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": "ug/m3"
+        },
+        {
+          "ParameterCode": "__rr_fl_temp",
+          "Label": "Temperature (flaga)",
+          "ReadWrite": "R",
+          "Details": [
+            {
+              "State": 0,
+              "Description": "Ok",
+              "Param": "__ok"
+            },
+            {
+              "State": 1,
+              "Description": "Not ok",
+              "Param": "__nie_ok"
+            }
+          ],
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": null
+        },
+        {
+          "ParameterCode": "__rt_odczyt_co2",
+          "Label": "Rt - co2 reading",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": "ppm"
+        },
+        {
+          "ParameterCode": "__rt_proc_co2",
+          "Label": "Rt - procent co2",
+          "ReadWrite": "R",
+          "Details": null,
+          "MinValue": null,
+          "MaxValue": null,
+          "Unit": "%"
+        }
+      ],
+      "Code": 0,
+      "Class": 46,
+      "ID": ""
+    },
     {
       "Name": "SPM - Nano Color",
       "Parameters": [

{compit_inext_api_beta-0.4.0b10 → compit_inext_api_beta-0.6.0b7}/compit_inext_api/device_definitions.py

@@ -1,7 +1,9 @@
 from importlib import resources
 import json
 import logging
-import aiofiles
+import aiofiles  # type: ignore
+
+from compit_inext_api.consts import CompitDevice
 
 from .types.DeviceDefinitions import DeviceDefinitions, Device
 
@@ -22,7 +24,7 @@ class DeviceDefinitionsLoader:
 
         config_path = resources.files('compit_inext_api.definitions').joinpath(file_name)
         try:        
-            async with aiofiles.open(config_path, encoding="utf-8", mode='r') as file:
+            async with aiofiles.open(str(config_path), encoding="utf-8", mode='r') as file:
                 content = await file.read()
                 definitions = DeviceDefinitions.from_json(json.loads(content))
                 DeviceDefinitionsLoader.cache[lang] = definitions
@@ -35,8 +37,19 @@ class DeviceDefinitionsLoader:
             raise ValueError("No definitions found") from None
         
     @staticmethod
-    async def get_device_definition(code: int, lang: str = "en") -> Device:
+    async def get_device_definition(code: int, lang: str | None = None) -> Device:
         """Get the device definition for a specific device type."""
+        if not lang:
+            device = CompitDevice(code)
+            return Device(
+                name=device.label,
+                parameters=[],
+                code=int(device.value),
+                device_class=device.device_class,
+                id=None,
+            )
+
+
         definitions = await DeviceDefinitionsLoader.get_device_definitions(lang)
         for device in definitions.devices:
             if device.code == code: