weheat 2025.1.14__py3-none-any.whl → 2025.1.15__py3-none-any.whl

weheat/api_response.py

@@ -1,29 +1,21 @@
 """API response object."""
 
 from __future__ import annotations
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Generic, TypeVar
+from pydantic import Field, StrictInt, StrictStr, StrictBytes, BaseModel
 
-try:
-    from pydantic.v1 import Field, StrictInt, StrictStr
-except ImportError:
-    from pydantic import Field, StrictInt, StrictStr
+T = TypeVar("T")
 
-class ApiResponse:
+class ApiResponse(BaseModel, Generic[T]):
     """
     API response object
     """
 
-    status_code: Optional[StrictInt] = Field(None, description="HTTP status code")
+    status_code: StrictInt = Field(description="HTTP status code")
     headers: Optional[Dict[StrictStr, StrictStr]] = Field(None, description="HTTP headers")
-    data: Optional[Any] = Field(None, description="Deserialized data given the data type")
-    raw_data: Optional[Any] = Field(None, description="Raw data (HTTP response body)")
+    data: T = Field(description="Deserialized data given the data type")
+    raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
 
-    def __init__(self,
-                 status_code=None,
-                 headers=None,
-                 data=None,
-                 raw_data=None) -> None:
-        self.status_code = status_code
-        self.headers = headers
-        self.data = data
-        self.raw_data = raw_data
+    model_config = {
+        "arbitrary_types_allowed": True
+    }

weheat/configuration.py

@@ -14,8 +14,9 @@
 
 import copy
 import logging
-import multiprocessing
 import sys
+
+import aiohttp
 import urllib3
 
 import http.client as httplib
@@ -52,6 +53,7 @@ class Configuration:
       values before.
     :param ssl_ca_cert: str - the path to a file of concatenated CA certificates
       in PEM format.
+    : param client_session: A aiohttp.ClientSession to use
 
     :Example:
     """
@@ -64,7 +66,7 @@ class Configuration:
                  access_token=None,
                  server_index=None, server_variables=None,
                  server_operation_index=None, server_operation_variables=None,
-                 ssl_ca_cert=None,
+                 ssl_ca_cert=None, client_session=None
                  ) -> None:
         """Constructor
         """
@@ -148,12 +150,9 @@ class Configuration:
            Set this to the SNI value expected by the server.
         """
 
-        self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
-        """urllib3 connection pool's maximum number of connections saved
-           per pool. urllib3 uses 1 connection as default value, but this is
-           not the best value when you are making a lot of possibly parallel
-           requests to the same host, which is often the case here.
-           cpu_count * 5 is used as default value to increase performance.
+        self.connection_pool_maxsize = 100
+        """This value is passed to the aiohttp to limit simultaneous connections.
+           Default values is 100, None means no-limit.
         """
 
         self.proxy = None
@@ -183,6 +182,8 @@ class Configuration:
         """date format
         """
 
+        self._client_session = client_session
+
     def __deepcopy__(self, memo):
         cls = self.__class__
         result = cls.__new__(cls)
@@ -200,6 +201,10 @@ class Configuration:
     def __setattr__(self, name, value):
         object.__setattr__(self, name, value)
 
+    @property
+    def client_session(self) -> aiohttp.ClientSession|None:
+        return self._client_session
+
     @classmethod
     def set_default(cls, default):
         """Set default instance of configuration.
@@ -376,7 +381,7 @@ class Configuration:
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: v1\n"\
-               "SDK Package Version: 2024.07.08".\
+               "SDK Package Version: 2024.11.15".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self):

weheat/exceptions.py

