fin-infra 0.1.62__py3-none-any.whl → 0.1.69__py3-none-any.whl

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
 
@@ -145,19 +145,21 @@ def add_normalization(
     @router.get("/convert")
     async def convert_currency(
         amount: float = Query(..., description="Amount to convert"),
-        from_currency: str = Query(..., alias="from", description="Source currency code (e.g., USD)"),
+        from_currency: str = Query(
+            ..., alias="from", description="Source currency code (e.g., USD)"
+        ),
         to_currency: str = Query(..., alias="to", description="Target currency code (e.g., EUR)"),
     ):
         """Convert amount between currencies."""
         try:
-            result = await converter.convert(amount, from_currency, to_currency)
+            result = await converter.convert_with_details(amount, from_currency, to_currency)
             return {
-                "amount": amount,
-                "from_currency": from_currency,
-                "to_currency": to_currency,
-                "result": result.amount,
+                "amount": result.amount,
+                "from_currency": result.from_currency,
+                "to_currency": result.to_currency,
+                "result": result.converted,
                 "rate": result.rate,
-                "timestamp": result.timestamp.isoformat(),
+                "timestamp": result.date.isoformat() if result.date else None,
             }
         except CurrencyNotSupportedError as e:
             raise HTTPException(status_code=400, detail=str(e))

fin_infra/normalization/providers/exchangerate.py

@@ -2,7 +2,7 @@
 
 import os
 from datetime import date as DateType
-from typing import Optional
+from typing import Optional, cast
 
 import httpx
 
@@ -66,10 +66,10 @@ class ExchangeRateClient:
                         raise ExchangeRateAPIError(
                             f"API returned error: {data.get('error-type', 'unknown')}"
                         )
-                    return data["conversion_rates"]
+                    return cast(dict[str, float], data["conversion_rates"])
                 else:
                     # Free tier response format
-                    return data["rates"]
+                    return cast(dict[str, float], data["rates"])
 
         except httpx.HTTPError as e:
             raise ExchangeRateAPIError(f"HTTP error fetching rates: {e}")

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/banking/plaid_client.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from datetime import date, datetime, timedelta
+from typing import Any, cast
 
 # Plaid SDK v25+ uses new API structure
 try:
@@ -33,7 +34,7 @@ class PlaidClient(BankingProvider):
         environment: str | None = None,
     ) -> None:
         """Initialize Plaid client with either Settings object or individual parameters.
-        
+
         Args:
             settings: Settings object (legacy pattern)
             client_id: Plaid client ID (preferred - from env or passed directly)
@@ -44,14 +45,14 @@ class PlaidClient(BankingProvider):
             raise RuntimeError(
                 "plaid-python SDK not available or import failed; check installed version (requires v25+)"
             )
-        
+
         # Support both patterns: Settings object or individual params
         if settings is not None:
             # Legacy pattern with Settings object
             client_id = client_id or settings.plaid_client_id
             secret = secret or settings.plaid_secret
             environment = environment or settings.plaid_env
-        
+
         # Map environment string to Plaid Environment enum
         # Note: Plaid only has Sandbox and Production (no Development in SDK)
         env_str = environment or "sandbox"
@@ -60,22 +61,22 @@ class PlaidClient(BankingProvider):
             "development": plaid.Environment.Sandbox,  # Map development to sandbox (Plaid SDK limitation)
             "production": plaid.Environment.Production,
         }
-        
+
         if env_str not in env_map:
             raise ValueError(
                 f"Invalid Plaid environment: '{env_str}'. "
                 f"Must be one of: sandbox, development, production"
             )
-        
+
         host = env_map[env_str]
-        
+
         # Configure Plaid client (v8.0.0+ API)
         configuration = plaid.Configuration(
             host=host,
             api_key={
                 "clientId": client_id,
                 "secret": secret,
-            }
+            },
         )
         api_client = plaid.ApiClient(configuration)
         self.client = plaid_api.PlaidApi(api_client)
@@ -85,18 +86,18 @@ class PlaidClient(BankingProvider):
             user=LinkTokenCreateRequestUser(client_user_id=user_id),
             client_name="fin-infra",
             products=[
-                Products("auth"),           # Account/routing numbers for ACH
-                Products("transactions"),   # Transaction history
-                Products("liabilities"),    # Credit cards, loans, student loans
-                Products("investments"),    # Brokerage, retirement accounts
-                Products("assets"),         # Asset reports for lending/verification
-                Products("identity"),       # Account holder info (name, email, phone)
+                Products("auth"),  # Account/routing numbers for ACH
+                Products("transactions"),  # Transaction history
+                Products("liabilities"),  # Credit cards, loans, student loans
+                Products("investments"),  # Brokerage, retirement accounts
+                Products("assets"),  # Asset reports for lending/verification
+                Products("identity"),  # Account holder info (name, email, phone)
             ],
             country_codes=[CountryCode("US")],
             language="en",
         )
         response = self.client.link_token_create(request)
-        return response["link_token"]
+        return cast(str, response["link_token"])
 
     def exchange_public_token(self, public_token: str) -> dict:
         request = ItemPublicTokenExchangeRequest(public_token=public_token)
@@ -121,7 +122,7 @@ class PlaidClient(BankingProvider):
             start = end - timedelta(days=30)
             start_date = start_date or start.isoformat()
             end_date = end_date or end.isoformat()
-        
+
         request = TransactionsGetRequest(
             access_token=access_token,
             start_date=date.fromisoformat(start_date),
@@ -135,19 +136,19 @@ class PlaidClient(BankingProvider):
         request = AccountsBalanceGetRequest(access_token=access_token)
         response = self.client.accounts_balance_get(request)
         accounts = [acc.to_dict() for acc in response["accounts"]]
-        
+
         if account_id:
             # Filter to specific account
             for account in accounts:
                 if account.get("account_id") == account_id:
                     return {"balances": [account.get("balances", {})]}
             return {"balances": []}
-        
+
         # Return all balances
         return {"balances": [acc.get("balances", {}) for acc in accounts]}
 
-    def identity(self, access_token: str) -> dict:
+    def identity(self, access_token: str) -> dict[Any, Any]:
         """Fetch identity/account holder information."""
         request = IdentityGetRequest(access_token=access_token)
         response = self.client.identity_get(request)
-        return response.to_dict()
+        return cast(dict[Any, Any], response.to_dict())

fin_infra/providers/banking/teller_client.py

@@ -24,7 +24,7 @@ from __future__ import annotations
 
 import ssl
 import httpx
-from typing import Any
+from typing import Any, cast
 
 from ..base import BankingProvider
 
@@ -93,7 +93,13 @@ class TellerClient(BankingProvider):
             ssl_context.load_cert_chain(certfile=cert_path, keyfile=key_path)
             client_kwargs["verify"] = ssl_context
 
-        self.client = httpx.Client(**client_kwargs)
+        # Create client with explicit parameters to satisfy type checker
+        self.client = httpx.Client(
+            base_url=str(client_kwargs["base_url"]),
+            timeout=float(client_kwargs["timeout"]),  # type: ignore[arg-type]
+            headers=client_kwargs["headers"],  # type: ignore[arg-type]
+            verify=client_kwargs.get("verify", True),  # type: ignore[arg-type]
+        )
 
     def _request(self, method: str, path: str, **kwargs: Any) -> Any:
         """Make HTTP request to Teller API with error handling.
