ynab-amazon-categorizer 2.0.2__tar.gz → 2.1.2__tar.gz

{ynab_amazon_categorizer-2.0.2 → ynab_amazon_categorizer-2.1.2}/.github/workflows/release.yml

@@ -22,14 +22,45 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install -e .
+        pip install -e .[dev]
     
-    - name: Test package can be imported and run
+    - name: Run tests
+      run: pytest
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.9'
+    - name: Install dependencies
       run: |
-        python -c "from ynab_amazon_categorizer.cli import main; print('Package imports successfully')"
+        python -m pip install --upgrade pip
+        pip install -e .[dev]
+    - name: Run pre-commit hooks
+      run: pre-commit run --all-files
+
+  type-check:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.9'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e .[dev]
+    - name: Run type checker
+      run: mypy .
 
   publish:
-    needs: test
+    needs: [test, lint, type-check]
     runs-on: ubuntu-latest
     permissions:
       id-token: write
@@ -61,7 +92,7 @@ jobs:
       uses: pypa/gh-action-pypi-publish@release/v1
 
   create-release:
-    needs: [test, publish]
+    needs: [publish]
     runs-on: ubuntu-latest
     permissions:
       contents: write

{ynab_amazon_categorizer-2.0.2 → ynab_amazon_categorizer-2.1.2}/.gitignore

@@ -48,4 +48,10 @@ Thumbs.db
 RELEASE_NOTES.md
 temp_release.json
 release/
-.claude/
+.claude/
+
+# Backups
+ynab_amazon_categorizer.py.backup
+
+# Auto-generated files
+src/ynab_amazon_categorizer/_version.py

ynab_amazon_categorizer-2.1.2/.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+repos:
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  # Ruff version.
+  rev: v0.13.2
+  hooks:
+    # Run the linter.
+    - id: ruff-check
+      args: [ --fix ]
+    # Run the formatter.
+    - id: ruff-format

