ynab-cli 0.3.0__py3-none-any.whl

ynab_cli/host/click/commands/payees.py

@@ -0,0 +1,157 @@
+import asyncio
+
+import click
+from rich.table import Table
+
+from ynab_cli.adapters.rich import io
+from ynab_cli.domain.settings import Settings
+from ynab_cli.domain.use_cases import payees as use_cases
+from ynab_cli.host.click.commands.rich.progress_table import ProgressTable
+from ynab_cli.host.constants import CONTEXT_KEY_SETTINGS
+
+
+async def _normalize_names(settings: Settings) -> None:
+    params: use_cases.NormalizeNamesParams = {}
+
+    table = Table(title="Normalized Payees")
+    table.add_column("Payee Id")
+    table.add_column("Payee Name")
+    table.add_column("Normalized Name")
+
+    console = None
+    with ProgressTable(table) as progress:
+        console = progress.console
+
+        task_id = progress.add_task("Normalizing payee names...")
+        async for payee, normalized_name in use_cases.normalize_names(settings, io.RichIO((progress, task_id)), params):
+            table.add_row(
+                str(payee.id),
+                payee.name,
+                normalized_name,
+            )
+
+    if console:
+        console.print(table)
+
+
+async def _list_duplicates(settings: Settings) -> None:
+    params: use_cases.ListDuplicatesParams = {}
+
+    table = Table(title="Duplicate Payees")
+    table.add_column("Payee Id")
+    table.add_column("Payee Name")
+    table.add_column("Duplicate Payee Id")
+    table.add_column("Duplicate Payee Name")
+
+    console = None
+    with ProgressTable(table) as progress:
+        console = progress.console
+
+        task_id = progress.add_task("Loading duplicate payees...")
+        async for payee, duplicate_payee in use_cases.list_duplicates(settings, io.RichIO((progress, task_id)), params):
+            table.add_row(
+                str(payee.id),
+                payee.name,
+                str(duplicate_payee.id),
+                duplicate_payee.name,
+            )
+
+    if console:
+        console.print(table)
+
+
+async def _list_unused(settings: Settings, prefix_unused: bool) -> None:
+    params: use_cases.ListUnusedParams = {
+        "prefix_unused": prefix_unused,
+    }
+
+    table = Table(title="Unused Payees")
+    table.add_column("Payee Id")
+    table.add_column("Payee Name")
+
+    console = None
+    with ProgressTable(table) as progress:
+        console = progress.console
+
+        task_id = progress.add_task("Loading unused payees...")
+        async for payee in use_cases.list_unused(settings, io.RichIO((progress, task_id)), params):
+            table.add_row(
+                str(payee.id),
+                payee.name,
+            )
+
+    if console:
+        console.print(table)
+
+
+async def _list_all(settings: Settings) -> None:
+    params: use_cases.ListAllParams = {}
+
+    table = Table(title="All Payees")
+    table.add_column("Payee Id")
+    table.add_column("Payee Name")
+
+    console = None
+    with ProgressTable(table) as progress:
+        console = progress.console
+
+        task_id = progress.add_task("Loading all payees...")
+        async for payee in use_cases.list_all(settings, io.RichIO((progress, task_id)), params):
+            table.add_row(
+                str(payee.id),
+                payee.name,
+            )
+
+    if console:
+        console.print(table)
+
+
+@click.command()
+@click.pass_context
+def normalize_names(ctx: click.Context) -> None:
+    """Normalize payee names in the YNAB budget."""
+
+    ctx.ensure_object(dict)
+    asyncio.run(_normalize_names(ctx.obj.get(CONTEXT_KEY_SETTINGS, Settings())))
+
+
+@click.command()
+@click.pass_context
+def list_duplicates(ctx: click.Context) -> None:
+    """List duplicate payees in the YNAB budget."""
+
+    ctx.ensure_object(dict)
+    asyncio.run(_list_duplicates(ctx.obj.get(CONTEXT_KEY_SETTINGS, Settings())))
+
+
+@click.command()
+@click.option("--prefix-unused", is_flag=True, default=False, help="Add a prefix to the unused payee names.")
+@click.pass_context
+def list_unused(ctx: click.Context, prefix_unused: bool) -> None:
+    """List unused payees in the YNAB budget."""
+
+    ctx.ensure_object(dict)
+    asyncio.run(_list_unused(ctx.obj.get(CONTEXT_KEY_SETTINGS, Settings()), prefix_unused))
+
+
+@click.command()
+@click.pass_context
+def list_all(ctx: click.Context) -> None:
+    """List all payees in the YNAB budget."""
+
+    ctx.ensure_object(dict)
+    asyncio.run(_list_all(ctx.obj.get(CONTEXT_KEY_SETTINGS, Settings())))
+
+
+@click.group()
+@click.pass_context
+def payees(ctx: click.Context) -> None:
+    """Manage payees in the YNAB budget."""
+
+    ctx.ensure_object(dict)
+
+
+payees.add_command(normalize_names)
+payees.add_command(list_duplicates)
+payees.add_command(list_unused)
+payees.add_command(list_all)

