ynab-amazon-categorizer 2.2.4__tar.gz → 2.3.1__tar.gz

ynab_amazon_categorizer-2.3.1/.agents/rules/graphify.md

@@ -0,0 +1,14 @@
+---
+trigger: always_on
+description: Consult the graphify knowledge graph at graphify-out/ for codebase and architecture questions.
+---
+
+## graphify
+
+This project has a graphify knowledge graph at graphify-out/.
+
+Rules:
+- For codebase or architecture questions, when `graphify-out/graph.json` exists, first run `graphify query "<question>"` (CLI) or `query_graph` (MCP). Use `graphify path "<A>" "<B>"` / `shortest_path` for relationships and `graphify explain "<concept>"` / `get_node` for focused concepts. These return a scoped subgraph, usually much smaller than `GRAPH_REPORT.md` or raw grep output.
+- If graphify-out/wiki/index.md exists, navigate it instead of reading raw files
+- Read graphify-out/GRAPH_REPORT.md only for broad architecture review or when query/path/explain do not surface enough context
+- After modifying code files in this session, run `graphify update .` to keep the graph current (AST-only, no API cost)

ynab_amazon_categorizer-2.3.1/.agents/workflows/graphify.md

@@ -0,0 +1,10 @@
+---
+name: graphify
+description: Turn any folder of files into a navigable knowledge graph
+---
+
+# Workflow: graphify
+
+Follow the graphify skill installed at ~/.gemini/config/skills/graphify/SKILL.md to run the full pipeline.
+
+If no path argument is given, use `.` (current directory).

ynab_amazon_categorizer-2.3.1/.github/workflows/ci.yml