{ynab_amazon_categorizer-2.0.2/src/ynab_amazon_categorizer.egg-info → ynab_amazon_categorizer-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ynab-amazon-categorizer
-Version: 2.0.2
+Version: 2.1.2
 Summary: Automatically categorize Amazon transactions in YNAB with rich item information
 Author: dizzlkheinz
 License: GPL-3.0
@@ -14,15 +14,14 @@ Classifier: Intended Audience :: End Users/Desktop
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Office/Business :: Financial :: Accounting
 Classifier: Topic :: Utilities
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.25.0
@@ -40,7 +39,7 @@ Dynamic: license-file
 
 # YNAB Amazon Categorizer
 
-An enhanced Python package that automatically categorizes Amazon transactions in YNAB (You Need A Budget) with rich item information and automatic memo generation.
+A Python package that assists in categorizing Amazon transactions in YNAB (You Need A Budget) with rich item information, automatic memo generation, and tab-completion for categories.
 
 ## Features
 

{ynab_amazon_categorizer-2.0.2 → ynab_amazon_categorizer-2.1.2}/README.md

@@ -1,6 +1,6 @@
 # YNAB Amazon Categorizer
 
-An enhanced Python package that automatically categorizes Amazon transactions in YNAB (You Need A Budget) with rich item information and automatic memo generation.
+A Python package that assists in categorizing Amazon transactions in YNAB (You Need A Budget) with rich item information, automatic memo generation, and tab-completion for categories.
 
 ## Features
 

{ynab_amazon_categorizer-2.0.2 → ynab_amazon_categorizer-2.1.2}/pyproject.toml

@@ -7,7 +7,7 @@ name = "ynab-amazon-categorizer"
 dynamic = ["version"]
 description = "Automatically categorize Amazon transactions in YNAB with rich item information"
 readme = "README.md"
-requires-python = ">=3.7"
+requires-python = ">=3.9"
 license = {text = "GPL-3.0"}
 authors = [
     {name = "dizzlkheinz"},
@@ -20,12 +20,11 @@ classifiers = [
     "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Office/Business :: Financial :: Accounting",
     "Topic :: Utilities",
 ]
@@ -95,12 +94,15 @@ exclude_lines = [
 
 [tool.black]
 line-length = 88
-target-version = ["py37"]
+target-version = ["py39"]
 include = '\\.pyi?$'
 
 [tool.ruff]
-target-version = "py37"
+target-version = "py39"
 line-length = 88
+extend-exclude = ["src/ynab_amazon_categorizer/_version.py"]
+
+[tool.ruff.lint]
 select = [
     "E",  # pycodestyle errors
     "W",  # pycodestyle warnings
@@ -117,7 +119,7 @@ ignore = [
 ]
 
 [tool.mypy]
-python_version = "3.7"
+python_version = "3.11"
 check_untyped_defs = true
 disallow_any_generics = true
 disallow_incomplete_defs = true
@@ -125,4 +127,6 @@ disallow_untyped_defs = true
 no_implicit_optional = true
 warn_redundant_casts = true
 warn_unused_ignores = true
+ignore_missing_imports = true
+allow_redefinition = true
 

{ynab_amazon_categorizer-2.0.2 → ynab_amazon_categorizer-2.1.2}/src/ynab_amazon_categorizer/__init__.py

@@ -4,7 +4,10 @@ try:
     from importlib.metadata import PackageNotFoundError, version
 except ImportError:
     # Python < 3.8
-    from importlib_metadata import PackageNotFoundError, version
+    from importlib_metadata import (  # type: ignore[no-redef]
+        PackageNotFoundError,
+        version,
+    )
 
 try:
     __version__ = version("ynab-amazon-categorizer")

{ynab_amazon_categorizer-2.0.2 → ynab_amazon_categorizer-2.1.2}/src/ynab_amazon_categorizer/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.0.2'
-__version_tuple__ = version_tuple = (2, 0, 2)
+__version__ = version = '2.1.2'
+__version_tuple__ = version_tuple = (2, 1, 2)
 
-__commit_id__ = commit_id = 'g24166dc0b'
+__commit_id__ = commit_id = 'g4639f2a18'

{ynab_amazon_categorizer-2.0.2 → ynab_amazon_categorizer-2.1.2}/src/ynab_amazon_categorizer/amazon_parser.py

@@ -1,20 +1,23 @@
 """Amazon order parsing functionality."""
+
 import re
+from typing import Optional
 
 
 class Order:
     """Represents a parsed Amazon order."""
-    def __init__(self):
-        self.order_id = None
-        self.total = None
-        self.date_str = None
-        self.items = []
+
+    def __init__(self) -> None:
+        self.order_id: Optional[str] = None
+        self.total: Optional[float] = None
+        self.date_str: Optional[str] = None
+        self.items: list[str] = []
 
 
 class AmazonParser:
     """Parses Amazon order data from order history pages."""
 
-    def parse_orders_page(self, orders_text: str) -> list:
+    def parse_orders_page(self, orders_text: str) -> list[Order]:
         """Parse Amazon orders page text to extract order information"""
         if not orders_text.strip():
             return []
@@ -23,7 +26,9 @@ class AmazonParser:
 
         # 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 = re.finditer(
+            order_pattern, orders_text, re.DOTALL | re.IGNORECASE
+        )
 
         for match in order_matches:
             order_date = match.group(1).strip()
@@ -32,7 +37,9 @@ class AmazonParser:
 
             # 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)
+            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]
@@ -54,7 +61,7 @@ class AmazonParser:
 
         return orders
 
-    def extract_items_from_content(self, order_content):
+    def extract_items_from_content(self, order_content: str) -> list[str]:
         """Extract item names from order content."""
         items = []
         lines = order_content.split("\n")

{ynab_amazon_categorizer-2.0.2 → ynab_amazon_categorizer-2.1.2}/src/ynab_amazon_categorizer/cli.py

@@ -1,15 +1,16 @@
 import json
 import os  # For history file path
-import re  # For order ID extraction
-from datetime import datetime
+from collections.abc import Iterable
+from typing import Optional, Union
 
 # --- NEW: Import prompt_toolkit components ---
 from prompt_toolkit import prompt
-from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+from prompt_toolkit.document import Document
 from prompt_toolkit.history import FileHistory
-from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
 
-from .amazon_parser import AmazonParser
+from .amazon_parser import AmazonParser, Order
 
 # --- END NEW ---
 # --- Import extracted modules ---
@@ -33,7 +34,7 @@ YNAB_API_URL = "https://api.ynab.com/v1"
 # NOTE: Amazon order parsing has been moved to amazon_parser.py
 
 
-def prompt_for_amazon_orders_data():
+def prompt_for_amazon_orders_data() -> Optional[list[Order]]:
     """Prompt user to paste Amazon orders page data"""
     print("\n--- Amazon Orders Data Entry ---")
     print("You can copy and paste the content from your Amazon orders page.")
@@ -71,12 +72,14 @@ def prompt_for_amazon_orders_data():
 # NOTE: find_matching_order moved to transaction_matcher.py
 
 
-def get_multiline_input_with_custom_submit(prompt_message="Enter multiline text: "):
+def get_multiline_input_with_custom_submit(
+    prompt_message: str = "Enter multiline text: ",
+) -> Optional[str]:
     """Get multiline input with Ctrl+J to submit"""
     kb = KeyBindings()
 
     @kb.add("escape", "enter")  # Binds Alt+Enter to submit
-    def _(event):
+    def _(event: KeyPressEvent) -> None:
         """When Alt+Enter is pressed, accept the current buffer's text."""
         event.app.exit(result=event.app.current_buffer.text)
 
@@ -95,7 +98,7 @@ def get_multiline_input_with_custom_submit(prompt_message="Enter multiline text:
         return None
 
 
-def generate_split_summary_memo(matching_order):
+def generate_split_summary_memo(matching_order: Order) -> str:
     """Generate a summary memo for split transactions showing all items"""
     if (
         not matching_order
@@ -116,11 +119,13 @@ def generate_split_summary_memo(matching_order):
     return summary
 
 
-def prompt_for_item_details():
+def prompt_for_item_details() -> Optional[
+    dict[str, Union[str, int, float, list[str], None]]
+]:
     """Prompt user to enter item details manually"""
     print("\n--- Manual Item Details Entry ---")
 
-    item_details = {}
+    item_details: dict[str, Union[str, int, float, list[str], None]] = {}
 
     # Get item title/description
     title = input("Enter item title/description (optional): ").strip()
@@ -174,11 +179,13 @@ def prompt_for_item_details():
 
 class CategoryCompleter(Completer):
     # ... (implementation from v3) ...
-    def __init__(self, category_list):
+    def __init__(self, category_list: list[tuple[str, str]]) -> None:
         self.categories = [name for name, _id in category_list]
         self.category_list = category_list
 
-    def get_completions(self, document, complete_event):
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
         text_before_cursor = document.text_before_cursor.lower()
         if text_before_cursor:
             for category_name in self.categories:
@@ -188,7 +195,9 @@ class CategoryCompleter(Completer):
                     )
 
 
-def prompt_for_category_selection(category_completer, name_to_id_map):
+def prompt_for_category_selection(
+    category_completer: CategoryCompleter, name_to_id_map: dict[str, str]
+) -> tuple[Optional[str], Optional[str]]:
     # ... (implementation from v3) ...
     history_file = os.path.join(os.path.expanduser("~"), ".ynab_amazon_cat_history")
     history = FileHistory(history_file)
@@ -227,7 +236,7 @@ def prompt_for_category_selection(category_completer, name_to_id_map):
 # --- Main Script Logic ---
 
 
-def main():
+def main() -> None:
     """Main CLI function."""
     # Load configuration using extracted Config class
     try:
@@ -260,10 +269,7 @@ def main():
     print(f"\nFound {len(categories_list)} usable categories. Completion enabled.")
 
     # Setup history for memo input (optional, but can be nice)
-    memo_history_file = os.path.join(
-        os.path.expanduser("~"), ".ynab_amazon_memo_history"
-    )
-    memo_history = FileHistory(memo_history_file)
+    os.path.join(os.path.expanduser("~"), ".ynab_amazon_memo_history")
 
     # Ask user if they want to provide Amazon orders data for automatic item detection
     print("\n--- Optional: Amazon Orders Data ---")
@@ -363,18 +369,29 @@ def main():
             )
             if matching_order:
                 print("\n  🎯 MATCHED ORDER FOUND:")
-                print(f"     Order ID: {matching_order.order_id}")
-                print(f"     Total: ${getattr(matching_order, 'total', 'N/A')}")
-                print(f"     Date: {getattr(matching_order, 'date_str', 'N/A')}")
+                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(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'}")
                 # Use extracted memo generator for order link
                 memo_generator = MemoGenerator()
-                order_link = memo_generator.generate_amazon_order_link(
-                    matching_order.order_id
-                )
+                order_link = memo_generator.generate_amazon_order_link(order_id)
                 print(f"     Order Link: {order_link}")
-                if hasattr(matching_order, "items") and matching_order.items:
+                if items:
                     print("     Items:")
-                    for item in matching_order.items:
+                    for item in items:
                         print(f"       - {item}")
                 print()
             else:
@@ -397,12 +414,18 @@ def main():
                 updated_payload_dict = None
 
                 # Check if there are multiple items and suggest splitting
-                if (
-                    matching_order
-                    and hasattr(matching_order, "items")
-                    and matching_order.items
-                    and len(matching_order.items) > 1
-                ):
+                # 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)
+
+                if should_offer_split:
                     print("There is more than one item in this transaction.")
 
                 split_decision = input(
@@ -419,17 +442,29 @@ def main():
                         continue  # Back to action prompt
 
                     # --- ENHANCED MEMO INPUT WITH AUTOMATIC ITEM DETECTION ---
+                    item_details: Optional[
+                        dict[str, Union[str, int, float, list[str], None]]
+                    ] = None
                     enhanced_memo = None
 
                     # Use matched order data or prompt for manual entry
                     if matching_order:
                         print("Using matched order data for memo generation...")
-                        item_details = {
-                            "order_id": matching_order.order_id,
-                            "items": getattr(matching_order, "items", []),
-                            "total": getattr(matching_order, "total", None),
-                            "date": getattr(matching_order, "date_str", None),
-                        }
+                        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"),
+                            }
                     else:
                         # Ask if user wants to enter item details manually
                         manual_entry = input(
@@ -443,15 +478,19 @@ def main():
                     if item_details:
                         if isinstance(item_details, dict) and "items" in item_details:
                             # Auto-matched order data - format as: Item Name\n Order Link
+                            items_list = item_details["items"]
                             items_text = (
-                                item_details["items"][0]
-                                if item_details["items"]
+                                items_list[0]
+                                if isinstance(items_list, list) and items_list
                                 else "Amazon Purchase"
                             )
                             # Use extracted memo generator
                             memo_generator = MemoGenerator()
+                            order_id_value = item_details["order_id"]
                             order_link = memo_generator.generate_amazon_order_link(
-                                item_details["order_id"]
+                                order_id_value
+                                if isinstance(order_id_value, str)
+                                else None
                             )
                             enhanced_memo = (
                                 f"{items_text}\n {order_link}"
@@ -514,7 +553,7 @@ def main():
                 else:
                     # --- SPLITTING ---
                     print("\n--- Splitting Transaction ---")
-                    subtransactions = []
+                    subtransactions: list[dict[str, Union[int, str, None]]] = []
                     remaining_milliunits = amount_milliunits
                     split_count = 1
 
@@ -524,12 +563,15 @@ def main():
                         )
 
                         # Show which item this split is for if we have matched order data
-                        if (
-                            matching_order
-                            and hasattr(matching_order, "items")
-                            and matching_order.items
-                        ):
-                            items = matching_order.items
+                        # Show which item this split is for if we have matched order data
+                        items = []
+                        if matching_order:
+                            if isinstance(matching_order, Order):
+                                items = matching_order.items or []
+                            else:
+                                items = matching_order.get("items", [])
+
+                        if items:
                             if split_count <= len(items):
                                 print(f"Item {split_count}: {items[split_count - 1]}")
                             else:
@@ -590,19 +632,26 @@ def main():
 
                         # --- ENHANCED SPLIT MEMO INPUT ---
                         # Generate memo for each split based on matched order data
-                        suggested_split_memo = ""
+                        split_memo: Optional[str] = None
+                        suggested_split_memo: str = ""
 
                         # Use the already matched order if available
                         if matching_order:
                             print("Using matched order data for split memo...")
-                            items = getattr(matching_order, "items", [])
+                            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")
+
                             if split_count <= len(items):
                                 # Use the specific item for this split
                                 items_text = items[split_count - 1]
                                 # Use extracted memo generator
                                 memo_generator = MemoGenerator()
                                 order_link = memo_generator.generate_amazon_order_link(
-                                    matching_order.order_id
+                                    order_id
                                 )
                                 suggested_split_memo = (
                                     f"{items_text}\n {order_link}"
@@ -652,15 +701,14 @@ def main():
                             print(
                                 f"Enter optional memo for '{category_name}' split (multiline):"
                             )
-                            split_memo = get_multiline_input_with_custom_submit("> ")
-                            if split_memo is None:
-                                split_memo = ""
-                            else:
-                                split_memo = split_memo.strip()
-                            if split_memo is None:
-                                split_memo = ""
-                            else:
-                                split_memo = split_memo.strip()
+                            split_memo_input = get_multiline_input_with_custom_submit(
+                                "> "
+                            )
+                            split_memo = (
+                                split_memo_input.strip()
+                                if split_memo_input is not None
+                                else ""
+                            )
                         # --- END ENHANCED SPLIT MEMO INPUT ---
 
                         subtransactions.append(
@@ -695,7 +743,7 @@ def main():
                             "payee_name": payee,
                             "category_id": None,  # Null for splits
                             "memo": generate_split_summary_memo(matching_order)
-                            if matching_order
+                            if matching_order and isinstance(matching_order, Order)
                             else original_memo,  # Generate summary memo for splits
                             "cleared": t.get("cleared"),
                             "approved": True,
@@ -731,8 +779,7 @@ def main():
                         confirm = "y"
                     if confirm == "y":
                         if ynab_client.update_transaction(
-                            transaction_id,
-                            updated_payload_dict
+                            transaction_id, updated_payload_dict
                         ):
                             print("Update successful.")
                             break  # Exit action loop, go to next transaction

{ynab_amazon_categorizer-2.0.2 → ynab_amazon_categorizer-2.1.2}/src/ynab_amazon_categorizer/config.py

@@ -2,6 +2,7 @@
 
 import os
 from pathlib import Path
+from typing import Optional
 
 from .exceptions import ConfigurationError
 
@@ -16,13 +17,13 @@ except ImportError:
 class Config:
     """Configuration class for YNAB Amazon Categorizer."""
 
-    def __init__(self, api_key: str, budget_id: str, account_id: str = None):
+    def __init__(self, api_key: str, budget_id: str, account_id: Optional[str] = None):
         self.api_key = api_key
         self.budget_id = budget_id
         self.account_id = account_id
 
     @classmethod
-    def from_env(cls):
+    def from_env(cls) -> "Config":
         # Load .env file if available
         if DOTENV_AVAILABLE:
             # Look for .env file in current directory and parent directories

{ynab_amazon_categorizer-2.0.2 → ynab_amazon_categorizer-2.1.2}/src/ynab_amazon_categorizer/exceptions.py

@@ -3,4 +3,5 @@
 
 class ConfigurationError(Exception):
     """Raised when configuration is invalid or missing."""
+
     pass