ynab_cli/host/click/commands/rich/progress_table.py

@@ -0,0 +1,37 @@
+from typing import Any
+
+from rich import console as rich_console
+from rich import progress as rich_progress
+from rich import table as rich_table
+from typing_extensions import override
+
+
+class ProgressTable(rich_progress.Progress):
+    @override
+    def __init__(
+        self,
+        table: rich_table.Table,
+        *columns: str | rich_progress.ProgressColumn,
+        auto_refresh: bool = True,
+        transient: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        self._render_table = False
+        self._table = table
+        super().__init__(*columns, auto_refresh=auto_refresh, transient=transient, **kwargs)
+
+    @override
+    def get_renderable(self) -> rich_console.RenderableType:
+        if self._render_table and self.live.is_started:
+            return rich_console.Group(*self.get_renderables(), self._table)
+        return super().get_renderable()
+
+    @override
+    def start(self) -> None:
+        self._render_table = True
+        return super().start()
+
+    @override
+    def stop(self) -> None:
+        self._render_table = False
+        return super().stop()

ynab_cli/host/click/commands/transactions.py

@@ -0,0 +1,76 @@
+import asyncio
+import json
+from typing import IO, Any
+
+import click
+from rich.table import Table
+
+from ynab_cli.adapters.rich import io
+from ynab_cli.domain.models import rules
+from ynab_cli.domain.settings import Settings
+from ynab_cli.domain.use_cases import transactions as use_cases
+from ynab_cli.host.click.commands.rich.progress_table import ProgressTable
+from ynab_cli.host.constants import CONTEXT_KEY_SETTINGS
+
+
+async def _apply_rules(settings: Settings, transaction_rules: rules.TransactionRules) -> None:
+    params: use_cases.ApplyRulesParams = {
+        "transaction_rules": transaction_rules,
+    }
+
+    table = Table(title="Updated Transactions")
+    table.add_column("Transaction Id")
+    table.add_column("Transaction Date")
+    table.add_column("Transaction Payee")
+    table.add_column("Transaction Category")
+    table.add_column("Transaction Memo")
+    table.add_column("Transaction Amount")
+    table.add_column("Transaction Changes")
+
+    console = None
+    with ProgressTable(table) as progress:
+        console = progress.console
+
+        task_id = progress.add_task("Updating transactions...")
+        async for transaction, save_transaction in use_cases.apply_rules(
+            settings, io.RichIO((progress, task_id)), params
+        ):
+            table.add_row(
+                transaction.id,
+                transaction.date.isoformat(),
+                str(transaction.payee_name),
+                str(transaction.category_name),
+                str(transaction.memo),
+                str(transaction.amount),
+                str(save_transaction.to_dict()),
+            )
+
+    if console:
+        console.print(table)
+
+
+@click.command()
+@click.argument("rules-file", type=click.File())
+@click.pass_context
+def apply_rules(ctx: click.Context, rules_file: IO[Any]) -> None:
+    """Apply transaction rules from a JSON RULES_FILE to transactions in the YNAB budget.
+
+    RULES_FILE should be a JSON file containing transaction rules.
+    """
+
+    ctx.ensure_object(dict)
+
+    transaction_rules = rules.TransactionRules.from_dict(json.load(rules_file))
+
+    asyncio.run(_apply_rules(ctx.obj.get(CONTEXT_KEY_SETTINGS, Settings()), transaction_rules))
+
+
+@click.group()
+@click.pass_context
+def transactions(ctx: click.Context) -> None:
+    """Manage transactions in the YNAB budget."""
+
+    ctx.ensure_object(dict)
+
+
+transactions.add_command(apply_rules)

ynab_cli/host/constants.py

@@ -0,0 +1,3 @@
+ENV_PREFIX = "YNAB_CLI"
+
+CONTEXT_KEY_SETTINGS = "SETTINGS"

ynab_cli/host/textual/app.py

@@ -0,0 +1,98 @@
+from typing import Any, ClassVar
+
+from textual.app import App as _App
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Horizontal, Vertical
+from textual.reactive import reactive
+from textual.widgets import Checkbox, Footer, Header, Input, Label, TabbedContent, TabPane
+from typing_extensions import override
+
+from ynab_cli.domain.settings import Settings
+from ynab_cli.host.textual.widgets import RunnableWidget
+from ynab_cli.host.textual.widgets.categories import CategoriesTabs
+from ynab_cli.host.textual.widgets.payees import PayeesTabs
+from ynab_cli.host.textual.widgets.transactions import TransactionsTabs
+
+
+class CommandTabs(RunnableWidget):
+    @override
+    def compose(self) -> ComposeResult:
+        with TabbedContent():
+            with TabPane("Transactions", id="transactions"):
+                yield TransactionsTabs().data_bind(settings=CommandTabs.settings)
+            with TabPane("Categories", id="categories"):
+                yield CategoriesTabs().data_bind(settings=CommandTabs.settings)
+            with TabPane("Payees", id="payees"):
+                yield PayeesTabs().data_bind(settings=CommandTabs.settings)
+
+    @override
+    async def run_command(self) -> None:
+        tabbed_content = self.query_one(TabbedContent)
+        if tabbed_content.active_pane:
+            if tabbed_content.active_pane.id == "transactions":
+                await self.query_one(TransactionsTabs).run_command()
+            elif tabbed_content.active_pane.id == "categories":
+                await self.query_one(CategoriesTabs).run_command()
+            elif tabbed_content.active_pane.id == "payees":
+                await self.query_one(PayeesTabs).run_command()
+
+
+class App(_App[None]):
+    TITLE = "YNAB CLI"
+    CSS_PATH: ClassVar[str] = "app.tcss"
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("ctrl+c", "quit", "Quit", show=True, priority=True),
+        Binding("r", "run", "Run", show=True, priority=False),
+    ]
+
+    settings: reactive[Settings] = reactive(Settings())
+
+    def __init__(
+        self,
+        settings: Settings,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.settings = settings
+
+    @override
+    def compose(self) -> ComposeResult:
+        yield Header(id="header")
+        with Vertical(id="settings"):
+            with Horizontal():
+                with Vertical():
+                    yield Label("Access Token")
+                    yield Input(self.settings.ynab.access_token, placeholder="Access Token", id="access_token")
+                with Vertical():
+                    yield Label("Budget Id")
+                    yield Input(self.settings.ynab.budget_id, placeholder="Budget Id", id="budget_id")
+            with Horizontal():
+                yield Checkbox("Debug", self.settings.debug, id="debug")
+                yield Checkbox("Dry Run", self.settings.dry_run, id="dry_run")
+
+        with Vertical(id="main"):
+            yield CommandTabs().data_bind(settings=App.settings)
+        yield Footer(id="footer")
+
+    def on_mount(self) -> None:
+        self.query_one(CommandTabs).query_one(TabbedContent).focus()
+
+    async def action_run(self) -> None:
+        command_tabs = self.query_one(CommandTabs)
+        await command_tabs.run_command()
+
+    async def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id == "access_token":
+            self.settings.ynab.access_token = event.value
+        elif event.input.id == "budget_id":
+            self.settings.ynab.budget_id = event.value
+        self.mutate_reactive(App.settings)
+
+    async def on_checkbox_changed(self, event: Checkbox.Changed) -> None:
+        if event.checkbox.id == "debug":
+            self.settings.debug = event.value
+        elif event.checkbox.id == "dry_run":
+            self.settings.dry_run = event.value
+        self.mutate_reactive(App.settings)

ynab_cli/host/textual/app.tcss

@@ -0,0 +1,47 @@
+Screen {
+    Vertical#settings {
+        margin-top: 1;
+        height: auto;
+        border: solid $primary;
+
+        Horizontal {
+            height: auto;
+
+            Vertical {
+                height: auto;
+
+                Input {
+                    border: solid $secondary;
+                }
+            }
+        }
+    }
+    Vertical#main {
+        margin-top: 1;
+        margin-bottom: 1;
+        
+        CommandTabs {
+            height: 1fr;
+            TransactionsTabs, CategoriesTabs, PayeesTabs {
+                padding-top: 1;
+                border: solid $primary;
+                height: 1fr;
+
+                DataTable {
+                    border: solid $secondary;
+                    height: 3fr;
+                }
+                Log {
+                    border: solid $secondary;
+                    height: 1fr;
+                }
+            }
+        }
+    }
+}
+
+IOScreen {
+    Label {
+        margin: 1;
+    }
+}

