leneda-client 0.5.0__tar.gz → 0.6.0__tar.gz

{leneda_client-0.5.0/src/leneda_client.egg-info → leneda_client-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leneda-client
-Version: 0.5.0
+Version: 0.6.0
 Summary: Python client for the Leneda energy data platform
 Home-page: https://github.com/fedus/leneda-client
 Author: fedus

{leneda_client-0.5.0 → leneda_client-0.6.0}/examples/advanced_usage.py

@@ -36,7 +36,7 @@ logging.basicConfig(
 logger = logging.getLogger("leneda_advanced_example")
 
 
-def parse_arguments():
+def parse_arguments() -> argparse.Namespace:
     """Parse command-line arguments."""
     parser = argparse.ArgumentParser(description="Leneda API Client Advanced Usage Example")
 
@@ -94,7 +94,7 @@ def parse_arguments():
     return parser.parse_args()
 
 
-def get_credentials(args):
+def get_credentials(args: argparse.Namespace) -> tuple[str, str]:
     """Get API credentials from arguments or environment variables."""
     api_key = args.api_key or os.environ.get("LENEDA_API_KEY")
     energy_id = args.energy_id or os.environ.get("LENEDA_ENERGY_ID")
@@ -159,7 +159,7 @@ def detect_anomalies(df: pd.DataFrame, threshold: float) -> pd.DataFrame:
     return df
 
 
-async def main():
+async def main() -> None:
     # Parse command-line arguments
     args = parse_arguments()
 

{leneda_client-0.5.0 → leneda_client-0.6.0}/examples/basic_usage.py

@@ -29,7 +29,7 @@ logging.basicConfig(
 logger = logging.getLogger("leneda_example")
 
 
-def parse_arguments():
+def parse_arguments() -> argparse.Namespace:
     """Parse command-line arguments."""
     parser = argparse.ArgumentParser(description="Leneda API Client Basic Usage Example")
 
@@ -59,7 +59,7 @@ def parse_arguments():
     return parser.parse_args()
 
 
-def get_credentials(args):
+def get_credentials(args: argparse.Namespace) -> tuple[str, str]:
     """Get API credentials from arguments or environment variables."""
     api_key = args.api_key or os.environ.get("LENEDA_API_KEY")
     energy_id = args.energy_id or os.environ.get("LENEDA_ENERGY_ID")
@@ -79,7 +79,7 @@ def get_credentials(args):
     return api_key, energy_id
 
 
-async def main():
+async def main() -> None:
     # Parse command-line arguments
     args = parse_arguments()
 
@@ -148,11 +148,11 @@ async def main():
     # Display all measurements
     if aggregated_data.aggregated_time_series:
         print("\nMonthly measurements:")
-        for item in aggregated_data.aggregated_time_series:
+        for metering_value in aggregated_data.aggregated_time_series:
             print(
-                f"Period: {item.started_at.strftime('%Y-%m')}, "
-                f"Value: {item.value} {aggregated_data.unit}, "
-                f"Calculated: {item.calculated}"
+                f"Period: {metering_value.started_at.strftime('%Y-%m')}, "
+                f"Value: {metering_value.value} {aggregated_data.unit}, "
+                f"Calculated: {metering_value.calculated}"
             )
 
 

{leneda_client-0.5.0 → leneda_client-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [tool.black]
 line-length = 100
-target-version = ['py38', 'py39', 'py310', 'py311']
+target-version = ['py39', 'py310', 'py311']
 include = '\.pyi?$'
 
 [tool.isort]
@@ -14,12 +14,12 @@ multi_line_output = 3
 src_paths = ["src", "tests"]
 
 [tool.mypy]
-python_version = "3.8"
+python_version = "3.9"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true
 disallow_incomplete_defs = true
-mypy_path = "src"
+explicit_package_bases = true
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{leneda_client-0.5.0 → leneda_client-0.6.0}/setup.py

@@ -35,6 +35,8 @@ setup(
     url="https://github.com/fedus/leneda-client",
     package_dir={"": "src"},
     packages=find_packages(where="src"),
+    include_package_data=True,
+    package_data={"leneda": ["py.typed"]},
     install_requires=requirements,
     classifiers=[
         "Development Status :: 4 - Beta",

{leneda_client-0.5.0 → leneda_client-0.6.0}/src/leneda/client.py

@@ -8,14 +8,15 @@ energy consumption and production data for electricity and gas.
 import json
 import logging
 from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Union
 
 import aiohttp
-from aiohttp import ClientTimeout
+from aiohttp import ClientResponseError, ClientTimeout
 
-from .exceptions import ForbiddenException, UnauthorizedException
+from .exceptions import ForbiddenException, MeteringPointNotFoundException, UnauthorizedException
 from .models import (
     AggregatedMeteringData,
+    AuthenticationProbeResult,
     MeteringData,
 )
 from .obis_codes import ObisCode
@@ -115,7 +116,7 @@ class LenedaClient:
 
                     # Parse the response
                     if response.content:
-                        response_data = await response.json()
+                        response_data: dict = await response.json()
                         logger.debug(f"Response status: {response.status}")
                         logger.debug(f"Response data: {json.dumps(response_data, indent=2)}")
                         return response_data
@@ -133,6 +134,39 @@ class LenedaClient:
             logger.error(f"JSON decode error: {e}")
             raise
 
+    async def _make_metering_request(
+        self, request_callable: Callable[..., Awaitable[dict[Any, Any]]], *args: Any, **kwargs: Any
+    ) -> dict[Any, Any]:
+        """
+        Make a request to a metering data endpoint with 404 error handling.
+
+        This wrapper around any request callable specifically handles 404 errors for metering data
+        endpoints by raising MeteringPointNotFoundException.
+
+        Args:
+            request_callable: The callable to execute (e.g., self._make_request)
+            *args: Arguments to pass to the callable
+            **kwargs: Keyword arguments to pass to the callable
+
+        Returns:
+            The JSON response from the API
+
+        Raises:
+            MeteringPointNotFoundException: If the API returns a 404 status code
+            UnauthorizedException: If the API returns a 401 status code
+            ForbiddenException: If the API returns a 403 status code
+            aiohttp.ClientError: For other request errors
+            json.JSONDecodeError: If the response cannot be parsed as JSON
+        """
+        try:
+            return await request_callable(*args, **kwargs)
+        except aiohttp.ClientResponseError as e:
+            if e.status == 404:
+                raise MeteringPointNotFoundException(
+                    "Metering point not found. The requested metering point may not exist or you may not have access to it."
+                )
+            raise
+
     async def get_metering_data(
         self,
         metering_point_code: str,
@@ -167,7 +201,9 @@ class LenedaClient:
         }
 
         # Make the request
-        response_data = await self._make_request(method="GET", endpoint=endpoint, params=params)
+        response_data = await self._make_metering_request(
+            self._make_request, method="GET", endpoint=endpoint, params=params
+        )
 
         # Parse the response into a MeteringData object
         return MeteringData.from_dict(response_data)
@@ -212,7 +248,9 @@ class LenedaClient:
         }
 
         # Make the request
-        response_data = await self._make_request(method="GET", endpoint=endpoint, params=params)
+        response_data = await self._make_metering_request(
+            self._make_request, method="GET", endpoint=endpoint, params=params
+        )
 
         # Parse the response into an AggregatedMeteringData object
         return AggregatedMeteringData.from_dict(response_data)
@@ -320,3 +358,41 @@ class LenedaClient:
             if await self.probe_metering_point_obis_code(metering_point_code, obis_code):
                 supported_codes.append(obis_code)
         return supported_codes
+
+    async def probe_credentials(self) -> AuthenticationProbeResult:
+        """
+        Probe if credentials are valid.
+
+        NOTE: This is an experimental function, as the Leneda API does not provide a native way to verify credentials only.
+        Use with caution, may break or yield unexpected results.
+
+        This method attempts to verify authentication by making a request to the metering data access endpoint
+        with invalid parameters. If the API returns a 400 status code, it indicates that authentication is successful
+        but the request parameters are invalid. If it returns a 401 status code, authentication has failed.
+
+        We make a request with invalid parameters because we don't want to actually lodge a metering data access request,
+        we just want to verify that the credentials are valid.
+
+        Returns:
+            AuthenticationProbeResult: SUCCESS if authentication is valid, FAILURE if authentication failed,
+            or UNKNOWN if the result cannot be determined
+
+        Raises:
+            ForbiddenException: If the API returns a 403 status code
+        """
+        try:
+            await self.request_metering_data_access("", "", [], [])
+        except UnauthorizedException:
+            return AuthenticationProbeResult.FAILURE
+        except ClientResponseError as e:
+            # We expect a 400 response if authentication is successful and our request is invalid
+            if e.status == 400:
+                # Update the config entry with new token
+                return AuthenticationProbeResult.SUCCESS
+            return AuthenticationProbeResult.UNKNOWN
+        except ForbiddenException:
+            raise
+        except Exception:
+            return AuthenticationProbeResult.UNKNOWN
+
+        return AuthenticationProbeResult.UNKNOWN

{leneda_client-0.5.0 → leneda_client-0.6.0}/src/leneda/exceptions.py

@@ -19,3 +19,9 @@ class ForbiddenException(LenedaException):
     """Raised when access is forbidden (403 Forbidden), typically due to geoblocking or other access restrictions."""
 
     pass
+
+
+class MeteringPointNotFoundException(LenedaException):
+    """Raised when a metering point is not found."""
+
+    pass

{leneda_client-0.5.0 → leneda_client-0.6.0}/src/leneda/models.py

@@ -8,6 +8,7 @@ making it easier to work with the data in a type-safe manner.
 import logging
 from dataclasses import dataclass, field
 from datetime import datetime
+from enum import Enum
 from typing import Any, Dict, List
 
 from dateutil import parser
@@ -237,3 +238,11 @@ class AggregatedMeteringData:
             f"AggregatedMeteringData(unit={self.unit}, "
             f"items_count={len(self.aggregated_time_series)})"
         )
+
+
+class AuthenticationProbeResult(Enum):
+    """Result of an authentication probe."""
+
+    SUCCESS = "SUCCESS"
+    FAILURE = "FAILURE"
+    UNKNOWN = "UNKNOWN"

{leneda_client-0.5.0 → leneda_client-0.6.0}/src/leneda/version.py

@@ -1,3 +1,3 @@
 """Version information."""
 
-__version__ = "0.5.0"
+__version__ = "0.6.0"

{leneda_client-0.5.0 → leneda_client-0.6.0/src/leneda_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leneda-client
-Version: 0.5.0
+Version: 0.6.0
 Summary: Python client for the Leneda energy data platform
 Home-page: https://github.com/fedus/leneda-client
 Author: fedus

{leneda_client-0.5.0 → leneda_client-0.6.0}/src/leneda_client.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/leneda/client.py
 src/leneda/exceptions.py
 src/leneda/models.py
 src/leneda/obis_codes.py
+src/leneda/py.typed
 src/leneda/version.py
 src/leneda_client.egg-info/PKG-INFO
 src/leneda_client.egg-info/SOURCES.txt

{leneda_client-0.5.0 → leneda_client-0.6.0}/tests/test_client.py

@@ -3,25 +3,24 @@ Tests for the Leneda API client.
 """
 
 import json
-import os
-import sys
 import unittest
-from unittest.mock import AsyncMock, patch
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import aiohttp
 import pytest
-
-# Add the src directory to the path
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from aiohttp import ClientResponseError
 
 from src.leneda import LenedaClient
 from src.leneda.exceptions import (
     ForbiddenException,
+    MeteringPointNotFoundException,
     UnauthorizedException,
 )
 from src.leneda.models import (
     AggregatedMeteringData,
     AggregatedMeteringValue,
+    AuthenticationProbeResult,
     MeteringData,
     MeteringValue,
 )
@@ -33,7 +32,7 @@ class TestLenedaClient:
     """Test cases for the LenedaClient class."""
 
     @pytest.fixture(autouse=True)
-    def setup(self):
+    def setup(self) -> None:
         """Set up test fixtures."""
         self.api_key = "test_api_key"
         self.energy_id = "test_energy_id"
@@ -82,7 +81,7 @@ class TestLenedaClient:
         }
 
     @patch("aiohttp.ClientSession.request")
-    async def test_get_time_series(self, mock_request):
+    async def test_get_time_series(self, mock_request: Any) -> None:
         """Test getting time series data."""
         # Set up the mock response
         mock_response = AsyncMock()
@@ -131,7 +130,7 @@ class TestLenedaClient:
         }
 
     @patch("aiohttp.ClientSession.request")
-    async def test_get_aggregated_time_series(self, mock_request):
+    async def test_get_aggregated_time_series(self, mock_request: Any) -> None:
         """Test getting aggregated time series data."""
         # Set up the mock response
         mock_response = AsyncMock()
@@ -183,7 +182,7 @@ class TestLenedaClient:
         }
 
     @patch("aiohttp.ClientSession.request")
-    async def test_request_metering_data_access(self, mock_request):
+    async def test_request_metering_data_access(self, mock_request: Any) -> None:
         """Test requesting metering data access."""
         # Set up the mock response
         mock_response = AsyncMock()
@@ -224,14 +223,12 @@ class TestLenedaClient:
         }
 
     @patch("aiohttp.ClientSession.request")
-    async def test_unauthorized_error(self, mock_request):
+    async def test_unauthorized_error(self, mock_request: Any) -> None:
         """Test handling of 401 Unauthorized errors."""
         # Set up the mock response with 401 status
-        mock_response = AsyncMock()
-        mock_response.status = 401
-        mock_response.content = b"Unauthorized"
-        mock_response.raise_for_status = lambda: None
-        mock_request.return_value.__aenter__.return_value = mock_response
+        mock_request.return_value.__aenter__.return_value = build_error_mock_response(
+            401, "Unauthorized"
+        )
 
         # Call the method and check that it raises UnauthorizedException
         with pytest.raises(UnauthorizedException) as exc_info:
@@ -246,14 +243,12 @@ class TestLenedaClient:
         assert "API authentication failed" in str(exc_info.value)
 
     @patch("aiohttp.ClientSession.request")
-    async def test_forbidden_error(self, mock_request):
+    async def test_forbidden_error(self, mock_request: Any) -> None:
         """Test handling of 403 Forbidden errors."""
         # Set up the mock response with 403 status
-        mock_response = AsyncMock()
-        mock_response.status = 403
-        mock_response.content = b"Forbidden"
-        mock_response.raise_for_status = lambda: None
-        mock_request.return_value.__aenter__.return_value = mock_response
+        mock_request.return_value.__aenter__.return_value = build_error_mock_response(
+            403, "Forbidden"
+        )
 
         # Call the method and check that it raises ForbiddenException
         with pytest.raises(ForbiddenException) as exc_info:
@@ -268,13 +263,15 @@ class TestLenedaClient:
         assert "geoblocking" in str(exc_info.value)
 
     @patch("aiohttp.ClientSession.request")
-    async def test_error_handling(self, mock_request):
-        """Test error handling for other HTTP errors."""
+    async def test_metering_point_not_found_handling(self, mock_request: Any) -> None:
+        """Test error handling when a metering point is not found."""
         # Set up the mock response to raise an exception
-        mock_request.side_effect = aiohttp.ClientError("404 Client Error")
+        mock_request.return_value.__aenter__.return_value = build_error_mock_response(
+            404, "Not found"
+        )
 
         # Call the method and check that it raises an exception
-        with pytest.raises(aiohttp.ClientError):
+        with pytest.raises(MeteringPointNotFoundException):
             await self.client.get_metering_data(
                 "LU-METERING_POINT1",
                 ObisCode.ELEC_CONSUMPTION_ACTIVE,
@@ -283,7 +280,7 @@ class TestLenedaClient:
             )
 
     @patch("aiohttp.ClientSession.request")
-    async def test_probe_metering_point_obis_code_valid(self, mock_request):
+    async def test_probe_metering_point_obis_code_valid(self, mock_request: Any) -> None:
         """Test probe_metering_point_obis_code with a valid metering point and OBIS code."""
         # Set up the mock response with valid data
         mock_response = AsyncMock()
@@ -304,7 +301,7 @@ class TestLenedaClient:
         mock_request.assert_called_once()
 
     @patch("aiohttp.ClientSession.request")
-    async def test_probe_metering_point_obis_code_invalid(self, mock_request):
+    async def test_probe_metering_point_obis_code_invalid(self, mock_request: Any) -> None:
         """Test probe_metering_point_obis_code with an invalid metering point or unsupported OBIS code."""
         # Set up the mock response with null unit
         mock_response = AsyncMock()
@@ -325,11 +322,11 @@ class TestLenedaClient:
         mock_request.assert_called_once()
 
     @patch.object(LenedaClient, "probe_metering_point_obis_code")
-    async def test_get_supported_obis_codes(self, mock_probe):
+    async def test_get_supported_obis_codes(self, mock_probe: Any) -> None:
         """Test getting supported OBIS codes for a metering point."""
 
         # Mock probe_metering_point_obis_code to return True for two codes, False otherwise
-        def side_effect(metering_point_code, obis_code):
+        def side_effect(metering_point_code: str, obis_code: ObisCode) -> bool:
             return obis_code in [ObisCode.ELEC_CONSUMPTION_ACTIVE, ObisCode.ELEC_PRODUCTION_ACTIVE]
 
         mock_probe.side_effect = side_effect
@@ -347,7 +344,7 @@ class TestLenedaClient:
         assert mock_probe.call_count == len(ObisCode)
 
     @patch.object(LenedaClient, "probe_metering_point_obis_code", return_value=False)
-    async def test_get_supported_obis_codes_none(self, mock_probe):
+    async def test_get_supported_obis_codes_none(self, mock_probe: Any) -> None:
         """Test getting supported OBIS codes when none are supported."""
         # Call the method
         result = await self.client.get_supported_obis_codes("INVALID-METERING-POINT")
@@ -359,6 +356,120 @@ class TestLenedaClient:
         # Check that the probe was called for each OBIS code
         assert mock_probe.call_count == len(ObisCode)
 
+    @patch("aiohttp.ClientSession.request")
+    async def test_probe_credentials_success(self, mock_request: Any) -> None:
+        """Test probe_credentials with valid credentials (400 response expected)."""
+        # Set up the mock response with 400 status (expected for valid credentials with invalid request)
+        mock_request.return_value.__aenter__.return_value = build_error_mock_response(
+            400, "Bad request"
+        )
+
+        # Call the method
+        result = await self.client.probe_credentials()
+
+        # Check the result
+        assert result == AuthenticationProbeResult.SUCCESS
+
+        # Check that the request was made correctly
+        mock_request.assert_called_once()
+        call_kwargs = mock_request.call_args[1]
+        assert call_kwargs["method"] == "POST"
+        assert call_kwargs["url"] == "https://api.leneda.lu/api/metering-data-access-request"
+        assert call_kwargs["headers"] == {
+            "X-API-KEY": "test_api_key",
+            "X-ENERGY-ID": "test_energy_id",
+            "Content-Type": "application/json",
+        }
+        assert call_kwargs["json"] == {
+            "from": "",
+            "fromName": "",
+            "meteringPointCodes": [],
+            "obisCodes": [],
+        }
+
+    @patch("aiohttp.ClientSession.request")
+    async def test_probe_credentials_unauthorized(self, mock_request: Any) -> None:
+        """Test probe_credentials with invalid credentials (401 response)."""
+        # Set up the mock response with 401 status
+        mock_request.return_value.__aenter__.return_value = build_error_mock_response(
+            401, "Unauthorized"
+        )
+
+        # Call the method
+        result = await self.client.probe_credentials()
+
+        # Check the result
+        assert result == AuthenticationProbeResult.FAILURE
+
+        # Check that the request was made correctly
+        mock_request.assert_called_once()
+
+    @patch("aiohttp.ClientSession.request")
+    async def test_probe_credentials_forbidden(self, mock_request: Any) -> None:
+        """Test probe_credentials with forbidden access (403 response)."""
+        # Set up the mock response with 403 status
+        mock_request.return_value.__aenter__.return_value = build_error_mock_response(
+            403, "Forbidden"
+        )
+
+        # Call the method and check that it raises ForbiddenException
+        with pytest.raises(ForbiddenException):
+            await self.client.probe_credentials()
+
+        # Check that the request was made correctly
+        mock_request.assert_called_once()
+
+    @patch("aiohttp.ClientSession.request")
+    async def test_probe_credentials_unknown_response(self, mock_request: Any) -> None:
+        """Test probe_credentials with unexpected response (500 response)."""
+        mock_request.return_value.__aenter__.return_value = build_error_mock_response(
+            500, "Internal server error"
+        )
+
+        # Call the method
+        result = await self.client.probe_credentials()
+
+        # Check the result
+        assert result == AuthenticationProbeResult.UNKNOWN
+
+        # Check that the request was made correctly
+        mock_request.assert_called_once()
+
+    @patch("aiohttp.ClientSession.request")
+    async def test_probe_credentials_network_error(self, mock_request: Any) -> None:
+        """Test probe_credentials with network error."""
+        # Set up the mock to raise a network error
+        mock_request.side_effect = aiohttp.ClientError("Network error")
+
+        # Call the method
+        result = await self.client.probe_credentials()
+
+        # Check the result
+        assert result == AuthenticationProbeResult.UNKNOWN
+
+        # Check that the request was attempted
+        mock_request.assert_called_once()
+
+
+def build_error_mock_response(status: int, message: str) -> AsyncMock:
+    """Build a mock response for an error case."""
+
+    def raise_for_status() -> None:
+        raise ClientResponseError(
+            status=status,
+            history=(),
+            message=message,
+            headers=None,
+            request_info=MagicMock(),
+        )
+
+    mock_response = AsyncMock()
+    mock_response.status = status
+    mock_response.content = message
+    mock_response.raise_for_status = raise_for_status
+
+    return mock_response
+
 
 if __name__ == "__main__":
     unittest.main()