pyspark-fluvius 0.1.0__py3-none-any.whl

pyspark_fluvius/datasources/mandates.py

@@ -0,0 +1,76 @@
+"""Fluvius Mandates data source for PySpark."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pyspark.sql.datasource import DataSource, DataSourceReader
+from pyspark.sql.types import StructType
+
+from ..readers.mandates_reader import FluviusMandatesReader
+from ..schemas.mandates_schema import MANDATES_SCHEMA
+
+if TYPE_CHECKING:
+    pass
+
+
+class FluviusMandatesDataSource(DataSource):
+    """PySpark data source for reading Fluvius mandates.
+
+    This data source allows you to read mandates from the Fluvius Energy API
+    directly into a Spark DataFrame.
+
+    Options:
+        Credential options (if not using environment variables):
+            - subscription_key: Azure API Management subscription key
+            - client_id: Azure AD application (client) ID
+            - tenant_id: Azure AD tenant ID
+            - scope: OAuth2 scope
+            - data_access_contract_number: Data access contract number
+            - certificate_thumbprint: Certificate thumbprint (for cert auth)
+            - private_key: Private key in PEM format (for cert auth)
+            - client_secret: Client secret (for secret auth)
+            - credentials_prefix: Environment variable prefix (default: "FLUVIUS")
+
+        Environment options:
+            - environment: "sandbox" (default) or "production"
+
+        Filter options:
+            - reference_number: Filter by custom reference number
+            - ean: Filter by GSRN EAN-code
+            - data_service_types: Comma-separated list of data service types
+            - energy_type: "E" (electricity) or "G" (gas)
+            - status: Mandate status (Requested, Approved, Rejected, Finished)
+            - mandate_expiration_date: Filter by expiration date (ISO format)
+            - renewal_status: ToBeRenewed, RenewalRequested, or Expired
+            - last_updated_from: Start of last updated filter (ISO format)
+            - last_updated_to: End of last updated filter (ISO format)
+
+    Example:
+        ```python
+        df = spark.read.format("fluvius.mandates") \\
+            .option("status", "Approved") \\
+            .option("energy_type", "E") \\
+            .load()
+        ```
+    """
+
+    @classmethod
+    def name(cls) -> str:
+        """Return the short name of this data source."""
+        return "fluvius.mandates"
+
+    def schema(self) -> StructType:
+        """Return the schema for mandates data."""
+        return MANDATES_SCHEMA
+
+    def reader(self, schema: StructType) -> DataSourceReader:
+        """Return a reader for mandates data.
+
+        Args:
+            schema: The schema to use (typically the default MANDATES_SCHEMA).
+
+        Returns:
+            A FluviusMandatesReader instance.
+        """
+        return FluviusMandatesReader(schema, self.options)

pyspark_fluvius/readers/__init__.py

@@ -0,0 +1,6 @@
+"""Data source readers for Fluvius API."""
+
+from .energy_reader import FluviusEnergyReader
+from .mandates_reader import FluviusMandatesReader
+
+__all__ = ["FluviusEnergyReader", "FluviusMandatesReader"]

pyspark_fluvius/readers/energy_reader.py

@@ -0,0 +1,91 @@
+"""Energy data source reader."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Iterator
+
+from pyspark.sql.datasource import DataSourceReader, InputPartition
+
+from fluvius_energy_api import FluviusEnergyClient
+from fluvius_energy_api.models.enums import PeriodType
+
+from ..converters.energy_converter import EnergyTuple, convert_energy_response
+from ..utils.credentials import get_credentials, get_environment
+
+if TYPE_CHECKING:
+    from pyspark.sql.types import StructType
+
+
+class FluviusEnergyReader(DataSourceReader):
+    """Reader for Fluvius energy data."""
+
+    def __init__(self, schema: StructType, options: dict[str, str]) -> None:
+        """Initialize the energy reader.
+
+        Args:
+            schema: The Spark schema for energy data.
+            options: Options passed to the data source.
+        """
+        self._schema = schema
+        self._options = options
+
+    def partitions(self) -> list[InputPartition]:
+        """Return a single partition for energy data."""
+        return [InputPartition(0)]
+
+    def read(self, partition: InputPartition) -> Iterator[EnergyTuple]:
+        """Read energy data from the Fluvius API.
+
+        Args:
+            partition: The partition to read (unused, single partition).
+
+        Yields:
+            Tuples representing energy measurement rows.
+
+        Raises:
+            ValueError: If required options (ean, period_type) are missing.
+        """
+        # Required options
+        ean = self._options.get("ean")
+        if not ean:
+            raise ValueError("Option 'ean' is required for fluvius.energy data source")
+
+        period_type_str = self._options.get("period_type")
+        if not period_type_str:
+            raise ValueError("Option 'period_type' is required for fluvius.energy data source")
+
+        period_type = PeriodType(period_type_str)
+
+        # Optional filters
+        reference_number = self._options.get("reference_number")
+        granularity = self._options.get("granularity")
+        complex_energy_types = self._options.get("complex_energy_types")
+
+        # Parse dates
+        from_date_str = self._options.get("from_date")
+        from_date: datetime | None = None
+        if from_date_str:
+            from_date = datetime.fromisoformat(from_date_str.replace("Z", "+00:00"))
+
+        to_date_str = self._options.get("to_date")
+        to_date: datetime | None = None
+        if to_date_str:
+            to_date = datetime.fromisoformat(to_date_str.replace("Z", "+00:00"))
+
+        credentials = get_credentials(self._options)
+        environment = get_environment(self._options)
+
+        with FluviusEnergyClient(credentials=credentials, environment=environment) as client:
+            response = client.get_energy(
+                ean=ean,
+                period_type=period_type,
+                reference_number=reference_number,
+                granularity=granularity,
+                complex_energy_types=complex_energy_types,
+                from_date=from_date,
+                to_date=to_date,
+            )
+
+            rows = convert_energy_response(response)
+            yield from rows

