fin-infra 0.1.65__py3-none-any.whl → 0.1.67__py3-none-any.whl

fin_infra/net_worth/add.py

@@ -36,13 +36,16 @@ tracker = add_net_worth_tracking(app)
 """
 
 from datetime import datetime, timedelta
+from typing import Any
 
 from fastapi import FastAPI, HTTPException, Query
 
 from fin_infra.net_worth.ease import NetWorthTracker, easy_net_worth
 from fin_infra.net_worth.models import (
+    AssetDetail,
     ConversationResponse,
     GoalProgressResponse,
+    LiabilityDetail,
     NetWorthResponse,
     SnapshotHistoryResponse,
 )
@@ -188,8 +191,8 @@ def add_net_worth_tracking(
             # Persistence: Asset/liability details stored in snapshot JSON fields or separate tables.
             # Generate with: fin-infra scaffold net_worth --dest-dir app/models/
             # For now, create empty lists for testing/examples.
-            asset_details = []
-            liability_details = []
+            asset_details: list[AssetDetail] = []
+            liability_details: list[LiabilityDetail] = []
 
             # Calculate breakdowns
             asset_allocation = calculate_asset_allocation(asset_details)
@@ -508,7 +511,7 @@ def add_net_worth_tracking(
             snapshot = await tracker.calculate_net_worth(user_id=user_id, access_token=access_token)
 
             # Get goals for context (if goal_tracker available)
-            goals = []
+            goals: list[Any] = []
             if tracker.goal_tracker:
                 # TODO: Implement get_goals() method
                 pass
@@ -657,10 +660,10 @@ def add_net_worth_tracking(
 
         try:
             # Get current snapshot
-            snapshot = await tracker.calculate_net_worth(user_id=user_id, access_token=access_token)
+            await tracker.calculate_net_worth(user_id=user_id, access_token=access_token)
 
             # Get historical snapshots for progress tracking
-            snapshots = await tracker.get_snapshots(user_id=user_id, days=90)
+            await tracker.get_snapshots(user_id=user_id, days=90)
 
             # Persistence: Goal retrieval via scaffolded goals repository.
             # Generate with: fin-infra scaffold goals --dest-dir app/models/

fin_infra/net_worth/aggregator.py

@@ -213,16 +213,17 @@ class NetWorthAggregator:
         results = await asyncio.gather(*tasks, return_exceptions=True)
 
         # Aggregate results (skip failed providers)
-        all_assets = []
-        all_liabilities = []
-        actual_providers = []
+        all_assets: list[AssetDetail] = []
+        all_liabilities: list[LiabilityDetail] = []
+        actual_providers: list[str] = []
 
         for i, result in enumerate(results):
-            if isinstance(result, Exception):
+            if isinstance(result, BaseException):
                 # Log error but continue (graceful degradation)
                 print(f"Provider {providers_used[i]} failed: {result}")
                 continue
 
+            # result is now tuple[list[AssetDetail], list[LiabilityDetail]]
             assets, liabilities = result
             all_assets.extend(assets)
             all_liabilities.extend(liabilities)

fin_infra/net_worth/ease.py

@@ -377,7 +377,7 @@ def easy_net_worth(
 
     if enable_llm:
         try:
-            from ai_infra.llm.llm import LLM  # type: ignore[attr-defined]
+            from ai_infra.llm.llm import LLM
         except ImportError:
             raise ImportError(
                 "LLM features require ai-infra package. " "Install with: pip install ai-infra"

fin_infra/net_worth/models.py

@@ -19,6 +19,7 @@ Pydantic V2 models for net worth tracking.
 
 from datetime import datetime
 from enum import Enum
+from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, ConfigDict, Field, computed_field
 
@@ -207,54 +208,100 @@ class AssetAllocation(BaseModel):
     vehicles: float = Field(0.0, ge=0, description="Vehicle value")
     other_assets: float = Field(0.0, ge=0, description="Other asset value")
 
-    @computed_field
-    @property
-    def total_assets(self) -> float:
-        """Sum of all asset categories."""
-        return (
-            self.cash
-            + self.investments
-            + self.crypto
-            + self.real_estate
-            + self.vehicles
-            + self.other_assets
-        )
-
-    @computed_field
-    @property
-    def cash_percentage(self) -> float:
-        """Cash as percentage of total assets."""
-        return (self.cash / self.total_assets * 100) if self.total_assets > 0 else 0.0
-
-    @computed_field
-    @property
-    def investments_percentage(self) -> float:
-        """Investments as percentage of total assets."""
-        return (self.investments / self.total_assets * 100) if self.total_assets > 0 else 0.0
-
-    @computed_field
-    @property
-    def crypto_percentage(self) -> float:
-        """Crypto as percentage of total assets."""
-        return (self.crypto / self.total_assets * 100) if self.total_assets > 0 else 0.0
-
-    @computed_field
-    @property
-    def real_estate_percentage(self) -> float:
-        """Real estate as percentage of total assets."""
-        return (self.real_estate / self.total_assets * 100) if self.total_assets > 0 else 0.0
-
-    @computed_field
-    @property
-    def vehicles_percentage(self) -> float:
-        """Vehicles as percentage of total assets."""
-        return (self.vehicles / self.total_assets * 100) if self.total_assets > 0 else 0.0
-
-    @computed_field
-    @property
-    def other_percentage(self) -> float:
-        """Other assets as percentage of total assets."""
-        return (self.other_assets / self.total_assets * 100) if self.total_assets > 0 else 0.0
+    if TYPE_CHECKING:
+
+        @property
+        def total_assets(self) -> float:
+            """Sum of all asset categories."""
+            return (
+                self.cash
+                + self.investments
+                + self.crypto
+                + self.real_estate
+                + self.vehicles
+                + self.other_assets
+            )
+
+        @property
+        def cash_percentage(self) -> float:
+            """Cash as percentage of total assets."""
+            return (self.cash / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+        @property
+        def investments_percentage(self) -> float:
+            """Investments as percentage of total assets."""
+            return (self.investments / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+        @property
+        def crypto_percentage(self) -> float:
+            """Crypto as percentage of total assets."""
+            return (self.crypto / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+        @property
+        def real_estate_percentage(self) -> float:
+            """Real estate as percentage of total assets."""
+            return (self.real_estate / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+        @property
+        def vehicles_percentage(self) -> float:
+            """Vehicles as percentage of total assets."""
+            return (self.vehicles / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+        @property
+        def other_percentage(self) -> float:
+            """Other assets as percentage of total assets."""
+            return (self.other_assets / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+    else:
+
+        @computed_field
+        @property
+        def total_assets(self) -> float:
+            """Sum of all asset categories."""
+            return (
+                self.cash
+                + self.investments
+                + self.crypto
+                + self.real_estate
+                + self.vehicles
+                + self.other_assets
+            )
+
+        @computed_field
+        @property
+        def cash_percentage(self) -> float:
+            """Cash as percentage of total assets."""
+            return (self.cash / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+        @computed_field
+        @property
+        def investments_percentage(self) -> float:
+            """Investments as percentage of total assets."""
+            return (self.investments / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+        @computed_field
+        @property
+        def crypto_percentage(self) -> float:
+            """Crypto as percentage of total assets."""
+            return (self.crypto / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+        @computed_field
+        @property
+        def real_estate_percentage(self) -> float:
+            """Real estate as percentage of total assets."""
+            return (self.real_estate / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+        @computed_field
+        @property
+        def vehicles_percentage(self) -> float:
+            """Vehicles as percentage of total assets."""
+            return (self.vehicles / self.total_assets * 100) if self.total_assets > 0 else 0.0
+
+        @computed_field
+        @property
+        def other_percentage(self) -> float:
+            """Other assets as percentage of total assets."""
+            return (self.other_assets / self.total_assets * 100) if self.total_assets > 0 else 0.0
 
 
 class LiabilityBreakdown(BaseModel):
@@ -288,74 +335,148 @@ class LiabilityBreakdown(BaseModel):
     personal_loans: float = Field(0.0, ge=0, description="Personal loan balance")
     lines_of_credit: float = Field(0.0, ge=0, description="Line of credit balance")
 
-    @computed_field
-    @property
-    def total_liabilities(self) -> float:
-        """Sum of all liability categories."""
-        return (
-            self.credit_cards
-            + self.mortgages
-            + self.auto_loans
-            + self.student_loans
-            + self.personal_loans
-            + self.lines_of_credit
-        )
-
-    @computed_field
-    @property
-    def credit_cards_percentage(self) -> float:
-        """Credit cards as percentage of total liabilities."""
-        return (
-            (self.credit_cards / self.total_liabilities * 100)
-            if self.total_liabilities > 0
-            else 0.0
-        )
-
-    @computed_field
-    @property
-    def mortgages_percentage(self) -> float:
-        """Mortgages as percentage of total liabilities."""
-        return (
-            (self.mortgages / self.total_liabilities * 100) if self.total_liabilities > 0 else 0.0
-        )
-
-    @computed_field
-    @property
-    def auto_loans_percentage(self) -> float:
-        """Auto loans as percentage of total liabilities."""
-        return (
-            (self.auto_loans / self.total_liabilities * 100) if self.total_liabilities > 0 else 0.0
-        )
-
-    @computed_field
-    @property
-    def student_loans_percentage(self) -> float:
-        """Student loans as percentage of total liabilities."""
-        return (
-            (self.student_loans / self.total_liabilities * 100)
-            if self.total_liabilities > 0
-            else 0.0
-        )
-
-    @computed_field
-    @property
-    def personal_loans_percentage(self) -> float:
-        """Personal loans as percentage of total liabilities."""
-        return (
-            (self.personal_loans / self.total_liabilities * 100)
-            if self.total_liabilities > 0
-            else 0.0
-        )
-
-    @computed_field
-    @property
-    def lines_of_credit_percentage(self) -> float:
-        """Lines of credit as percentage of total liabilities."""
-        return (
-            (self.lines_of_credit / self.total_liabilities * 100)
-            if self.total_liabilities > 0
-            else 0.0
-        )
+    if TYPE_CHECKING:
+
+        @property
+        def total_liabilities(self) -> float:
+            """Sum of all liability categories."""
+            return (
+                self.credit_cards
+                + self.mortgages
+                + self.auto_loans
+                + self.student_loans
+                + self.personal_loans
+                + self.lines_of_credit
+            )
+
+        @property
+        def credit_cards_percentage(self) -> float:
+            """Credit cards as percentage of total liabilities."""
+            return (
+                (self.credit_cards / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+        @property
+        def mortgages_percentage(self) -> float:
+            """Mortgages as percentage of total liabilities."""
+            return (
+                (self.mortgages / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+        @property
+        def auto_loans_percentage(self) -> float:
+            """Auto loans as percentage of total liabilities."""
+            return (
+                (self.auto_loans / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+        @property
+        def student_loans_percentage(self) -> float:
+            """Student loans as percentage of total liabilities."""
+            return (
+                (self.student_loans / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+        @property
+        def personal_loans_percentage(self) -> float:
+            """Personal loans as percentage of total liabilities."""
+            return (
+                (self.personal_loans / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+        @property
+        def lines_of_credit_percentage(self) -> float:
+            """Lines of credit as percentage of total liabilities."""
+            return (
+                (self.lines_of_credit / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+    else:
+
+        @computed_field
+        @property
+        def total_liabilities(self) -> float:
+            """Sum of all liability categories."""
+            return (
+                self.credit_cards
+                + self.mortgages
+                + self.auto_loans
+                + self.student_loans
+                + self.personal_loans
+                + self.lines_of_credit
+            )
+
+        @computed_field
+        @property
+        def credit_cards_percentage(self) -> float:
+            """Credit cards as percentage of total liabilities."""
+            return (
+                (self.credit_cards / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+        @computed_field
+        @property
+        def mortgages_percentage(self) -> float:
+            """Mortgages as percentage of total liabilities."""
+            return (
+                (self.mortgages / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+        @computed_field
+        @property
+        def auto_loans_percentage(self) -> float:
+            """Auto loans as percentage of total liabilities."""
+            return (
+                (self.auto_loans / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+        @computed_field
+        @property
+        def student_loans_percentage(self) -> float:
+            """Student loans as percentage of total liabilities."""
+            return (
+                (self.student_loans / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+        @computed_field
+        @property
+        def personal_loans_percentage(self) -> float:
+            """Personal loans as percentage of total liabilities."""
+            return (
+                (self.personal_loans / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
+
+        @computed_field
+        @property
+        def lines_of_credit_percentage(self) -> float:
+            """Lines of credit as percentage of total liabilities."""
+            return (
+                (self.lines_of_credit / self.total_liabilities * 100)
+                if self.total_liabilities > 0
+                else 0.0
+            )
 
 
 class AssetDetail(BaseModel):

fin_infra/normalization/__init__.py

@@ -1,5 +1,10 @@
 """Data normalization module for financial symbols and currencies."""
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
 from fin_infra.normalization.currency_converter import (
     CurrencyConverter,
     CurrencyNotSupportedError,
@@ -64,7 +69,7 @@ def easy_normalization(
 
 
 def add_normalization(
-    app: "FastAPI",  # type: ignore
+    app: "FastAPI",
     *,
     prefix: str = "/normalize",
     api_key: str | None = None,
@@ -110,11 +115,6 @@ def add_normalization(
         - Integrated with svc-infra observability (request metrics)
         - Scoped docs at {prefix}/docs for standalone documentation
     """
