ynab-amazon-categorizer 2.1.8__tar.gz → 2.2.2__tar.gz

ynab_amazon_categorizer-2.2.2/CHANGELOG.md

@@ -0,0 +1,47 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/),
+and this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [2.2.2] - 2026-04-23
+
+### Fixed
+
+- Pin `ty==0.0.14` in dev dependencies so CI uses the same type-checker version as the lock file
+
+## [2.2.1] - 2026-04-23
+
+### Fixed
+
+- Cancelled orders no longer cause their items to bleed into the preceding valid order
+- Quantity badge numbers (e.g. trailing ` 2`, ` 4`) are stripped from item names when the bare form also appears, without corrupting size numbers like `Size 10`
+- `"Now arriving today X:XX p.m."` delivery status lines are no longer extracted as item names
+
+## [2.2.0] - 2026-02-23
+
+### Fixed
+
+- Comprehensive audit fixes across all modules
+- Preserve Amazon order link in memo truncation when prefix space is too small
+
+## [2.1.8] - 2026-02-05
+
+### Fixed
+
+- Ruff formatting compliance for CI
+
+## [2.1.7] - 2026-02-04
+
+### Changed
+
+- Extracted testable functions from `cli.py` for better modularity
+- Added retry logic to YNAB API client (3 retries with backoff on 429/5xx)
+- Added stdlib logging throughout the codebase
+
+### Added
+
+- Comprehensive test suite for extracted CLI functions

