leneda-client 0.1.0__py3-none-any.whl

leneda/__init__.py

@@ -0,0 +1,36 @@
+"""
+Leneda API client package.
+
+This package provides a client for the Leneda API, which allows access to
+energy consumption and production data for electricity and gas.
+"""
+
+# Import the client class
+from .client import LenedaClient
+
+# Import the data models
+from .models import (
+    AggregatedMeteringData,
+    AggregatedMeteringValue,
+    MeteringData,
+    MeteringValue,
+)
+
+# Import the OBIS code constants
+from .obis_codes import ElectricityConsumption, ElectricityProduction, GasConsumption
+
+# Import the version
+from .version import __version__
+
+# Define what's available when using "from leneda import *"
+__all__ = [
+    "LenedaClient",
+    "ElectricityConsumption",
+    "ElectricityProduction",
+    "GasConsumption",
+    "MeteringValue",
+    "MeteringData",
+    "AggregatedMeteringValue",
+    "AggregatedMeteringData",
+    "__version__",
+]

leneda/client.py

@@ -0,0 +1,226 @@
+"""
+Leneda API client for accessing energy consumption and production data.
+
+This module provides a client for the Leneda API, which allows access to
+energy consumption and production data for electricity and gas.
+"""
+
+import json
+import logging
+from datetime import datetime
+from typing import Any, Dict, Union
+
+import requests
+
+from .models import AggregatedMeteringData, MeteringData
+
+# Set up logging
+logger = logging.getLogger("leneda.client")
+
+
+class LenedaClient:
+    """Client for the Leneda API."""
+
+    BASE_URL = "https://api.leneda.lu/api"
+
+    def __init__(self, api_key: str, energy_id: str, debug: bool = False):
+        """
+        Initialize the Leneda API client.
+
+        Args:
+            api_key: Your Leneda API key
+            energy_id: Your Energy ID
+            debug: Enable debug logging
+        """
+        self.api_key = api_key
+        self.energy_id = energy_id
+
+        # Set up headers for API requests
+        self.headers = {
+            "X-API-KEY": api_key,
+            "X-ENERGY-ID": energy_id,
+            "Content-Type": "application/json",
+        }
+
+        # Set up debug logging if requested
+        if debug:
+            logging.getLogger("leneda").setLevel(logging.DEBUG)
+            logger.setLevel(logging.DEBUG)
+            logger.debug("Debug logging enabled for Leneda client")
+
+    def _make_request(
+        self,
+        endpoint: str,
+        method: str = "GET",
+        params: Dict[str, Any] = None,
+        data: Dict[str, Any] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make a request to the Leneda API.
+
+        Args:
+            endpoint: API endpoint to call
+            method: HTTP method to use
+            params: Query parameters
+            data: Request body data
+
+        Returns:
+            API response as a dictionary
+        """
+        url = f"{self.BASE_URL}/{endpoint}"
+
+        # Log the request details
+        logger.debug(f"Making {method} request to {url}")
+        if params:
+            logger.debug(f"Query parameters: {params}")
+        if data:
+            logger.debug(f"Request data: {data}")
+
+        try:
+            # Make the request
+            response = requests.request(
+                method=method, url=url, headers=self.headers, params=params, json=data
+            )
+
+            # Check for HTTP errors
+            response.raise_for_status()
+
+            # Parse the response
+            if response.content:
+                response_data = response.json()
+                logger.debug(f"Response status: {response.status_code}")
+                logger.debug(f"Response data: {json.dumps(response_data, indent=2)}")
+                return response_data
+            else:
+                logger.debug(f"Response status: {response.status_code} (no content)")
+                return {}
+
+        except requests.exceptions.HTTPError as e:
+            # Handle HTTP errors
+            logger.error(f"HTTP error: {e}")
+            if hasattr(e, "response") and e.response is not None:
+                logger.error(f"Response status: {e.response.status_code}")
+                logger.error(f"Response body: {e.response.text}")
+            raise
+
+        except requests.exceptions.RequestException as e:
+            # Handle other request errors
+            logger.error(f"Request error: {e}")
+            raise
+
+        except json.JSONDecodeError as e:
+            # Handle JSON parsing errors
+            logger.error(f"JSON decode error: {e}")
+            logger.error(f"Response text: {response.text}")
+            raise
+
+    def get_metering_data(
+        self,
+        metering_point_code: str,
+        obis_code: str,
+        start_date_time: Union[str, datetime],
+        end_date_time: Union[str, datetime],
+    ) -> MeteringData:
+        """
+        Get time series data for a specific metering point and OBIS code.
+
+        Args:
+            metering_point_code: The metering point code
+            obis_code: The OBIS code
+            start_date_time: Start date and time (ISO format string or datetime object)
+            end_date_time: End date and time (ISO format string or datetime object)
+
+        Returns:
+            MeteringData object containing the time series data
+        """
+        # Convert datetime objects to ISO format strings if needed
+        if isinstance(start_date_time, datetime):
+            start_date_time = start_date_time.strftime("%Y-%m-%dT%H:%M:%SZ")
+        if isinstance(end_date_time, datetime):
+            end_date_time = end_date_time.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        # Set up the endpoint and parameters
+        endpoint = f"metering-points/{metering_point_code}/time-series"
+        params = {
+            "obisCode": obis_code,
+            "startDateTime": start_date_time,
+            "endDateTime": end_date_time,
+        }
+
+        # Make the request
+        response_data = self._make_request(endpoint, params=params)
+
+        # Parse the response into a MeteringData object
+        return MeteringData.from_dict(
+            response_data, metering_point_code=metering_point_code, obis_code=obis_code
+        )
+
+    def get_aggregated_metering_data(
+        self,
+        metering_point_code: str,
+        obis_code: str,
+        start_date: Union[str, datetime],
+        end_date: Union[str, datetime],
+        aggregation_level: str = "Day",
+        transformation_mode: str = "Accumulation",
+    ) -> AggregatedMeteringData:
+        """
+        Get aggregated time series data for a specific metering point and OBIS code.
+
+        Args:
+            metering_point_code: The metering point code
+            obis_code: The OBIS code
+            start_date: Start date (ISO format string or datetime object)
+            end_date: End date (ISO format string or datetime object)
+            aggregation_level: Aggregation level (Day, Week, Month, Quarter, Year)
+            transformation_mode: Transformation mode (Accumulation, Average, Maximum, Minimum)
+
+        Returns:
+            AggregatedMeteringData object containing the aggregated time series data
+        """
+        # Convert datetime objects to ISO format strings if needed
+        if isinstance(start_date, datetime):
+            start_date = start_date.strftime("%Y-%m-%d")
+        if isinstance(end_date, datetime):
+            end_date = end_date.strftime("%Y-%m-%d")
+
+        # Set up the endpoint and parameters
+        endpoint = f"metering-points/{metering_point_code}/time-series/aggregated"
+        params = {
+            "obisCode": obis_code,
+            "startDate": start_date,
+            "endDate": end_date,
+            "aggregationLevel": aggregation_level,
+            "transformationMode": transformation_mode,
+        }
+
+        # Make the request
+        response_data = self._make_request(endpoint, params=params)
+
+        # Parse the response into an AggregatedMeteringData object
+        return AggregatedMeteringData.from_dict(
+            response_data,
+            metering_point_code=metering_point_code,
+            obis_code=obis_code,
+            aggregation_level=aggregation_level,
+            transformation_mode=transformation_mode,
+        )
+
+    def request_metering_data_access(self, metering_point_code: str) -> Dict[str, Any]:
+        """
+        Request access to metering data for a specific metering point.
+
+        Args:
+            metering_point_code: The metering point code
+
+        Returns:
+            Response data from the API
+        """
+        # Set up the endpoint and data
+        endpoint = "metering-data-access-request"
+        data = {"meteringPointCode": metering_point_code}
+
+        # Make the request
+        response_data = self._make_request(endpoint, method="POST", data=data)
+
+        return response_data

leneda/models.py

@@ -0,0 +1,235 @@
+"""
+Data models for the Leneda API responses.
+
+This module provides typed data classes for the various responses from the Leneda API,
+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 typing import Any, Dict, List
+
+from dateutil import parser
+
+# Set up logging
+logger = logging.getLogger("leneda.models")
+
+
+@dataclass
+class MeteringValue:
+    """A single metering value from a time series."""
+
+    value: float
+    started_at: datetime
+    type: str
+    version: int
+    calculated: bool
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "MeteringValue":
+        """Create a MeteringValue from a dictionary."""
+        try:
+            # Handle the required fields
+            value = float(data["value"])
+
+            # Parse ISO format string to datetime using dateutil
+            started_at = parser.isoparse(data["startedAt"])
+
+            # Get type, version and calculated
+            type_value = data["type"]
+            version = int(data["version"])
+            calculated = bool(data["calculated"])
+
+            return cls(
+                value=value,
+                started_at=started_at,
+                type=type_value,
+                version=version,
+                calculated=calculated,
+            )
+        except KeyError as e:
+            # Log the error and the data that caused it
+            logger.error(f"Missing key in API response: {e}")
+            logger.debug(f"API response data: {data}")
+            raise
+        except Exception as e:
+            logger.error(f"Error parsing metering value: {e}")
+            logger.debug(f"API response data: {data}")
+            raise
+
+
+@dataclass
+class MeteringData:
+    """Metering data for a specific metering point and OBIS code."""
+
+    metering_point_code: str
+    obis_code: str
+    interval_length: str
+    unit: str
+    items: List[MeteringValue] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(
+        cls, data: Dict[str, Any], metering_point_code: str = "", obis_code: str = ""
+    ) -> "MeteringData":
+        """Create a MeteringData from a dictionary."""
+        try:
+            # Log the raw data for debugging
+            logger.debug(f"Creating MeteringData from: {data}")
+
+            # Use values from the response, falling back to provided values if not in response
+            metering_point_code_value = data.get("meteringPointCode", metering_point_code)
+            obis_code_value = data.get("obisCode", obis_code)
+
+            # Extract items safely
+            items_data = data.get("items", [])
+            items = []
+
+            for item_data in items_data:
+                try:
+                    item = MeteringValue.from_dict(item_data)
+                    items.append(item)
+                except Exception as e:
+                    logger.warning(f"Skipping invalid item: {e}")
+                    logger.debug(f"Invalid item data: {item_data}")
+
+            return cls(
+                metering_point_code=metering_point_code_value,
+                obis_code=obis_code_value,
+                interval_length=data.get("intervalLength", ""),
+                unit=data.get("unit", ""),
+                items=items,
+            )
+        except Exception as e:
+            logger.error(f"Error creating MeteringData: {e}")
+            logger.debug(f"API response data: {data}")
+            raise
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the MeteringData to a dictionary."""
+        return {
+            "meteringPointCode": self.metering_point_code,
+            "obisCode": self.obis_code,
+            "intervalLength": self.interval_length,
+            "unit": self.unit,
+            "items": [
+                {
+                    "value": item.value,
+                    "startedAt": item.started_at.isoformat(),
+                    "type": item.type,
+                    "version": item.version,
+                    "calculated": item.calculated,
+                }
+                for item in self.items
+            ],
+        }
+
+    def __str__(self) -> str:
+        """Return a string representation of the MeteringData."""
+        return (
+            f"MeteringData(metering_point_code={self.metering_point_code}, "
+            f"obis_code={self.obis_code}, unit={self.unit}, "
+            f"items_count={len(self.items)})"
+        )
+
+
+@dataclass
+class AggregatedMeteringValue:
+    """A single aggregated metering value."""
+
+    value: float
+    started_at: datetime
+    ended_at: datetime
+    calculated: bool
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AggregatedMeteringValue":
+        """Create an AggregatedMeteringValue from a dictionary."""
+        try:
+            # Handle the required fields
+            value = float(data["value"])
+
+            # Parse ISO format string to datetime using dateutil
+            started_at = parser.isoparse(data["startedAt"])
+            ended_at = parser.isoparse(data["endedAt"])
+
+            # Get calculated
+            calculated = bool(data["calculated"])
+
+            return cls(
+                value=value,
+                started_at=started_at,
+                ended_at=ended_at,
+                calculated=calculated,
+            )
+        except KeyError as e:
+            logger.error(f"Missing key in API response: {e}")
+            logger.debug(f"API response data: {data}")
+            raise
+        except Exception as e:
+            logger.error(f"Error parsing aggregated metering value: {e}")
+            logger.debug(f"API response data: {data}")
+            raise
+
+
+@dataclass
+class AggregatedMeteringData:
+    """Aggregated metering data for a specific metering point and OBIS code."""
+
+    unit: str
+    aggregated_time_series: List[AggregatedMeteringValue] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(
+        cls,
+        data: Dict[str, Any],
+        metering_point_code: str = "",
+        obis_code: str = "",
+        aggregation_level: str = "",
+        transformation_mode: str = "",
+    ) -> "AggregatedMeteringData":
+        """Create an AggregatedMeteringData from a dictionary."""
+        try:
+            # Log the raw data for debugging
+            logger.debug(f"Creating AggregatedMeteringData from: {data}")
+
+            # Extract items safely
+            time_series_data = data.get("aggregatedTimeSeries", [])
+            time_series = []
+
+            for item_data in time_series_data:
+                try:
+                    item = AggregatedMeteringValue.from_dict(item_data)
+                    time_series.append(item)
+                except Exception as e:
+                    logger.warning(f"Skipping invalid aggregated item: {e}")
+                    logger.debug(f"Invalid item data: {item_data}")
+
+            return cls(unit=data.get("unit", ""), aggregated_time_series=time_series)
+        except Exception as e:
+            logger.error(f"Error creating AggregatedMeteringData: {e}")
+            logger.debug(f"API response data: {data}")
+            raise
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the AggregatedMeteringData to a dictionary."""
+        return {
+            "unit": self.unit,
+            "aggregatedTimeSeries": [
+                {
+                    "value": item.value,
+                    "startedAt": item.started_at.isoformat(),
+                    "endedAt": item.ended_at.isoformat(),
+                    "calculated": item.calculated,
+                }
+                for item in self.aggregated_time_series
+            ],
+        }
+
+    def __str__(self) -> str:
+        """Return a string representation of the AggregatedMeteringData."""
+        return (
+            f"AggregatedMeteringData(unit={self.unit}, "
+            f"items_count={len(self.aggregated_time_series)})"
+        )

leneda/obis_codes.py

@@ -0,0 +1,232 @@
+"""
+OBIS (Object Identification System) codes for the Leneda API.
+
+This module provides constants for the various OBIS codes used in the Leneda platform,
+making it easier to reference the correct codes when retrieving energy data.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, List
+
+
+@dataclass
+class ObisCodeInfo:
+    """Information about an OBIS code."""
+
+    code: str
+    unit: str
+    service_type: str
+    description: str
+
+
+class ElectricityConsumption(str, Enum):
+    """OBIS codes for electricity consumption."""
+
+    ACTIVE = "1-1:1.29.0"  # Measured active consumption (kW)
+    REACTIVE = "1-1:3.29.0"  # Measured reactive consumption (kVAR)
+
+    # Consumption covered by production sharing groups
+    COVERED_LAYER1 = "1-65:1.29.1"  # Layer 1 sharing Group (AIR)
+    COVERED_LAYER2 = "1-65:1.29.3"  # Layer 2 sharing Group (ACR/ACF/AC1)
+    COVERED_LAYER3 = "1-65:1.29.2"  # Layer 3 sharing Group (CEL)
+    COVERED_LAYER4 = "1-65:1.29.4"  # Layer 4 sharing Group (APS/CER/CEN)
+    REMAINING = "1-65:1.29.9"  # Remaining consumption after sharing invoiced by supplier
+
+
+class ElectricityProduction(str, Enum):
+    """OBIS codes for electricity production."""
+
+    ACTIVE = "1-1:2.29.0"  # Measured active production (kW)
+    REACTIVE = "1-1:4.29.0"  # Measured reactive production (kVAR)
+
+    # Production shared within sharing groups
+    SHARED_LAYER1 = "1-65:2.29.1"  # Layer 1 sharing Group (AIR)
+    SHARED_LAYER2 = "1-65:2.29.3"  # Layer 2 sharing Group (ACR/ACF/AC1)
+    SHARED_LAYER3 = "1-65:2.29.2"  # Layer 3 sharing Group (CEL)
+    SHARED_LAYER4 = "1-65:2.29.4"  # Layer 4 sharing Group (APS/CER/CEN)
+    REMAINING = "1-65:2.29.9"  # Remaining production after sharing sold to market
+
+
+class GasConsumption(str, Enum):
+    """OBIS codes for gas consumption."""
+
+    VOLUME = "7-1:99.23.15"  # Measured consumed volume (m³)
+    STANDARD_VOLUME = "7-1:99.23.17"  # Measured consumed standard volume (Nm³)
+    ENERGY = "7-20:99.33.17"  # Measured consumed energy (kWh)
+
+
+# Complete mapping of all OBIS codes to their details
+OBIS_CODES: Dict[str, ObisCodeInfo] = {
+    # Electricity Consumption
+    ElectricityConsumption.ACTIVE: ObisCodeInfo(
+        ElectricityConsumption.ACTIVE,
+        "kW",
+        "Consumption",
+        "Measured active consumption",
+    ),
+    ElectricityConsumption.REACTIVE: ObisCodeInfo(
+        ElectricityConsumption.REACTIVE,
+        "kVAR",
+        "Consumption",
+        "Measured reactive consumption",
+    ),
+    ElectricityConsumption.COVERED_LAYER1: ObisCodeInfo(
+        ElectricityConsumption.COVERED_LAYER1,
+        "kW",
+        "Consumption",
+        "Consumption covered by production of layer 1 sharing Group (AIR)",
+    ),
+    ElectricityConsumption.COVERED_LAYER2: ObisCodeInfo(
+        ElectricityConsumption.COVERED_LAYER2,
+        "kW",
+        "Consumption",
+        "Consumption covered by production of layer 2 sharing Group (ACR/ACF/AC1)",
+    ),
+    ElectricityConsumption.COVERED_LAYER3: ObisCodeInfo(
+        ElectricityConsumption.COVERED_LAYER3,
+        "kW",
+        "Consumption",
+        "Consumption covered by production of layer 3 sharing Group (CEL)",
+    ),
+    ElectricityConsumption.COVERED_LAYER4: ObisCodeInfo(
+        ElectricityConsumption.COVERED_LAYER4,
+        "kW",
+        "Consumption",
+        "Consumption covered by production of layer 4 sharing Group (APS/CER/CEN)",
+    ),
+    ElectricityConsumption.REMAINING: ObisCodeInfo(
+        ElectricityConsumption.REMAINING,
+        "kW",
+        "Consumption",
+        "Remaining consumption after sharing invoiced by supplier",
+    ),
+    # Electricity Production
+    ElectricityProduction.ACTIVE: ObisCodeInfo(
+        ElectricityProduction.ACTIVE, "kW", "Production", "Measured active production"
+    ),
+    ElectricityProduction.REACTIVE: ObisCodeInfo(
+        ElectricityProduction.REACTIVE,
+        "kVAR",
+        "Consumption",
+        "Measured reactive production",
+    ),
+    ElectricityProduction.SHARED_LAYER1: ObisCodeInfo(
+        ElectricityProduction.SHARED_LAYER1,
+        "kW",
+        "Production",
+        "Production shared within layer 1 sharing Group (AIR)",
+    ),
+    ElectricityProduction.SHARED_LAYER2: ObisCodeInfo(
+        ElectricityProduction.SHARED_LAYER2,
+        "kW",
+        "Production",
+        "Production shared within layer 2 sharing Group (ACR/ACF/AC1)",
+    ),
+    ElectricityProduction.SHARED_LAYER3: ObisCodeInfo(
+        ElectricityProduction.SHARED_LAYER3,
+        "kW",
+        "Production",
+        "Production shared within layer 3 sharing Group (CEL)",
+    ),
+    ElectricityProduction.SHARED_LAYER4: ObisCodeInfo(
+        ElectricityProduction.SHARED_LAYER4,
+        "kW",
+        "Production",
+        "Production shared within layer 4 sharing Group (APS/CER/CEN)",
+    ),
+    ElectricityProduction.REMAINING: ObisCodeInfo(
+        ElectricityProduction.REMAINING,
+        "kW",
+        "Production",
+        "Remaining production after sharing sold to market",
+    ),
+    # Gas Consumption
+    GasConsumption.VOLUME: ObisCodeInfo(
+        GasConsumption.VOLUME, "m³", "Consumption", "Measured consumed volume"
+    ),
+    GasConsumption.STANDARD_VOLUME: ObisCodeInfo(
+        GasConsumption.STANDARD_VOLUME,
+        "Nm³",
+        "Consumption",
+        "Measured consumed standard volume",
+    ),
+    GasConsumption.ENERGY: ObisCodeInfo(
+        GasConsumption.ENERGY, "kWh", "Consumption", "Measured consumed energy"
+    ),
+}
+
+
+def get_obis_info(obis_code: str) -> ObisCodeInfo:
+    """
+    Get information about an OBIS code.
+
+    Args:
+        obis_code: The OBIS code to look up
+
+    Returns:
+        Information about the OBIS code
+
+    Raises:
+        KeyError: If the OBIS code is not found
+
+    Example:
+        >>> info = get_obis_info(ElectricityConsumption.ACTIVE)
+        >>> print(info.unit)
+        'kW'
+    """
+    return OBIS_CODES[obis_code]
+
+
+def get_unit(obis_code: str) -> str:
+    """
+    Get the unit of measurement for an OBIS code.
+
+    Args:
+        obis_code: The OBIS code to look up
+
+    Returns:
+        The unit of measurement
+
+    Raises:
+        KeyError: If the OBIS code is not found
+
+    Example:
+        >>> unit = get_unit(ElectricityConsumption.ACTIVE)
+        >>> print(unit)
+        'kW'
+    """
+    return OBIS_CODES[obis_code].unit
+
+
+def list_all_obis_codes() -> List[ObisCodeInfo]:
+    """
+    Get a list of all OBIS codes and their information.
+
+    Returns:
+        A list of all OBIS code information
+
+    Example:
+        >>> codes = list_all_obis_codes()
+        >>> print(len(codes))
+        17
+    """
+    return list(OBIS_CODES.values())
+
+
+def list_obis_codes_by_service_type(service_type: str) -> List[ObisCodeInfo]:
+    """
+    Get a list of OBIS codes filtered by service type.
+
+    Args:
+        service_type: The service type to filter by (e.g., "Consumption", "Production")
+
+    Returns:
+        A list of OBIS code information matching the service type
+
+    Example:
+        >>> codes = list_obis_codes_by_service_type("Production")
+        >>> print(len(codes))
+        7
+    """
+    return [info for info in OBIS_CODES.values() if info.service_type == service_type]

leneda/version.py

@@ -0,0 +1,3 @@
+"""Version information."""
+
+__version__ = "0.1.0"

leneda_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: leneda-client
+Version: 0.1.0
+Summary: Python client for the Leneda energy data platform
+Home-page: https://github.com/fedus/leneda-client
+Author: fedus
+Author-email: fedus@dillendapp.eu
+Project-URL: Bug Reports, https://github.com/yourusername/leneda-client/issues
+Project-URL: Source, https://github.com/yourusername/leneda-client
+Project-URL: Documentation, https://github.com/yourusername/leneda-client#readme
+Keywords: leneda,energy,api,client
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: python-dateutil>=2.8.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Leneda API Client
+
+[![PyPI version]](https://pypi.org/project/leneda-client/)
+[![Python versions]](https://pypi.org/project/leneda-client/)
+[![License]](https://github.com/fedus/leneda-client/blob/main/LICENSE)
+
+A Python client for interacting with the Leneda energy data platform API.
+
+## Overview
+
+This client provides a simple interface to the Leneda API, which allows users to:
+
+- Retrieve metering data for specific time ranges
+- Get aggregated metering data (hourly, daily, weekly, monthly, or total)
+- Create metering data access requests
+- Use predefined OBIS code constants for easy reference
+
+## Installation
+
+```bash
+pip install leneda-client

leneda_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+leneda/__init__.py,sha256=JLvEM9M0jk2LcYK9DWYKrSF_BXTvmC8i570N_BggPck,850
+leneda/client.py,sha256=G_4kQi54ob3Te5gcQqH1KBRfkYBe00b-WDDTn6HCMNI,7716
+leneda/models.py,sha256=hTDEsdgUZJA-9jSqbOOoeJbCvFmgHMj3eZ8JZilWGpo,7861
+leneda/obis_codes.py,sha256=gPrxnYfUNvWrbKFA3z-4TSTHnOhWHt5hkm5GAwoo0-w,7170
+leneda/version.py,sha256=HOmU5sgXU14tXjdvSe0iIIyluugGL0Y7R8eo1JaeyxE,50
+leneda_client-0.1.0.dist-info/METADATA,sha256=lVPMKoe-FKvngJjQXzFLEpmKn3nrhsMppBWhwEvoobI,1994
+leneda_client-0.1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+leneda_client-0.1.0.dist-info/top_level.txt,sha256=PANScm25ep7WLjKiph0fhJPb8s_sa_uLHemnBpQBaJ8,7
+leneda_client-0.1.0.dist-info/RECORD,,

leneda_client-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

leneda_client-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+leneda