e-data 2.0.2.dev137__py3-none-any.whl → 2.0.2.dev138__py3-none-any.whl

{e_data-2.0.2.dev137.dist-info → e_data-2.0.2.dev138.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e-data
-Version: 2.0.2.dev137
+Version: 2.0.2.dev138
 Summary: Python library for managing spanish energy data from various web providers
 Author-email: VMG <vmayorg@outlook.es>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -696,10 +696,9 @@ Requires-Dist: Jinja2<4,>=3.1
 Requires-Dist: pydantic<3,>=2.10
 Requires-Dist: python_dateutil<3,>=2.8
 Requires-Dist: Requests<3,>=2.31
-Requires-Dist: SQLAlchemy[asyncio]<3,>=2.0
+Requires-Dist: SQLAlchemy<3,>=2.0
 Requires-Dist: sqlmodel<0.1,>=0.0.45
 Requires-Dist: typer<1,>=0.12
-Requires-Dist: aiosqlite<1,>=0.21
 Dynamic: license-file
 
 [![Downloads](https://pepy.tech/badge/e-data)](https://pepy.tech/project/e-data)

{e_data-2.0.2.dev137.dist-info → e_data-2.0.2.dev138.dist-info}/RECORD

@@ -1,4 +1,4 @@
-e_data-2.0.2.dev137.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+e_data-2.0.2.dev138.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 edata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 edata/cli.py,sha256=CsBYDggt0grkLb4cebrckOvJyHr9PaGTnlWqT4yjuFo,5215
 edata/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -6,7 +6,7 @@ edata/core/completion.py,sha256=A0ekfu7eCjaLblUYO5DrvaWuDPAO9k1buzy2qdfjdNc,3914
 edata/core/const.py,sha256=X9J2f7lt9jXJnghqz0JFi-J7USa3xlYvbuiki70eHNE,43
 edata/core/utils.py,sha256=uQX8GmNjuhof56jiXXoV-Fk-d590OuIoBJbM9ymZyV8,3194
 edata/database/__init__.py,sha256=HP_pDbGLzeMY9Ufm_Dps5cxzW_3YTonT8w8dstG558c,46
-edata/database/controller.py,sha256=bI3cE1Q4SK9U1Eep_61EhlmyVjgYH87F5lfBLhwSpmg,23211
+edata/database/controller.py,sha256=iNZcmdJYvw0sBu02VuBs9HypvK-NSpqFeOKx0ta6hMM,23967
 edata/database/models.py,sha256=WWZHYgFBgSDqHORxw5z4Vip7HvorMcQbt9oCpV61NJA,5780
 edata/database/queries.py,sha256=XziDSG2V-PVFmvRkj8UrEvgrc9Qc-ShhnxgsPHIsyik,8304
 edata/database/utils.py,sha256=V-FJfyAh8YJBGHB85BbWtG3Ilq09pM9Gl-L86TffB4g,1062
@@ -18,20 +18,20 @@ edata/models/bill.py,sha256=-qZ4l9f8BnPFlykFRoNYnmRe6-ELWmuNh6usks_k4X0,2674
 edata/models/data.py,sha256=O1aj0H_G92mnJjm6mYhC8fnl8ZOoatGiokRf8b7ziD8,2388
 edata/models/supply.py,sha256=qM0Q22-7PfBN93-Tu3ljAE58p5gfob0YWw-o5FccjrI,878
 edata/providers/__init__.py,sha256=5xaRKPttYM6EpVE1I_vhUAF25L9pEM_qK_5Ix6xnQe0,104
-edata/providers/datadis.py,sha256=VZ_MhO3x1crSmOH2dn3SWJ5Eq1gWUIDCEvB9oRRMZfQ,21468
+edata/providers/datadis.py,sha256=3oSMWpiSHa111X1e0GUkOgnANoFvoUHeGwJN8pduW1Q,21968
 edata/providers/redata.py,sha256=i6aBjunyZMb34SGgAgNQvaNu_GFoe5P2rUIY-_vOElw,3727
 edata/services/bill_service.py,sha256=KAM78u7TpoVF-KTlB7bqj2Kp-rJERiPPoGTJCc-7rM0,15264
 edata/services/data_service.py,sha256=JJCdivjrwNt3aLhz3uMBWv06y-EL7UiK2G5EBr97l_8,19374
 edata/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 edata/tests/test_completion.py,sha256=-iyVt-juU3U1HqMuLUJXJthil2-n_4ddWiJq2GwnXTo,3551
-edata/tests/test_controller.py,sha256=YvilJ9cIpjhdGGtVJtlEevhRL7IHAVnU0At7AmxM5_8,3983
-edata/tests/test_datadis_connector.py,sha256=8Xet2M2eG-kMhiRDTCSH0R5nYO2oIpQTPOuTZKMKoLo,12538
-edata/tests/test_incremental.py,sha256=dn1LRgjBi2HuNYELPKDVdZQlS01hk4lsP9L-vyvtEHo,3479
-edata/tests/test_migrations.py,sha256=3Io2nokZVdv2xU9fCZCMIvwAwPVtGc0UivClSouP3pw,6418
+edata/tests/test_controller.py,sha256=CZmT6TC1vfQsxfBNRq1sKKwD4kIWDWW6OYTYeIpLKpc,4147
+edata/tests/test_datadis_connector.py,sha256=yh-cYX6zIU3HaTPimD5Rvm_QiPWJWBIskjKp2M5LpO8,12579
+edata/tests/test_incremental.py,sha256=MPRc7pPSIUuBSMFzlVTpV_wafeRat4kV3wy8p6NmyFQ,3280
+edata/tests/test_migrations.py,sha256=P8Qaas8u1Nwu2qNLSoqUAGL0WFqx9d59gs4Bp6L8RtY,6219
 edata/tests/test_redata_connector.py,sha256=SBvxsma5t-qvz2drxNisNM2P1STTurqEs1TSDgwaPJ8,508
-edata/tests/test_services.py,sha256=Ya5cbADHj1Qsffb_IuMeDD0BViz8nqrgwazUWK0-hRc,8297
+edata/tests/test_services.py,sha256=DiXA8Y9zZgtAs9HGiMOfystz2shaGAGEs444GJ2AymE,8321
 edata/tests/test_utils.py,sha256=h6yBzT7j3eA42zbXJ-AK9lXcZkjCMf16wnob1oqGvUE,2307
-e_data-2.0.2.dev137.dist-info/METADATA,sha256=-7nOw3zSVBn4BVOgnmEXPt44pUE_qauv2ZZ2yjDjXt4,48084
-e_data-2.0.2.dev137.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-e_data-2.0.2.dev137.dist-info/top_level.txt,sha256=Ez-fReWtUVTMcFuH0dzCnoKIgMBHgjLaBuba8QiKC7g,6
-e_data-2.0.2.dev137.dist-info/RECORD,,
+e_data-2.0.2.dev138.dist-info/METADATA,sha256=-DmL66kwdc79X1tIqaJYUATBtnLaFEfXPJjuCNlq7oo,48041
+e_data-2.0.2.dev138.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+e_data-2.0.2.dev138.dist-info/top_level.txt,sha256=Ez-fReWtUVTMcFuH0dzCnoKIgMBHgjLaBuba8QiKC7g,6
+e_data-2.0.2.dev138.dist-info/RECORD,,

edata/database/controller.py

@@ -1,15 +1,15 @@
 import asyncio
+import functools
 import logging
 import os
 import typing
+from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 
-from sqlalchemy import Select, Table, event, insert, or_
+from sqlalchemy import Engine, Select, Table, create_engine, event, insert, or_
 from sqlalchemy.dialects.sqlite import insert as sqlite_insert
 from sqlalchemy.exc import IntegrityError
-from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
-from sqlmodel import SQLModel, UniqueConstraint
-from sqlmodel.ext.asyncio.session import AsyncSession
+from sqlmodel import Session, SQLModel, UniqueConstraint
 from sqlmodel.sql.expression import SelectOfScalar
 
 import edata.database.queries as q
@@ -28,6 +28,7 @@ from edata.models.bill import Bill, EnergyPrice
 _LOGGER = logging.getLogger(__name__)
 
 T = typing.TypeVar("T", bound=SQLModel)
+R = typing.TypeVar("R")
 
 
 def _set_sqlite_pragmas(dbapi_connection, connection_record) -> None:
@@ -77,53 +78,91 @@ def _conflict_columns(table: Table) -> list[str]:
     return [c.name for c in table.primary_key.columns]
 
 
+def _in_db_thread(
+    fn: typing.Callable[..., R],
+) -> typing.Callable[..., typing.Coroutine[typing.Any, typing.Any, R]]:
+    """Turn a blocking ``EdataDB`` method into a coroutine run on its DB thread."""
+
+    @functools.wraps(fn)
+    async def wrapper(self: "EdataDB", *args: typing.Any, **kwargs: typing.Any) -> R:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            self._executor, functools.partial(fn, self, *args, **kwargs)
+        )
+
+    return wrapper
+
+
 class EdataDB:
+    """SQLite store.
+
+    The public API is async, but every database operation (SQLAlchemy, pydantic
+    (de)serialization and SQLite itself) runs on a single dedicated thread so a
+    large import never stalls the caller's event loop (e.g. Home Assistant's).
+    One thread also serializes access, which suits SQLite's single writer.
+    """
 
     _instance = None
-    _engine: AsyncEngine | None = None
+    _engine: Engine | None = None
     _db_url: str | None = None
 
     def __new__(cls, sqlite_path: str):
-        db_url = f"sqlite+aiosqlite:////{os.path.abspath(sqlite_path)}"
+        db_url = f"sqlite:////{os.path.abspath(sqlite_path)}"
         if cls._instance is None:
             cls._instance = super().__new__(cls)
             cls._db_url = db_url
             # Ensure parent directory exists before the first connection is opened.
             dir_path = os.path.dirname(os.path.abspath(sqlite_path))
             os.makedirs(dir_path, exist_ok=True)
-            cls._engine = create_async_engine(db_url, future=True)
-            event.listen(cls._engine.sync_engine, "connect", _set_sqlite_pragmas)
+            cls._engine = create_engine(db_url)
+            event.listen(cls._engine, "connect", _set_sqlite_pragmas)
             cls._instance._tables_initialized = False
-            cls._instance._tables_lock = asyncio.Lock()
+            cls._instance._executor = ThreadPoolExecutor(
+                max_workers=1, thread_name_prefix="edata-db"
+            )
         elif db_url != cls._db_url:
             raise ValueError("EdataDB already initialized with a different db_url")
         return cls._instance
 
+    @classmethod
+    def reset(cls) -> None:
+        """Close the shared instance (its DB thread and engine) and forget it.
+
+        Waits for queued database work to finish first. A later ``EdataDB(...)``
+        starts afresh, possibly on another path.
+        """
+
+        if cls._instance is not None:
+            cls._instance._executor.shutdown(wait=True)
+        if cls._engine is not None:
+            cls._engine.dispose()
+        cls._instance = None
+        cls._engine = None
+        cls._db_url = None
+
     @property
-    def engine(self) -> AsyncEngine | None:
-        """Return the async database engine."""
+    def engine(self) -> Engine | None:
+        """Return the database engine."""
 
         return self._engine
 
-    async def _ensure_tables(self) -> None:
-        """Create tables if not already created (lazy init)."""
+    def _ensure_tables(self) -> None:
+        """Create tables and missing indexes if not already done (lazy init).
 
-        if self._tables_initialized:
+        Only ever runs on the database thread, so concurrent first calls are
+        serialized and cannot race to create the same index.
+        """
+
+        if self._tables_initialized or not self.engine:
             return
-        # concurrent first calls (e.g. several websocket requests right after
-        # startup) would otherwise all see the index missing and race to create
-        # it, failing with "index ... already exists"
-        async with self._tables_lock:
-            if self._tables_initialized or not self.engine:
-                return
-            async with self.engine.begin() as conn:
-                await conn.run_sync(SQLModel.metadata.create_all)
-                await conn.run_sync(_create_missing_indexes)
-            self._tables_initialized = True
-
-    async def _add_one(
+        with self.engine.begin() as conn:
+            SQLModel.metadata.create_all(conn)
+            _create_missing_indexes(conn)
+        self._tables_initialized = True
+
+    def _add_one(
         self,
-        session: AsyncSession,
+        session: Session,
         record: T,
         commit: bool = True,
     ) -> T:
@@ -131,15 +170,15 @@ class EdataDB:
 
         session.add(record)
         if commit:
-            await session.commit()
-            await session.refresh(record)
+            session.commit()
+            session.refresh(record)
         else:
-            await session.flush()
+            session.flush()
         return record
 
-    async def _update_one(
+    def _update_one(
         self,
-        session: AsyncSession,
+        session: Session,
         query: SelectOfScalar,
         data: typing.Any,
         commit: bool = True,
@@ -147,7 +186,7 @@ class EdataDB:
     ) -> T | None:  # type: ignore
         """Update a single record in the database."""
 
-        result = await session.exec(query)
+        result = session.exec(query)
         existing = result.first()
         if existing and getattr(existing, "data") == data and not overrides:
             return existing
@@ -156,15 +195,15 @@ class EdataDB:
             for key, value in overrides.items():
                 setattr(existing, key, value)
         if commit:
-            await session.commit()
-            await session.refresh(existing)
+            session.commit()
+            session.refresh(existing)
         else:
-            await session.flush()
+            session.flush()
         return existing
 
-    async def _add_or_update_one(
+    def _add_or_update_one(
         self,
-        session: AsyncSession,
+        session: Session,
         query: SelectOfScalar,
         record: T,
         commit: bool = True,
@@ -173,12 +212,12 @@ class EdataDB:
         """Add a single record into the database and fallback to update safely."""
 
         try:
-            async with session.begin_nested():
+            with session.begin_nested():
                 session.add(record)
-                await session.flush()
+                session.flush()
             if commit:
-                await session.commit()
-                await session.refresh(record)
+                session.commit()
+                session.refresh(record)
             return record
         except IntegrityError:
             new_data = getattr(record, "data")
@@ -188,13 +227,13 @@ class EdataDB:
                 override_dict = {
                     x: record_json[x] for x in record.model_dump() if x in override
                 }
-            return await self._update_one(
+            return self._update_one(
                 session, query, new_data, commit=commit, overrides=override_dict
             )
 
-    async def _add_or_update_many(
+    def _add_or_update_many(
         self,
-        session: AsyncSession,
+        session: Session,
         model: type[SQLModel],
         rows: list[dict[str, typing.Any]],
         override: list[str] | None = None,
@@ -232,166 +271,183 @@ class EdataDB:
             },
             where=or_(*(table.c[c].is_distinct_from(stmt.excluded[c]) for c in updated)),
         )
-        connection = await session.connection()
-        await connection.execute(stmt, rows)
-        await session.commit()
+        connection = session.connection()
+        connection.execute(stmt, rows)
+        session.commit()
 
-    async def get_supply(self, cups: str) -> SupplyModel | None:
+    @_in_db_thread
+    def get_supply(self, cups: str) -> SupplyModel | None:
         """Get a supply record by cups."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.get_supply(cups))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.get_supply(cups))
             return result.first()
 
-    async def get_contract(
+    @_in_db_thread
+    def get_contract(
         self, cups: str, date_start: datetime | None = None
     ) -> ContractModel | None:
         """Get a contract record by cups."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.get_contract(cups, date_start))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.get_contract(cups, date_start))
             return result.first()
 
-    async def get_last_energy(self, cups: str) -> EnergyModel | None:
+    @_in_db_thread
+    def get_last_energy(self, cups: str) -> EnergyModel | None:
         """Get the most recent Energy record by cups."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.get_last_energy(cups))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.get_last_energy(cups))
             return result.first()
 
-    async def get_last_power(self, cups: str) -> PowerModel | None:
+    @_in_db_thread
+    def get_last_power(self, cups: str) -> PowerModel | None:
         """Get the most recent power record by cups."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.get_last_power(cups))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.get_last_power(cups))
             return result.first()
 
-    async def get_last_pvpc(self) -> PVPCModel | None:
+    @_in_db_thread
+    def get_last_pvpc(self) -> PVPCModel | None:
         """Get the most recent pvpc."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.get_last_pvpc())
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.get_last_pvpc())
             return result.first()
 
-    async def get_last_bill(self, cups: str) -> BillModel | None:
+    @_in_db_thread
+    def get_last_bill(self, cups: str) -> BillModel | None:
         """Get the most recent bill record by cups."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.get_last_bill(cups))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.get_last_bill(cups))
             return result.first()
 
-    async def get_last_complete_statistic(
+    @_in_db_thread
+    def get_last_complete_statistic(
         self, cups: str, type_: typing.Literal["day", "month"]
     ) -> StatisticsModel | None:
         """Get the most recent complete statistics record by cups and type."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.get_last_complete_statistic(cups, type_))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.get_last_complete_statistic(cups, type_))
             return result.first()
 
-    async def get_last_complete_bill(
+    @_in_db_thread
+    def get_last_complete_bill(
         self, cups: str, type_: typing.Literal["hour", "day", "month"]
     ) -> BillModel | None:
         """Get the most recent complete bill record by cups and type."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.get_last_complete_bill(cups, type_))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.get_last_complete_bill(cups, type_))
             return result.first()
 
-    async def add_contract(self, cups: str, contract: Contract) -> ContractModel | None:
+    @_in_db_thread
+    def add_contract(self, cups: str, contract: Contract) -> ContractModel | None:
         """Add or update a contract record."""
 
-        await self._ensure_tables()
+        self._ensure_tables()
         record = ContractModel(cups=cups, date_start=contract.date_start, data=contract)
-        async with AsyncSession(self.engine) as session:
-            return await self._add_or_update_one(
+        with Session(self.engine) as session:
+            return self._add_or_update_one(
                 session, q.get_contract(cups, contract.date_start), record
             )
 
-    async def add_supply(self, supply: Supply) -> SupplyModel | None:
+    @_in_db_thread
+    def add_supply(self, supply: Supply) -> SupplyModel | None:
         """Add or update a supply record."""
 
-        await self._ensure_tables()
+        self._ensure_tables()
         record = SupplyModel(cups=supply.cups, data=supply)
-        async with AsyncSession(self.engine) as session:
-            return await self._add_or_update_one(
+        with Session(self.engine) as session:
+            return self._add_or_update_one(
                 session, q.get_supply(supply.cups), record
             )
 
-    async def add_energy(self, cups: str, energy: Energy) -> EnergyModel | None:
+    @_in_db_thread
+    def add_energy(self, cups: str, energy: Energy) -> EnergyModel | None:
         """Add or update an energy record."""
 
-        await self._ensure_tables()
+        self._ensure_tables()
         record = EnergyModel(
             cups=cups, delta_h=energy.delta_h, datetime=energy.datetime, data=energy
         )
-        async with AsyncSession(self.engine) as session:
-            return await self._add_or_update_one(
+        with Session(self.engine) as session:
+            return self._add_or_update_one(
                 session, q.get_energy(cups, energy.datetime), record
             )
 
-    async def add_energy_list(self, cups: str, energy: list[Energy]) -> None:
+    @_in_db_thread
+    def add_energy_list(self, cups: str, energy: list[Energy]) -> None:
         """Add or update a list of energy records."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
+        self._ensure_tables()
+        with Session(self.engine) as session:
             unique_map = {item.datetime: item for item in energy}
             unique = list(unique_map.values())
             rows = [
                 {"cups": cups, "delta_h": x.delta_h, "datetime": x.datetime, "data": x}
                 for x in unique
             ]
-            await self._add_or_update_many(session, EnergyModel, rows)
+            self._add_or_update_many(session, EnergyModel, rows)
 
-    async def add_power(self, cups: str, power: Power) -> PowerModel | None:
+    @_in_db_thread
+    def add_power(self, cups: str, power: Power) -> PowerModel | None:
         """Add or update a power record for a given CUPS and Power instance."""
 
-        await self._ensure_tables()
+        self._ensure_tables()
         record = PowerModel(cups=cups, datetime=power.datetime, data=power)
-        async with AsyncSession(self.engine) as session:
-            return await self._add_or_update_one(
+        with Session(self.engine) as session:
+            return self._add_or_update_one(
                 session, q.get_power(cups, power.datetime), record
             )
 
-    async def add_power_list(self, cups: str, power: list[Power]) -> None:
+    @_in_db_thread
+    def add_power_list(self, cups: str, power: list[Power]) -> None:
         """Add or update a list of power records."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
+        self._ensure_tables()
+        with Session(self.engine) as session:
             unique_map = {item.datetime: item for item in power}
             unique = list(unique_map.values())
             rows = [{"cups": cups, "datetime": x.datetime, "data": x} for x in unique]
-            await self._add_or_update_many(session, PowerModel, rows)
+            self._add_or_update_many(session, PowerModel, rows)
 
-    async def add_pvpc(self, pvpc: EnergyPrice) -> PVPCModel | None:
+    @_in_db_thread
+    def add_pvpc(self, pvpc: EnergyPrice) -> PVPCModel | None:
         """Add or update a pvpc record."""
 
-        await self._ensure_tables()
+        self._ensure_tables()
         record = PVPCModel(datetime=pvpc.datetime, data=pvpc)
-        async with AsyncSession(self.engine) as session:
-            return await self._add_or_update_one(
+        with Session(self.engine) as session:
+            return self._add_or_update_one(
                 session, q.get_pvpc(pvpc.datetime), record
             )
 
-    async def add_pvpc_list(self, pvpc: list[EnergyPrice]) -> None:
+    @_in_db_thread
+    def add_pvpc_list(self, pvpc: list[EnergyPrice]) -> None:
         """Add or update a list of pvpc records."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
+        self._ensure_tables()
+        with Session(self.engine) as session:
             unique_map = {item.datetime: item for item in pvpc}
             unique = list(unique_map.values())
             rows = [{"datetime": x.datetime, "data": x} for x in unique]
-            await self._add_or_update_many(session, PVPCModel, rows)
+            self._add_or_update_many(session, PVPCModel, rows)
 
-    async def add_statistics(
+    @_in_db_thread
+    def add_statistics(
         self,
         cups: str,
         type_: typing.Literal["day", "month"],
@@ -400,19 +456,20 @@ class EdataDB:
     ) -> StatisticsModel | None:
         """Add or update a statistics record."""
 
-        await self._ensure_tables()
+        self._ensure_tables()
         record = StatisticsModel(
             cups=cups, datetime=data.datetime, type=type_, data=data, complete=complete
         )
-        async with AsyncSession(self.engine) as session:
-            return await self._add_or_update_one(
+        with Session(self.engine) as session:
+            return self._add_or_update_one(
                 session,
                 q.get_statistics(cups, type_, data.datetime),
                 record,
                 override=["complete"],
             )
 
-    async def add_statistics_list(
+    @_in_db_thread
+    def add_statistics_list(
         self,
         cups: str,
         type_: typing.Literal["day", "month"],
@@ -421,8 +478,8 @@ class EdataDB:
     ) -> None:
         """Add or update a list of statistics records."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
+        self._ensure_tables()
+        with Session(self.engine) as session:
             unique_map = {item.datetime: item for item in statistics}
             rows = [
                 {
@@ -434,11 +491,12 @@ class EdataDB:
                 }
                 for x in unique_map.values()
             ]
-            await self._add_or_update_many(
+            self._add_or_update_many(
                 session, StatisticsModel, rows, override=["complete"]
             )
 
-    async def add_bill(
+    @_in_db_thread
+    def add_bill(
         self,
         cups: str,
         type_: typing.Literal["hour", "day", "month"],
@@ -448,7 +506,7 @@ class EdataDB:
     ) -> BillModel | None:
         """Add or update a bill record."""
 
-        await self._ensure_tables()
+        self._ensure_tables()
         record = BillModel(
             cups=cups,
             datetime=data.datetime,
@@ -457,15 +515,16 @@ class EdataDB:
             confhash=confhash,
             data=data,
         )
-        async with AsyncSession(self.engine) as session:
-            return await self._add_or_update_one(
+        with Session(self.engine) as session:
+            return self._add_or_update_one(
                 session,
                 q.get_bill(cups, type_, data.datetime),
                 record,
                 override=["complete", "confhash"],
             )
 
-    async def add_bill_list(
+    @_in_db_thread
+    def add_bill_list(
         self,
         cups: str,
         type_: typing.Literal["hour", "day", "month"],
@@ -475,8 +534,8 @@ class EdataDB:
     ) -> None:
         """Add or update a list of bill records."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
+        self._ensure_tables()
+        with Session(self.engine) as session:
             unique_map = {item.datetime: item for item in bill}
             unique = list(unique_map.values())
             rows = [
@@ -490,51 +549,55 @@ class EdataDB:
                 }
                 for x in unique
             ]
-            await self._add_or_update_many(
+            self._add_or_update_many(
                 session, BillModel, rows, override=["complete", "confhash"]
             )
 
-    async def clear_bills(self, cups: str, since: datetime | None = None) -> None:
+    @_in_db_thread
+    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()
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            session.exec(q.delete_bill(cups, since))  # type: ignore[call-overload]
+            session.commit()
 
-    async def list_supplies(self) -> typing.Sequence[SupplyModel]:
+    @_in_db_thread
+    def list_supplies(self) -> typing.Sequence[SupplyModel]:
         """List all supply records."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.list_supply())
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.list_supply())
             return result.all()
 
-    async def list_contracts(
+    @_in_db_thread
+    def list_contracts(
         self, cups: str | None = None
     ) -> typing.Sequence[ContractModel]:
         """List all contract records."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.list_contract(cups))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.list_contract(cups))
             return result.all()
 
-    async def _list_data(self, query: SelectOfScalar, model: type[SQLModel]) -> list:
+    def _list_data(self, query: SelectOfScalar, model: type[SQLModel]) -> list:
         """Return only the ``data`` payload of the rows selected by ``query``.
 
         Skips building an ORM instance per row, which nearly halves the cost of
         reading a month of hourly records.
         """
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(
                 query.with_only_columns(model.data)  # type: ignore[attr-defined]
             )
             return list(result.all())
 
-    async def list_energy_data(
+    @_in_db_thread
+    def list_energy_data(
         self,
         cups: str,
         date_from: datetime | None = None,
@@ -542,20 +605,22 @@ class EdataDB:
     ) -> list[Energy]:
         """List the energy data (without row metadata)."""
 
-        return await self._list_data(
+        return self._list_data(
             q.list_energy(cups, date_from, date_to), EnergyModel
         )
 
-    async def list_pvpc_data(
+    @_in_db_thread
+    def list_pvpc_data(
         self,
         date_from: datetime | None = None,
         date_to: datetime | None = None,
     ) -> list[EnergyPrice]:
         """List the pvpc data (without row metadata)."""
 
-        return await self._list_data(q.list_pvpc(date_from, date_to), PVPCModel)
+        return self._list_data(q.list_pvpc(date_from, date_to), PVPCModel)
 
-    async def list_bill_data(
+    @_in_db_thread
+    def list_bill_data(
         self,
         cups: str,
         type_: typing.Literal["hour", "day", "month"],
@@ -564,11 +629,12 @@ class EdataDB:
     ) -> list[Bill]:
         """List the bill data (without row metadata)."""
 
-        return await self._list_data(
+        return self._list_data(
             q.list_bill(cups, type_, date_from, date_to), BillModel
         )
 
-    async def list_energy(
+    @_in_db_thread
+    def list_energy(
         self,
         cups: str,
         date_from: datetime | None = None,
@@ -576,12 +642,13 @@ class EdataDB:
     ) -> typing.Sequence[EnergyModel]:
         """List energy records."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.list_energy(cups, date_from, date_to))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.list_energy(cups, date_from, date_to))
             return result.all()
 
-    async def list_power(
+    @_in_db_thread
+    def list_power(
         self,
         cups: str,
         date_from: datetime | None = None,
@@ -589,24 +656,26 @@ class EdataDB:
     ) -> typing.Sequence[PowerModel]:
         """List power records."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.list_power(cups, date_from, date_to))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.list_power(cups, date_from, date_to))
             return result.all()
 
-    async def list_pvpc(
+    @_in_db_thread
+    def list_pvpc(
         self,
         date_from: datetime | None = None,
         date_to: datetime | None = None,
     ) -> typing.Sequence[PVPCModel]:
         """List pvpc records."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(q.list_pvpc(date_from, date_to))
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(q.list_pvpc(date_from, date_to))
             return result.all()
 
-    async def list_statistics(
+    @_in_db_thread
+    def list_statistics(
         self,
         cups: str,
         type_: typing.Literal["day", "month"],
@@ -616,14 +685,15 @@ class EdataDB:
     ) -> typing.Sequence[StatisticsModel]:
         """List statistics records filtered by type ('day' or 'month') and date range."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(
                 q.list_statistics(cups, type_, date_from, date_to, complete)
             )
             return result.all()
 
-    async def list_bill(
+    @_in_db_thread
+    def list_bill(
         self,
         cups: str,
         type_: typing.Literal["hour", "day", "month"],
@@ -633,9 +703,9 @@ class EdataDB:
     ) -> typing.Sequence[BillModel]:
         """List bill records filtered by type ('hour', 'day' or 'month') and date range."""
 
-        await self._ensure_tables()
-        async with AsyncSession(self.engine) as session:
-            result = await session.exec(
+        self._ensure_tables()
+        with Session(self.engine) as session:
+            result = session.exec(
                 q.list_bill(cups, type_, date_from, date_to, complete)
             )
             return result.all()

edata/providers/datadis.py

@@ -3,6 +3,7 @@
 import asyncio
 import contextlib
 import hashlib
+import json
 import logging
 import os
 import tempfile
@@ -69,6 +70,59 @@ def migrate_storage(storage_dir: str) -> None:
         os.remove(os.path.join(storage_dir, "edata_recent_queries_cache.json"))
 
 
+def _parse_consumptions(
+    response: dict[str, typing.Any], start_date: datetime, end_date: datetime
+) -> list[Energy]:
+    """Build the energy records of a 'get_consumption_data' response."""
+
+    consumptions = []
+    for i in response.get("timeCurve", []):
+        if "consumptionKWh" in i:
+            if all(k in i for k in GET_CONSUMPTION_DATA_MANDATORY_FIELDS):
+                raw_hour = int(i["time"].split(":")[0])
+                # Datadis delivers hours 1..24 (end-of-interval). A sporadic
+                # i-DE glitch emits an extra "00:00" row on a day already
+                # carrying its full 24 hours, so drop it -- 01:00..24:00
+                # already covers the day -- instead of remapping onto 23:00
+                # and overlapping that day's 24:00 slot.
+                if raw_hour == 0:
+                    continue
+                date_as_dt = datetime.strptime(
+                    i["date"], "%Y/%m/%d"
+                ) + timedelta(hours=raw_hour - 1)
+                if not (start_date <= date_as_dt <= end_date):
+                    continue  # skip element if dt is out of range
+
+                # sanitize these values
+                _surplus_kwh = i.get("surplusEnergyKWh", 0)
+                if _surplus_kwh is None:
+                    _surplus_kwh = 0
+                _generation_kwh = i.get("generationEnergyKWh", 0)
+                if _generation_kwh is None:
+                    _generation_kwh = 0
+                _selfconsumption_kwh = i.get("selfConsumptionEnergyKWh", 0)
+                if _selfconsumption_kwh is None:
+                    _selfconsumption_kwh = 0
+
+                consumptions.append(
+                    Energy(
+                        datetime=date_as_dt,
+                        delta_h=1,
+                        consumption_kwh=i["consumptionKWh"],
+                        surplus_kwh=_surplus_kwh,
+                        generation_kwh=_generation_kwh,
+                        selfconsumption_kwh=_selfconsumption_kwh,
+                        real=i["obtainMethod"] == "Real",
+                    )
+                )
+            else:
+                _LOGGER.warning(
+                    "Weird data structure while fetching consumption data, got %s",
+                    response,
+                )
+    return consumptions
+
+
 class DatadisConnector:
     """A Datadis private API connector."""
 
@@ -237,7 +291,10 @@ class DatadisConnector:
                         # it here as well would decode every (large) payload twice
                         if reply.status == 200:
                             try:
-                                json_data = await reply.json(content_type=None)
+                                # decode off the event loop: a full-history
+                                # response is several MB of JSON
+                                body = await reply.read()
+                                json_data = await asyncio.to_thread(json.loads, body)
                                 if json_data:
                                     response = json_data
                                     if not ignore_cache:
@@ -419,52 +476,11 @@ class DatadisConnector:
 
         response = await self._async_get(URL_GET_CONSUMPTION_DATA, request_data=data)
 
-        consumptions = []
-        for i in response.get("timeCurve", []):
-            if "consumptionKWh" in i:
-                if all(k in i for k in GET_CONSUMPTION_DATA_MANDATORY_FIELDS):
-                    raw_hour = int(i["time"].split(":")[0])
-                    # Datadis delivers hours 1..24 (end-of-interval). A sporadic
-                    # i-DE glitch emits an extra "00:00" row on a day already
-                    # carrying its full 24 hours, so drop it -- 01:00..24:00
-                    # already covers the day -- instead of remapping onto 23:00
-                    # and overlapping that day's 24:00 slot.
-                    if raw_hour == 0:
-                        continue
-                    date_as_dt = datetime.strptime(
-                        i["date"], "%Y/%m/%d"
-                    ) + timedelta(hours=raw_hour - 1)
-                    if not (start_date <= date_as_dt <= end_date):
-                        continue  # skip element if dt is out of range
-
-                    # sanitize these values
-                    _surplus_kwh = i.get("surplusEnergyKWh", 0)
-                    if _surplus_kwh is None:
-                        _surplus_kwh = 0
-                    _generation_kwh = i.get("generationEnergyKWh", 0)
-                    if _generation_kwh is None:
-                        _generation_kwh = 0
-                    _selfconsumption_kwh = i.get("selfConsumptionEnergyKWh", 0)
-                    if _selfconsumption_kwh is None:
-                        _selfconsumption_kwh = 0
-
-                    consumptions.append(
-                        Energy(
-                            datetime=date_as_dt,
-                            delta_h=1,
-                            consumption_kwh=i["consumptionKWh"],
-                            surplus_kwh=_surplus_kwh,
-                            generation_kwh=_generation_kwh,
-                            selfconsumption_kwh=_selfconsumption_kwh,
-                            real=i["obtainMethod"] == "Real",
-                        )
-                    )
-                else:
-                    _LOGGER.warning(
-                        "Weird data structure while fetching consumption data, got %s",
-                        response,
-                    )
-        return consumptions
+        # building tens of thousands of records on a first import takes long
+        # enough to stall the event loop, so parse in a worker thread
+        return await asyncio.to_thread(
+            _parse_consumptions, response, start_date, end_date
+        )
 
     def get_consumption_data(
         self,

edata/tests/test_controller.py

@@ -1,6 +1,7 @@
 """Tests for the database controller."""
 
 import asyncio
+import threading
 from collections.abc import AsyncIterator
 from datetime import datetime, timedelta
 
@@ -16,16 +17,10 @@ CUPS = "ESXXXXXXXXXXXXXXXXTEST"
 START = datetime(2024, 1, 1)
 
 
-def _reset_singleton() -> None:
-    EdataDB._instance = None
-    EdataDB._engine = None
-    EdataDB._db_url = None
-
-
 @pytest_asyncio.fixture
 async def db(tmp_path) -> AsyncIterator[EdataDB]:
     """An EdataDB on an isolated on-disk database with one supply."""
-    _reset_singleton()
+    EdataDB.reset()
     database = EdataDB(str(tmp_path / "edata.db"))
     await database.add_supply(
         Supply(
@@ -42,9 +37,7 @@ async def db(tmp_path) -> AsyncIterator[EdataDB]:
         )
     )
     yield database
-    if EdataDB._engine is not None:
-        await EdataDB._engine.dispose()
-    _reset_singleton()
+    EdataDB.reset()
 
 
 def _energy(hours: int, kwh: float) -> list[Energy]:
@@ -97,14 +90,14 @@ async def test_add_bill_list_applies_overrides(db: EdataDB) -> None:
 @pytest.mark.asyncio
 async def test_concurrent_first_calls_do_not_race_index_creation(db: EdataDB) -> None:
     # simulate a database created before the index existed, opened fresh
-    async with db.engine.begin() as conn:
-        await conn.exec_driver_sql("DROP INDEX ix_energy_cups_datetime")
+    with db.engine.begin() as conn:
+        conn.exec_driver_sql("DROP INDEX ix_energy_cups_datetime")
     db._tables_initialized = False
 
     await asyncio.gather(*(db.get_last_energy(CUPS) for _ in range(10)))
 
-    async with db.engine.connect() as conn:
-        result = await conn.exec_driver_sql(
+    with db.engine.connect() as conn:
+        result = conn.exec_driver_sql(
             "SELECT name FROM sqlite_master WHERE name='ix_energy_cups_datetime'"
         )
         assert result.first() is not None
@@ -121,3 +114,14 @@ def test_datetime_columns_are_naive() -> None:
     ]
     assert len(columns) == 20
     assert all(column.type.timezone is False for column in columns)
+
+
+@pytest.mark.asyncio
+async def test_reset_stops_db_thread_and_allows_new_path(db: EdataDB, tmp_path) -> None:
+    assert await db.list_supplies()
+    EdataDB.reset()
+
+    assert not any(t.name.startswith("edata-db") for t in threading.enumerate())
+    other = EdataDB(str(tmp_path / "other.db"))
+    assert other is not db
+    assert await other.list_supplies() == []

edata/tests/test_datadis_connector.py

@@ -1,6 +1,7 @@
 """Tests for DatadisConnector (offline)."""
 
 import datetime
+import json
 import os
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -8,6 +9,12 @@ import pytest
 
 from edata.providers.datadis import DatadisConnector
 
+
+def _json_body(payload) -> AsyncMock:
+    """Mock ``reply.read()`` returning ``payload`` as a JSON body."""
+    return AsyncMock(return_value=json.dumps(payload).encode())
+
+
 MOCK_USERNAME = "USERNAME"
 MOCK_PASSWORD = "PASSWORD"
 
@@ -126,7 +133,7 @@ def test_get_supplies(mock_token, mock_get, snapshot):
     mock_response = MagicMock()
     mock_response.status = 200
     mock_response.text = AsyncMock(return_value="text")
-    mock_response.json = AsyncMock(return_value=SUPPLIES_RESPONSE)
+    mock_response.read = _json_body(SUPPLIES_RESPONSE)
     mock_get.return_value.__aenter__.return_value = mock_response
     connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
     assert connector.get_supplies() == snapshot
@@ -141,7 +148,7 @@ def test_get_contract_detail(mock_token, mock_get, snapshot):
     mock_response = MagicMock()
     mock_response.status = 200
     mock_response.text = AsyncMock(return_value="text")
-    mock_response.json = AsyncMock(return_value=CONTRACTS_RESPONSE)
+    mock_response.read = _json_body(CONTRACTS_RESPONSE)
     mock_get.return_value.__aenter__.return_value = mock_response
     connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
     assert connector.get_contract_detail("ESXXXXXXXXXXXXXXXXTEST", "2") == snapshot
@@ -156,7 +163,7 @@ def test_get_consumption_data(mock_token, mock_get, snapshot):
     mock_response = MagicMock()
     mock_response.status = 200
     mock_response.text = AsyncMock(return_value="text")
-    mock_response.json = AsyncMock(return_value=CONSUMPTIONS_RESPONSE)
+    mock_response.read = _json_body(CONSUMPTIONS_RESPONSE)
     mock_get.return_value.__aenter__.return_value = mock_response
     connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
     assert (
@@ -181,9 +188,7 @@ def test_get_consumption_data_skips_zero_hour(mock_token, mock_get):
     mock_response = MagicMock()
     mock_response.status = 200
     mock_response.text = AsyncMock(return_value="text")
-    mock_response.json = AsyncMock(
-        return_value=CONSUMPTIONS_RESPONSE_WITH_ZERO_HOUR
-    )
+    mock_response.read = _json_body(CONSUMPTIONS_RESPONSE_WITH_ZERO_HOUR)
     mock_get.return_value.__aenter__.return_value = mock_response
     connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
 
@@ -215,7 +220,7 @@ def test_get_max_power(mock_token, mock_get, snapshot):
     mock_response = MagicMock()
     mock_response.status = 200
     mock_response.text = AsyncMock(return_value="text")
-    mock_response.json = AsyncMock(return_value=MAXIMETER_RESPONSE)
+    mock_response.read = _json_body(MAXIMETER_RESPONSE)
     mock_get.return_value.__aenter__.return_value = mock_response
     connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
     assert (
@@ -239,7 +244,7 @@ def test_get_supplies_empty_response(mock_token, mock_get, snapshot):
     mock_response = MagicMock()
     mock_response.status = 200
     mock_response.text = AsyncMock(return_value="text")
-    mock_response.json = AsyncMock(return_value={"supplies": []})
+    mock_response.read = _json_body({"supplies": []})
     mock_get.return_value.__aenter__.return_value = mock_response
     connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
     assert connector.get_supplies() == snapshot
@@ -255,7 +260,7 @@ def test_get_supplies_malformed_response(mock_token, mock_get, snapshot):
     mock_response = MagicMock()
     mock_response.status = 200
     mock_response.text = AsyncMock(return_value="text")
-    mock_response.json = AsyncMock(return_value=malformed)
+    mock_response.read = _json_body(malformed)
     mock_get.return_value.__aenter__.return_value = mock_response
     connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
     assert connector.get_supplies() == snapshot
@@ -274,7 +279,7 @@ def test_get_supplies_partial_response(mock_token, mock_get, snapshot):
     mock_response = MagicMock()
     mock_response.status = 200
     mock_response.text = AsyncMock(return_value="text")
-    mock_response.json = AsyncMock(return_value=partial)
+    mock_response.read = _json_body(partial)
     mock_get.return_value.__aenter__.return_value = mock_response
     connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
     assert connector.get_supplies() == snapshot
@@ -289,7 +294,7 @@ def test_get_consumption_data_cache(mock_token, mock_get, snapshot):
     mock_response = MagicMock()
     mock_response.status = 200
     mock_response.text = AsyncMock(return_value="text")
-    mock_response.json = AsyncMock(return_value=CONSUMPTIONS_RESPONSE)
+    mock_response.read = _json_body(CONSUMPTIONS_RESPONSE)
     mock_get.return_value.__aenter__.return_value = mock_response
     connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
     # First call populates cache
@@ -345,7 +350,7 @@ def test_get_supplies_optional_fields_none(mock_token, mock_get, snapshot):
     mock_response = MagicMock()
     mock_response.status = 200
     mock_response.text = AsyncMock(return_value="text")
-    mock_response.json = AsyncMock(return_value=response)
+    mock_response.read = _json_body(response)
     mock_get.return_value.__aenter__.return_value = mock_response
     connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
     assert connector.get_supplies() == snapshot
@@ -359,7 +364,7 @@ async def test_shared_session_is_reused(mock_token, tmp_path, snapshot):
     """A caller-provided session serves the requests and is left open."""
     mock_response = MagicMock()
     mock_response.status = 200
-    mock_response.json = AsyncMock(return_value=SUPPLIES_RESPONSE)
+    mock_response.read = _json_body(SUPPLIES_RESPONSE)
     session = MagicMock()
     session.get.return_value.__aenter__.return_value = mock_response
     session.close = AsyncMock()

edata/tests/test_incremental.py

@@ -15,25 +15,17 @@ from edata.services.data_service import DataService
 CUPS = "ESXXXXXXXXXXXXXXXXTEST"
 
 
-def _reset_singleton() -> None:
-    EdataDB._instance = None
-    EdataDB._engine = None
-    EdataDB._db_url = None
-
-
 @pytest_asyncio.fixture
 async def data_service(tmp_path) -> AsyncIterator[DataService]:
     """A DataService on an isolated on-disk database, singleton reset around it."""
-    _reset_singleton()
+    EdataDB.reset()
     with (
         patch("edata.services.data_service.DatadisConnector"),
         patch("edata.services.data_service.REDataConnector"),
     ):
         service = DataService(CUPS, "user", "pwd", storage_path=str(tmp_path))
     yield service
-    if EdataDB._engine is not None:
-        await EdataDB._engine.dispose()
-    _reset_singleton()
+    EdataDB.reset()
 
 
 def _hourly_energy(start: datetime, end: datetime) -> list[Energy]:

edata/tests/test_migrations.py

@@ -18,12 +18,6 @@ ASSETS = os.path.join(os.path.dirname(__file__), "assets")
 CUPS = "ESXXXXXXXXXXXXXXXXTEST"
 
 
-def _reset_singleton() -> None:
-    EdataDB._instance = None
-    EdataDB._engine = None
-    EdataDB._db_url = None
-
-
 def _raw() -> dict:
     with open(os.path.join(ASSETS, "legacy_1.3.3.json"), encoding="utf-8") as f:
         return json.load(f)
@@ -40,16 +34,14 @@ def _install_legacy_file(storage_dir: str, cups: str = CUPS) -> str:
 @pytest_asyncio.fixture
 async def data_service(tmp_path) -> AsyncIterator[DataService]:
     """A DataService on an isolated on-disk database, singleton reset around it."""
-    _reset_singleton()
+    EdataDB.reset()
     with (
         patch("edata.services.data_service.DatadisConnector"),
         patch("edata.services.data_service.REDataConnector"),
     ):
         service = DataService(CUPS, "user", "pwd", storage_path=str(tmp_path))
     yield service
-    if EdataDB._engine is not None:
-        await EdataDB._engine.dispose()
-    _reset_singleton()
+    EdataDB.reset()
 
 
 # --- pure mappers ---

edata/tests/test_services.py

@@ -258,13 +258,13 @@ async def test_update_power_is_incremental(populated_data_service, power):
 async def test_missing_indexes_are_created_on_existing_db(populated_data_service):
     db = populated_data_service.db
 
-    async with db.engine.begin() as conn:
-        await conn.exec_driver_sql("DROP INDEX IF EXISTS ix_energy_cups_datetime")
+    with db.engine.begin() as conn:
+        conn.exec_driver_sql("DROP INDEX IF EXISTS ix_energy_cups_datetime")
     db._tables_initialized = False
-    await db._ensure_tables()
+    await db.list_supplies()  # any call lazily re-runs the table/index setup
 
-    async with db.engine.connect() as conn:
-        result = await conn.exec_driver_sql(
+    with db.engine.connect() as conn:
+        result = conn.exec_driver_sql(
             "SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='energy'"
         )
         assert "ix_energy_cups_datetime" in {row[0] for row in result}