leneda-client 0.3.0__tar.gz → 0.4.0__tar.gz

{leneda_client-0.3.0/src/leneda_client.egg-info → leneda_client-0.4.0}/PKG-INFO

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

{leneda_client-0.3.0 → leneda_client-0.4.0}/src/leneda/client.py

@@ -12,7 +12,7 @@ from typing import Any, Dict, List, Optional, Union
 
 import requests
 
-from .exceptions import ForbiddenException, InvalidMeteringPointException, UnauthorizedException
+from .exceptions import ForbiddenException, UnauthorizedException
 from .models import (
     AggregatedMeteringData,
     MeteringData,
@@ -250,19 +250,24 @@ class LenedaClient:
 
         return response_data
 
-    def test_metering_point(self, metering_point_code: str) -> bool:
+    def probe_metering_point_obis_code(self, metering_point_code: str, obis_code: ObisCode) -> bool:
         """
-        Test if a metering point code is valid and accessible.
+        Probe if a metering point provides data for a specific OBIS code.
 
-        This method checks if a metering point code is valid by making a request
-        for aggregated metering data. If the unit property in the response is null,
-        it indicates that the metering point is invalid or not accessible.
+        NOTE: This method is essentially a best guess since the Leneda API does not provide a way to check
+        if a metering point provides data for a specific OBIS code or whether a metering point code is valid
+
+        This method checks if a metering point provides data for the specified OBIS code by making a request
+        for aggregated metering data. If the unit property in the response is null, it indicates that either:
+        - The metering point is invalid, or
+        - The metering point does not provide data for the specified OBIS code
 
         Args:
-            metering_point_code: The metering point code to test
+            metering_point_code: The metering point code to probe
+            obis_code: The OBIS code to check for data availability
 
         Returns:
-            bool: True if the metering point is valid and accessible, False otherwise
+            bool: True if the metering point provides data for the specified OBIS code, False otherwise
 
         Raises:
             UnauthorizedException: If the API returns a 401 status code
@@ -273,20 +278,43 @@ class LenedaClient:
         end_date = datetime.now()
         start_date = end_date - timedelta(weeks=4)
 
-        # Try to get aggregated data for electricity consumption
+        # Try to get aggregated data for the specified OBIS code
         result = self.get_aggregated_metering_data(
             metering_point_code=metering_point_code,
-            obis_code=ObisCode.ELEC_CONSUMPTION_ACTIVE,
+            obis_code=obis_code,
             start_date=start_date,
             end_date=end_date,
             aggregation_level="Month",
             transformation_mode="Accumulation",
         )
 
-        # If we get here and the unit is None, the metering point is invalid
-        if result.unit is None:
-            raise InvalidMeteringPointException(
-                f"Metering point {metering_point_code} is invalid or not accessible"
-            )
+        # Return True if we got data (unit is not None), False otherwise
+        return result.unit is not None
+
+    def get_supported_obis_codes(self, metering_point_code: str) -> List[ObisCode]:
+        """
+        Get all OBIS codes that are supported by a given metering point.
+
+        NOTE: Please see the documentation of the probe_metering_point_obis_code method about best guess
+        behaviour. If this method returns an empty list, chances are high that the metering point code
+        is invalid or that the Energy ID has no access to it.
+
+        This method probes each OBIS code defined in the ObisCode enum to determine
+        which ones are supported by the specified metering point.
+
+        Args:
+            metering_point_code: The metering point code to check
 
-        return True
+        Returns:
+            List[ObisCode]: A list of OBIS codes that are supported by the metering point
+
+        Raises:
+            UnauthorizedException: If the API returns a 401 status code
+            ForbiddenException: If the API returns a 403 status code
+            requests.exceptions.RequestException: For other request errors
+        """
+        return [
+            obis_code
+            for obis_code in ObisCode
+            if self.probe_metering_point_obis_code(metering_point_code, obis_code)
+        ]

{leneda_client-0.3.0 → leneda_client-0.4.0}/src/leneda/exceptions.py

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

{leneda_client-0.3.0 → leneda_client-0.4.0}/src/leneda/version.py

@@ -1,3 +1,3 @@
 """Version information."""
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"

{leneda_client-0.3.0 → leneda_client-0.4.0/src/leneda_client.egg-info}/PKG-INFO

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

{leneda_client-0.3.0 → leneda_client-0.4.0}/tests/test_client.py

@@ -16,7 +16,6 @@ sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")
 from src.leneda import LenedaClient
 from src.leneda.exceptions import (
     ForbiddenException,
-    InvalidMeteringPointException,
     UnauthorizedException,
 )
 from src.leneda.models import (
@@ -283,8 +282,8 @@ class TestLenedaClient(unittest.TestCase):
             )
 
     @patch("requests.request")
-    def test_test_metering_point_valid(self, mock_request):
-        """Test test_metering_point with a valid metering point."""
+    def test_probe_metering_point_obis_code_valid(self, mock_request):
+        """Test probe_metering_point_obis_code with a valid metering point and OBIS code."""
         # Set up the mock response with valid data
         mock_response = MagicMock()
         mock_response.status_code = 200
@@ -293,7 +292,9 @@ class TestLenedaClient(unittest.TestCase):
         mock_request.return_value = mock_response
 
         # Call the method
-        result = self.client.test_metering_point("LU-METERING_POINT1")
+        result = self.client.probe_metering_point_obis_code(
+            "LU-METERING_POINT1", ObisCode.ELEC_CONSUMPTION_ACTIVE
+        )
 
         # Check the result
         self.assertTrue(result)
@@ -302,8 +303,8 @@ class TestLenedaClient(unittest.TestCase):
         mock_request.assert_called_once()
 
     @patch("requests.request")
-    def test_test_metering_point_invalid(self, mock_request):
-        """Test test_metering_point with an invalid metering point."""
+    def test_probe_metering_point_obis_code_invalid(self, mock_request):
+        """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 = MagicMock()
         mock_response.status_code = 200
@@ -311,16 +312,72 @@ class TestLenedaClient(unittest.TestCase):
         mock_response.content = json.dumps(mock_response.json.return_value).encode()
         mock_request.return_value = mock_response
 
-        # Call the method and check that it raises InvalidMeteringPointException
-        with self.assertRaises(InvalidMeteringPointException) as context:
-            self.client.test_metering_point("INVALID-METERING-POINT")
+        # Call the method
+        result = self.client.probe_metering_point_obis_code(
+            "INVALID-METERING-POINT", ObisCode.ELEC_CONSUMPTION_ACTIVE
+        )
 
-        # Check the error message
-        self.assertIn("INVALID-METERING-POINT", str(context.exception))
+        # Check the result
+        self.assertFalse(result)
 
         # Check that the request was made correctly
         mock_request.assert_called_once()
 
+    @patch("requests.request")
+    def test_get_supported_obis_codes(self, mock_request):
+        """Test getting supported OBIS codes for a metering point."""
+
+        # Set up the mock response to return different results for different OBIS codes
+        def mock_response_side_effect(*args, **kwargs):
+            mock_response = MagicMock()
+            mock_response.status_code = 200
+
+            # Check which OBIS code is being probed
+            obis_code = kwargs.get("params", {}).get("obisCode")
+            if obis_code == ObisCode.ELEC_CONSUMPTION_ACTIVE.value:
+                mock_response.json.return_value = {"unit": "kWh", "aggregatedTimeSeries": []}
+            elif obis_code == ObisCode.ELEC_PRODUCTION_ACTIVE.value:
+                mock_response.json.return_value = {"unit": "kWh", "aggregatedTimeSeries": []}
+            else:
+                mock_response.json.return_value = {"unit": None, "aggregatedTimeSeries": []}
+
+            mock_response.content = json.dumps(mock_response.json.return_value).encode()
+            return mock_response
+
+        mock_request.side_effect = mock_response_side_effect
+
+        # Call the method
+        result = self.client.get_supported_obis_codes("LU-METERING_POINT1")
+
+        # Check the result
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 2)  # We expect 2 supported OBIS codes
+        self.assertIn(ObisCode.ELEC_CONSUMPTION_ACTIVE, result)
+        self.assertIn(ObisCode.ELEC_PRODUCTION_ACTIVE, result)
+
+        # Check that the request was made for each OBIS code
+        self.assertEqual(mock_request.call_count, len(ObisCode))
+
+    @patch("requests.request")
+    def test_get_supported_obis_codes_none(self, mock_request):
+        """Test getting supported OBIS codes when none are supported."""
+        # Set up the mock response to return null unit for all OBIS codes
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"unit": None, "aggregatedTimeSeries": []}
+        mock_response.content = json.dumps(mock_response.json.return_value).encode()
+        mock_request.return_value = mock_response
+
+        # Call the method
+        result = self.client.get_supported_obis_codes("INVALID-METERING-POINT")
+
+        # Check the result
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 0)  # No supported OBIS codes
+
+        # Check that the request was made for each OBIS code
+        self.assertEqual(mock_request.call_count, len(ObisCode))
+
 
 if __name__ == "__main__":
     unittest.main()