ynab_cli/host/textual/cli.py

@@ -0,0 +1,42 @@
+import asyncio
+import logging
+
+import click
+from textual.logging import TextualHandler
+
+from ynab_cli.domain.settings import Settings, YnabSettings
+from ynab_cli.host.constants import CONTEXT_KEY_SETTINGS, ENV_PREFIX
+from ynab_cli.host.textual.app import App
+
+
+async def _tui(settings: Settings) -> None:
+    app = App(settings)
+    await app.run_async()
+
+
+@click.command()
+@click.option(
+    "--access-token", default="", envvar=f"{ENV_PREFIX}_ACCESS_TOKEN", show_envvar=True, help="YNAB API access token."
+)
+@click.option("--budget-id", default="", envvar=f"{ENV_PREFIX}_BUDGET_ID", show_envvar=True, help="YNAB budget ID.")
+@click.pass_context
+def tui(
+    ctx: click.Context,
+    access_token: str,
+    budget_id: str,
+) -> None:
+    """Run the Textual User Interface (TUI) for YNAB CLI."""
+
+    ctx.ensure_object(dict)
+    settings: Settings = ctx.obj.get(CONTEXT_KEY_SETTINGS, Settings())
+    settings.ynab = YnabSettings(access_token=access_token, budget_id=budget_id)
+    ctx.obj[CONTEXT_KEY_SETTINGS] = settings
+
+    logging.basicConfig(
+        level="DEBUG" if settings.debug else "WARNING",  # NOTSET, DEBUG, INFO, WARNING, ERROR, CRITICAL
+        format="%(message)s",
+        datefmt="[%X]",
+        handlers=[TextualHandler()],
+    )
+
+    asyncio.run(_tui(ctx.obj[CONTEXT_KEY_SETTINGS]))