pyspark_fluvius/readers/mandates_reader.py

@@ -0,0 +1,120 @@
+"""Mandates data source reader."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Iterator
+
+from pyspark.sql.datasource import DataSourceReader, InputPartition
+
+from fluvius_energy_api import FluviusEnergyClient
+from fluvius_energy_api.models.enums import (
+    DataServiceType,
+    EnergyType,
+    MandateRenewalStatus,
+    MandateStatus,
+)
+
+from ..converters.mandates_converter import MandateTuple, convert_mandate
+from ..utils.credentials import get_credentials, get_environment
+
+if TYPE_CHECKING:
+    from pyspark.sql.types import StructType
+
+
+class FluviusMandatesReader(DataSourceReader):
+    """Reader for Fluvius mandates data."""
+
+    def __init__(self, schema: StructType, options: dict[str, str]) -> None:
+        """Initialize the mandates reader.
+
+        Args:
+            schema: The Spark schema for mandates.
+            options: Options passed to the data source.
+        """
+        self._schema = schema
+        self._options = options
+
+    def partitions(self) -> list[InputPartition]:
+        """Return a single partition for mandates."""
+        return [InputPartition(0)]
+
+    def read(self, partition: InputPartition) -> Iterator[MandateTuple]:
+        """Read mandates from the Fluvius API.
+
+        Args:
+            partition: The partition to read (unused, single partition).
+
+        Yields:
+            Tuples representing mandate rows.
+        """
+        credentials = get_credentials(self._options)
+        environment = get_environment(self._options)
+
+        # Parse filter options
+        reference_number = self._options.get("reference_number")
+        ean = self._options.get("ean")
+
+        # Parse data_service_types (comma-separated string)
+        data_service_types_str = self._options.get("data_service_types")
+        data_service_types: list[DataServiceType] | None = None
+        if data_service_types_str:
+            data_service_types = [
+                DataServiceType(t.strip()) for t in data_service_types_str.split(",")
+            ]
+
+        # Parse energy_type
+        energy_type_str = self._options.get("energy_type")
+        energy_type: EnergyType | None = None
+        if energy_type_str:
+            energy_type = EnergyType(energy_type_str)
+
+        # Parse status
+        status_str = self._options.get("status")
+        status: MandateStatus | None = None
+        if status_str:
+            status = MandateStatus(status_str)
+
+        # Parse mandate_expiration_date
+        mandate_expiration_date_str = self._options.get("mandate_expiration_date")
+        mandate_expiration_date: datetime | None = None
+        if mandate_expiration_date_str:
+            mandate_expiration_date = datetime.fromisoformat(
+                mandate_expiration_date_str.replace("Z", "+00:00")
+            )
+
+        # Parse renewal_status
+        renewal_status_str = self._options.get("renewal_status")
+        renewal_status: MandateRenewalStatus | None = None
+        if renewal_status_str:
+            renewal_status = MandateRenewalStatus(renewal_status_str)
+
+        # Parse last_updated_from/to
+        last_updated_from_str = self._options.get("last_updated_from")
+        last_updated_from: datetime | None = None
+        if last_updated_from_str:
+            last_updated_from = datetime.fromisoformat(
+                last_updated_from_str.replace("Z", "+00:00")
+            )
+
+        last_updated_to_str = self._options.get("last_updated_to")
+        last_updated_to: datetime | None = None
+        if last_updated_to_str:
+            last_updated_to = datetime.fromisoformat(last_updated_to_str.replace("Z", "+00:00"))
+
+        with FluviusEnergyClient(credentials=credentials, environment=environment) as client:
+            response = client.get_mandates(
+                reference_number=reference_number,
+                ean=ean,
+                data_service_types=data_service_types,
+                energy_type=energy_type,
+                status=status,
+                mandate_expiration_date=mandate_expiration_date,
+                renewal_status=renewal_status,
+                last_updated_from=last_updated_from,
+                last_updated_to=last_updated_to,
+            )
+
+            if response.data and response.data.mandates:
+                for mandate in response.data.mandates:
+                    yield convert_mandate(mandate)

pyspark_fluvius/schemas/__init__.py

@@ -0,0 +1,6 @@
+"""Spark schema definitions for Fluvius data sources."""
+
+from .energy_schema import ENERGY_SCHEMA
+from .mandates_schema import MANDATES_SCHEMA
+
+__all__ = ["ENERGY_SCHEMA", "MANDATES_SCHEMA"]

pyspark_fluvius/schemas/energy_schema.py

@@ -0,0 +1,62 @@
+"""Spark schema for energy data."""
+
+from pyspark.sql.types import (
+    DoubleType,
+    StringType,
+    StructField,
+    StructType,
+    TimestampType,
+)
+
+
+def _measurement_fields(direction: str, register: str, include_gas_factor: bool = False) -> list[StructField]:
+    """Generate measurement fields for a direction/register combination."""
+    prefix = f"{direction}_{register}"
+    fields = [
+        StructField(f"{prefix}_value", DoubleType(), nullable=True),
+        StructField(f"{prefix}_unit", StringType(), nullable=True),
+        StructField(f"{prefix}_validation_state", StringType(), nullable=True),
+    ]
+    if include_gas_factor:
+        fields.append(StructField(f"{prefix}_gas_conversion_factor", StringType(), nullable=True))
+    return fields
+
+
+def _direction_fields(direction: str) -> list[StructField]:
+    """Generate all measurement fields for a direction."""
+    fields = []
+    # total includes gas_conversion_factor
+    fields.extend(_measurement_fields(direction, "total", include_gas_factor=True))
+    # Other registers don't have gas_conversion_factor
+    for register in ["day", "night", "reactive", "inductive", "capacitive"]:
+        fields.extend(_measurement_fields(direction, register))
+    return fields
+
+
+ENERGY_SCHEMA = StructType(
+    [
+        # Headpoint identification
+        StructField("ean", StringType(), nullable=True),
+        StructField("energy_type", StringType(), nullable=True),
+        StructField("metering_type", StringType(), nullable=True),
+        # Time slice information
+        StructField("measurement_start", TimestampType(), nullable=True),
+        StructField("measurement_end", TimestampType(), nullable=True),
+        StructField("granularity", StringType(), nullable=True),
+        # Meter information (for metering-on-meter installations)
+        StructField("meter_seq_number", StringType(), nullable=True),
+        StructField("meter_id", StringType(), nullable=True),
+        # Subheadpoint information (for submetering installations)
+        StructField("subheadpoint_ean", StringType(), nullable=True),
+        StructField("subheadpoint_type", StringType(), nullable=True),
+        StructField("subheadpoint_seq_number", StringType(), nullable=True),
+        # Offtake measurements (total, day, night, reactive, inductive, capacitive)
+        *_direction_fields("offtake"),
+        # Injection measurements
+        *_direction_fields("injection"),
+        # Production measurements
+        *_direction_fields("production"),
+        # Auxiliary measurements
+        *_direction_fields("auxiliary"),
+    ]
+)

pyspark_fluvius/schemas/mandates_schema.py

@@ -0,0 +1,17 @@
+"""Spark schema for mandates data."""
+
+from pyspark.sql.types import StringType, StructField, StructType, TimestampType
+
+MANDATES_SCHEMA = StructType(
+    [
+        StructField("reference_number", StringType(), nullable=True),
+        StructField("status", StringType(), nullable=True),
+        StructField("ean", StringType(), nullable=True),
+        StructField("energy_type", StringType(), nullable=True),
+        StructField("data_period_from", TimestampType(), nullable=True),
+        StructField("data_period_to", TimestampType(), nullable=True),
+        StructField("data_service_type", StringType(), nullable=True),
+        StructField("mandate_expiration_date", TimestampType(), nullable=True),
+        StructField("renewal_status", StringType(), nullable=True),
+    ]
+)

pyspark_fluvius/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utility functions for pyspark-fluvius."""
+
+from .credentials import get_credentials
+
+__all__ = ["get_credentials"]