@@ -11,6 +11,9 @@
     Do not edit the class manually.
 """  # noqa: E501
 
+from typing import Any, Optional
+
+from typing_extensions import Self
 
 class OpenApiException(Exception):
     """The base exception class for all OpenAPIExceptions"""
@@ -101,17 +104,56 @@ class ApiKeyError(OpenApiException, KeyError):
 
 class ApiException(OpenApiException):
 
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
+    def __init__(
+        self, 
+        status=None, 
+        reason=None, 
+        http_resp=None,
+        *,
+        body: Optional[str] = None,
+        data: Optional[Any] = None,
+    ) -> None:
+        self.status = status
+        self.reason = reason
+        self.body = body
+        self.data = data
+        self.headers = None
+
         if http_resp:
-            self.status = http_resp.status
-            self.reason = http_resp.reason
-            self.body = http_resp.data
+            if self.status is None:
+                self.status = http_resp.status
+            if self.reason is None:
+                self.reason = http_resp.reason
+            if self.body is None:
+                try:
+                    self.body = http_resp.data.decode('utf-8')
+                except Exception:
+                    pass
             self.headers = http_resp.getheaders()
-        else:
-            self.status = status
-            self.reason = reason
-            self.body = None
-            self.headers = None
+
+    @classmethod
+    def from_response(
+        cls, 
+        *, 
+        http_resp, 
+        body: Optional[str], 
+        data: Optional[Any],
+    ) -> Self:
+        if http_resp.status == 400:
+            raise BadRequestException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 401:
+            raise UnauthorizedException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 403:
+            raise ForbiddenException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 404:
+            raise NotFoundException(http_resp=http_resp, body=body, data=data)
+
+        if 500 <= http_resp.status <= 599:
+            raise ServiceException(http_resp=http_resp, body=body, data=data)
+        raise ApiException(http_resp=http_resp, body=body, data=data)
 
     def __str__(self):
         """Custom error messages for exception"""
@@ -121,38 +163,30 @@ class ApiException(OpenApiException):
             error_message += "HTTP response headers: {0}\n".format(
                 self.headers)
 
-        if self.body:
-            error_message += "HTTP response body: {0}\n".format(self.body)
+        if self.data or self.body:
+            error_message += "HTTP response body: {0}\n".format(self.data or self.body)
 
         return error_message
 
+
 class BadRequestException(ApiException):
+    pass
 
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(BadRequestException, self).__init__(status, reason, http_resp)
 
 class NotFoundException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(NotFoundException, self).__init__(status, reason, http_resp)
+    pass
 
 
 class UnauthorizedException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(UnauthorizedException, self).__init__(status, reason, http_resp)
+    pass
 
 
 class ForbiddenException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(ForbiddenException, self).__init__(status, reason, http_resp)
+    pass
 
 
 class ServiceException(ApiException):
-
-    def __init__(self, status=None, reason=None, http_resp=None) -> None:
-        super(ServiceException, self).__init__(status, reason, http_resp)
+    pass
 
 
 def render_path(path_to_item):

weheat/models/__init__.py

@@ -14,11 +14,17 @@
 
 
 # import models into model package
+from weheat.models.boiler_type import BoilerType
 from weheat.models.device_state import DeviceState
+from weheat.models.dhw_type import DhwType
 from weheat.models.energy_view_dto import EnergyViewDto
 from weheat.models.heat_pump_log_view_dto import HeatPumpLogViewDto
+from weheat.models.heat_pump_model import HeatPumpModel
+from weheat.models.heat_pump_status_enum import HeatPumpStatusEnum
+from weheat.models.heat_pump_type import HeatPumpType
 from weheat.models.raw_heat_pump_log_dto import RawHeatPumpLogDto
 from weheat.models.read_all_heat_pump_dto import ReadAllHeatPumpDto
 from weheat.models.read_heat_pump_dto import ReadHeatPumpDto
 from weheat.models.read_user_dto import ReadUserDto
+from weheat.models.read_user_me_dto import ReadUserMeDto
 from weheat.models.role import Role

weheat/models/boiler_type.py

@@ -12,13 +12,18 @@
 """  # noqa: E501
 
 
+from __future__ import annotations
 import json
 import pprint
 import re  # noqa: F401
-from aenum import Enum, no_arg
+from enum import Enum
 
 
 
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
 
 
 class BoilerType(int, Enum):
@@ -35,8 +40,8 @@ class BoilerType(int, Enum):
     NUMBER_3 = 3
 
     @classmethod
-    def from_json(cls, json_str: str) -> BoilerType:
+    def from_json(cls, json_str: str) -> Self:
         """Create an instance of BoilerType from a JSON string"""
-        return BoilerType(json.loads(json_str))
+        return cls(json.loads(json_str))
 
 

weheat/models/device_state.py

@@ -12,18 +12,23 @@
 """  # noqa: E501
 
 
+from __future__ import annotations
 import json
 import pprint
 import re  # noqa: F401
-from aenum import Enum, no_arg
+from enum import Enum
 
 
 
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
 
 
 class DeviceState(int, Enum):
     """