@@ -0,0 +1,65 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: test (${{ matrix.os }}, py${{ matrix.python-version }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python-version: ["3.12", "3.13"]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0  # Fetch full history and tags for setuptools-scm
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: uv sync --extra dev
+      - name: Run tests
+        run: uv run python -X utf8 -m pytest tests/ -v
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.12"
+      - name: Install dependencies
+        run: uv sync --extra dev
+      - name: Ruff format check
+        run: uv run --extra dev ruff format --check src tests
+      - name: Ruff lint
+        run: uv run --extra dev ruff check src tests
+
+  type-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0  # Fetch full history and tags for setuptools-scm
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.12"
+      - name: Install dependencies
+        run: uv sync --extra dev
+      - name: Run type checker
+        run: uv run --extra dev ty check src tests

{ynab_amazon_categorizer-2.2.4 → ynab_amazon_categorizer-2.3.1}/.gitignore

@@ -29,6 +29,15 @@ wheels/
 venv/
 env/
 ENV/
+.venv/
+
+# Test / coverage artifacts
+.coverage
+.coverage.*
+htmlcov/
+.pytest_cache/
+.ruff_cache/
+.uv-cache/
 
 # IDE
 .vscode/

{ynab_amazon_categorizer-2.2.4 → ynab_amazon_categorizer-2.3.1}/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [2.3.1] - 2026-07-09
+
+### Fixed
+
+- Amazon order item extraction now stops at unparsed order-like blocks and post-pagination recommendation sections, preventing unrelated page content from leaking into YNAB memos.
+
+## [2.3.0] - 2026-06-19
+
+### Added
+
+- `--dry-run` flag: preview every update without sending changes to YNAB
+- `--batch` flag: non-interactively auto-set memos (items + order link) for confidently matched transactions, leaving categories unchanged; combine with `--dry-run` to preview
+- CI workflow running tests (Ubuntu + Windows, Python 3.12 & 3.13), lint, and type checks on every push and pull request
+
+### Changed
+
+- All interactive prompts now go through `prompt_toolkit` for consistent input handling (replaces the builtin `input()`)
+
+### Fixed
+
+- A matched Amazon order is no longer reused for multiple same-amount transactions in a single run
+- "Subscribe & Save" / delivery-management lines and refund-status lines are no longer extracted as order items
+
 ## [2.2.4] - 2026-05-13
 
 ### Fixed

{ynab_amazon_categorizer-2.2.4 → ynab_amazon_categorizer-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ynab-amazon-categorizer
-Version: 2.2.4
+Version: 2.3.1
 Summary: Automatically categorize Amazon transactions in YNAB with rich item information
 Author: dizzlkheinz
 License: GPL-3.0
@@ -138,6 +138,37 @@ ynab-amazon-categorizer
 python -m ynab_amazon_categorizer
 ```
 
+### Dry run
+
+Use `--dry-run` to walk through the full interactive flow and preview every
+update without sending any changes to YNAB:
+
+```bash
+ynab-amazon-categorizer --dry-run
+```
+
+The tool still shows the JSON preview for each transaction but skips the API
+call, so it is safe for trying the tool out or verifying matches.
+
+### Batch mode
+
+Use `--batch` to run non-interactively: for every transaction with a single
+high-confidence order match (unique exact-amount match within ~7 days), the
+tool sets the memo (items + order link) automatically and **leaves the category
+unchanged**, so you can still review/categorize later. Transactions with no
+match or an ambiguous match are skipped.
+
+```bash
+# Preview what batch mode would enrich
+ynab-amazon-categorizer --batch --dry-run
+
+# Apply memo enrichment
+ynab-amazon-categorizer --batch
+```
+
+You still paste the Amazon orders page once when prompted; `--batch` only
+removes the per-transaction prompting.
+
 ### Workflow
 1. **Provide Amazon Orders Data** (optional but recommended):
    - Copy your Amazon orders page content

{ynab_amazon_categorizer-2.2.4 → ynab_amazon_categorizer-2.3.1}/README.md

@@ -104,6 +104,37 @@ ynab-amazon-categorizer
 python -m ynab_amazon_categorizer
 ```
 
+### Dry run
+
+Use `--dry-run` to walk through the full interactive flow and preview every
+update without sending any changes to YNAB:
+
+```bash
+ynab-amazon-categorizer --dry-run
+```
+
+The tool still shows the JSON preview for each transaction but skips the API
+call, so it is safe for trying the tool out or verifying matches.
+
+### Batch mode
+
+Use `--batch` to run non-interactively: for every transaction with a single
+high-confidence order match (unique exact-amount match within ~7 days), the
+tool sets the memo (items + order link) automatically and **leaves the category
+unchanged**, so you can still review/categorize later. Transactions with no
+match or an ambiguous match are skipped.
+
+```bash
+# Preview what batch mode would enrich
+ynab-amazon-categorizer --batch --dry-run
+
+# Apply memo enrichment
+ynab-amazon-categorizer --batch
+```
+
+You still paste the Amazon orders page once when prompted; `--batch` only
+removes the per-transaction prompting.
+
 ### Workflow
 1. **Provide Amazon Orders Data** (optional but recommended):
    - Copy your Amazon orders page content

{ynab_amazon_categorizer-2.2.4 → ynab_amazon_categorizer-2.3.1}/src/ynab_amazon_categorizer/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.4'
-__version_tuple__ = version_tuple = (2, 2, 4)
+__version__ = version = '2.3.1'
+__version_tuple__ = version_tuple = (2, 3, 1)
 
-__commit_id__ = commit_id = 'g034b5e27c'
+__commit_id__ = commit_id = 'g70c0a58c8'

ynab_amazon_categorizer-2.3.1/src/ynab_amazon_categorizer/amazon_parser.py

@@ -0,0 +1,240 @@
+"""Amazon order parsing functionality."""
+
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+# Maximum items to extract per order (keeps memos manageable)
+MAX_ITEMS_PER_ORDER = 10
+
+ORDER_CONTENT_BOUNDARY_PATTERN = re.compile(
+    r"^\s*(?:Order placed|Subscription charged on|Digital order placed)\b",
+    re.IGNORECASE | re.MULTILINE,
+)
+
+ORDER_TAIL_SENTINEL_PATTERN = re.compile(
+    r"^\s*(?:"
+    r"[←<]?\s*Previous\b.*|"
+    r"Next\s*[→>]?\s*$|"
+    r"Sponsored\s*$|"
+    r"Learn more[ \t]*(?:\r?\n)[ \t]*\$\d|"
+    r"Top .+ For You\s*$|"
+    r"Get to Know Us\s*$|"
+    r"Make Money with Us\s*$|"
+    r"Amazon Payment Products\s*$|"
+    r"Let Us Help You\s*$"
+    r")",
+    re.IGNORECASE | re.MULTILINE,
+)
+
+
+class Order:
+    """Represents a parsed Amazon order."""
+
+    def __init__(self) -> None:
+        self.order_id: str | None = None
+        self.total: float | None = None
+        self.date_str: str | None = None
+        self.items: list[str] = []
+
+
+class AmazonParser:
+    """Parses Amazon order data from order history pages."""
+
+    def _remove_cancelled_orders(self, text: str) -> str:
+        """Remove cancelled order blocks so their items don't bleed into adjacent orders."""
+        parts = re.split(r"(?=Order placed)", text)
+        kept = []
+        for part in parts:
+            if (
+                re.match(r"\s*Order placed", part)
+                and "Your order was cancelled" in part
+            ):
+                continue
+            kept.append(part)
+        return "".join(kept)
+
+    def parse_orders_page(self, orders_text: str) -> list[Order]:
+        """Parse Amazon orders page text to extract order information.
+
+        Orders are kept even when item extraction fails (partial orders)
+        so that amount/date matching can still work.
+        """
+        if not orders_text.strip():
+            return []
+
+        orders_text = self._remove_cancelled_orders(orders_text)
+
+        orders = []
+
+        # Find all order blocks using regex
+        order_pattern = r"Order placed\s*([A-Za-z]+ \d+, \d{4})\s*Total\s*\$([0-9][0-9,]*(?:\.[0-9]{1,2})?)\s*.*?Order # (\d{3}-\d{7}-\d{7})"
+        order_matches = list(
+            re.finditer(order_pattern, orders_text, re.DOTALL | re.IGNORECASE)
+        )
+
+        for idx, match in enumerate(order_matches):
+            order_date = match.group(1).strip()
+            order_total = float(match.group(2).replace(",", ""))
+            order_id = match.group(3)
+
+            # Find the content after this order until the next order-like block or end
+            start_pos = match.end()
+            if idx + 1 < len(order_matches):
+                end_pos = order_matches[idx + 1].start()
+            else:
+                end_pos = len(orders_text)
+            end_pos = self._find_order_content_end(orders_text, start_pos, end_pos)
+            order_content = orders_text[start_pos:end_pos]
+
+            # Extract items from the order content
+            items = self.extract_items_from_content(order_content)
+
+            # Always keep the order even without items (partial order)
+            order = Order()
+            order.order_id = order_id
+            order.total = order_total
+            order.date_str = order_date
+            order.items = items
+
+            if not items:
+                logger.info(
+                    "Order %s parsed without items (amount=%.2f). "
+                    "It can still match by amount/date.",
+                    order_id,
+                    order_total,
+                )
+
+            orders.append(order)
+
+        return orders
+
+    def _find_order_content_end(
+        self, orders_text: str, start_pos: int, default_end: int
+    ) -> int:
+        """Find the earliest unparsed order-like boundary before the default end."""
+        boundary = ORDER_CONTENT_BOUNDARY_PATTERN.search(
+            orders_text, start_pos, default_end
+        )
+        if boundary:
+            return boundary.start()
+        return default_end
+
+    def _trim_footer(self, order_content: str) -> str:
+        """Trim at page footer sentinels to avoid extracting navigation/legal boilerplate."""
+        footer_sentinel = ORDER_TAIL_SENTINEL_PATTERN.search(order_content)
+        if not footer_sentinel:
+            footer_sentinel = re.search(
+                r"©\s*\d{4}|To move between items",
+                order_content,
+                re.IGNORECASE,
+            )
+        if footer_sentinel:
+            return order_content[: footer_sentinel.start()]
+        return order_content
+
+    def _get_valid_cleaned_item(self, line: str) -> str | None:
+        """Check if a line matches product name criteria and return the cleaned string, or None."""
+        line = line.strip()
+        if not line or len(line) < 15:
+            return None
+
+        # Skip common UI elements and delivery status lines
+        skip_patterns = [
+            r"^(Buy it again|Track package|View|Return|Write|Get|Share|Leave|Ask)",
+            r"^(Delivered|Arriving|Now arriving|Auto-delivered|Package was)",
+            r"^(Return items:|Return or replace|Refund issued|Refund:|Returned)",
+            r"^(Subscribe & Save|Subscribe now|Skip this delivery|Deliver every"
+            r"|Change delivery|Manage subscription|Edit delivery|Set up now)",
+            r"^\d+\.?\d* out of \d+ stars",
+            r"^FREE|^Today by|^Get it|^List:|^Was:|^Limited-time deal",
+            r"^\$\d+\.\d+|\(\$\d+\.\d+",
+            r"^\d+ sustainability features?$",
+            r"^[A-Z\s]+$",  # All caps lines (must be ONLY caps and spaces)
+            r"^(Ship to|Order #|View order|Invoice)",
+        ]
+
+        if any(re.match(pattern, line, re.IGNORECASE) for pattern in skip_patterns):
+            return None
+
+        # Look for product names - they usually contain specific patterns
+        has_product_pattern = (
+            any(
+                word in line.lower()
+                for word in [
+                    "pack",
+                    "count",
+                    "size",
+                    "oz",
+                    "ml",
+                    "lbs",
+                    "kg",
+                    "inch",
+                    "cm",
+                ]
+            )
+            or re.search(
+                r"[A-Z][a-z].*[A-Z]", line
+            )  # Mixed case indicating product names
+            or len(line.split()) >= 5
+        )  # Long descriptive lines
+
+        if not has_product_pattern:
+            return None
+
+        # Clean up the line
+        cleaned_line = re.sub(r"\s+", " ", line)
+        cleaned_line = re.sub(r"^[-•]\s*", "", cleaned_line)  # Remove bullet points
+
+        # Skip if it looks like navigation or common elements
+        skip_words = [
+            "account",
+            "orders",
+            "cart",
+            "search",
+            "hello",
+            "browse",
+            "prime",
+            "shipping",
+            "mastercard",
+            "your brand",
+            "registry & gift",
+            "attract and engage",
+            "interest-based",
+        ]
+        if any(word in cleaned_line.lower() for word in skip_words):
+            return None
+
+        return cleaned_line
+
+    def _deduplicate_and_badge_filter(self, candidates: list[str]) -> list[str]:
+        """Build lookup set to detect quantity-badge duplicates and keep up to MAX_ITEMS_PER_ORDER."""
+        # Amazon shows "Product Name <qty>" and "Product Name" on adjacent lines when
+        # qty > 1. We want to strip the badge only when the bare form also appears.
+        candidate_set = set(candidates)
+        seen: set[str] = set()
+        unique_items: list[str] = []
+        for item in candidates:
+            stripped = re.sub(r"\s+\d+$", "", item)
+            normalized = (
+                stripped if (stripped != item and stripped in candidate_set) else item
+            )
+            if normalized not in seen and len(normalized) > 15:
+                seen.add(normalized)
+                unique_items.append(normalized)
+                if len(unique_items) >= MAX_ITEMS_PER_ORDER:
+                    break
+        return unique_items
+
+    def extract_items_from_content(self, order_content: str) -> list[str]:
+        """Extract item names from order content."""
+        order_content = self._trim_footer(order_content)
+
+        candidates: list[str] = []
+        for line in order_content.split("\n"):
+            cleaned = self._get_valid_cleaned_item(line)
+            if cleaned:
+                candidates.append(cleaned)
+
+        return self._deduplicate_and_badge_filter(candidates)