Hydro-Quebec-API-Wrapper 4.2.5__tar.gz → 4.2.6__tar.gz

{hydro_quebec_api_wrapper-4.2.5 → hydro_quebec_api_wrapper-4.2.6}/Hydro_Quebec_API_Wrapper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Hydro-Quebec-API-Wrapper
-Version: 4.2.5
+Version: 4.2.6
 Summary: A wrapper library to access hydro quebec API and more
 Home-page: https://hydroqc.ca
 Author-email: Hydroqc Team <info@hydroqc.ca>

{hydro_quebec_api_wrapper-4.2.5 → hydro_quebec_api_wrapper-4.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Hydro-Quebec-API-Wrapper
-Version: 4.2.5
+Version: 4.2.6
 Summary: A wrapper library to access hydro quebec API and more
 Home-page: https://hydroqc.ca
 Author-email: Hydroqc Team <info@hydroqc.ca>

hydro_quebec_api_wrapper-4.2.6/hydroqc/hydro_api/cache.py

@@ -0,0 +1,50 @@
+"""Custon cache module."""
+
+import functools
+from collections.abc import Callable
+from typing import ParamSpec, TypeVar, cast
+
+from aiocache import Cache, cached  # type: ignore
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+class CCached(cached):  # type: ignore[misc]
+    """Custom cache class based on aiocache.
+
+    This decorator respects the enable_cache attribute on the instance
+    (self) if it exists, allowing caching to be toggled at runtime.
+    """
+
+    def __init__(self, ttl: int) -> None:
+        """Initialize custom cache decorator.
+
+        Args:
+            ttl: Time to live for cached values in seconds.
+
+        """
+        cached.__init__(self, ttl=ttl, cache=Cache.MEMORY)
+        self.ttl = ttl
+
+    def __call__(self, func: Callable[P, T]) -> Callable[P, T]:
+        """Call custom cache decorator."""
+        self.cache = self._cache()
+
+        @functools.wraps(func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            # Check if the first argument (self) has enable_cache attribute
+            # If caching is disabled, call the function directly
+            if args and hasattr(args[0], "enable_cache") and not args[0].enable_cache:
+                result = func(*args, **kwargs)
+                # func is async, so we need to await it
+                if hasattr(result, "__await__"):
+                    return await result  # type: ignore[no-any-return]
+                return result  # pragma: no cover
+
+            # Otherwise use the cached decorator
+            value = await self.decorator(func, *args, **kwargs)
+            return cast(T, value)
+
+        wrapper.cache = self.cache  # type: ignore[attr-defined]
+        return cast(Callable[P, T], wrapper)

{hydro_quebec_api_wrapper-4.2.5 → hydro_quebec_api_wrapper-4.2.6}/hydroqc/hydro_api/client.py

@@ -91,13 +91,27 @@ class HydroClient:
         session: aiohttp.ClientSession | None = None,
         log_level: str | None = "INFO",
         diag_folder: str | None = None,
+        enable_cache: bool = True,
     ):
-        """Initialize the client object."""
+        """Initialize the client object.
+
+        Args:
+            username: Hydro-Québec account username.
+            password: Hydro-Québec account password.
+            timeout: HTTP request timeout in seconds. Defaults to REQUESTS_TIMEOUT.
+            verify_ssl: Whether to verify SSL certificates. Defaults to True.
+            session: Optional aiohttp ClientSession to reuse. Defaults to None.
+            log_level: Logging level. Defaults to "INFO".
+            diag_folder: Optional folder path for diagnostic output. Defaults to None.
+            enable_cache: Whether to enable response caching. Defaults to True.
+
+        """
         self.username: str = username
         self.password: str = password
         self._timeout: int = timeout
         self._session: aiohttp.ClientSession | None = session
         self._verify_ssl: bool = verify_ssl
+        self.enable_cache: bool = enable_cache
 
         # OAuth handling variables
         self._id_token: str = ""
@@ -113,7 +127,10 @@ class HydroClient:
         self._diag_id: int = 0
         self.guid: str = str(uuid.uuid1())
         self._logger: logging.Logger = get_logger("httpclient", log_level)
-        self._logger.debug("HydroQc initialized")
+        self._logger.debug(
+            "HydroQc initialized (caching: %s)",
+            "enabled" if enable_cache else "disabled",
+        )
         # Cache for blocking operations (initialized lazily)
         self._cached_version: str | None = None
         self.reset()
@@ -247,8 +264,26 @@ class HydroClient:
         try:
             return json.loads(data)
         except json.decoder.JSONDecodeError as exp:
-            self._logger.debug("JSON received : ", data)
-            raise HydroQcHTTPError("Bad JSON format") from exp
+            # Log the actual response for debugging
+            data_preview = (
+                (
+                    data[:500]
+                    if isinstance(data, str)
+                    else data[:500].decode("utf-8", errors="replace")
+                )
+                if data
+                else "(empty response)"
+            )
+            self._logger.error(
+                "Failed to parse JSON response. Position: line %d column %d. "
+                "Response preview (first 500 chars): %s",
+                exp.lineno,
+                exp.colno,
+                data_preview,
+            )
+            raise HydroQcHTTPError(
+                f"Bad JSON format at line {exp.lineno} column {exp.colno}: {exp.msg}"
+            ) from exp
 
     def get_token_data(self) -> IDTokenTyping | None:
         """Decode id token data."""
@@ -776,7 +811,20 @@ class HydroClient:
             HOURLY_CONSUMPTION_API_URL, "get", params=params
         )
         # We can not use res.json() because the response header are not application/json
