dinary 1.2.2__tar.gz → 1.2.3__tar.gz

{dinary-1.2.2 → dinary-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dinary
-Version: 1.2.2
+Version: 1.2.3
 Summary: Server for [Dinary - your dinar diary](https://github.com/andgineer/dinary). Track expenses, scan receipts, analyze spending with AI
 Project-URL: Homepage, https://andgineer.github.io/dinary/
 Project-URL: Documentation, https://andgineer.github.io/dinary/

dinary-1.2.3/src/dinary/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.2.3"

{dinary-1.2.2 → dinary-1.2.3}/tasks/__init__.py

@@ -20,10 +20,10 @@ from .devtools.constants import ALLOWED_VERSION_TYPES
 from .devtools.dev import build_static, dev, pre, reqs, test, uv, ver_task_factory, version
 from .healthcheck import healthcheck
 from .imports.import_tasks import (
-    export_income_original,
     import_budget,
     import_budget_all,
     import_catalog,
+    import_extract_income,
     import_income,
     import_income_all,
     import_report_2d_3d,
@@ -48,11 +48,11 @@ __all__ = [
     "dev",
     "docs_task_factory",
     "healthcheck",
-    "export_income_original",
     "import_budget",
     "import_budget_all",
     "import_catalog",
     "import_config",
+    "import_extract_income",
     "import_income",
     "import_income_all",
     "import_report_2d_3d",

{dinary-1.2.2 → dinary-1.2.3}/tasks/imports/import_tasks.py

@@ -7,7 +7,7 @@ from datetime import datetime as _dt
 
 from invoke import task
 
-from tasks.imports import income_original_export
+from tasks.imports import income_extract
 from tasks.imports import report_2d_3d as _report_2d_3d_module
 from tasks.reports import verify_budget, verify_income
 from tasks.ssh_utils import remote_snapshot_cmd, ssh_capture_bytes, ssh_json, ssh_run
@@ -250,16 +250,16 @@ def verify_income_equivalence_all(c, json=False):  # noqa: A002
     sys.exit(verify_income.exit_code_for_batch(results))
 
 
-@task(name="export-income-original")
-def export_income_original(c, output=""):
-    """Export income from all sheets in original currency (RUB/RSD) to a JSON file.
+@task(name="import-extract-income")
+def import_extract_income(c, output=""):
+    """Extract individual income records from all sheets in original currency to JSON.
 
     Reads every registered income source from .deploy/import_sources.json and
-    writes a flat list of {year, month, amount, currency} entries to JSON.
-    Default output path: data/income_original.json. Override with --output.
+    writes one entry per sheet row with predicted income_month.
+    Default output path: data/income_extract.json. Override with --output.
     """
-    dest = Path(output) if output else income_original_export.DEFAULT_OUTPUT
-    count = income_original_export.export_to_file(dest)
+    dest = Path(output) if output else income_extract.DEFAULT_OUTPUT
+    count = income_extract.export_to_file(dest)
     print(f"Wrote {count} entries to {dest}")
 
 

dinary-1.2.2/tasks/imports/income_original_export.py → dinary-1.2.3/tasks/imports/income_extract.py

@@ -1,33 +1,36 @@
-"""Extract monthly income from Google Sheets in original currency (no EUR conversion).
+"""Extract individual income records from Google Sheets in original currency.
 
 Reads every registered income source from ``.deploy/import_sources.json``
-and aggregates amounts per (year, month) in the currency the sheet is
-denominated in — RUB for years up to mid-2022, RSD from mid-2022 onward
-(exact boundary is the ``transition_month`` in each year's ``IncomeLayout``).
+and returns one entry per sheet row. Amounts are NOT summed by month.
 
-The result is written as a JSON file with a flat list of entries:
+Each entry carries the raw payment date and a predicted ``income_month``:
+  - day <= 25 -> previous month  (salary paid at start of month for prior month)
+  - day > 25  -> current month   (late payment belonging to the same month)
+
+Output JSON:
 
 .. code-block:: json
 
     {
       "generated_at": "2026-05-31",
       "entries": [
-        {"year": 2019, "month": 1, "amount": "85000.00", "currency": "RUB"},
-        ...
+        {
+          "year": 2019, "month": 1, "day": 10,
+          "amount": "85000.00", "currency": "RUB",
+          "income_year": 2018, "income_month": 12
+        }
       ]
     }
 
-``inv export-income-original`` is the operator entry point. The module
-can also be run with ``uv run python -m tasks.imports.income_original_export``.
+``inv import-extract-income`` is the operator entry point.
+Can also be run with ``uv run python -m tasks.imports.income_extract``.
 """
 
 import argparse
 import json
 import logging
 import sys
-from collections import defaultdict
 from datetime import date
-from decimal import Decimal
 from pathlib import Path
 
 from dinary.adapters.sheets_client import get_sheet
@@ -38,38 +41,49 @@ from tasks.imports.income_import import (
     IncomeLayout,
     _cell,
     _parse_amount,
-    _parse_date,
+    _parse_full_date,
 )
 
 logger = logging.getLogger(__name__)
 
-DEFAULT_OUTPUT = Path("data/income_original.json")
+DEFAULT_OUTPUT = Path("data/income_extract.json")
+
+INCOME_MONTH_LATE_CUTOFF = 25
+
+
+def _predict_income_month(year: int, month: int, day: int) -> tuple[int, int]:
+    """Return (income_year, income_month) for a payment on the given date.
+
+    day <= 25 -> previous month; day > 25 -> current month.
+    """
+    if day > INCOME_MONTH_LATE_CUTOFF:
+        return year, month
+    return (year - 1, 12) if month == 1 else (year, month - 1)
 
 
-def aggregate_original_currency(
+def extract_income_records(
     year: int,
     spreadsheet_id: str,
     worksheet_name: str,
     layout: IncomeLayout,
-) -> dict[tuple[int, str], Decimal]:
-    """Read one Income/Balance worksheet; return ``{(month, currency): total}``.
+) -> list[dict]:
+    """Read one Income/Balance worksheet; return one dict per income row.
 
-    Does NOT convert to accounting currency. Each month carries exactly
-    one currency (the layout's ``currency`` before ``transition_month``,
-    ``transition_currency`` from that month onward).
+    Each row is a separate entry with raw payment date and predicted
+    income_year/income_month. No aggregation.
     """
     ss = get_sheet(spreadsheet_id)
     ws = ss.worksheet(worksheet_name)
     all_values = ws.get_all_values()
 
-    monthly: dict[tuple[int, str], Decimal] = defaultdict(Decimal)
+    records: list[dict] = []
 
     for row_idx in range(layout.header_rows, len(all_values)):
         row = all_values[row_idx]
-        parsed = _parse_date(_cell(row, layout.col_date))
+        parsed = _parse_full_date(_cell(row, layout.col_date))
         if parsed is None:
             continue
-        row_year, month = parsed
+        row_year, month, day = parsed
         if row_year != year:
             continue
         if not 1 <= month <= MONTHS_IN_YEAR:
@@ -87,18 +101,24 @@ def aggregate_original_currency(
         ):
             currency = layout.transition_currency
 
-        monthly[(month, currency)] += amount
+        income_year, income_month = _predict_income_month(year, month, day)
+        records.append(
+            {
+                "year": year,
+                "month": month,
+                "day": day,
+                "amount": format(amount, "f"),
+                "currency": currency,
+                "income_year": income_year,
+                "income_month": income_month,
+            },
+        )
 
-    return dict(monthly)
+    return records
 
 
 def extract_all_years() -> list[dict]:
-    """Return a flat list of ``{year, month, amount, currency}`` dicts.
-
-    Iterates every import source that has an income worksheet. Years with
-    no registered source or no income worksheet are silently skipped.
-    Amounts are ``str`` (canonical decimal notation) to avoid float rounding.
-    """
+    """Return a flat list of individual income records across all registered years."""
     sources = read_import_sources()
     entries: list[dict] = []
 
@@ -122,7 +142,7 @@ def extract_all_years() -> list[dict]:
         )
 
         try:
-            monthly = aggregate_original_currency(
+            records = extract_income_records(
                 source.year,
                 source.spreadsheet_id,
                 source.income_worksheet_name,
@@ -132,21 +152,13 @@ def extract_all_years() -> list[dict]:
             logger.exception("Failed to read year %d — skipping", source.year)
             continue
 
-        for (month, currency), total in sorted(monthly.items()):
-            entries.append(
-                {
-                    "year": source.year,
-                    "month": month,
-                    "amount": format(total, "f"),
-                    "currency": currency,
-                },
-            )
+        entries.extend(sorted(records, key=lambda r: (r["month"], r["day"])))
 
     return entries
 
 
 def export_to_file(output: Path) -> int:
-    """Extract all income in original currency and write to ``output``.
+    """Extract all income records and write to ``output``.
 
     Returns the number of entries written. Raises on I/O errors.
     """
@@ -162,7 +174,9 @@ def export_to_file(output: Path) -> int:
 
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
-        description="Extract income from all sheets in original currency to JSON.",
+        description=(
+            "Extract individual income records from all sheets in original currency to JSON."
+        ),
     )
     parser.add_argument(
         "--output",

{dinary-1.2.2 → dinary-1.2.3}/tasks/imports/income_import.py

@@ -106,6 +106,38 @@ def _parse_date(raw: str) -> tuple[int, int] | None:
     return None
 
 
+def _parse_full_date(raw: str) -> tuple[int, int, int] | None:
+    """Extract (year, month, day) from a date string. Returns None if unparseable."""
+    if not raw:
+        return None
+    m = _LOOSE_DATE_RE.match(raw)
+    if m:
+        return int(m.group(1)), int(m.group(2)), int(m.group(3))
+    for fmt in _DATE_FORMATS:
+        try:
+            dt = datetime.strptime(raw, fmt)  # noqa: DTZ007
+            return dt.year, dt.month, dt.day
+        except ValueError:
+            continue
+    return None
+
+
+def _parse_full_date(raw: str) -> tuple[int, int, int] | None:
+    """Extract (year, month, day) from a date string. Returns None if unparseable."""
+    if not raw:
+        return None
+    m = _LOOSE_DATE_RE.match(raw)
+    if m:
+        return int(m.group(1)), int(m.group(2)), int(m.group(3))
+    for fmt in _DATE_FORMATS:
+        try:
+            dt = datetime.strptime(raw, fmt)  # noqa: DTZ007
+            return dt.year, dt.month, dt.day
+        except ValueError:
+            continue
+    return None
+
+
 def _convert_to_accounting_from_cache(
     amount: Decimal,
     currency: str,

dinary-1.2.3/tests/imports/test_income_extract.py

@@ -0,0 +1,330 @@
+"""Tests for income_extract: individual-record extraction from sheets."""
+
+import json
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+import tasks.imports.income_extract as _mod
+from dinary.config import ImportSourceRow
+from tasks.imports.income_extract import (
+    _predict_income_month,
+    export_to_file,
+    extract_all_years,
+    extract_income_records,
+)
+from tasks.imports.income_import import INCOME_LAYOUTS
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _ws(rows: list[list[str]]) -> MagicMock:
+    ws = MagicMock()
+    ws.get_all_values.return_value = rows
+    return ws
+
+
+def _ss(ws: MagicMock) -> MagicMock:
+    ss = MagicMock()
+    ss.worksheet.return_value = ws
+    return ss
+
+
+# ---------------------------------------------------------------------------
+# _predict_income_month
+# ---------------------------------------------------------------------------
+
+
+class TestPredictIncomeMonth:
+    def test_day_25_is_prev_month(self):
+        assert _predict_income_month(2024, 3, 25) == (2024, 2)
+
+    def test_day_1_is_prev_month(self):
+        assert _predict_income_month(2024, 5, 1) == (2024, 4)
+
+    def test_day_26_is_current_month(self):
+        assert _predict_income_month(2024, 3, 26) == (2024, 3)
+
+    def test_day_31_is_current_month(self):
+        assert _predict_income_month(2024, 1, 31) == (2024, 1)
+
+    def test_january_day_le_25_wraps_to_december_prev_year(self):
+        assert _predict_income_month(2024, 1, 10) == (2023, 12)
+
+    def test_january_day_26_stays_january(self):
+        assert _predict_income_month(2024, 1, 26) == (2024, 1)
+
+
+# ---------------------------------------------------------------------------
+# extract_income_records
+# ---------------------------------------------------------------------------
+
+
+class TestExtractIncomeRecords:
+    def test_returns_separate_record_per_row(self):
+        layout = INCOME_LAYOUTS["balance_rub"]
+        rows = [
+            ["date", "amount"],
+            ["2019-01-15", "50000"],
+            ["2019-01-20", "35000"],
+        ]
+        ss = _ss(_ws(rows))
+        with patch("tasks.imports.income_extract.get_sheet", return_value=ss):
+            result = extract_income_records(2019, "sid", "Income", layout)
+
+        assert len(result) == 2
+        assert result[0]["amount"] == "50000"
+        assert result[1]["amount"] == "35000"
+
+    def test_record_fields(self):
+        layout = INCOME_LAYOUTS["balance_rub"]
+        rows = [["date", "amount"], ["2019-03-10", "90000"]]
+        ss = _ss(_ws(rows))
+        with patch("tasks.imports.income_extract.get_sheet", return_value=ss):
+            result = extract_income_records(2019, "sid", "Income", layout)
+
+        rec = result[0]
+        assert rec["year"] == 2019
+        assert rec["month"] == 3
+        assert rec["day"] == 10
+        assert rec["currency"] == "RUB"
+        assert rec["income_year"] == 2019
+        assert rec["income_month"] == 2  # day 10 <= 25 -> prev month
+
+    def test_day_26_maps_to_current_month(self):
+        layout = INCOME_LAYOUTS["balance_rsd"]
+        rows = [["date", "amount"], ["2023-05-26", "120000"]]
+        ss = _ss(_ws(rows))
+        with patch("tasks.imports.income_extract.get_sheet", return_value=ss):
+            result = extract_income_records(2023, "sid", "Income", layout)
+
+        assert result[0]["income_month"] == 5
+        assert result[0]["income_year"] == 2023
+
+    def test_transition_layout_currency(self):
+        layout = INCOME_LAYOUTS["balance_rub_rsd"]
+        rows = [
+            ["date", "amount"],
+            ["2022-07-10", "60000"],
+            ["2022-08-10", "120000"],
+        ]
+        ss = _ss(_ws(rows))
+        with patch("tasks.imports.income_extract.get_sheet", return_value=ss):
+            result = extract_income_records(2022, "sid", "Balance", layout)
+
+        assert result[0]["currency"] == "RUB"
+        assert result[1]["currency"] == "RSD"
+
+    def test_skips_rows_from_other_years(self):
+        layout = INCOME_LAYOUTS["balance_rub"]
+        rows = [
+            ["date", "amount"],
+            ["2019-06-01", "10000"],
+            ["2020-06-01", "99999"],
+        ]
+        ss = _ss(_ws(rows))
+        with patch("tasks.imports.income_extract.get_sheet", return_value=ss):
+            result = extract_income_records(2019, "sid", "Balance", layout)
+
+        assert len(result) == 1
+        assert result[0]["month"] == 6
+
+    def test_skips_blank_and_zero_amounts(self):
+        layout = INCOME_LAYOUTS["balance_rsd"]
+        rows = [
+            ["date", "amount"],
+            ["2023-03-01", ""],
+            ["2023-03-05", "0"],
+            ["2023-03-10", "75000"],
+        ]
+        ss = _ss(_ws(rows))
+        with patch("tasks.imports.income_extract.get_sheet", return_value=ss):
+            result = extract_income_records(2023, "sid", "Income", layout)
+
+        assert len(result) == 1
+        assert result[0]["amount"] == "75000"
+
+    def test_skips_unparseable_dates(self):
+        layout = INCOME_LAYOUTS["balance_rsd"]
+        rows = [
+            ["date", "amount"],
+            ["not-a-date", "50000"],
+            ["2023-04-01", "50000"],
+        ]
+        ss = _ss(_ws(rows))
+        with patch("tasks.imports.income_extract.get_sheet", return_value=ss):
+            result = extract_income_records(2023, "sid", "Income", layout)
+
+        assert len(result) == 1
+        assert result[0]["month"] == 4
+
+
+# ---------------------------------------------------------------------------
+# extract_all_years
+# ---------------------------------------------------------------------------
+
+
+class TestExtractAllYears:
+    @pytest.fixture(autouse=True)
+    def _stub_sources(self, monkeypatch):
+        sources = [
+            ImportSourceRow(
+                year=2021,
+                spreadsheet_id="sid21",
+                worksheet_name="Budget",
+                income_worksheet_name="Balance",
+                income_layout_key="balance_rub",
+            ),
+            ImportSourceRow(
+                year=2023,
+                spreadsheet_id="sid23",
+                worksheet_name="Budget",
+                income_worksheet_name="Income",
+                income_layout_key="balance_rsd",
+            ),
+            ImportSourceRow(
+                year=2025,
+                spreadsheet_id="sid25",
+                worksheet_name="Budget",
+                income_worksheet_name="",
+                income_layout_key="",
+            ),
+        ]
+        monkeypatch.setattr(_mod, "read_import_sources", lambda: list(sources))
+
+    def _make_get_sheet(self, data_by_sid: dict[str, list[list[str]]]):
+        def _get_sheet(spreadsheet_id: str):
+            return _ss(_ws(data_by_sid[spreadsheet_id]))
+
+        return _get_sheet
+
+    def test_returns_entries_for_years_with_income(self):
+        data = {
+            "sid21": [["date", "amount"], ["2021-05-10", "90000"]],
+            "sid23": [["date", "amount"], ["2023-06-10", "150000"]],
+        }
+        with patch(
+            "tasks.imports.income_extract.get_sheet", side_effect=self._make_get_sheet(data)
+        ):
+            entries = extract_all_years()
+
+        assert len(entries) == 2
+        years = {e["year"] for e in entries}
+        assert years == {2021, 2023}
+
+    def test_skips_year_without_income_worksheet(self):
+        data = {
+            "sid21": [["date", "amount"], ["2021-01-01", "50000"]],
+            "sid23": [["date", "amount"], ["2023-01-01", "100000"]],
+        }
+        with patch(
+            "tasks.imports.income_extract.get_sheet", side_effect=self._make_get_sheet(data)
+        ):
+            entries = extract_all_years()
+
+        assert all(e["year"] != 2025 for e in entries)
+
+    def test_sheet_failure_skips_year_continues(self):
+        call_count = 0
+
+        def _get_sheet(spreadsheet_id: str):
+            nonlocal call_count
+            call_count += 1
+            if spreadsheet_id == "sid21":
+                raise OSError("network error")
+            return _ss(_ws([["date", "amount"], ["2023-03-01", "120000"]]))
+
+        with patch("tasks.imports.income_extract.get_sheet", side_effect=_get_sheet):
+            entries = extract_all_years()
+
+        assert call_count == 2
+        assert all(e["year"] != 2021 for e in entries)
+        assert any(e["year"] == 2023 for e in entries)
+
+    def test_entries_sorted_by_month_then_day_within_year(self):
+        data = {
+            "sid21": [
+                ["date", "amount"],
+                ["2021-03-15", "1000"],
+                ["2021-01-20", "2000"],
+                ["2021-01-05", "3000"],
+            ],
+            "sid23": [["date", "amount"], ["2023-02-01", "4000"]],
+        }
+        with patch(
+            "tasks.imports.income_extract.get_sheet", side_effect=self._make_get_sheet(data)
+        ):
+            entries = extract_all_years()
+
+        yr21 = [e for e in entries if e["year"] == 2021]
+        assert yr21[0]["month"] == 1
+        assert yr21[0]["day"] == 5
+        assert yr21[1]["month"] == 1
+        assert yr21[1]["day"] == 20
+        assert yr21[2]["month"] == 3
+
+
+# ---------------------------------------------------------------------------
+# export_to_file
+# ---------------------------------------------------------------------------
+
+
+class TestExportToFile:
+    def test_writes_valid_json_with_all_fields(self, tmp_path, monkeypatch):
+        sources = [
+            ImportSourceRow(
+                year=2024,
+                spreadsheet_id="sid24",
+                worksheet_name="Budget",
+                income_worksheet_name="Income",
+                income_layout_key="income_rsd",
+            ),
+        ]
+        monkeypatch.setattr(_mod, "read_import_sources", lambda: list(sources))
+        ws = _ws([["date", "amount"], ["2024-04-10", "300000"]])
+        ss = _ss(ws)
+        with patch("tasks.imports.income_extract.get_sheet", return_value=ss):
+            dest = tmp_path / "out.json"
+            count = export_to_file(dest)
+
+        assert count == 1
+        payload = json.loads(dest.read_text())
+        assert "generated_at" in payload
+        entry = payload["entries"][0]
+        assert entry["year"] == 2024
+        assert entry["month"] == 4
+        assert entry["day"] == 10
+        assert entry["currency"] == "RSD"
+        assert entry["income_year"] == 2024
+        assert entry["income_month"] == 3  # day 10 <= 25 -> prev month
+
+    def test_creates_parent_directory(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(_mod, "read_import_sources", lambda: [])
+        dest = tmp_path / "nested" / "dir" / "income.json"
+        export_to_file(dest)
+        assert dest.exists()
+
+    def test_amount_is_decimal_string(self, tmp_path, monkeypatch):
+        sources = [
+            ImportSourceRow(
+                year=2023,
+                spreadsheet_id="sid23",
+                worksheet_name="Budget",
+                income_worksheet_name="Income",
+                income_layout_key="balance_rsd",
+            ),
+        ]
+        monkeypatch.setattr(_mod, "read_import_sources", lambda: list(sources))
+        ws = _ws([["date", "amount"], ["2023-01-10", "123456.78"]])
+        ss = _ss(ws)
+        with patch("tasks.imports.income_extract.get_sheet", return_value=ss):
+            dest = tmp_path / "out.json"
+            export_to_file(dest)
+
+        payload = json.loads(dest.read_text())
+        amount = payload["entries"][0]["amount"]
+        assert isinstance(amount, str)
+        assert "." in amount

{dinary-1.2.2 → dinary-1.2.3}/webapp/src/components/ProviderCard.vue

@@ -41,6 +41,18 @@ const latencyColor = computed(() => {
   if (ms == null) return "var(--muted)";
   return ms > 3000 ? "var(--warning)" : "var(--muted)";
 });
+
+const errorMessage = computed(() => {
+  const raw = props.provider.last_error_detail;
+  if (!raw) return null;
+  try {
+    let parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) parsed = parsed[0];
+    return parsed?.error?.message ?? raw;
+  } catch {
+    return raw;
+  }
+});
 </script>
 
 <template>
@@ -63,7 +75,7 @@ const latencyColor = computed(() => {
         <span v-if="rateLimitSecsLeft > 0" class="rate-limit-pill">{{ rateLimitSecsLeft }}s</span>
       </div>
       <div class="card-model">{{ provider.model }}</div>
-      <div v-if="provider.last_error_detail" class="error-detail">{{ provider.last_error_detail }}</div>
+      <div v-if="errorMessage" class="error-detail">{{ errorMessage }}</div>
     </div>
 
     <div class="usage-row">
@@ -195,9 +207,10 @@ const latencyColor = computed(() => {
   font-size: 0.7rem;
   color: var(--danger, #ef4444);
   margin-top: 0.2rem;
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
   overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
 }
 
 .card-model {