python-hilo 2024.10.2__tar.gz → 2025.2.2__tar.gz

{python_hilo-2024.10.2 → python_hilo-2025.2.2}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: python-hilo
-Version: 2024.10.2
+Version: 2025.2.2
 Summary: A Python3, async interface to the Hilo API
-Home-page: https://github.com/dvd-dev/python-hilo
 License: MIT
 Author: David Vallee Delisle
 Author-email: me@dvd.dev
@@ -30,7 +29,7 @@ Requires-Dist: backoff (>=1.11.1)
 Requires-Dist: python-dateutil (>=2.8.2)
 Requires-Dist: ruyaml (>=0.91.0)
 Requires-Dist: voluptuous (>=0.13.1)
-Requires-Dist: websockets (>=8.1,<14.0)
+Requires-Dist: websockets (>=8.1,<16.0)
 Project-URL: Repository, https://github.com/dvd-dev/python-hilo
 Description-Content-Type: text/markdown
 

{python_hilo-2024.10.2 → python_hilo-2025.2.2}/pyhilo/api.py

@@ -27,7 +27,7 @@ from pyhilo.const import (
     API_NOTIFICATIONS_ENDPOINT,
     API_REGISTRATION_ENDPOINT,
     API_REGISTRATION_HEADERS,
-    AUTOMATION_DEVICEHUB_ENDPOINT,
+    AUTOMATION_CHALLENGE_ENDPOINT,
     DEFAULT_STATE_FILE,
     DEFAULT_USER_AGENT,
     FB_APP_ID,
@@ -51,7 +51,7 @@ from pyhilo.util.state import (
     get_state,
     set_state,
 )
-from pyhilo.websocket import WebsocketClient
+from pyhilo.websocket import WebsocketClient, WebsocketManager
 
 
 class API:
@@ -81,9 +81,17 @@ class API:
         self.device_attributes = get_device_attributes()
         self.session: ClientSession = session
         self._oauth_session = oauth_session
+        self.websocket_devices: WebsocketClient
+        # Backward compatibility during transition to websocket for challenges. Currently the HA Hilo integration
+        # uses the .websocket attribute. Re-added this attribute and point to the same object as websocket_devices.
+        # Should be removed once the transition to the challenge websocket is completed everywhere.
         self.websocket: WebsocketClient
+        self.websocket_challenges: WebsocketClient
         self.log_traces = log_traces
         self._get_device_callbacks: list[Callable[..., Any]] = []
+        self.ws_url: str = ""
+        self.ws_token: str = ""
+        self.endpoint: str = ""
 
     @classmethod
     async def async_create(
@@ -132,6 +140,9 @@ class API:
         if not self._oauth_session.valid_token:
             await self._oauth_session.async_ensure_token_valid()
 
+        access_token = str(self._oauth_session.token["access_token"])
+        LOG.debug(f"ic-dev21 access token is {access_token}")
+
         return str(self._oauth_session.token["access_token"])
 
     def dev_atts(
@@ -216,6 +227,8 @@ class API:
         :rtype: dict[str, Any]
         """
         kwargs.setdefault("headers", self.headers)
+        access_token = await self.async_get_access_token()
+
         if endpoint.startswith(API_REGISTRATION_ENDPOINT):
             kwargs["headers"] = {**kwargs["headers"], **API_REGISTRATION_HEADERS}
         if endpoint.startswith(FB_INSTALL_ENDPOINT):
@@ -223,10 +236,15 @@ class API:
         if endpoint.startswith(ANDROID_CLIENT_ENDPOINT):
             kwargs["headers"] = {**kwargs["headers"], **ANDROID_CLIENT_HEADERS}
         if host == API_HOSTNAME:
-            access_token = await self.async_get_access_token()
             kwargs["headers"]["authorization"] = f"Bearer {access_token}"
         kwargs["headers"]["Host"] = host
 
+        # ic-dev21 trying Leicas suggestion
+        if endpoint.startswith(AUTOMATION_CHALLENGE_ENDPOINT):
+            # remove Ocp-Apim-Subscription-Key header to avoid 401 error
+            kwargs["headers"].pop("Ocp-Apim-Subscription-Key", None)
+            kwargs["headers"]["authorization"] = f"Bearer {access_token}"
+
         data: dict[str, Any] = {}
         url = parse.urljoin(f"https://{host}", endpoint)
         if self.log_traces:
@@ -303,8 +321,9 @@ class API:
                 LOG.info(
                     "401 detected on websocket, refreshing websocket token. Old url: {self.ws_url} Old Token: {self.ws_token}"
                 )
+                LOG.info(f"401 detected on {err.request_info.url}")
                 async with self._backoff_refresh_lock_ws:
-                    (self.ws_url, self.ws_token) = await self.post_devicehub_negociate()
+                    await self.refresh_ws_token()
                     await self.get_websocket_params()
                 return
 
@@ -354,33 +373,31 @@ class API:
         LOG.debug("Websocket postinit")
         await self._get_fid()
         await self._get_device_token()
-        await self.refresh_ws_token()
-        self.websocket = WebsocketClient(self)
 
-    async def refresh_ws_token(self) -> None:
-        (self.ws_url, self.ws_token) = await self.post_devicehub_negociate()
-        await self.get_websocket_params()
-
-    async def post_devicehub_negociate(self) -> tuple[str, str]:
-        LOG.debug("Getting websocket url")
-        url = f"{AUTOMATION_DEVICEHUB_ENDPOINT}/negotiate"
-        resp = await self.async_request("post", url)
-        ws_url = resp.get("url")
-        ws_token = resp.get("accessToken")
-        LOG.debug("Calling set_state")
-        await set_state(
-            self._state_yaml,
-            "websocket",
-            {
-                "url": ws_url,
-                "token": ws_token,
-            },
+        # Initialize WebsocketManager ic-dev21
+        self.websocket_manager = WebsocketManager(
+            self.session, self.async_request, self._state_yaml, set_state
         )
-        return (ws_url, ws_token)
+        await self.websocket_manager.initialize_websockets()
+
+        # Create both websocket clients
+        # ic-dev21 need to work on this as it can't lint as is, may need to
+        # instantiate differently
+        self.websocket_devices = WebsocketClient(self.websocket_manager.devicehub)
+
+        # For backward compatibility during the transition to challengehub websocket
+        self.websocket = self.websocket_devices
+        self.websocket_challenges = WebsocketClient(self.websocket_manager.challengehub)
+
+    async def refresh_ws_token(self) -> None:
+        """Refresh the websocket token."""
+        await self.websocket_manager.refresh_token(self.websocket_manager.devicehub)
+        await self.websocket_manager.refresh_token(self.websocket_manager.challengehub)
 
     async def get_websocket_params(self) -> None:
         uri = parse.urlparse(self.ws_url)
         LOG.debug("Getting websocket params")
+        LOG.debug(f"Getting uri {uri}")
         resp: dict[str, Any] = await self.async_request(
             "post",
             f"{uri.path}negotiate?{uri.query}",
@@ -391,6 +408,7 @@ class API:
         )
         conn_id: str = resp.get("connectionId", "")
         self.full_ws_url = f"{self.ws_url}&id={conn_id}&access_token={self.ws_token}"
+        LOG.debug(f"Getting full ws URL {self.full_ws_url}")
         transport_dict: list[WebsocketTransportsDict] = resp.get(
             "availableTransports", []
         )
@@ -399,7 +417,7 @@ class API:
             "available_transports": transport_dict,
             "full_ws_url": self.full_ws_url,
         }
-        LOG.debug("Calling set_state")
+        LOG.debug("Calling set_state websocket_params")
         await set_state(self._state_yaml, "websocket", websocket_dict)
 
     async def fb_install(self, fb_id: str) -> None:
@@ -425,7 +443,7 @@ class API:
             raise RequestError(err) from err
         LOG.debug(f"FB Install data: {resp}")
         auth_token = resp.get("authToken", {})
-        LOG.debug("Calling set_state")
+        LOG.debug("Calling set_state fb_install")
         await set_state(
             self._state_yaml,
             "firebase",
@@ -467,7 +485,7 @@ class API:
             LOG.error(f"Android registration error: {msg}")
             raise RequestError
         token = msg.split("=")[-1]
-        LOG.debug("Calling set_state")
+        LOG.debug("Calling set_state android_register")
         await set_state(
             self._state_yaml,
             "android",
@@ -478,12 +496,14 @@ class API:
 
     async def get_location_id(self) -> int:
         url = f"{API_AUTOMATION_ENDPOINT}/Locations"
+        LOG.debug(f"LocationId URL is {url}")
         req: list[dict[str, Any]] = await self.async_request("get", url)
         return int(req[0]["id"])
 
     async def get_devices(self, location_id: int) -> list[dict[str, Any]]:
         """Get list of all devices"""
         url = self._get_url("Devices", location_id)
+        LOG.debug(f"Devices URL is {url}")
         devices: list[dict[str, Any]] = await self.async_request("get", url)
         devices.append(await self.get_gateway(location_id))
         # Now it's time to add devices coming from external sources like hass
@@ -499,6 +519,7 @@ class API:
         value: Union[str, float, int, None],
     ) -> None:
         url = self._get_url(f"Devices/{device.id}/Attributes", device.location_id)
+        LOG.debug(f"Device Attribute URL is {url}")
         await self.async_request("put", url, json={key.hilo_attribute: value})
 
     async def get_event_notifications(self, location_id: int) -> dict[str, Any]:
@@ -526,6 +547,7 @@ class API:
           "viewed": false
         }"""
         url = self._get_url(None, location_id, events=True)
+        LOG.debug(f"Event Notifications URL is {url}")
         return cast(dict[str, Any], await self.async_request("get", url))
 
     async def get_gd_events(
@@ -597,6 +619,8 @@ class API:
             url += "?active=true"
         else:
             url += f"/{event_id}"
+
+        LOG.debug(f"get_gd_events URL is {url}")
         return cast(dict[str, Any], await self.async_request("get", url))
 
     async def get_seasons(self, location_id: int) -> dict[str, Any]:
@@ -624,6 +648,7 @@ class API:
 
     async def get_gateway(self, location_id: int) -> dict[str, Any]:
         url = self._get_url("Gateways/Info", location_id)
+        LOG.debug(f"Gateway URL is {url}")
         req = await self.async_request("get", url)
         saved_attrs = [
             "zigBeePairingActivated",

{python_hilo-2024.10.2 → python_hilo-2025.2.2}/pyhilo/const.py

@@ -8,7 +8,7 @@ import homeassistant.core
 LOG: Final = logging.getLogger(__package__)
 DEFAULT_STATE_FILE: Final = "hilo_state.yaml"
 REQUEST_RETRY: Final = 9
-PYHILO_VERSION: Final = "2024.10.02"
+PYHILO_VERSION: Final = "2025.2.02"
 # TODO: Find a way to keep previous line in sync with pyproject.toml automatically
 
 CONTENT_TYPE_FORM: Final = "application/x-www-form-urlencoded"
@@ -42,6 +42,8 @@ API_REGISTRATION_HEADERS: Final = {
 
 # Automation server constant
 AUTOMATION_DEVICEHUB_ENDPOINT: Final = "/DeviceHub"
+AUTOMATION_CHALLENGE_ENDPOINT: Final = "/ChallengeHub"
+
 
 # Request constants
 DEFAULT_USER_AGENT: Final = f"PyHilo/{PYHILO_VERSION} HomeAssistant/{homeassistant.core.__version__} aiohttp/{aiohttp.__version__} Python/{platform.python_version()}"

{python_hilo-2024.10.2 → python_hilo-2025.2.2}/pyhilo/event.py

@@ -1,12 +1,16 @@
 """Event object """
 from datetime import datetime, timedelta, timezone
+import logging
 import re
 from typing import Any, cast
 
 from pyhilo.util import camel_to_snake, from_utc_timestamp
 
+LOG = logging.getLogger(__package__)
+
 
 class Event:
+    """This class is used to populate the data of a Hilo Challenge Event, contains datetime info and consumption data"""
     setting_deadline: datetime
     pre_cold_start: datetime
     pre_cold_end: datetime
@@ -59,6 +63,20 @@ class Event:
             "last_update",
         ]
 
+    def update_wh(self, used_wH: float) -> None:
+        """This function is used to update the used_kWh attribute during a Hilo Challenge Event"""
+        LOG.debug(f"Updating Wh: {used_wH}")
+        self.used_kWh = round(used_wH / 1000, 2)
+        self.last_update = datetime.now(timezone.utc).astimezone()
+
+    def should_check_for_allowed_wh(self) -> bool:
+        """This function is used to authorize subscribing to a specific event in Hilo to receive the allowed_kWh
+        that is made available in the pre_heat phase"""
+        now = datetime.now(self.preheat_start.tzinfo)
+        time_since_preheat_start = (self.preheat_start - now).total_seconds()
+        already_has_allowed_wh = self.allowed_kWh > 0
+        return 1800 <= time_since_preheat_start <= 2700 and not already_has_allowed_wh
+
     def as_dict(self) -> dict[str, Any]:
         rep = {k: getattr(self, k) for k in self.dict_items}
         rep["phases"] = {k: getattr(self, k) for k in self.phases_list}
@@ -66,6 +84,7 @@ class Event:
         return rep
 
     def _convert_phases(self, phases: dict[str, Any]) -> None:
+        """Formats phase times for later use"""
         self.phases_list = []
         for key, value in phases.items():
             phase_match = re.match(r"(.*)(DateUTC|Utc)", key)
@@ -86,6 +105,7 @@ class Event:
     def _create_phases(
         self, hours: int, phase_name: str, parent_phase: str
     ) -> datetime:
+        """Creates optional "appreciation" and "pre_cold" phases according to Hilo phases datetimes"""
         parent_start = getattr(self, f"{parent_phase}_start")
         phase_start = f"{phase_name}_start"
         phase_end = f"{phase_name}_end"
@@ -125,10 +145,14 @@ class Event:
 
     @property
     def state(self) -> str:
+        """Defines state in the next_event attribute"""
         now = datetime.now(self.preheat_start.tzinfo)
-        if self.pre_cold_start <= now < self.pre_cold_end:
+        if self.pre_cold_start and self.pre_cold_start <= now < self.pre_cold_end:
             return "pre_cold"
-        elif self.appreciation_start <= now < self.appreciation_end:
+        elif (
+            self.appreciation_start
+            and self.appreciation_start <= now < self.appreciation_end
+        ):
             return "appreciation"
         elif self.preheat_start > now:
             return "scheduled"
@@ -138,9 +162,12 @@ class Event:
             return "reduction"
         elif self.recovery_start <= now < self.recovery_end:
             return "recovery"
+        elif now >= self.recovery_end + timedelta(minutes=5):
+            return "off"
         elif now >= self.recovery_end:
             return "completed"
         elif self.progress:
             return self.progress
+
         else:
             return "unknown"

{python_hilo-2024.10.2 → python_hilo-2025.2.2}/pyhilo/util/__init__.py

@@ -35,7 +35,11 @@ def snake_to_camel(string: str) -> str:
 def from_utc_timestamp(date_string: str) -> datetime:
     from_zone = tz.tzutc()
     to_zone = tz.tzlocal()
-    return parse(date_string).replace(tzinfo=from_zone).astimezone(to_zone)
+    dt = parse(date_string)
+    if dt.tzinfo is None:  # Only replace tzinfo if not already set
+        dt = dt.replace(tzinfo=from_zone)
+    output = dt.astimezone(to_zone)
+    return output
 
 
 def time_diff(ts1: datetime, ts2: datetime) -> timedelta:

{python_hilo-2024.10.2 → python_hilo-2025.2.2}/pyhilo/websocket.py

@@ -7,9 +7,10 @@ from datetime import datetime, timedelta
 from enum import IntEnum
 import json
 from os import environ
-from typing import TYPE_CHECKING, Any, Callable, Dict
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple
+from urllib import parse
 
-from aiohttp import ClientWebSocketResponse, WSMsgType
+from aiohttp import ClientSession, ClientWebSocketResponse, WSMsgType
 from aiohttp.client_exceptions import (
     ClientError,
     ServerDisconnectedError,
@@ -17,7 +18,12 @@ from aiohttp.client_exceptions import (
 )
 from yarl import URL
 
-from pyhilo.const import DEFAULT_USER_AGENT, LOG
+from pyhilo.const import (
+    AUTOMATION_CHALLENGE_ENDPOINT,
+    AUTOMATION_DEVICEHUB_ENDPOINT,
+    DEFAULT_USER_AGENT,
+    LOG,
+)
 from pyhilo.exceptions import (
     CannotConnectError,
     ConnectionClosedError,
@@ -208,16 +214,19 @@ class WebsocketClient:
 
         if self._api.log_traces:
             LOG.debug(
-                f"[TRACE] Sending data to websocket server: {json.dumps(payload)}"
+                f"[TRACE] Sending data to websocket {self._api.endpoint} : {json.dumps(payload)}"
             )
         # Hilo added a control character (chr(30)) at the end of each payload they send.
         # They also expect this char to be there at the end of every payload we send them.
+        LOG.debug(f"ic-dev21 send_json {payload}")
         await self._client.send_str(json.dumps(payload) + chr(30))
 
     def _parse_message(self, msg: dict[str, Any]) -> None:
         """Parse an incoming message."""
         if self._api.log_traces:
-            LOG.debug(f"[TRACE] Received message from websocket: {msg}")
+            LOG.debug(
+                f"[TRACE] Received message on websocket(_parse_message) {self._api.endpoint}: {msg}"
+            )
         if msg.get("type") == SignalRMsgType.PING:
             schedule_callback(self._async_pong)
             return
@@ -247,7 +256,7 @@ class WebsocketClient:
         return self._add_callback(self._disconnect_callbacks, callback)
 
     def add_event_callback(self, callback: Callable[..., Any]) -> Callable[..., None]:
-        """Add a callback callback to be called upon receiving an event.
+        """Add a callback to be called upon receiving an event.
         Note that callbacks should expect to receive a WebsocketEvent object as a
         parameter.
         :param callback: The method to call after receiving an event.
@@ -261,7 +270,7 @@ class WebsocketClient:
             LOG.debug("Websocket: async_connect() called but already connected")
             return
 
-        LOG.info("Websocket: Connecting to server")
+        LOG.info("Websocket: Connecting to server %s", self._api.endpoint)
         if self._api.log_traces:
             LOG.debug(f"[TRACE] Websocket URL: {self._api.full_ws_url}")
         headers = {
@@ -281,7 +290,7 @@ class WebsocketClient:
         try:
             self._client = await self._api.session.ws_connect(
                 URL(
-                    self._api.full_ws_url.replace("/DeviceHub", "%2FDeviceHub"),
+                    self._api.full_ws_url,
                     encoded=True,
                 ),
                 heartbeat=55,
@@ -296,7 +305,7 @@ class WebsocketClient:
             LOG.error(f"Unable to connect to WS server {err}")
             raise CannotConnectError(err) from err
 
-        LOG.info("Connected to websocket server")
+        LOG.info(f"Connected to websocket server {self._api.endpoint}")
         self._watchdog.trigger()
         for callback in self._connect_callbacks:
             schedule_callback(callback)
@@ -368,6 +377,9 @@ class WebsocketClient:
             except asyncio.TimeoutError:
                 return
             self._ready_event.clear()
+        LOG.debug(
+            f"ic-dev21 invoke argument: {arg}, invocationId: {inv_id}, target: {target}, type: {type}"
+        )
         await self._async_send_json(
             {
                 "arguments": arg,
@@ -376,3 +388,144 @@ class WebsocketClient:
                 "type": inv_type,
             }
         )
+
+
+@dataclass
+class WebsocketConfig:
+    """Configuration for a websocket connection"""
+
+    endpoint: str
+    url: Optional[str] = None
+    token: Optional[str] = None
+    connection_id: Optional[str] = None
+    full_ws_url: Optional[str] = None
+    log_traces: bool = True
+    session: ClientSession | None = None
+
+
+class WebsocketManager:
+    """Manages multiple websocket connections for the Hilo API"""
+
+    def __init__(
+        self,
+        session: ClientSession,
+        async_request: Callable[..., Any],
+        state_yaml: str,
+        set_state_callback: Callable[..., Any],
+    ) -> None:
+        """Initialize the websocket manager.
+
+        Args:
+            session: The aiohttp client session
+            async_request: The async request method from the API class
+            state_yaml: Path to the state file
+            set_state_callback: Callback to save state
+        """
+        self.session = session
+        self.async_request = async_request
+        self._state_yaml = state_yaml
+        self._set_state = set_state_callback
+        self._shared_token: Optional[str] = None
+        # Initialize websocket configurations, more can be added here
+        self.devicehub = WebsocketConfig(
+            endpoint=AUTOMATION_DEVICEHUB_ENDPOINT, session=session
+        )
+        self.challengehub = WebsocketConfig(
+            endpoint=AUTOMATION_CHALLENGE_ENDPOINT, session=session
+        )
+
+    async def initialize_websockets(self) -> None:
+        """Initialize both websocket connections"""
+        # ic-dev21 get token from device hub
+        await self.refresh_token(self.devicehub, get_new_token=True)
+        # ic-dev21 get token from challenge hub
+        await self.refresh_token(self.challengehub, get_new_token=True)
+
+    async def refresh_token(
+        self, config: WebsocketConfig, get_new_token: bool = True
+    ) -> None:
+        """Refresh token for a specific websocket configuration.
+        Args:
+            config: The websocket configuration to refresh
+        """
+        if get_new_token:
+            config.url, self._shared_token = await self._negotiate(config)
+            config.token = self._shared_token
+        else:
+            config.url, _ = await self._negotiate(config)
+            config.token = self._shared_token
+
+        await self._get_websocket_params(config)
+
+    async def _negotiate(self, config: WebsocketConfig) -> Tuple[str, str]:
+        """Negotiate websocket connection and get URL and token.
+        Args:
+            config: The websocket configuration to negotiate
+        Returns:
+            Tuple containing the websocket URL and access token
+        """
+        LOG.debug(f"Getting websocket url for {config.endpoint}")
+        url = f"{config.endpoint}/negotiate"
+        LOG.debug(f"Negotiate URL is {url}")
+
+        resp = await self.async_request("post", url)
+        ws_url = resp.get("url")
+        ws_token = resp.get("accessToken")
+
+        # Save state
+        state_key = (
+            "websocketDevices"
+            if config.endpoint == AUTOMATION_DEVICEHUB_ENDPOINT
+            else "websocketChallenges"
+        )
+        await self._set_state(
+            self._state_yaml,
+            state_key,
+            {
+                "url": ws_url,
+                "token": ws_token,
+            },
+        )
+
+        return ws_url, ws_token
+
+    async def _get_websocket_params(self, config: WebsocketConfig) -> None:
+        """Get websocket parameters including connection ID.
+
+        Args:
+            config: The websocket configuration to get parameters for
+        """
+        uri = parse.urlparse(config.url)
+        LOG.debug(f"Getting websocket params for {config.endpoint}")
+        LOG.debug(f"Getting uri {uri}")
+
+        resp = await self.async_request(
+            "post",
+            f"{uri.path}negotiate?{uri.query}",  # type: ignore
+            host=uri.netloc,
+            headers={
+                "authorization": f"Bearer {config.token}",
+            },
+        )
+
+        config.connection_id = resp.get("connectionId", "")
+        config.full_ws_url = (
+            f"{config.url}&id={config.connection_id}&access_token={config.token}"
+        )
+        LOG.debug(f"Getting full ws URL {config.full_ws_url}")
+
+        transport_dict = resp.get("availableTransports", [])
+        websocket_dict = {
+            "connection_id": config.connection_id,
+            "available_transports": transport_dict,
+            "full_url": config.full_ws_url,
+        }
+
+        # Save state
+        state_key = (
+            "websocketDevices"
+            if config.endpoint == AUTOMATION_DEVICEHUB_ENDPOINT
+            else "websocketChallenges"
+        )
+        LOG.debug(f"Calling set_state {state_key}_params")
+        await self._set_state(self._state_yaml, state_key, websocket_dict)

{python_hilo-2024.10.2 → python_hilo-2025.2.2}/pyproject.toml

@@ -40,7 +40,7 @@ exclude = ".venv/.*"
 
 [tool.poetry]
 name = "python-hilo"
-version = "2024.10.2"
+version = "2025.2.2"
 description = "A Python3, async interface to the Hilo API"
 readme = "README.md"
 authors = ["David Vallee Delisle <me@dvd.dev>"]
@@ -74,7 +74,7 @@ python-dateutil = ">=2.8.2"
 ruyaml = ">=0.91.0"
 python = "^3.9.0"
 voluptuous = ">=0.13.1"
-websockets = ">=8.1,<14.0"
+websockets = ">=8.1,<16.0"
 
 [tool.poetry.dev-dependencies]
 Sphinx = "^7.1.2"
@@ -83,9 +83,9 @@ asynctest = "^0.13.0"
 pre-commit = "^4.0.0"
 pytest = "^8.0.0"
 pytest-aiohttp = "^1.0.4"
-pytest-cov = "^5.0.0"
+pytest-cov = "^6.0.0"
 sphinx-rtd-theme = "^3.0.0"
-types-pytz = "^2024.1.0"
+types-pytz = "^2025.1.0"
 
 [tool.pylint.BASIC]
 expected-line-ending-format = "LF"