pyspark_fluvius/utils/credentials.py

@@ -0,0 +1,62 @@
+"""Credential handling for Fluvius data sources."""
+
+from __future__ import annotations
+
+from fluvius_energy_api import FluviusCredentials
+from fluvius_energy_api.client import Environment
+
+
+def get_credentials(options: dict[str, str]) -> FluviusCredentials:
+    """Get Fluvius credentials from Spark options or environment variables.
+
+    Priority:
+    1. Spark .option() parameters (if all required fields are present)
+    2. Environment variables (via FluviusCredentials.from_env())
+
+    Args:
+        options: Dictionary of options from Spark DataSource.
+
+    Returns:
+        FluviusCredentials instance.
+
+    Raises:
+        ConfigurationError: If credentials cannot be loaded.
+    """
+    # Check if credentials are provided via options
+    subscription_key = options.get("subscription_key")
+    client_id = options.get("client_id")
+    tenant_id = options.get("tenant_id")
+    scope = options.get("scope")
+    data_access_contract_number = options.get("data_access_contract_number")
+
+    # If all required fields are present in options, use them
+    if all([subscription_key, client_id, tenant_id, scope, data_access_contract_number]):
+        return FluviusCredentials(
+            subscription_key=subscription_key,  # type: ignore[arg-type]
+            client_id=client_id,  # type: ignore[arg-type]
+            tenant_id=tenant_id,  # type: ignore[arg-type]
+            scope=scope,  # type: ignore[arg-type]
+            data_access_contract_number=data_access_contract_number,  # type: ignore[arg-type]
+            certificate_thumbprint=options.get("certificate_thumbprint"),
+            private_key=options.get("private_key"),
+            client_secret=options.get("client_secret"),
+        )
+
+    # Fall back to environment variables
+    prefix = options.get("credentials_prefix", "FLUVIUS")
+    return FluviusCredentials.from_env(prefix=prefix)
+
+
+def get_environment(options: dict[str, str]) -> Environment:
+    """Get the Fluvius API environment from options.
+
+    Args:
+        options: Dictionary of options from Spark DataSource.
+
+    Returns:
+        Environment enum value.
+    """
+    env_str = options.get("environment", "sandbox").lower()
+    if env_str == "production":
+        return Environment.PRODUCTION
+    return Environment.SANDBOX

