sqlite-export-for-ynab 2.4.0__tar.gz → 2.5.0__tar.gz

{sqlite_export_for_ynab-2.4.0/sqlite_export_for_ynab.egg-info → sqlite_export_for_ynab-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlite_export_for_ynab
-Version: 2.4.0
+Version: 2.5.0
 Summary: SQLite Export for YNAB - Export YNAB Data to SQLite
 Home-page: https://github.com/mxr/sqlite-export-for-ynab
 Author: Max R
@@ -15,8 +15,9 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3
+Requires-Dist: aiopathlib
 Requires-Dist: aiosqlite
-Requires-Dist: tldm
+Requires-Dist: rich
 Dynamic: license-file
 
 # sqlite-export-for-ynab

{sqlite_export_for_ynab-2.4.0 → sqlite_export_for_ynab-2.5.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = sqlite_export_for_ynab
-version = 2.4.0
+version = 2.5.0
 description = SQLite Export for YNAB - Export YNAB Data to SQLite
 long_description = file: README.md
 long_description_content_type = text/markdown
@@ -20,8 +20,9 @@ keywords = ynab, sqlite, sql, budget, plan, cli
 packages = find:
 install_requires = 
 	aiohttp>=3
+	aiopathlib
 	aiosqlite
-	tldm
+	rich
 python_requires = >=3.12
 
 [options.entry_points]

{sqlite_export_for_ynab-2.4.0 → sqlite_export_for_ynab-2.5.0}/sqlite_export_for_ynab/_main.py

@@ -4,6 +4,8 @@ import argparse
 import asyncio
 import json
 import os
+from contextlib import asynccontextmanager
+from contextlib import contextmanager
 from dataclasses import dataclass
 from importlib import resources
 from importlib.metadata import version
@@ -21,13 +23,18 @@ from urllib.parse import urlunparse
 
 import aiohttp
 import aiosqlite
-from tldm import tldm
+from aiopathlib import AsyncPath
+from rich.progress import BarColumn
+from rich.progress import MofNCompleteColumn
+from rich.progress import Progress
+from rich.progress import TaskID
+from rich.progress import TextColumn
+from rich.progress import TimeElapsedColumn
 
 from sqlite_export_for_ynab import ddl
 
 if TYPE_CHECKING:
-    from collections.abc import Awaitable, Sequence
-    from typing import Never
+    from collections.abc import AsyncIterator, Awaitable, Iterator, Sequence
 
 
 _EntryTable = (
@@ -60,6 +67,13 @@ _PACKAGE = "sqlite-export-for-ynab"
 
 _BATCH_SIZE = 100
 
+_PROGRESS_COLUMNS = (
+    TextColumn("[progress.description]{task.description}"),
+    BarColumn(),
+    MofNCompleteColumn(),
+    TimeElapsedColumn(),
+)
+
 
 def resolve_token(token_override: str | None = None) -> str:
     token = token_override or os.environ.get(_ENV_TOKEN)
@@ -124,69 +138,92 @@ def _print(message: str, *, quiet: bool) -> None:
         print(message)
 
 
+@dataclass
+class _Context:
+    session: aiohttp.ClientSession
+    progress: Progress
+    con: aiosqlite.Connection
+
+
+@asynccontextmanager
+async def _context(db: Path, *, quiet: bool) -> AsyncIterator[_Context]:
+    progress = Progress(*_PROGRESS_COLUMNS, disable=quiet)
+    async with aiohttp.ClientSession() as session, aiosqlite.connect(db) as con:
+        con.row_factory = aiosqlite.Row
+        yield _Context(session, progress, con)
+
+
+@contextmanager
+def _progress(context: _Context) -> Iterator[None]:
+    context.progress.start()
+    try:
+        yield
+    finally:
+        context.progress.stop()
+        for task_id in context.progress.task_ids:
+            context.progress.remove_task(task_id)
+
+
 async def sync(
     token: str, db: Path, full_refresh: bool, *, quiet: bool = False
 ) -> None:
-    async with aiohttp.ClientSession() as session:
-        plans = (await YnabClient(token, session)("plans"))["plans"]
-
-    plan_ids = [plan["id"] for plan in plans]
+    await AsyncPath(db).parent.mkdir(parents=True, exist_ok=True)
 
-    if not db.exists():
-        db.parent.mkdir(parents=True, exist_ok=True)
+    async with _context(db, quiet=quiet) as context:
+        plans = (await YnabClient(token, context.session)("plans"))["plans"]
 
-    async with aiosqlite.connect(db) as con:
-        con.row_factory = aiosqlite.Row
+        plan_ids = [plan["id"] for plan in plans]
 
         if full_refresh:
             _print("Dropping relations...", quiet=quiet)
-            async with con.cursor() as cur:
-                await cur.executescript(contents("drop-relations.sql"))
-            await con.commit()
+            async with context.con.cursor() as cur:
+                await cur.executescript(await contents("drop-relations.sql"))
+            await context.con.commit()
             _print("Done", quiet=quiet)
 
-        async with con.cursor() as cur:
+        async with context.con.cursor() as cur:
             relations = await get_relations(cur)
             if relations != _ALL_RELATIONS:
                 _print("Recreating relations...", quiet=quiet)
-                await cur.executescript(contents("create-relations.sql"))
-                await con.commit()
+                await cur.executescript(await contents("create-relations.sql"))
+                await context.con.commit()
                 _print("Done", quiet=quiet)
 
         _print("Fetching plan data...", quiet=quiet)
-        async with con.cursor() as cur:
+        async with context.con.cursor() as cur:
             lkos = await get_last_knowledge_of_server(cur)
-        async with aiohttp.ClientSession() as session:
-            with tldm(
-                desc="Plan Data", total=len(plans) * len(_ENDPOINTS), disable=quiet
-            ) as pbar:
-                yc = ProgressYnabClient(YnabClient(token, session), pbar)
-
-                endpoint_data = dict(
-                    zip(
-                        _ENDPOINTS,
-                        await asyncio.gather(
-                            *(
-                                asyncio.gather(*jobs(yc, endpoint, plan_ids, lkos))
-                                for endpoint in _ENDPOINTS
-                            )
-                        ),
-                        strict=True,
-                    )
+        with _progress(context):
+            yc = ProgressYnabClient(
+                YnabClient(token, context.session),
+                context,
+                context.progress.add_task(
+                    "Plan Data", total=len(plans) * len(_ENDPOINTS)
+                ),
+            )
+
+            endpoint_data = dict(
+                zip(
+                    _ENDPOINTS,
+                    await asyncio.gather(
+                        *(
+                            asyncio.gather(*jobs(yc, endpoint, plan_ids, lkos))
+                            for endpoint in _ENDPOINTS
+                        )
+                    ),
+                    strict=True,
                 )
+            )
 
-            all_account_data = endpoint_data["accounts"]
-            all_cat_data = endpoint_data["categories"]
-            all_payee_data = endpoint_data["payees"]
-            all_txn_data = endpoint_data["transactions"]
-            all_sched_txn_data = endpoint_data["scheduled_transactions"]
+        all_account_data = endpoint_data["accounts"]
+        all_cat_data = endpoint_data["categories"]
+        all_payee_data = endpoint_data["payees"]
+        all_txn_data = endpoint_data["transactions"]
+        all_sched_txn_data = endpoint_data["scheduled_transactions"]
 
-            new_lkos = {
-                plan_id: transaction_data["server_knowledge"]
-                for plan_id, transaction_data in zip(
-                    plan_ids, all_txn_data, strict=True
-                )
-            }
+        new_lkos = {
+            plan_id: transaction_data["server_knowledge"]
+            for plan_id, transaction_data in zip(plan_ids, all_txn_data, strict=True)
+        }
         _print("Done", quiet=quiet)
 
         if (
@@ -199,63 +236,24 @@ async def sync(
             _print("No new data fetched", quiet=quiet)
         else:
             _print("Inserting plan data...", quiet=quiet)
-            await insert_plans(con, plans, new_lkos)
-            await asyncio.gather(
-                *(
-                    insert_accounts(
-                        con,
-                        plan_id,
-                        account_data["accounts"],
-                        quiet=quiet,
-                    )
-                    for plan_id, account_data in zip(
-                        plan_ids, all_account_data, strict=True
-                    )
-                ),
-                *(
-                    insert_category_groups(
-                        con,
-                        plan_id,
-                        cat_data["category_groups"],
-                        quiet=quiet,
-                    )
-                    for plan_id, cat_data in zip(plan_ids, all_cat_data, strict=True)
-                ),
-                *(
-                    insert_payees(con, plan_id, payee_data["payees"], quiet=quiet)
-                    for plan_id, payee_data in zip(
-                        plan_ids, all_payee_data, strict=True
-                    )
-                ),
-            )
-            await asyncio.gather(
-                *(
-                    insert_transactions(
-                        con,
-                        plan_id,
-                        txn_data["transactions"],
-                        quiet=quiet,
-                    )
-                    for plan_id, txn_data in zip(plan_ids, all_txn_data, strict=True)
-                ),
-                *(
-                    insert_scheduled_transactions(
-                        con,
-                        plan_id,
-                        sched_txn_data["scheduled_transactions"],
-                        quiet=quiet,
-                    )
-                    for plan_id, sched_txn_data in zip(
-                        plan_ids, all_sched_txn_data, strict=True
-                    )
-                ),
-            )
-            await con.commit()
+            with _progress(context):
+                await insert_plan_data(
+                    context,
+                    plans,
+                    plan_ids,
+                    all_account_data,
+                    all_cat_data,
+                    all_payee_data,
+                    all_txn_data,
+                    all_sched_txn_data,
+                    new_lkos,
+                )
+                await context.con.commit()
             _print("Done", quiet=quiet)
 
 
-def contents(filename: str) -> str:
-    return (resources.files(ddl) / filename).read_text()
+async def contents(filename: str) -> str:
+    return await AsyncPath(resources.files(ddl) / filename).read_text()
 
 
 async def get_relations(cur: aiosqlite.Cursor) -> set[str]:
@@ -272,10 +270,52 @@ async def get_last_knowledge_of_server(cur: aiosqlite.Cursor) -> dict[str, int]:
     return {r["id"]: r["last_knowledge_of_server"] for r in await cur.fetchall()}
 
 
+async def insert_plan_data(
+    context: _Context,
+    plans: list[dict[str, Any]],
+    plan_ids: list[str],
+    all_account_data: list[dict[str, Any]],
+    all_cat_data: list[dict[str, Any]],
+    all_payee_data: list[dict[str, Any]],
+    all_txn_data: list[dict[str, Any]],
+    all_sched_txn_data: list[dict[str, Any]],
+    new_lkos: dict[str, int],
+) -> None:
+    await insert_plans(context, plans, new_lkos)
+    await asyncio.gather(
+        *(
+            insert_accounts(context, plan_id, account_data["accounts"])
+            for plan_id, account_data in zip(plan_ids, all_account_data, strict=True)
+        ),
+        *(
+            insert_category_groups(context, plan_id, cat_data["category_groups"])
+            for plan_id, cat_data in zip(plan_ids, all_cat_data, strict=True)
+        ),
+        *(
+            insert_payees(context, plan_id, payee_data["payees"])
+            for plan_id, payee_data in zip(plan_ids, all_payee_data, strict=True)
+        ),
+    )
+    await asyncio.gather(
+        *(
+            insert_transactions(context, plan_id, txn_data["transactions"])
+            for plan_id, txn_data in zip(plan_ids, all_txn_data, strict=True)
+        ),
+        *(
+            insert_scheduled_transactions(
+                context, plan_id, sched_txn_data["scheduled_transactions"]
+            )
+            for plan_id, sched_txn_data in zip(
+                plan_ids, all_sched_txn_data, strict=True
+            )
+        ),
+    )
+
+
 async def insert_plans(
-    con: aiosqlite.Connection, plans: list[dict[str, Any]], lkos: dict[str, int]
+    context: _Context, plans: list[dict[str, Any]], lkos: dict[str, int]
 ) -> None:
-    async with con.cursor() as cur:
+    async with context.con.cursor() as cur:
         for plan_batch in batched(plans, _BATCH_SIZE):
             await cur.executemany(
                 """
@@ -316,11 +356,9 @@ _LOAN_ACCOUNT_PERIODIC_VALUES = frozenset(
 
 
 async def insert_accounts(
-    con: aiosqlite.Connection,
+    context: _Context,
     plan_id: str,
     accounts: list[dict[str, Any]],
-    *,
-    quiet: bool = False,
 ) -> None:
     # YNAB's LoanAccountPeriodValues are untyped dicts so we need to turn them into a more standard sub-entry view
     updated_accounts = [
@@ -341,146 +379,126 @@ async def insert_accounts(
     ]
 
     await insert_nested_entries(
-        con,
+        context,
         plan_id,
         updated_accounts,
         "Accounts",
         "accounts",
         "account_periodic_values",
         "account_periodic_values",
-        quiet=quiet,
     )
 
 
 async def insert_category_groups(
-    con: aiosqlite.Connection,
+    context: _Context,
     plan_id: str,
     category_groups: list[dict[str, Any]],
-    *,
-    quiet: bool = False,
 ) -> None:
     await insert_nested_entries(
-        con,
+        context,
         plan_id,
         category_groups,
         "Categories",
         "category_groups",
         "categories",
         "categories",
-        quiet=quiet,
     )
 
 
 async def insert_payees(
-    con: aiosqlite.Connection,
+    context: _Context,
     plan_id: str,
     payees: list[dict[str, Any]],
-    *,
-    quiet: bool = False,
 ) -> None:
     if not payees:
         return
 
-    with tldm(total=len(payees), desc="Payees", disable=quiet) as pbar:
-        await insert_entries(con, "payees", plan_id, payees, pbar)
+    task_id = context.progress.add_task("Payees", total=len(payees))
+    await insert_entries(context, "payees", plan_id, payees, task_id)
 
 
 async def insert_transactions(
-    con: aiosqlite.Connection,
+    context: _Context,
     plan_id: str,
     transactions: list[dict[str, Any]],
-    *,
-    quiet: bool = False,
 ) -> None:
     await insert_nested_entries(
-        con,
+        context,
         plan_id,
         transactions,
         "Transactions",
         "transactions",
         "subtransactions",
         "subtransactions",
-        quiet=quiet,
     )
 
 
 async def insert_scheduled_transactions(
-    con: aiosqlite.Connection,
+    context: _Context,
     plan_id: str,
     scheduled_transactions: list[dict[str, Any]],
-    *,
-    quiet: bool = False,
 ) -> None:
     await insert_nested_entries(
-        con,
+        context,
         plan_id,
         scheduled_transactions,
         "Scheduled Transactions",
         "scheduled_transactions",
         "subtransactions",
         "scheduled_subtransactions",
-        quiet=quiet,
     )
 
 
 @overload
 async def insert_nested_entries(
-    con: aiosqlite.Connection,
+    context: _Context,
     plan_id: str,
     entries: list[dict[str, Any]],
     desc: Literal["Accounts"],
     entries_name: Literal["accounts"],
     subentries_name: Literal["account_periodic_values"],
     subentries_table_name: Literal["account_periodic_values"],
-    *,
-    quiet: bool = False,
 ) -> None: ...
 
 
 @overload
 async def insert_nested_entries(
-    con: aiosqlite.Connection,
+    context: _Context,
     plan_id: str,
     entries: list[dict[str, Any]],
     desc: Literal["Categories"],
     entries_name: Literal["category_groups"],
     subentries_name: Literal["categories"],
     subentries_table_name: Literal["categories"],
-    *,
-    quiet: bool = False,
 ) -> None: ...
 
 
 @overload
 async def insert_nested_entries(
-    con: aiosqlite.Connection,
+    context: _Context,
     plan_id: str,
     entries: list[dict[str, Any]],
     desc: Literal["Transactions"],
     entries_name: Literal["transactions"],
     subentries_name: Literal["subtransactions"],
     subentries_table_name: Literal["subtransactions"],
-    *,
-    quiet: bool = False,
 ) -> None: ...
 
 
 @overload
 async def insert_nested_entries(
-    con: aiosqlite.Connection,
+    context: _Context,
     plan_id: str,
     entries: list[dict[str, Any]],
     desc: Literal["Scheduled Transactions"],
     entries_name: Literal["scheduled_transactions"],
     subentries_name: Literal["subtransactions"],
     subentries_table_name: Literal["scheduled_subtransactions"],
-    *,
-    quiet: bool = False,
 ) -> None: ...
 
 
 async def insert_nested_entries(
-    con: aiosqlite.Connection,
+    context: _Context,
     plan_id: str,
     entries: list[dict[str, Any]],
     desc: (
@@ -506,42 +524,35 @@ async def insert_nested_entries(
         | Literal["subtransactions"]
         | Literal["scheduled_subtransactions"]
     ),
-    *,
-    quiet: bool = False,
 ) -> None:
     if not entries:
         return
 
-    with tldm(
-        total=sum(1 + len(e[subentries_name]) for e in entries),
-        desc=desc,
-        disable=quiet,
-    ) as pbar:
-        await insert_entries(
-            con,
-            entries_name,
-            plan_id,
-            [
-                {k: v for k, v in entry.items() if k != subentries_name}
-                for entry in entries
-            ],
-            pbar,
-        )
-        await insert_entries(
-            con,
-            subentries_table_name,
-            plan_id,
-            [subentry for entry in entries for subentry in entry[subentries_name]],
-            pbar,
-        )
+    task_id = context.progress.add_task(
+        desc, total=sum(1 + len(e[subentries_name]) for e in entries)
+    )
+    await insert_entries(
+        context,
+        entries_name,
+        plan_id,
+        [{k: v for k, v in entry.items() if k != subentries_name} for entry in entries],
+        task_id,
+    )
+    await insert_entries(
+        context,
+        subentries_table_name,
+        plan_id,
+        [subentry for entry in entries for subentry in entry[subentries_name]],
+        task_id,
+    )
 
 
 async def insert_entries(
-    con: aiosqlite.Connection,
+    context: _Context,
     table: _EntryTable,
     plan_id: str,
     entries: list[dict[str, Any]],
-    pbar: tldm[Never],
+    task_id: TaskID,
 ) -> None:
     if not entries:
         return
@@ -549,14 +560,14 @@ async def insert_entries(
     entry_keys = tuple(entries[0])
     sql = f"INSERT OR REPLACE INTO {table} ({', '.join(entry_keys + ('plan_id',))}) VALUES ({', '.join('?' * (len(entry_keys) + 1))})"
 
-    async with con.cursor() as cur:
+    async with context.con.cursor() as cur:
         for entry_batch in batched(entries, _BATCH_SIZE):
             values_batch = [
                 tuple(entry[key] for key in entry_keys) + (plan_id,)
                 for entry in entry_batch
             ]
             await cur.executemany(sql, values_batch)
-            pbar.update(len(values_batch))
+            context.progress.update(task_id, advance=len(values_batch))
 
 
 def jobs(
@@ -580,7 +591,8 @@ class SupportsYnabClient(Protocol):
 @dataclass
 class ProgressYnabClient:
     yc: YnabClient
-    pbar: tldm[Never]
+    context: _Context
+    task_id: TaskID
 
     async def __call__(
         self, path: str, last_knowledge_of_server: int | None = None
@@ -588,7 +600,7 @@ class ProgressYnabClient:
         try:
             return await self.yc(path, last_knowledge_of_server)
         finally:
-            self.pbar.update()
+            self.context.progress.update(self.task_id, advance=1)
 
 
 @dataclass

{sqlite_export_for_ynab-2.4.0 → sqlite_export_for_ynab-2.5.0/sqlite_export_for_ynab.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlite_export_for_ynab
-Version: 2.4.0
+Version: 2.5.0
 Summary: SQLite Export for YNAB - Export YNAB Data to SQLite
 Home-page: https://github.com/mxr/sqlite-export-for-ynab
 Author: Max R
@@ -15,8 +15,9 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3
+Requires-Dist: aiopathlib
 Requires-Dist: aiosqlite
-Requires-Dist: tldm
+Requires-Dist: rich
 Dynamic: license-file
 
 # sqlite-export-for-ynab

{sqlite_export_for_ynab-2.4.0 → sqlite_export_for_ynab-2.5.0}/sqlite_export_for_ynab.egg-info/requires.txt

@@ -1,3 +1,4 @@
 aiohttp>=3
+aiopathlib
 aiosqlite
-tldm
+rich

{sqlite_export_for_ynab-2.4.0 → sqlite_export_for_ynab-2.5.0}/testing/fixtures.py

@@ -2,14 +2,14 @@ from __future__ import annotations
 
 import re
 from typing import Any
+from typing import TYPE_CHECKING
 from uuid import uuid4
 
-import aiosqlite
 import pytest
-import pytest_asyncio
 from aioresponses import aioresponses
 
-from sqlite_export_for_ynab._main import contents
+if TYPE_CHECKING:
+    import aiosqlite
 
 PLAN_ID_1 = str(uuid4())
 PLAN_ID_2 = str(uuid4())
@@ -353,20 +353,6 @@ SCHEDULED_TRANSACTIONS: list[dict[str, Any]] = [
 ]
 
 
-@pytest_asyncio.fixture
-async def con():
-    async with aiosqlite.connect(":memory:") as con:
-        con.row_factory = aiosqlite.Row
-        await con.executescript(contents("create-relations.sql"))
-        yield con
-
-
-@pytest_asyncio.fixture
-async def cur(con):
-    async with con.cursor() as cursor:
-        yield cursor
-
-
 @pytest.fixture
 def mock_aioresponses():
     with aioresponses() as m:

{sqlite_export_for_ynab-2.4.0 → sqlite_export_for_ynab-2.5.0}/tests/_main_test.py

@@ -9,13 +9,16 @@ from unittest.mock import patch
 import aiohttp
 import aiosqlite
 import pytest
+import pytest_asyncio
 from aiohttp.http_exceptions import HttpProcessingError
-from tldm import tldm
+from rich.progress import Progress
 
 from sqlite_export_for_ynab import default_db_path
 from sqlite_export_for_ynab._main import _ALL_RELATIONS
+from sqlite_export_for_ynab._main import _Context
 from sqlite_export_for_ynab._main import _ENV_TOKEN
 from sqlite_export_for_ynab._main import _PACKAGE
+from sqlite_export_for_ynab._main import _PROGRESS_COLUMNS
 from sqlite_export_for_ynab._main import contents
 from sqlite_export_for_ynab._main import get_last_knowledge_of_server
 from sqlite_export_for_ynab._main import get_relations
@@ -49,8 +52,6 @@ from testing.fixtures import CATEGORY_NAME_1
 from testing.fixtures import CATEGORY_NAME_2
 from testing.fixtures import CATEGORY_NAME_3
 from testing.fixtures import CATEGORY_NAME_4
-from testing.fixtures import con
-from testing.fixtures import cur
 from testing.fixtures import EXAMPLE_ENDPOINT_RE
 from testing.fixtures import LKOS
 from testing.fixtures import mock_aioresponses
@@ -87,6 +88,18 @@ async def fetchall(con, query):
         return await cur.fetchall()
 
 
+@pytest_asyncio.fixture
+async def context():
+    with Progress(*_PROGRESS_COLUMNS, disable=True) as progress:
+        async with (
+            aiohttp.ClientSession(loop=asyncio.get_event_loop()) as session,
+            aiosqlite.connect(":memory:") as con,
+        ):
+            con.row_factory = aiosqlite.Row
+            await con.executescript(await contents("create-relations.sql"))
+            yield _Context(session, progress, con)
+
+
 @pytest.mark.parametrize(
     ("xdg_data_home", "expected_prefix"),
     (
@@ -99,26 +112,25 @@ def test_default_db_path(monkeypatch, xdg_data_home, expected_prefix):
     assert default_db_path() == expected_prefix / "sqlite-export-for-ynab" / "db.sqlite"
 
 
-@pytest.mark.usefixtures(cur.__name__)
 @pytest.mark.asyncio
-async def test_get_relations(cur):
-    assert await get_relations(cur) == _ALL_RELATIONS
+async def test_get_relations(context):
+    async with context.con.cursor() as cur:
+        assert await get_relations(cur) == _ALL_RELATIONS
 
 
-@pytest.mark.usefixtures(con.__name__)
 @pytest.mark.asyncio
-async def test_get_last_knowledge_of_server(con):
-    await insert_plans(con, PLANS, LKOS)
-    async with con.cursor() as cur:
+async def test_get_last_knowledge_of_server(context):
+    await insert_plans(context, PLANS, LKOS)
+    async with context.con.cursor() as cur:
         assert await get_last_knowledge_of_server(cur) == LKOS
 
 
-@pytest.mark.usefixtures(con.__name__)
 @pytest.mark.asyncio
-async def test_insert_plans(con):
-    await insert_plans(con, PLANS, LKOS)
+async def test_insert_plans(context):
+    await insert_plans(context, PLANS, LKOS)
     assert [
-        strip_nones(d) for d in await fetchall(con, "SELECT * FROM plans ORDER BY name")
+        strip_nones(d)
+        for d in await fetchall(context.con, "SELECT * FROM plans ORDER BY name")
     ] == [
         {
             "id": PLAN_ID_1,
@@ -147,17 +159,16 @@ async def test_insert_plans(con):
     ]
 
 
-@pytest.mark.usefixtures(con.__name__)
 @pytest.mark.asyncio
-async def test_insert_accounts(con):
-    await insert_accounts(con, PLAN_ID_1, [])
-    assert not await fetchall(con, "SELECT * FROM accounts")
-    assert not await fetchall(con, "SELECT * FROM account_periodic_values")
+async def test_insert_accounts(context):
+    await insert_accounts(context, PLAN_ID_1, [])
+    assert not await fetchall(context.con, "SELECT * FROM accounts")
+    assert not await fetchall(context.con, "SELECT * FROM account_periodic_values")
 
-    await insert_accounts(con, PLAN_ID_1, ACCOUNTS)
+    await insert_accounts(context, PLAN_ID_1, ACCOUNTS)
     assert [
         strip_nones(d)
-        for d in await fetchall(con, "SELECT * FROM accounts ORDER BY name")
+        for d in await fetchall(context.con, "SELECT * FROM accounts ORDER BY name")
     ] == [
         {
             "id": ACCOUNT_ID_1,
@@ -188,7 +199,7 @@ async def test_insert_accounts(con):
     assert [
         strip_nones(d)
         for d in await fetchall(
-            con, "SELECT * FROM account_periodic_values ORDER BY name"
+            context.con, "SELECT * FROM account_periodic_values ORDER BY name"
         )
     ] == [
         {
@@ -208,17 +219,18 @@ async def test_insert_accounts(con):
     ]
 
 
-@pytest.mark.usefixtures(con.__name__)
 @pytest.mark.asyncio
-async def test_insert_category_groups(con):
-    await insert_category_groups(con, PLAN_ID_1, [])
-    assert not await fetchall(con, "SELECT * FROM category_groups")
-    assert not await fetchall(con, "SELECT * FROM categories")
+async def test_insert_category_groups(context):
+    await insert_category_groups(context, PLAN_ID_1, [])
+    assert not await fetchall(context.con, "SELECT * FROM category_groups")
+    assert not await fetchall(context.con, "SELECT * FROM categories")
 
-    await insert_category_groups(con, PLAN_ID_1, CATEGORY_GROUPS)
+    await insert_category_groups(context, PLAN_ID_1, CATEGORY_GROUPS)
     assert [
         strip_nones(d)
-        for d in await fetchall(con, "SELECT * FROM category_groups ORDER BY name")
+        for d in await fetchall(
+            context.con, "SELECT * FROM category_groups ORDER BY name"
+        )
     ] == [
         {
             "id": CATEGORY_GROUP_ID_1,
@@ -234,7 +246,7 @@ async def test_insert_category_groups(con):
 
     assert [
         strip_nones(d)
-        for d in await fetchall(con, "SELECT * FROM categories ORDER BY name")
+        for d in await fetchall(context.con, "SELECT * FROM categories ORDER BY name")
     ] == [
         {
             "id": CATEGORY_ID_1,
@@ -300,20 +312,21 @@ async def test_insert_category_groups(con):
     ]
 
 
-@pytest.mark.usefixtures(con.__name__)
 @pytest.mark.asyncio
-async def test_insert_category_group_without_categories(con):
+async def test_insert_category_group_without_categories(context):
     category_group = {
         "id": CATEGORY_GROUP_ID_1,
         "name": CATEGORY_GROUP_NAME_1,
         "categories": [],
     }
 
-    await insert_category_groups(con, PLAN_ID_1, [category_group])
+    await insert_category_groups(context, PLAN_ID_1, [category_group])
 
     assert [
         strip_nones(d)
-        for d in await fetchall(con, "SELECT * FROM category_groups ORDER BY name")
+        for d in await fetchall(
+            context.con, "SELECT * FROM category_groups ORDER BY name"
+        )
     ] == [
         {
             "id": CATEGORY_GROUP_ID_1,
@@ -321,19 +334,18 @@ async def test_insert_category_group_without_categories(con):
             "plan_id": PLAN_ID_1,
         },
     ]
-    assert not await fetchall(con, "SELECT * FROM categories")
+    assert not await fetchall(context.con, "SELECT * FROM categories")
 
 
-@pytest.mark.usefixtures(con.__name__)
 @pytest.mark.asyncio
-async def test_insert_payees(con):
-    await insert_payees(con, PLAN_ID_1, [])
-    assert not await fetchall(con, "SELECT * FROM payees")
+async def test_insert_payees(context):
+    await insert_payees(context, PLAN_ID_1, [])
+    assert not await fetchall(context.con, "SELECT * FROM payees")
 
-    await insert_payees(con, PLAN_ID_1, PAYEES)
+    await insert_payees(context, PLAN_ID_1, PAYEES)
     assert [
         strip_nones(d)
-        for d in await fetchall(con, "SELECT * FROM payees ORDER BY name")
+        for d in await fetchall(context.con, "SELECT * FROM payees ORDER BY name")
     ] == [
         {
             "id": PAYEE_ID_1,
@@ -348,18 +360,17 @@ async def test_insert_payees(con):
     ]
 
 
-@pytest.mark.usefixtures(con.__name__)
 @pytest.mark.asyncio
-async def test_insert_transactions(con):
-    await insert_transactions(con, PLAN_ID_1, [])
-    assert not await fetchall(con, "SELECT * FROM transactions")
-    assert not await fetchall(con, "SELECT * FROM subtransactions")
+async def test_insert_transactions(context):
+    await insert_transactions(context, PLAN_ID_1, [])
+    assert not await fetchall(context.con, "SELECT * FROM transactions")
+    assert not await fetchall(context.con, "SELECT * FROM subtransactions")
 
-    await insert_category_groups(con, PLAN_ID_1, CATEGORY_GROUPS)
-    await insert_transactions(con, PLAN_ID_1, TRANSACTIONS)
+    await insert_category_groups(context, PLAN_ID_1, CATEGORY_GROUPS)
+    await insert_transactions(context, PLAN_ID_1, TRANSACTIONS)
     assert [
         strip_nones(d)
-        for d in await fetchall(con, "SELECT * FROM transactions ORDER BY date")
+        for d in await fetchall(context.con, "SELECT * FROM transactions ORDER BY date")
     ] == [
         {
             "id": TRANSACTION_ID_1,
@@ -401,7 +412,9 @@ async def test_insert_transactions(con):
 
     assert [
         strip_nones(d)
-        for d in await fetchall(con, "SELECT * FROM subtransactions ORDER BY amount")
+        for d in await fetchall(
+            context.con, "SELECT * FROM subtransactions ORDER BY amount"
+        )
     ] == [
         {
             "id": SUBTRANSACTION_ID_1,
@@ -429,7 +442,9 @@ async def test_insert_transactions(con):
 
     assert [
         strip_nones(d)
-        for d in await fetchall(con, "SELECT * FROM flat_transactions ORDER BY amount")
+        for d in await fetchall(
+            context.con, "SELECT * FROM flat_transactions ORDER BY amount"
+        )
     ] == [
         {
             "transaction_id": TRANSACTION_ID_1,
@@ -462,19 +477,18 @@ async def test_insert_transactions(con):
     ]
 
 
-@pytest.mark.usefixtures(con.__name__)
 @pytest.mark.asyncio
-async def test_insert_scheduled_transactions(con):
-    await insert_scheduled_transactions(con, PLAN_ID_1, [])
-    assert not await fetchall(con, "SELECT * FROM scheduled_transactions")
-    assert not await fetchall(con, "SELECT * FROM scheduled_subtransactions")
+async def test_insert_scheduled_transactions(context):
+    await insert_scheduled_transactions(context, PLAN_ID_1, [])
+    assert not await fetchall(context.con, "SELECT * FROM scheduled_transactions")
+    assert not await fetchall(context.con, "SELECT * FROM scheduled_subtransactions")
 
-    await insert_category_groups(con, PLAN_ID_1, CATEGORY_GROUPS)
-    await insert_scheduled_transactions(con, PLAN_ID_1, SCHEDULED_TRANSACTIONS)
+    await insert_category_groups(context, PLAN_ID_1, CATEGORY_GROUPS)
+    await insert_scheduled_transactions(context, PLAN_ID_1, SCHEDULED_TRANSACTIONS)
     assert [
         strip_nones(d)
         for d in await fetchall(
-            con, "SELECT * FROM scheduled_transactions ORDER BY amount"
+            context.con, "SELECT * FROM scheduled_transactions ORDER BY amount"
         )
     ] == [
         {
@@ -515,7 +529,7 @@ async def test_insert_scheduled_transactions(con):
     assert [
         strip_nones(d)
         for d in await fetchall(
-            con, "SELECT * FROM scheduled_subtransactions ORDER BY amount"
+            context.con, "SELECT * FROM scheduled_subtransactions ORDER BY amount"
         )
     ] == [
         {
@@ -545,7 +559,7 @@ async def test_insert_scheduled_transactions(con):
     assert [
         strip_nones(d)
         for d in await fetchall(
-            con, "SELECT * FROM scheduled_flat_transactions ORDER BY amount"
+            context.con, "SELECT * FROM scheduled_flat_transactions ORDER BY amount"
         )
     ] == [
         {
@@ -594,14 +608,13 @@ async def test_insert_scheduled_transactions(con):
 
 @pytest.mark.asyncio
 @pytest.mark.usefixtures(mock_aioresponses.__name__)
-async def test_progress_ynab_client_ok(mock_aioresponses):
+async def test_progress_ynab_client_ok(context, mock_aioresponses):
     expected = {"example": [{"id": 1, "value": 2}, {"id": 3, "value": 4}]}
     mock_aioresponses.get(EXAMPLE_ENDPOINT_RE, body=json.dumps({"data": expected}))
 
-    with tldm(disable=True) as pbar:
-        async with aiohttp.ClientSession(loop=asyncio.get_event_loop()) as session:
-            pyc = ProgressYnabClient(YnabClient(TOKEN, session), pbar)
-            entries = await pyc("example")
+    task_id = context.progress.add_task("Example", total=1)
+    pyc = ProgressYnabClient(YnabClient(TOKEN, context.session), context, task_id)
+    entries = await pyc("example")
 
     assert entries == expected
 
@@ -722,7 +735,7 @@ async def test_sync_no_data(tmp_path, mock_aioresponses):
     # create the db and tables to exercise all code branches
     db = tmp_path / "db.sqlite"
     async with aiosqlite.connect(db) as con:
-        await con.executescript(contents("create-relations.sql"))
+        await con.executescript(await contents("create-relations.sql"))
 
     await sync(TOKEN, db, False)
 
@@ -766,7 +779,7 @@ async def test_sync_no_data_quiet(tmp_path, mock_aioresponses, capsys):
 
     db = tmp_path / "db.sqlite"
     async with aiosqlite.connect(db) as con:
-        await con.executescript(contents("create-relations.sql"))
+        await con.executescript(await contents("create-relations.sql"))
 
     await sync(TOKEN, db, False, quiet=True)