e-data 2.0.0.dev120__tar.gz → 2.0.0.dev125__tar.gz

{e_data-2.0.0.dev120/e_data.egg-info → e_data-2.0.0.dev125}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e-data
-Version: 2.0.0.dev120
+Version: 2.0.0.dev125
 Summary: Python library for managing spanish energy data from various web providers
 Author-email: VMG <vmayorg@outlook.es>
 License:                     GNU GENERAL PUBLIC LICENSE

{e_data-2.0.0.dev120 → e_data-2.0.0.dev125/e_data.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e-data
-Version: 2.0.0.dev120
+Version: 2.0.0.dev125
 Summary: Python library for managing spanish energy data from various web providers
 Author-email: VMG <vmayorg@outlook.es>
 License:                     GNU GENERAL PUBLIC LICENSE

{e_data-2.0.0.dev120 → e_data-2.0.0.dev125}/edata/database/controller.py

@@ -374,6 +374,14 @@ class EdataDB:
                 session, queries, items, override=["complete", "confhash"]
             )
 
+    async def clear_bills(self, cups: str, since: datetime | None = None) -> None:
+        """Delete bill records for a cups, optionally only from a datetime onwards."""
+
+        await self._ensure_tables()
+        async with AsyncSession(self.engine) as session:
+            await session.exec(q.delete_bill(cups, since))  # type: ignore[call-overload]
+            await session.commit()
+
     async def list_supplies(self) -> typing.Sequence[SupplyModel]:
         """List all supply records."""
 

{e_data-2.0.0.dev120 → e_data-2.0.0.dev125}/edata/database/queries.py

@@ -1,6 +1,7 @@
 import typing
 from datetime import datetime
 
+from sqlalchemy import Delete, delete
 from sqlmodel import asc, desc, select
 from sqlmodel.sql.expression import SelectOfScalar
 
@@ -184,6 +185,15 @@ def get_last_bill(
     return query
 
 
+def delete_bill(cups: str, date_from: datetime | None = None) -> Delete:
+    """Query that deletes bill records, optionally from a datetime onwards."""
+
+    query = delete(BillModel).where(BillModel.cups == cups)
+    if date_from is not None:
+        query = query.where(BillModel.datetime >= date_from)
+    return query
+
+
 # Queries for "pvpc" table
 def get_pvpc(datetime_: datetime) -> SelectOfScalar[PVPCModel]:
     """Query that selects a PVPC record."""

{e_data-2.0.0.dev120 → e_data-2.0.0.dev125}/edata/providers/datadis.py

@@ -166,7 +166,7 @@ class DatadisConnector:
         refresh_token: bool = False,
         is_retry: bool = False,
         ignore_cache: bool = False,
-    ) -> list[dict[str, typing.Any]]:
+    ) -> dict[str, typing.Any]:
         """Async get request for Datadis API."""
 
         if request_data is None:
@@ -175,7 +175,7 @@ class DatadisConnector:
             data = request_data
 
         is_valid_token = False
-        response = []
+        response = {}
         if refresh_token:
             is_valid_token = await self._async_get_token()
         if is_valid_token or not refresh_token:
@@ -201,7 +201,7 @@ class DatadisConnector:
                 if _cache is not None:
                     _LOGGER.info("CACHED %s", url + anonym_params)
                     return _cache  # type: ignore
-                return []
+                return {}
 
             try:
                 _LOGGER.info("GET %s", url + anonym_params)
@@ -272,10 +272,10 @@ class DatadisConnector:
                             )
             except asyncio.TimeoutError:
                 _LOGGER.warning("Timeout at %s", url + anonym_params)
-                return []
+                return {}
             except Exception as e:
                 _LOGGER.warning("Exception at %s: %s", url + anonym_params, e)