ynab_cli/host/textual/widgets/__init__.py

@@ -0,0 +1,58 @@
+import logging
+from typing import Generic, TypeVar
+
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.message import Message
+from textual.reactive import var
+from textual.widgets import DataTable, Log, ProgressBar, Static
+from textual.worker import Worker, WorkerState
+from typing_extensions import override
+
+from ynab_cli.domain.settings import Settings
+
+log = logging.getLogger(__name__)
+
+
+PARAMS = TypeVar("PARAMS")
+
+
+class RunnableWidget(Static):
+    settings: var[Settings] = var(Settings())
+
+    async def run_command(self) -> None:
+        raise NotImplementedError
+
+
+class BaseCommand(RunnableWidget, Generic[PARAMS]):
+    class CommandCompleted(Message):
+        def __init__(self, worker_state: WorkerState) -> None:
+            super().__init__()
+            self.worker_state = worker_state
+
+        pass
+
+    @override
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield ProgressBar(total=0)
+            yield DataTable()
+            yield Log()
+
+    @work(exclusive=True)
+    async def _run_command_worker(self, use_case_params: PARAMS) -> None:
+        self.query_one(ProgressBar).update(total=None, progress=0)
+        self.query_one(DataTable).clear()
+        self.query_one(Log).write_line("Running command...")
+        await self._run_command(use_case_params)
+
+    async def _run_command(self, use_case_params: PARAMS) -> None:
+        raise NotImplementedError
+
+    def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
+        log = self.query_one(Log)
+        log.write_line(f"Worker state changed: {event.state}")
+
+        if event.state not in (WorkerState.PENDING, WorkerState.RUNNING):
+            self.post_message(self.CommandCompleted(event.state))