-    State of the device:   - Production (0),   - InStock (1),   - Sold (2),   - Active (3),   - Inactive (4),   - Broken (5),   - Test (6)   - Configured (7)  For now Production, InStock and Sold will only be applicable to Devices that can be actually installed in installation
+    State of the device:   - ProductionObsoleteState (0),   - InStock (1),   - Sold (2),   - Active (3),   - Inactive (4),   - Broken (5),   - Test (6)   - Configured (7)  For now Production, InStock and Sold will only be applicable to Devices that can be actually installed in installation
     """
 
     """
@@ -39,8 +44,8 @@ class DeviceState(int, Enum):
     NUMBER_7 = 7
 
     @classmethod
-    def from_json(cls, json_str: str) -> DeviceState:
+    def from_json(cls, json_str: str) -> Self:
         """Create an instance of DeviceState from a JSON string"""
-        return DeviceState(json.loads(json_str))
+        return cls(json.loads(json_str))
 
 

weheat/models/dhw_type.py

@@ -12,13 +12,18 @@
 """  # noqa: E501
 
 
+from __future__ import annotations
 import json
 import pprint
 import re  # noqa: F401
-from aenum import Enum, no_arg
+from enum import Enum
 
 
 
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
 
 
 class DhwType(int, Enum):
@@ -34,8 +39,8 @@ class DhwType(int, Enum):
     NUMBER_2 = 2
 
     @classmethod
-    def from_json(cls, json_str: str) -> DhwType:
+    def from_json(cls, json_str: str) -> Self:
         """Create an instance of DhwType from a JSON string"""
-        return DhwType(json.loads(json_str))
+        return cls(json.loads(json_str))
 
 

weheat/models/energy_view_dto.py

@@ -18,103 +18,118 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from typing import Optional, Union
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from pydantic import BaseModel, StrictFloat, StrictInt, StrictStr
+from pydantic import Field
 try:
-    from pydantic.v1 import BaseModel, Field, StrictFloat, StrictInt, StrictStr
+    from typing import Self
 except ImportError:
-    from pydantic import BaseModel, Field, StrictFloat, StrictInt, StrictStr
+    from typing_extensions import Self
 
 class EnergyViewDto(BaseModel):
     """
     EnergyViewDto