{ynab_amazon_categorizer-2.1.8 → ynab_amazon_categorizer-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ynab-amazon-categorizer
-Version: 2.1.8
+Version: 2.2.2
 Summary: Automatically categorize Amazon transactions in YNAB with rich item information
 Author: dizzlkheinz
 License: GPL-3.0
@@ -28,7 +28,7 @@ Provides-Extra: dev
 Requires-Dist: pytest>=9.0.2; extra == "dev"
 Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
 Requires-Dist: ruff>=0.15.0; extra == "dev"
-Requires-Dist: ty>=0.0.14; extra == "dev"
+Requires-Dist: ty==0.0.14; extra == "dev"
 Requires-Dist: pre-commit>=4.5.1; extra == "dev"
 Dynamic: license-file
 

{ynab_amazon_categorizer-2.1.8 → ynab_amazon_categorizer-2.2.2}/pyproject.toml

@@ -36,7 +36,7 @@ dev = [
     "pytest>=9.0.2",
     "pytest-cov>=7.0.0",
     "ruff>=0.15.0",
-    "ty>=0.0.14",
+    "ty==0.0.14",
     "pre-commit>=4.5.1",
 ]
 

ynab_amazon_categorizer-2.2.2/src/ynab_amazon_categorizer/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2.2.2'
+__version_tuple__ = version_tuple = (2, 2, 2)
+
+__commit_id__ = commit_id = 'g993627dd7'

{ynab_amazon_categorizer-2.1.8 → ynab_amazon_categorizer-2.2.2}/src/ynab_amazon_categorizer/amazon_parser.py

@@ -1,7 +1,13 @@
 """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
+
 
 class Order:
     """Represents a parsed Amazon order."""
@@ -16,64 +22,87 @@ class Order:
 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"""
+        """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*\$(\d+\.?\d*)\s*.*?Order # (\d{3}-\d{7}-\d{7})"
-        order_matches = re.finditer(
-            order_pattern, orders_text, re.DOTALL | re.IGNORECASE
+        order_matches = list(
+            re.finditer(order_pattern, orders_text, re.DOTALL | re.IGNORECASE)
         )
 
-        for match in order_matches:
+        for idx, match in enumerate(order_matches):
             order_date = match.group(1).strip()
             order_total = float(match.group(2))
             order_id = match.group(3)
 
             # Find the content after this order until the next order or end
             start_pos = match.end()
-            next_order = re.search(
-                r"Order placed", orders_text[start_pos:], re.IGNORECASE
-            )
-            if next_order:
-                end_pos = start_pos + next_order.start()
-                order_content = orders_text[start_pos:end_pos]
+            if idx + 1 < len(order_matches):
+                end_pos = order_matches[idx + 1].start()
             else:
-                order_content = orders_text[
-                    start_pos : start_pos + 2000
-                ]  # Take next 2000 chars
+                end_pos = len(orders_text)
+            order_content = orders_text[start_pos:end_pos]
 
             # Extract items from the order content
             items = self.extract_items_from_content(order_content)
 
-            if items:  # Only add orders that have identifiable items
-                order = Order()
-                order.order_id = order_id
-                order.total = order_total
-                order.date_str = order_date
-                order.items = items
-                orders.append(order)
+            # 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 extract_items_from_content(self, order_content: str) -> list[str]:
         """Extract item names from order content."""
-        items = []
+        candidates: list[str] = []
         lines = order_content.split("\n")
 
         for line in lines:
             line = line.strip()
-            if not line or len(line) < 20:
+            if not line or len(line) < 15:
                 continue
 
-            # Skip common UI elements
+            # 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|Auto-delivered|Package was)",
+                r"^(Delivered|Arriving|Now arriving|Auto-delivered|Package was)",
                 r"^(Return items:|Return or replace)",
                 r"^\d+\.?\d* out of \d+ stars",
                 r"^FREE|^Today by|^Get it|^List:|^Was:|^Limited-time deal",
@@ -125,16 +154,24 @@ class AmazonParser:
                     "shipping",
                 ]
                 if not any(word in cleaned_line.lower() for word in skip_words):
-                    items.append(cleaned_line)
-
-        # Remove duplicates and limit items
-        seen = set()
-        unique_items = []
-        for item in items:
-            if item not in seen and len(item) > 15:  # Only keep substantial items
-                seen.add(item)
-                unique_items.append(item)
-                if len(unique_items) >= 3:  # Limit to 3 items
+                    candidates.append(cleaned_line)
+
+        # Build lookup set to detect quantity-badge duplicates.
+        # 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

{ynab_amazon_categorizer-2.1.8 → ynab_amazon_categorizer-2.2.2}/src/ynab_amazon_categorizer/cli.py

@@ -1,11 +1,12 @@
 import copy
 import json
 import logging
-import os  # For history file path
+import os
+import sys
 from collections.abc import Iterable
 from typing import Any
 
-# --- NEW: Import prompt_toolkit components ---
+import requests
 from prompt_toolkit import prompt
 from prompt_toolkit.completion import CompleteEvent, Completer, Completion
 from prompt_toolkit.document import Document
@@ -13,11 +14,9 @@ from prompt_toolkit.history import FileHistory
 from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
 
 from .amazon_parser import AmazonParser, Order
-
-# --- END NEW ---
-# --- Import extracted modules ---
 from .config import Config
-from .memo_generator import MemoGenerator
+from .exceptions import ConfigurationError, YNABAPIError
+from .memo_generator import MemoGenerator, sanitize_memo
 from .transaction_matcher import TransactionMatcher
 from .ynab_client import YNABClient
 
@@ -29,14 +28,6 @@ logger = logging.getLogger(__name__)
 AMAZON_PAYEE_KEYWORDS = ["amazon", "amzn", "amz"]
 YNAB_API_URL = "https://api.ynab.com/v1"
 
-# --- Amazon Order Link Functions ---
-
-
-# NOTE: Memo generation functions have been moved to memo_generator.py
-
-
-# NOTE: Amazon order parsing has been moved to amazon_parser.py
-
 
 def prompt_for_amazon_orders_data() -> list[Order] | None:
     """Prompt user to paste Amazon orders page data"""
@@ -73,9 +64,6 @@ def prompt_for_amazon_orders_data() -> list[Order] | None:
     return parsed_orders
 
 
-# NOTE: find_matching_order moved to transaction_matcher.py
-
-
 def get_multiline_input_with_custom_submit(
     prompt_message: str = "Enter multiline text: ",
 ) -> str | None:
@@ -113,14 +101,14 @@ def generate_split_summary_memo(matching_order: Order) -> str:
 
     items = matching_order.items
     if len(items) == 1:
-        return items[0]
+        return sanitize_memo(items[0])
 
     # Format as: "2 Items:\n- Item 1\n- Item 2"
     summary = f"{len(items)} Items:"
     for item in items:
         summary += f"\n- {item}"
 
-    return summary
+    return sanitize_memo(summary)
 
 
 def prompt_for_item_details() -> dict[str, str | int | float | list[str] | None] | None:
@@ -180,7 +168,7 @@ def print_config_summary(config: Config) -> None:
         print(f"✓ Budget ID: ...{config.budget_id[-4:]}")
     else:
         print("✓ Budget ID: configured")
-    if config.account_id and config.account_id.lower() != "none":
+    if config.account_id:
         print("✓ Account ID: configured")
     else:
         print("✓ All accounts")
@@ -252,7 +240,7 @@ def build_single_payload(
         "payee_id": transaction.get("payee_id"),
         "payee_name": transaction.get("payee_name", "N/A"),
         "category_id": category_id,
-        "memo": memo,
+        "memo": sanitize_memo(memo),
         "cleared": transaction.get("cleared"),
         "approved": True,
         "flag_color": transaction.get("flag_color"),
@@ -263,10 +251,15 @@ def build_single_payload(
 def build_split_payload(
     transaction: dict[str, Any],
     subtransactions: list[dict[str, int | str | None]],
-    matching_order: Order | dict[str, Any] | None,
+    matching_order: Order | None,
     original_memo: str,
 ) -> dict[str, Any]:
     """Build update payload for a split transaction."""
+    memo = (
+        generate_split_summary_memo(matching_order)
+        if matching_order
+        else sanitize_memo(original_memo)
+    )
     return {
         "id": transaction["id"],
         "account_id": transaction["account_id"],
@@ -275,9 +268,7 @@ def build_split_payload(
         "payee_id": transaction.get("payee_id"),
         "payee_name": transaction.get("payee_name", "N/A"),
         "category_id": None,
-        "memo": generate_split_summary_memo(matching_order)
-        if matching_order and isinstance(matching_order, Order)
-        else original_memo,
+        "memo": memo,
         "cleared": transaction.get("cleared"),
         "approved": True,
         "flag_color": transaction.get("flag_color"),
@@ -291,7 +282,7 @@ def fetch_amazon_transactions(
 ) -> list[dict[str, Any]]:
     """Fetch transactions from YNAB and filter to uncategorized Amazon ones."""
     transactions_endpoint = f"/budgets/{config.budget_id}/transactions"
-    if config.account_id and config.account_id.lower() != "none":
+    if config.account_id:
         transactions_endpoint = (
             f"/budgets/{config.budget_id}/accounts/{config.account_id}/transactions"
         )
@@ -319,24 +310,13 @@ def fetch_amazon_transactions(
             and t.get("amount", 0) != 0
             and t.get("transfer_account_id") is None
             and not t.get("subtransactions")
-            and t.get("import_id") is not None
         )
         if is_valid_for_processing:
             transactions_to_process.append(t)
     return transactions_to_process
 
 
-# NOTE: YNAB API functions have been moved to ynab_client.py
-
-
-# NOTE: update_ynab_transaction moved to ynab_client.py
-
-
-# NOTE: get_categories moved to ynab_client.py
-
-
 class CategoryCompleter(Completer):
-    # ... (implementation from v3) ...
     def __init__(self, category_list: list[tuple[str, str]]) -> None:
         self.categories = [name for name, _id in category_list]
         self.category_list = category_list
@@ -356,7 +336,6 @@ class CategoryCompleter(Completer):
 def prompt_for_category_selection(
     category_completer: CategoryCompleter, name_to_id_map: dict[str, str]
 ) -> tuple[str | None, str | None]:
-    # ... (implementation from v3) ...
     history_file = os.path.join(os.path.expanduser("~"), ".ynab_amazon_cat_history")
     history = FileHistory(history_file)
     while True:
@@ -394,43 +373,34 @@ def prompt_for_category_selection(
 # --- Extracted per-transaction functions ---
 
 
-def display_matched_order(
-    matching_order: Order | dict[str, Any], memo_generator: MemoGenerator
-) -> None:
+def display_matched_order(matching_order: Order, memo_generator: MemoGenerator) -> None:
     """Display matched order details to the user."""
-    if isinstance(matching_order, Order):
-        order_id = matching_order.order_id
-        total = matching_order.total
-        date_str = matching_order.date_str
-        items = matching_order.items
-    else:
-        order_id = matching_order.get("order_id")
-        total = matching_order.get("total")
-        date_str = matching_order.get("date") or matching_order.get("date_str")
-        items = matching_order.get("items", [])
-
     print("\n  🎯 MATCHED ORDER FOUND:")
-    print(f"     Order ID: {order_id}")
-    print(f"     Total: ${total if total is not None else 'N/A'}")
-    print(f"     Date: {date_str if date_str is not None else 'N/A'}")
-    order_link = memo_generator.generate_amazon_order_link(order_id)
+    print(f"     Order ID: {matching_order.order_id}")
+    print(
+        f"     Total: ${matching_order.total if matching_order.total is not None else 'N/A'}"
+    )
+    print(
+        f"     Date: {matching_order.date_str if matching_order.date_str is not None else 'N/A'}"
+    )
+    order_link = memo_generator.generate_amazon_order_link(matching_order.order_id)
     print(f"     Order Link: {order_link}")
-    if items:
+    if matching_order.items:
         print("     Items:")
-        for item in items:
+        for item in matching_order.items:
             print(f"       - {item}")
     print()
 
 
 def resolve_memo(
-    matching_order: Order | dict[str, Any] | None,
+    matching_order: Order | None,
     original_memo: str,
     memo_generator: MemoGenerator,
 ) -> str:
     """Determine the memo for a single-category transaction.
 
     Uses matched order data when available, otherwise prompts for manual entry.
-    Returns the final memo string.
+    Returns the final memo string (already sanitized).
     """
     item_details: dict[str, str | int | float | list[str] | None] | None = None
     enhanced_memo = None
@@ -438,20 +408,12 @@ def resolve_memo(
     # Use matched order data or prompt for manual entry
     if matching_order:
         print("Using matched order data for memo generation...")
-        if isinstance(matching_order, Order):
-            item_details = {
-                "order_id": matching_order.order_id or "",
-                "items": matching_order.items,
-                "total": matching_order.total,
-                "date": matching_order.date_str,
-            }
-        else:
-            item_details = {
-                "order_id": matching_order.get("order_id", ""),
-                "items": matching_order.get("items", []),
-                "total": matching_order.get("total"),
-                "date": matching_order.get("date") or matching_order.get("date_str"),
-            }
+        item_details = {
+            "order_id": matching_order.order_id or "",
+            "items": matching_order.items,
+            "total": matching_order.total,
+            "date": matching_order.date_str,
+        }
     else:
         # Ask if user wants to enter item details manually
         manual_entry = input(
@@ -490,20 +452,20 @@ def resolve_memo(
         print(f"'{enhanced_memo}'")
         use_suggested = input("Use suggested memo? (y/n, default y): ").lower()
         if use_suggested != "n":
-            return enhanced_memo
+            return sanitize_memo(enhanced_memo)
         else:
             print("Enter custom memo (multiline):")
             memo_input = get_multiline_input_with_custom_submit("> ")
-            return memo_input.strip() if memo_input else ""
+            return sanitize_memo(memo_input.strip()) if memo_input else ""
     else:
         print("Enter optional memo (multiline):")
         memo_input = get_multiline_input_with_custom_submit("> ")
-        return memo_input.strip() if memo_input else ""
+        return sanitize_memo(memo_input.strip()) if memo_input else ""
 
 
 def handle_split(
     transaction: dict[str, Any],
-    matching_order: Order | dict[str, Any] | None,
+    matching_order: Order | None,
     memo_generator: MemoGenerator,
     category_completer: CategoryCompleter,
     category_name_map: dict[str, str],
@@ -524,12 +486,7 @@ def handle_split(
         )
 
         # Show which item this split is for if we have matched order data
-        items: list[str] = []
-        if matching_order:
-            if isinstance(matching_order, Order):
-                items = matching_order.items or []
-            else:
-                items = matching_order.get("items", [])
+        items: list[str] = matching_order.items if matching_order else []
 
         if items:
             if split_count <= len(items):
@@ -577,7 +534,7 @@ def handle_split(
             {
                 "amount": split_amount_milliunits,
                 "category_id": category_id,
-                "memo": split_memo if split_memo else None,
+                "memo": sanitize_memo(split_memo) if split_memo else None,
             }
         )
 
@@ -599,7 +556,7 @@ def handle_split(
 
 
 def _resolve_split_memo(
-    matching_order: Order | dict[str, Any] | None,
+    matching_order: Order | None,
     memo_generator: MemoGenerator,
     category_name: str | None,
     split_count: int,
@@ -609,12 +566,8 @@ def _resolve_split_memo(
 
     if matching_order:
         print("Using matched order data for split memo...")
-        if isinstance(matching_order, Order):
-            items = matching_order.items
-            order_id = matching_order.order_id
-        else:
-            items = matching_order.get("items", [])
-            order_id = matching_order.get("order_id")
+        items = matching_order.items
+        order_id = matching_order.order_id
 
         if split_count <= len(items):
             items_text = items[split_count - 1]
@@ -691,7 +644,7 @@ def process_transaction(
         print(f"  Original Memo: {original_memo}")
 
     # Try to find matching order from parsed data and show it
-    matching_order: Order | dict[str, Any] | None = None
+    matching_order: Order | None = None
     if parsed_orders:
         transaction_matcher = TransactionMatcher()
         matching_order = transaction_matcher.find_matching_order(
@@ -735,7 +688,7 @@ def process_transaction(
 
 def _handle_categorize(
     transaction: dict[str, Any],
-    matching_order: Order | dict[str, Any] | None,
+    matching_order: Order | None,
     original_memo: str,
     memo_generator: MemoGenerator,
     ynab_client: YNABClient,
@@ -752,15 +705,9 @@ def _handle_categorize(
     updated_payload_dict: dict[str, Any] | None = None
 
     # Check if we should offer splitting
-    should_offer_split = False
-    if matching_order:
-        if isinstance(matching_order, Order):
-            should_offer_split = bool(
-                matching_order.items and len(matching_order.items) > 1
-            )
-        else:
-            items = matching_order.get("items", [])
-            should_offer_split = bool(items and len(items) > 1)
+    should_offer_split = bool(
+        matching_order and matching_order.items and len(matching_order.items) > 1
+    )
 
     if should_offer_split:
         print("There is more than one item in this transaction.")
@@ -808,12 +755,13 @@ def _handle_categorize(
         if not confirm:
             confirm = "y"
         if confirm == "y":
-            if ynab_client.update_transaction(transaction_id, updated_payload_dict):
+            try:
+                ynab_client.update_transaction(transaction_id, updated_payload_dict)
                 print("Update successful.")
                 return "done"
-            else:
-                logger.error("Failed to update transaction %s.", transaction_id)
-                print("Update failed.")
+            except (YNABAPIError, requests.exceptions.RequestException) as exc:
+                logger.error("Failed to update transaction %s: %s", transaction_id, exc)
+                print(f"Update failed: {exc}")
                 return "continue"
         else:
             print("Update cancelled.")
@@ -833,22 +781,29 @@ def main() -> None:
     try:
         config = Config.from_env()
         print_config_summary(config)
-    except Exception as e:
+    except ConfigurationError as e:
         logger.error("Configuration error: %s", e)
         print("Please set environment variables or create a .env file.")
         print("See README.md for setup instructions.")
-        exit(1)
+        sys.exit(1)
 
     # Initialize YNAB client
     ynab_client = YNABClient(config.api_key, config.budget_id)
     memo_generator = MemoGenerator(config.amazon_domain)
 
     print("Fetching categories...")
-    categories_list, category_name_map, category_id_map = ynab_client.get_categories()
+    try:
+        categories_list, category_name_map, category_id_map = (
+            ynab_client.get_categories()
+        )
+    except (YNABAPIError, requests.exceptions.RequestException) as exc:
+        logger.error("Failed to fetch categories: %s", exc)
+        print(f"Could not fetch categories: {exc}")
+        sys.exit(1)
 
     if not categories_list:
         print("Exiting due to category fetch error or no usable categories found.")
-        exit()
+        sys.exit(1)
 
     category_completer_instance = CategoryCompleter(categories_list)
     print(f"\nFound {len(categories_list)} usable categories. Completion enabled.")
@@ -879,7 +834,13 @@ def main() -> None:
             print("No valid orders found in provided data.")
 
     print("\nFetching transactions...")
-    transactions_to_process = fetch_amazon_transactions(ynab_client, config)
+    try:
+        transactions_to_process = fetch_amazon_transactions(ynab_client, config)
+    except (YNABAPIError, requests.exceptions.RequestException) as exc:
+        logger.error("Failed to fetch transactions: %s", exc)
+        print(f"Could not fetch transactions: {exc}")
+        sys.exit(1)
+
     print(
         f"\nFound {len(transactions_to_process)} uncategorized Amazon transaction(s) needing attention."
     )
@@ -898,7 +859,7 @@ def main() -> None:
             category_id_map,
         )
         if not should_continue:
-            exit()
+            sys.exit(0)
 
     # End of processing loop
     print("\nFinished processing transactions.")