pyspark_fluvius-0.1.0.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: pyspark-fluvius
+Version: 0.1.0
+Summary: PySpark custom data source for Fluvius Energy API
+Project-URL: Homepage, https://github.com/warreee/spark-fluvius
+Project-URL: Repository, https://github.com/warreee/spark-fluvius
+Project-URL: Issues, https://github.com/warreee/spark-fluvius/issues
+Author: Ward Schodts
+License-Expression: AGPL-3.0-or-later
+License-File: LICENSE
+Keywords: api,data-source,energy,fluvius,pyspark,spark
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.13
+Requires-Dist: fluvius-energy-api>=0.1.1
+Requires-Dist: pyarrow>=15.0.0
+Requires-Dist: pyspark>=4.0.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.9.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+    # spark-fluvius
+
+PySpark custom data sources for the [Fluvius Energy API](https://github.com/warreee/fluvius-energy-api).
+
+Read energy measurements and mandates directly into Spark DataFrames.
+
+## Installation
+
+```bash
+pip install pyspark-fluvius
+```
+
+## Quick Start
+
+```python
+from pyspark.sql import SparkSession
+from pyspark_fluvius import register_datasources
+
+# Create SparkSession
+spark = SparkSession.builder.appName("MyApp").getOrCreate()
+
+# Register Fluvius data sources
+register_datasources()
+
+# Read mandates
+mandates_df = spark.read.format("fluvius.mandates") \
+    .option("status", "Approved") \
+    .load()
+
+# Read energy data
+energy_df = spark.read.format("fluvius.energy") \
+    .option("ean", "541234567890123456") \
+    .option("period_type", "readTime") \
+    .option("granularity", "daily") \
+    .option("from_date", "2024-01-01") \
+    .option("to_date", "2024-01-31") \
+    .load()
+```
+
+## Authentication
+
+Credentials can be provided via environment variables or Spark options.
+
+### Environment Variables
+
+```bash
+# Required
+export FLUVIUS_SUBSCRIPTION_KEY="your-subscription-key"
+export FLUVIUS_CLIENT_ID="your-client-id"
+export FLUVIUS_TENANT_ID="your-tenant-id"
+export FLUVIUS_SCOPE="your-scope"
+export FLUVIUS_DATA_ACCESS_CONTRACT_NUMBER="your-contract-number"
+
+# For sandbox (client secret auth)
+export FLUVIUS_CLIENT_SECRET="your-client-secret"
+
+# For production (certificate auth)
+export FLUVIUS_CERTIFICATE_THUMBPRINT="your-thumbprint"
+export FLUVIUS_PRIVATE_KEY="-----BEGIN RSA PRIVATE KEY-----..."
+# Or use a file path:
+export FLUVIUS_PRIVATE_KEY_PATH="/path/to/private_key.pem"
+```
+
+### Spark Options
+
+```python
+df = spark.read.format("fluvius.mandates") \
+    .option("subscription_key", "...") \
+    .option("client_id", "...") \
+    .option("tenant_id", "...") \
+    .option("scope", "...") \
+    .option("data_access_contract_number", "...") \
+    .option("client_secret", "...") \
+    .load()
+```
+
+## Data Sources
+
+### fluvius.mandates
+
+Read mandate data from the Fluvius API.
+
+**Options:**
+| Option | Description |
+|--------|-------------|
+| `reference_number` | Filter by custom reference number |
+| `ean` | Filter by GSRN EAN-code |
+| `data_service_types` | Comma-separated list (e.g., "VH_dag,VH_kwartier_uur") |
+| `energy_type` | "E" (electricity) or "G" (gas) |
+| `status` | Requested, Approved, Rejected, or Finished |
+| `mandate_expiration_date` | ISO format date filter |
+| `renewal_status` | ToBeRenewed, RenewalRequested, or Expired |
+| `last_updated_from` | ISO format datetime |
+| `last_updated_to` | ISO format datetime |
+| `environment` | "sandbox" (default) or "production" |
+
+**Schema:**
+| Column | Type |
+|--------|------|
+| reference_number | string |
+| status | string |
+| ean | string |
+| energy_type | string |
+| data_period_from | timestamp |
+| data_period_to | timestamp |
+| data_service_type | string |
+| mandate_expiration_date | timestamp |
+| renewal_status | string |
+
+### fluvius.energy
+
+Read energy measurement data from the Fluvius API.
+
+**Required Options:**
+| Option | Description |
+|--------|-------------|
+| `ean` | GSRN EAN-code (required) |
+| `period_type` | "readTime" or "insertTime" (required) |
+
+**Optional Options:**
+| Option | Description |
+|--------|-------------|
+| `reference_number` | Custom reference number |
+| `granularity` | e.g., "daily", "hourly_quarterhourly" |
+| `complex_energy_types` | e.g., "active,reactive" |
+| `from_date` | ISO format date (e.g., "2024-01-01") |
+| `to_date` | ISO format date (e.g., "2024-01-31") |
+| `environment` | "sandbox" (default) or "production" |
+
+**Schema:**
+| Column | Type | Description |
+|--------|------|-------------|
+| ean | string | EAN code of the installation |
+| energy_type | string | "E" or "G" |
+| metering_type | string | Type of metering installation |
+| measurement_start | timestamp | Start of measurement period |
+| measurement_end | timestamp | End of measurement period |
+| granularity | string | daily, hourly, or quarter_hourly |
+| meter_seq_number | string | Physical meter sequence (if applicable) |
+| meter_id | string | Physical meter ID (if applicable) |
+| subheadpoint_ean | string | Subheadpoint EAN (for submetering) |
+| subheadpoint_type | string | auxiliary, offtake, or production |
+| subheadpoint_seq_number | string | Subheadpoint sequence number |
+| offtake_total_value | double | Offtake measurement value |
+| offtake_total_unit | string | Measurement unit (e.g., kWh) |
+| offtake_total_validation_state | string | READ, EST, VAL, or NVAL |
+| offtake_total_gas_conversion_factor | string | P, D, or C (gas only) |
+| offtake_day_value | double | Day tariff offtake |
+| offtake_day_unit | string | Unit |
+| offtake_day_validation_state | string | Validation state |
+| offtake_night_value | double | Night tariff offtake |
+| offtake_night_unit | string | Unit |
+| offtake_night_validation_state | string | Validation state |
+| injection_total_value | double | Injection measurement |
+| injection_total_unit | string | Unit |
+| injection_total_validation_state | string | Validation state |
+| injection_day_value | double | Day tariff injection |
+| injection_day_unit | string | Unit |
+| injection_day_validation_state | string | Validation state |
+| injection_night_value | double | Night tariff injection |
+| injection_night_unit | string | Unit |
+| injection_night_validation_state | string | Validation state |
+| production_total_value | double | Production measurement |
+| production_total_unit | string | Unit |
+| production_total_validation_state | string | Validation state |
+
+## Requirements
+
+- Python 3.13+
+- PySpark 4.0+
+- fluvius-energy-api 0.1.0+
+
+## License
+
+AGPL-3.0-or-later

pyspark_fluvius-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+pyspark_fluvius/__init__.py,sha256=MQ6vxzjHIFskaGpFlNcDsX0x3_3lLkttu8cOqzex_uM,2112
+pyspark_fluvius/converters/__init__.py,sha256=HahX04i5A3gVCJ7toRJDiFHVb-DlVkMkssFHRbRMD1E,214
+pyspark_fluvius/converters/energy_converter.py,sha256=oh-XswN1aC-72iR-oE3wle9xWFVyIpIldeoZjDQ_7-o,13451
+pyspark_fluvius/converters/mandates_converter.py,sha256=Qj7rmUZy_sTReUbkrIz3nZehB9p0ewD5Pn5mzHFXnl0,1460
+pyspark_fluvius/datasources/__init__.py,sha256=vYFUCFM15ShiKSE1X5MyI4RSMioX6zcwof8ehtOQhJM,197
+pyspark_fluvius/datasources/energy.py,sha256=LrwJbKki7SWjgPxX8Syh-nIQwi3WwFMItdPeoj-dZjk,3964
+pyspark_fluvius/datasources/mandates.py,sha256=6E-3XgvD6mbB6U2LNoqQBkYVMs-A2NL9hcj3_IToT6Y,2775
+pyspark_fluvius/readers/__init__.py,sha256=Po9NDoudQWWJ-Z1pvEDwWfduA3W5wtrRUf6NxXAC9sk,202
+pyspark_fluvius/readers/energy_reader.py,sha256=frP-5AhemjOPnfqsqLrk69FPImNXGwWd-gaBiYfe9jo,3157
+pyspark_fluvius/readers/mandates_reader.py,sha256=zGAumUCvYSKrpzZ2piu7XAQTcR0DopQ7bSETUHW6-Zs,4370
+pyspark_fluvius/schemas/__init__.py,sha256=vaxbrJaxXeehA84cBCLKnwlzhn5tMBG9u2TZyqClNoM,192
+pyspark_fluvius/schemas/energy_schema.py,sha256=3x8HvHFTuBDOKUOU0VMD2rlgoGs-GAg_8Ahv3cw2xCQ,2585
+pyspark_fluvius/schemas/mandates_schema.py,sha256=S1CFf1gap-Wav9ddmE5_F8dsWzTvxTqt6RM80fZyavw,780
+pyspark_fluvius/utils/__init__.py,sha256=1YbeuzmzSXm_bF-wz_GqbJuGx2psLrHB7zk7QchbsYI,118
+pyspark_fluvius/utils/credentials.py,sha256=v3OrK5ncX4YCL3LShAZZ948CIKhjcWCTpmIKeQFP72E,2266
+pyspark_fluvius-0.1.0.dist-info/METADATA,sha256=Jpp92Cv7MM4PjXV3_d0Zye-sMBiF_xwN2oeue06vBYQ,6830
+pyspark_fluvius-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pyspark_fluvius-0.1.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+pyspark_fluvius-0.1.0.dist-info/RECORD,,

pyspark_fluvius-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any