@@ -139,7 +145,7 @@ class TellerClient(BankingProvider):
                 "products": ["accounts", "transactions", "balances", "identity"],
             },
         )
-        return response.get("enrollment_id", "")
+        return cast(str, response.get("enrollment_id", ""))
 
     def exchange_public_token(self, public_token: str) -> dict:
         """Exchange public token for access token.
@@ -186,7 +192,7 @@ class TellerClient(BankingProvider):
             auth=(access_token, ""),
         )
         response.raise_for_status()
-        return response.json()
+        return cast(list[dict[Any, Any]], response.json())
 
     def transactions(
         self,
@@ -229,7 +235,7 @@ class TellerClient(BankingProvider):
             params=params,
         )
         response.raise_for_status()
-        return response.json()
+        return cast(list[dict[Any, Any]], response.json())
 
     def balances(self, access_token: str, account_id: str | None = None) -> dict:
         """Fetch current balances.
@@ -261,7 +267,7 @@ class TellerClient(BankingProvider):
             )
 
         response.raise_for_status()
-        return response.json()
+        return cast(dict[Any, Any], response.json())
 
     def identity(self, access_token: str) -> dict:
         """Fetch identity/account holder information.
@@ -285,7 +291,7 @@ class TellerClient(BankingProvider):
             auth=(access_token, ""),
         )
         response.raise_for_status()
-        return response.json()
+        return cast(dict[Any, Any], response.json())
 
     def __del__(self) -> None:
         """Close HTTP client on cleanup."""