ynab_cli/host/textual/widgets/categories.py

@@ -0,0 +1,90 @@
+from textual.app import ComposeResult
+from textual.widgets import DataTable, Log, ProgressBar, TabbedContent, TabPane
+from typing_extensions import override
+
+from ynab_cli.adapters.textual.io import TextualWorkerIO
+from ynab_cli.domain.use_cases import categories as use_cases
+from ynab_cli.host.textual.widgets import BaseCommand, RunnableWidget
+
+
+class CategoriesTabs(RunnableWidget):
+    @override
+    def compose(self) -> ComposeResult:
+        with TabbedContent():
+            with TabPane("Unused", id="unused"):
+                yield CategoriesListUnusedCommand().data_bind(settings=CategoriesTabs.settings)
+            with TabPane("All", id="all"):
+                yield CategoriesListAllCommand().data_bind(settings=CategoriesTabs.settings)
+
+    @override
+    async def run_command(self) -> None:
+        tabbed_content = self.query_one(TabbedContent)
+        if tabbed_content.active_pane:
+            if tabbed_content.active_pane.id == "unused":
+                await self.query_one(CategoriesListUnusedCommand).run_command()
+            elif tabbed_content.active_pane.id == "all":
+                await self.query_one(CategoriesListAllCommand).run_command()
+
+
+class CategoriesListUnusedCommand(BaseCommand[use_cases.ListUnusedParams]):
+    def on_mount(self) -> None:
+        table = self.query_one(DataTable)
+        table.add_columns(
+            "Category Group Id",
+            "Category Group Name",
+            "Category Id",
+            "Category Name",
+        )
+
+    @override
+    async def run_command(self) -> None:
+        params: use_cases.ListUnusedParams = {}
+        self._run_command_worker(params)
+
+    @override
+    async def _run_command(self, use_case_params: use_cases.ListUnusedParams) -> None:
+        progress_bar = self.query_one(ProgressBar)
+        table = self.query_one(DataTable)
+        log = self.query_one(Log)
+
+        async for category in use_cases.list_unused(
+            self.settings, TextualWorkerIO(self.app, log, progress_bar), use_case_params
+        ):
+            table.add_row(
+                category.category_group_id,
+                category.category_group_name,
+                category.id,
+                category.name,
+            )
+
+
+class CategoriesListAllCommand(BaseCommand[use_cases.ListAllParams]):
+    def on_mount(self) -> None:
+        table = self.query_one(DataTable)
+        table.add_columns(
+            "Category Group Id",
+            "Category Group Name",
+            "Category Id",
+            "Category Name",
+        )
+
+    @override
+    async def run_command(self) -> None:
+        params: use_cases.ListAllParams = {}
+        self._run_command_worker(params)
+
+    @override
+    async def _run_command(self, use_case_params: use_cases.ListAllParams) -> None:
+        progress_bar = self.query_one(ProgressBar)
+        table = self.query_one(DataTable)
+        log = self.query_one(Log)
+
+        async for category in use_cases.list_all(
+            self.settings, TextualWorkerIO(self.app, log, progress_bar), use_case_params
+        ):
+            table.add_row(
+                category.category_group_id,
+                category.category_group_name,
+                category.id,
+                category.name,
+            )