-    """
-    interval: Optional[StrictStr] = Field(None, description="Interval of this EnergyViewDto (Correct intervals include: \"Hour\", \"Day\", \"Week\", \"Month\", \"Year\")")
-    time_bucket: Optional[datetime] = Field(None, alias="timeBucket")
-    total_ein_heating: Union[StrictFloat, StrictInt] = Field(..., alias="totalEInHeating", description="Total energy from electricity going into the heat pump for heating for this interval (in kwh)")
-    total_ein_dhw: Union[StrictFloat, StrictInt] = Field(..., alias="totalEInDhw", description="Total energy from electricity going into the heat pump for doing DHW for this interval (in kwh)")
-    total_ein_heating_defrost: Union[StrictFloat, StrictInt] = Field(..., alias="totalEInHeatingDefrost", description="Total energy from electricity going into the heat pump for defrosting whilst heating for this interval (in kwh)")
-    total_ein_dhw_defrost: Union[StrictFloat, StrictInt] = Field(..., alias="totalEInDhwDefrost", description="Total energy from electricity going into the heat pump for defrosting whilst doing DHW for this interval (in kwh)")
-    total_ein_cooling: Union[StrictFloat, StrictInt] = Field(..., alias="totalEInCooling", description="Total energy from electricity going into the heat pump for cooling for this interval (in kwh)")
-    total_e_out_heating: Union[StrictFloat, StrictInt] = Field(..., alias="totalEOutHeating", description="Total energy from electricity going out of the heat pump for heating for this interval (in kwh)")
-    total_e_out_dhw: Union[StrictFloat, StrictInt] = Field(..., alias="totalEOutDhw", description="Total energy from electricity going out of the heat pump for doing DHW for this interval (in kwh)")
-    total_e_out_heating_defrost: Union[StrictFloat, StrictInt] = Field(..., alias="totalEOutHeatingDefrost", description="Total energy from electricity going out of the heat pump for defrosting whilst heating for this interval (in kwh)")
-    total_e_out_dhw_defrost: Union[StrictFloat, StrictInt] = Field(..., alias="totalEOutDhwDefrost", description="Total energy from electricity going out of the heat pump for defrosting whilst doing DHW for this interval (in kwh)")
-    total_e_out_cooling: Union[StrictFloat, StrictInt] = Field(..., alias="totalEOutCooling", description="Total energy from electricity going out of the heat pump for cooling for this interval (in kwh)")
-    average_power_ein_heating: Union[StrictFloat, StrictInt] = Field(..., alias="averagePowerEInHeating", description="Average power from electricity going into the heat pump for heating for this interval (in kW)")
-    average_power_ein_dhw: Union[StrictFloat, StrictInt] = Field(..., alias="averagePowerEInDhw", description="Average power from electricity going into the heat pump for doing DHW for this interval (in kW)")
-    average_power_ein_heating_defrost: Union[StrictFloat, StrictInt] = Field(..., alias="averagePowerEInHeatingDefrost", description="Average power from electricity going into the heat pump for defrosting whilst heating for this interval (in kW)")
-    average_power_ein_dhw_defrost: Union[StrictFloat, StrictInt] = Field(..., alias="averagePowerEInDhwDefrost", description="Average power from electricity going into the heat pump for defrosting whilst doing DHW for this interval (in kW)")
-    average_power_ein_cooling: Union[StrictFloat, StrictInt] = Field(..., alias="averagePowerEInCooling", description="Average power from electricity going into the heat pump for cooling for this interval (in kW)")
-    average_power_e_out_heating: Union[StrictFloat, StrictInt] = Field(..., alias="averagePowerEOutHeating", description="Average power from electricity going out of the heat pump for heating for this interval (in kW)")
-    average_power_e_out_dhw: Union[StrictFloat, StrictInt] = Field(..., alias="averagePowerEOutDhw", description="Average power from electricity going out of the heat pump for doing DHW for this interval (in kW)")
-    average_power_e_out_heating_defrost: Union[StrictFloat, StrictInt] = Field(..., alias="averagePowerEOutHeatingDefrost", description="Average power from electricity going out of the heat pump for defrosting whilst heating for this interval (in kW)")
-    average_power_e_out_dhw_defrost: Union[StrictFloat, StrictInt] = Field(..., alias="averagePowerEOutDhwDefrost", description="Average power from electricity going out of the heat pump for defrosting whilst doing DHW for this interval (in kW)")
-    average_power_e_out_cooling: Union[StrictFloat, StrictInt] = Field(..., alias="averagePowerEOutCooling", description="Average power from electricity going out of the heat pump for cooling for this interval (in kW)")
-    __properties = ["interval", "timeBucket", "totalEInHeating", "totalEInDhw", "totalEInHeatingDefrost", "totalEInDhwDefrost", "totalEInCooling", "totalEOutHeating", "totalEOutDhw", "totalEOutHeatingDefrost", "totalEOutDhwDefrost", "totalEOutCooling", "averagePowerEInHeating", "averagePowerEInDhw", "averagePowerEInHeatingDefrost", "averagePowerEInDhwDefrost", "averagePowerEInCooling", "averagePowerEOutHeating", "averagePowerEOutDhw", "averagePowerEOutHeatingDefrost", "averagePowerEOutDhwDefrost", "averagePowerEOutCooling"]
-
-    class Config:
-        """Pydantic configuration"""
-        allow_population_by_field_name = True
-        validate_assignment = True
+    """ # noqa: E501
+    interval: Optional[StrictStr] = Field(default=None, description="Interval of this EnergyViewDto (Correct intervals include: \"Hour\", \"Day\", \"Week\", \"Month\", \"Year\")")
+    time_bucket: Optional[datetime] = Field(default=None, alias="timeBucket")
+    total_ein_heating: Union[StrictFloat, StrictInt] = Field(description="Total energy from electricity going into the heat pump for heating for this interval (in kwh)", alias="totalEInHeating")
+    total_ein_dhw: Union[StrictFloat, StrictInt] = Field(description="Total energy from electricity going into the heat pump for doing DHW for this interval (in kwh)", alias="totalEInDhw")
+    total_ein_heating_defrost: Union[StrictFloat, StrictInt] = Field(description="Total energy from electricity going into the heat pump for defrosting whilst heating for this interval (in kwh)", alias="totalEInHeatingDefrost")
+    total_ein_dhw_defrost: Union[StrictFloat, StrictInt] = Field(description="Total energy from electricity going into the heat pump for defrosting whilst doing DHW for this interval (in kwh)", alias="totalEInDhwDefrost")
+    total_ein_cooling: Union[StrictFloat, StrictInt] = Field(description="Total energy from electricity going into the heat pump for cooling for this interval (in kwh)", alias="totalEInCooling")
+    total_e_out_heating: Union[StrictFloat, StrictInt] = Field(description="Total energy from electricity going out of the heat pump for heating for this interval (in kwh)", alias="totalEOutHeating")
+    total_e_out_dhw: Union[StrictFloat, StrictInt] = Field(description="Total energy from electricity going out of the heat pump for doing DHW for this interval (in kwh)", alias="totalEOutDhw")
+    total_e_out_heating_defrost: Union[StrictFloat, StrictInt] = Field(description="Total energy from electricity going out of the heat pump for defrosting whilst heating for this interval (in kwh)", alias="totalEOutHeatingDefrost")
+    total_e_out_dhw_defrost: Union[StrictFloat, StrictInt] = Field(description="Total energy from electricity going out of the heat pump for defrosting whilst doing DHW for this interval (in kwh)", alias="totalEOutDhwDefrost")
+    total_e_out_cooling: Union[StrictFloat, StrictInt] = Field(description="Total energy from electricity going out of the heat pump for cooling for this interval (in kwh)", alias="totalEOutCooling")
+    average_power_ein_heating: Union[StrictFloat, StrictInt] = Field(description="Average power from electricity going into the heat pump for heating for this interval (in kW)", alias="averagePowerEInHeating")
+    average_power_ein_dhw: Union[StrictFloat, StrictInt] = Field(description="Average power from electricity going into the heat pump for doing DHW for this interval (in kW)", alias="averagePowerEInDhw")
+    average_power_ein_heating_defrost: Union[StrictFloat, StrictInt] = Field(description="Average power from electricity going into the heat pump for defrosting whilst heating for this interval (in kW)", alias="averagePowerEInHeatingDefrost")
+    average_power_ein_dhw_defrost: Union[StrictFloat, StrictInt] = Field(description="Average power from electricity going into the heat pump for defrosting whilst doing DHW for this interval (in kW)", alias="averagePowerEInDhwDefrost")
+    average_power_ein_cooling: Union[StrictFloat, StrictInt] = Field(description="Average power from electricity going into the heat pump for cooling for this interval (in kW)", alias="averagePowerEInCooling")
+    average_power_e_out_heating: Union[StrictFloat, StrictInt] = Field(description="Average power from electricity going out of the heat pump for heating for this interval (in kW)", alias="averagePowerEOutHeating")
+    average_power_e_out_dhw: Union[StrictFloat, StrictInt] = Field(description="Average power from electricity going out of the heat pump for doing DHW for this interval (in kW)", alias="averagePowerEOutDhw")
+    average_power_e_out_heating_defrost: Union[StrictFloat, StrictInt] = Field(description="Average power from electricity going out of the heat pump for defrosting whilst heating for this interval (in kW)", alias="averagePowerEOutHeatingDefrost")
+    average_power_e_out_dhw_defrost: Union[StrictFloat, StrictInt] = Field(description="Average power from electricity going out of the heat pump for defrosting whilst doing DHW for this interval (in kW)", alias="averagePowerEOutDhwDefrost")
+    average_power_e_out_cooling: Union[StrictFloat, StrictInt] = Field(description="Average power from electricity going out of the heat pump for cooling for this interval (in kW)", alias="averagePowerEOutCooling")
+    __properties: ClassVar[List[str]] = ["interval", "timeBucket", "totalEInHeating", "totalEInDhw", "totalEInHeatingDefrost", "totalEInDhwDefrost", "totalEInCooling", "totalEOutHeating", "totalEOutDhw", "totalEOutHeatingDefrost", "totalEOutDhwDefrost", "totalEOutCooling", "averagePowerEInHeating", "averagePowerEInDhw", "averagePowerEInHeatingDefrost", "averagePowerEInDhwDefrost", "averagePowerEInCooling", "averagePowerEOutHeating", "averagePowerEOutDhw", "averagePowerEOutHeatingDefrost", "averagePowerEOutDhwDefrost", "averagePowerEOutCooling"]
+
+    model_config = {
+        "populate_by_name": True,
+        "validate_assignment": True,
+        "protected_namespaces": (),
+    }
+
 
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.dict(by_alias=True))
+        return pprint.pformat(self.model_dump(by_alias=True))
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> EnergyViewDto:
+    def from_json(cls, json_str: str) -> Self:
         """Create an instance of EnergyViewDto from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
-    def to_dict(self):
-        """Returns the dictionary representation of the model using alias"""
-        _dict = self.dict(by_alias=True,
-                          exclude={
-                          },
-                          exclude_none=True)
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude={
+            },
+            exclude_none=True,
+        )
         # set to None if interval (nullable) is None
-        # and __fields_set__ contains the field
-        if self.interval is None and "interval" in self.__fields_set__:
+        # and model_fields_set contains the field
+        if self.interval is None and "interval" in self.model_fields_set:
             _dict['interval'] = None
 
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> EnergyViewDto:
+    def from_dict(cls, obj: Dict) -> Self:
         """Create an instance of EnergyViewDto from a dict"""
         if obj is None:
             return None
 
         if not isinstance(obj, dict):
-            return EnergyViewDto.parse_obj(obj)
+            return cls.model_validate(obj)
 
-        _obj = EnergyViewDto.parse_obj({
+        _obj = cls.model_validate({
             "interval": obj.get("interval"),
-            "time_bucket": obj.get("timeBucket"),
-            "total_ein_heating": obj.get("totalEInHeating"),
-            "total_ein_dhw": obj.get("totalEInDhw"),
-            "total_ein_heating_defrost": obj.get("totalEInHeatingDefrost"),
-            "total_ein_dhw_defrost": obj.get("totalEInDhwDefrost"),
-            "total_ein_cooling": obj.get("totalEInCooling"),
-            "total_e_out_heating": obj.get("totalEOutHeating"),
-            "total_e_out_dhw": obj.get("totalEOutDhw"),
-            "total_e_out_heating_defrost": obj.get("totalEOutHeatingDefrost"),
-            "total_e_out_dhw_defrost": obj.get("totalEOutDhwDefrost"),
-            "total_e_out_cooling": obj.get("totalEOutCooling"),
-            "average_power_ein_heating": obj.get("averagePowerEInHeating"),
-            "average_power_ein_dhw": obj.get("averagePowerEInDhw"),
-            "average_power_ein_heating_defrost": obj.get("averagePowerEInHeatingDefrost"),
-            "average_power_ein_dhw_defrost": obj.get("averagePowerEInDhwDefrost"),
-            "average_power_ein_cooling": obj.get("averagePowerEInCooling"),
-            "average_power_e_out_heating": obj.get("averagePowerEOutHeating"),
-            "average_power_e_out_dhw": obj.get("averagePowerEOutDhw"),
-            "average_power_e_out_heating_defrost": obj.get("averagePowerEOutHeatingDefrost"),
-            "average_power_e_out_dhw_defrost": obj.get("averagePowerEOutDhwDefrost"),
-            "average_power_e_out_cooling": obj.get("averagePowerEOutCooling")
+            "timeBucket": obj.get("timeBucket"),
+            "totalEInHeating": obj.get("totalEInHeating"),
+            "totalEInDhw": obj.get("totalEInDhw"),
+            "totalEInHeatingDefrost": obj.get("totalEInHeatingDefrost"),
+            "totalEInDhwDefrost": obj.get("totalEInDhwDefrost"),
+            "totalEInCooling": obj.get("totalEInCooling"),
+            "totalEOutHeating": obj.get("totalEOutHeating"),
+            "totalEOutDhw": obj.get("totalEOutDhw"),
+            "totalEOutHeatingDefrost": obj.get("totalEOutHeatingDefrost"),
+            "totalEOutDhwDefrost": obj.get("totalEOutDhwDefrost"),
+            "totalEOutCooling": obj.get("totalEOutCooling"),
+            "averagePowerEInHeating": obj.get("averagePowerEInHeating"),
+            "averagePowerEInDhw": obj.get("averagePowerEInDhw"),
+            "averagePowerEInHeatingDefrost": obj.get("averagePowerEInHeatingDefrost"),
+            "averagePowerEInDhwDefrost": obj.get("averagePowerEInDhwDefrost"),
+            "averagePowerEInCooling": obj.get("averagePowerEInCooling"),
+            "averagePowerEOutHeating": obj.get("averagePowerEOutHeating"),
+            "averagePowerEOutDhw": obj.get("averagePowerEOutDhw"),
+            "averagePowerEOutHeatingDefrost": obj.get("averagePowerEOutHeatingDefrost"),
+            "averagePowerEOutDhwDefrost": obj.get("averagePowerEOutDhwDefrost"),
+            "averagePowerEOutCooling": obj.get("averagePowerEOutCooling")
         })
         return _obj