-    from typing import TYPE_CHECKING
-
-    if TYPE_CHECKING:
-        from fastapi import FastAPI
-
     # Import FastAPI dependencies
     from fastapi import Query, HTTPException
 

fin_infra/obs/classifier.py

@@ -112,9 +112,9 @@ def financial_route_classifier(route_path: str, method: str) -> str:
 
 
 def compose_classifiers(
-    *classifiers: Callable[[str], str],
+    *classifiers: Callable[[str, str], str],
     default: str = "public",
-) -> Callable[[str], str]:
+) -> Callable[[str, str], str]:
     """
     Compose multiple route classifiers with fallback logic.
 

fin_infra/providers/base.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Iterable, Sequence
+from typing import Any, Iterable, Sequence
 
 from ..models import Quote, Candle
 
@@ -20,11 +20,11 @@ class MarketDataProvider(ABC):
 
 class CryptoDataProvider(ABC):
     @abstractmethod
-    def ticker(self, symbol_pair: str) -> Quote:
+    def ticker(self, symbol_pair: str) -> Any:
         pass
 
     @abstractmethod
-    def ohlcv(self, symbol_pair: str, timeframe: str = "1d", limit: int = 100) -> Sequence[Candle]:
+    def ohlcv(self, symbol_pair: str, timeframe: str = "1d", limit: int = 100) -> Any:
         pass
 
 
@@ -161,11 +161,11 @@ class IdentityProvider(ABC):
 
 class CreditProvider(ABC):
     @abstractmethod
-    def get_credit_score(self, user_id: str, **kwargs) -> dict | None:
+    def get_credit_score(self, user_id: str, **kwargs: Any) -> Any:
         pass
 
     @abstractmethod
-    def get_credit_report(self, user_id: str, **kwargs) -> dict | None:
+    def get_credit_report(self, user_id: str, **kwargs: Any) -> Any:
         """Retrieve full credit report for a user."""
         pass
 
@@ -174,36 +174,31 @@ class TaxProvider(ABC):
     """Provider for tax data and document retrieval."""
 
     @abstractmethod
-    def get_tax_forms(self, user_id: str, tax_year: int, **kwargs) -> list[dict]:
+    def get_tax_forms(self, user_id: str, tax_year: int, **kwargs: Any) -> Any:
         """Retrieve tax forms for a user and tax year."""
         pass
 
     @abstractmethod
-    def get_tax_documents(self, user_id: str, tax_year: int, **kwargs) -> list[dict]:
+    def get_tax_documents(self, user_id: str, tax_year: int, **kwargs: Any) -> Any:
         """Retrieve tax documents for a user and tax year."""
         pass
 
     @abstractmethod
-    def get_tax_document(self, document_id: str, **kwargs) -> dict:
+    def get_tax_document(self, document_id: str, **kwargs: Any) -> Any:
         """Retrieve a specific tax document by ID."""
         pass
 
     @abstractmethod
-    def calculate_crypto_gains(self, transactions: list[dict], **kwargs) -> dict:
+    def calculate_crypto_gains(self, *args: Any, **kwargs: Any) -> Any:
         """Calculate capital gains from crypto transactions."""
         pass
 
     @abstractmethod
     def calculate_tax_liability(
         self,
-        user_id: str,
-        income: float,
-        deductions: float,
-        filing_status: str,
-        tax_year: int,
-        state: str | None = None,
-        **kwargs,
-    ) -> dict:
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
         """Calculate estimated tax liability."""
         pass
 

fin_infra/recurring/add.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 
 import time
 from datetime import datetime, timedelta
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from .ease import easy_recurring_detection
 from .models import (
@@ -93,7 +93,7 @@ def add_recurring_detection(
         llm_model=llm_model,
     )
 
-        # Store on app.state
+    # Store on app.state
     app.state.recurring_detector = detector
 
     # Use svc-infra user_router for authentication (recurring detection is user-specific)
@@ -133,7 +133,7 @@ def add_recurring_detection(
         # For now, return empty result with structure.
         # In production: transactions = get_user_transactions(user.id, days=request.days)
 
-        transactions = []  # Placeholder
+        transactions: list[dict[str, Any]] = []  # Placeholder
 
         # Detect patterns
         patterns = detector.detect_patterns(transactions)
@@ -180,7 +180,7 @@ def add_recurring_detection(
         #     return cached
 
         # Detect patterns (same as /detect endpoint)
-        transactions = []  # Placeholder
+        transactions: list[dict[str, Any]] = []  # Placeholder
         patterns = detector.detect_patterns(transactions)
         patterns = [p for p in patterns if p.confidence >= min_confidence]
 
@@ -208,7 +208,7 @@ def add_recurring_detection(
         List of predicted charges with expected dates and amounts
         """
         # Get detected patterns