-        data: ConsumpHourlyTyping = self._load_json(await api_call_response.text())
+        response_text = await api_call_response.text()
+
+        # Check if response is empty or whitespace only
+        if not response_text or not response_text.strip():
+            self._logger.warning(
+                "Empty response received for hourly consumption on %s. "
+                "Data may not be available yet from Hydro-Québec.",
+                date_wanted.isoformat(),
+            )
+            raise HydroQcHTTPError(
+                f"No data available for date {date_wanted.isoformat()}"
+            )
+
+        data: ConsumpHourlyTyping = self._load_json(response_text)
         return data
 
     @CCached(ttl=43200)

{hydro_quebec_api_wrapper-4.2.5 → hydro_quebec_api_wrapper-4.2.6}/test_requirements.txt

@@ -1,15 +1,15 @@
 flake8==7.3.0
 pydocstyle==6.3.0
 parameterized==0.9.0
-pylint==4.0.3
-pytest==9.0.1
+pylint==4.0.4
+pytest==9.0.2
 pytest-cov==7.0.0
 pytest-asyncio==1.3.0
-black==25.11.0
+black==25.12.0
 mypy==1.19.0
 types-pytz==2025.2.0.20251108
 types-PyYAML==6.0.12.20250915
 types-python-dateutil==2.9.0.20251115
-homeassistant-stubs==2025.11.3
+homeassistant-stubs==2025.12.2
 pyright==1.1.407
 lxml==6.0.2

hydro_quebec_api_wrapper-4.2.5/hydroqc/hydro_api/cache.py

@@ -1,30 +0,0 @@
-"""Custon cache module."""
-
-import functools
-from collections.abc import Callable
-from typing import ParamSpec, TypeVar, cast
-
-from aiocache import Cache, cached  # type: ignore
-
-T = TypeVar("T")
-P = ParamSpec("P")
-
-
-class CCached(cached):  # type: ignore[misc]
-    """Custom cache class based on aiocache."""
-
-    def __init__(self, ttl: int) -> None:
-        """Initialize custom cache decorator."""
-        cached.__init__(self, ttl=ttl, cache=Cache.MEMORY)
-
-    def __call__(self, func: Callable[P, T]) -> Callable[P, T]:
-        """Call custom cache decorator."""
-        self.cache = self._cache()
-
-        @functools.wraps(func)
-        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-            value = await self.decorator(func, *args, **kwargs)
-            return cast(T, value)
-
-        wrapper.cache = self.cache  # type: ignore[attr-defined]
-        return cast(Callable[P, T], wrapper)