-                return []
+                return {}
         return response
 
     async def async_get_supplies(

{e_data-2.0.0.dev120 → e_data-2.0.0.dev125}/edata/services/bill_service.py

@@ -137,6 +137,39 @@ class BillService:
         await self.update_statistics(start, end)
         await self.fix_missing_statistics()
 
+    async def clear_bills(self, since: datetime | None = None) -> None:
+        """Delete stored bills for this cups, optionally only from a datetime onwards."""
+
+        await self.db.clear_bills(self._cups, since)
+
+    async def simulate(
+        self,
+        billing_rules: BillingRules | PVPCBillingRules | None = None,
+        is_pvpc: bool = True,
+        start: datetime | None = None,
+        end: datetime | None = None,
+    ) -> list[Bill]:
+        """Compile hourly bills for a date range without persisting them."""
+
+        if not billing_rules:
+            _LOGGER.info("%s non explicit billing rules, assuming PVPC", self._scups)
+            billing_rules = PVPCBillingRules()
+            is_pvpc = True
+
+        contracts = await self._get_contracts()
+        energy = await self._get_energy(start, end)
+
+        if is_pvpc:
+            pvpc = await self._get_pvpc(start, end)
+            billing_rules = PVPCBillingRules(**billing_rules.model_dump())
+            return await asyncio.to_thread(
+                self.simulate_pvpc, contracts, energy, pvpc, billing_rules
+            )
+
+        return await asyncio.to_thread(
+            self.simulate_custom, contracts, energy, billing_rules
+        )
+
     async def update_statistics(self, start: datetime, end: datetime):
         """Update the statistics during a period."""
 

{e_data-2.0.0.dev120 → e_data-2.0.0.dev125}/edata/services/data_service.py

@@ -109,6 +109,11 @@ class DataService:
         data = await self.db.list_statistics(self._cups, type_, start, end, complete)
         return [x.data for x in data]
 
+    async def get_last_energy_dt(self) -> datetime | None:
+        """Return the timestamp of the latest energy record."""
+
+        return await self._get_last_energy_dt()
+
     async def fix_missing_statistics(self) -> None:
         """Recompile statistics to fix missing data."""
 

{e_data-2.0.0.dev120 → e_data-2.0.0.dev125}/edata/tests/test_services.py

@@ -154,3 +154,60 @@ async def test_bill_service(
     assert len(monthly_stats) > 0
 
     assert monthly_stats == snapshot
+
+
+@pytest.mark.asyncio
+async def test_simulate_does_not_persist(
+    populated_data_service, snapshot: SnapshotAssertion, storage_dir
+):
+    bs = BillService("ESXXXXXXXXXXXXXXXXTEST", storage_path=storage_dir)
+
+    before = len(await bs.get_bills())
+
+    rules = BillingRules(
+        p1_kwh_eur=0.30,
+        p2_kwh_eur=0.30,
+        p3_kwh_eur=0.30,
+        p1_kw_year_eur=20,
+        p2_kw_year_eur=10,
+    )
+    simulated = await bs.simulate(billing_rules=rules, is_pvpc=False)
+
+    after = len(await bs.get_bills())
+
+    assert len(simulated) > 0
+    assert before == after
+
+    summary = {
+        "count": len(simulated),
+        "value_eur": round(sum(x.value_eur for x in simulated), 6),
+        "energy_term": round(sum(x.energy_term for x in simulated), 6),
+        "power_term": round(sum(x.power_term for x in simulated), 6),
+        "first": simulated[0],
+        "last": simulated[-1],
+    }
+    assert summary == snapshot
+
+
+@pytest.mark.asyncio
+async def test_clear_bills(populated_data_service, energy, storage_dir):
+    bs = BillService("ESXXXXXXXXXXXXXXXXTEST", storage_path=storage_dir)
+
+    all_energy = sorted(energy, key=lambda x: x.datetime)
+    rules = BillingRules(
+        p1_kwh_eur=0.20,
+        p2_kwh_eur=0.20,
+        p3_kwh_eur=0.20,
+        p1_kw_year_eur=20,
+        p2_kw_year_eur=10,
+    )
+    await bs.update(
+        all_energy[0].datetime, all_energy[-1].datetime, rules, is_pvpc=False
+    )
+    assert len(await bs.get_bills()) > 0
+
+    await bs.clear_bills()
+
+    assert len(await bs.get_bills("hour")) == 0
+    assert len(await bs.get_bills(type_="day")) == 0
+    assert len(await bs.get_bills(type_="month")) == 0

{e_data-2.0.0.dev120 → e_data-2.0.0.dev125}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "e-data"
-version = "2.0.0.dev120"
+version = "2.0.0.dev125"
 description = "Python library for managing spanish energy data from various web providers"
 readme = "README.md"
 authors = [