-        transactions = []  # Placeholder
+        transactions: list[dict[str, Any]] = []  # Placeholder
         patterns = detector.detect_patterns(transactions)
         patterns = [p for p in patterns if p.confidence >= min_confidence]
 
@@ -230,7 +230,7 @@ def add_recurring_detection(
         - Top merchants by amount
         """
         # Get all detected patterns
-        transactions = []  # Placeholder
+        transactions: list[dict[str, Any]] = []  # Placeholder
         patterns = detector.detect_patterns(transactions)
 
         # Calculate stats
@@ -321,7 +321,7 @@ def add_recurring_detection(
         from .summary import get_recurring_summary
 
         # Get detected patterns for user
-        transactions = []  # Placeholder - in production: get_user_transactions(user_id)
+        transactions: list[dict[str, Any]] = []  # Placeholder - in production: get_user_transactions(user_id)
         patterns = detector.detect_patterns(transactions)
 
         # Generate summary
@@ -375,7 +375,7 @@ def add_recurring_detection(
             **Cost:** ~$0.0002/generation with Google Gemini, <$0.00004 effective with caching
             """
             # Get detected patterns
-            transactions = []  # Placeholder
+            transactions: list[dict[str, Any]] = []  # Placeholder
             patterns = detector.detect_patterns(transactions)
 
             # Convert patterns to subscription dicts for LLM