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

fin_infra/investments/providers/snaptrade.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 
 from datetime import date
 from decimal import Decimal
-from typing import Any, Dict, List, Optional
+from typing import Any, cast
 
 import httpx
 
@@ -77,9 +77,7 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
             ValueError: If client_id or consumer_key is missing
         """
         if not client_id or not consumer_key:
-            raise ValueError(
-                "client_id and consumer_key are required for SnapTrade provider"
-            )
+            raise ValueError("client_id and consumer_key are required for SnapTrade provider")
 
         self.client_id = client_id
         self.consumer_key = consumer_key
@@ -95,17 +93,17 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
             timeout=30.0,
         )
 
-    def _auth_headers(self, user_id: str, user_secret: str) -> Dict[str, str]:
+    def _auth_headers(self, user_id: str, user_secret: str) -> dict[str, str]:
         """Build authentication headers for SnapTrade API requests.
-        
+
         SECURITY: User secrets are passed in headers, NOT URL params.
         URL params are logged in access logs, browser history, and proxy logs.
         Headers are not logged by default in most web servers.
-        
+
         Args:
             user_id: SnapTrade user ID
             user_secret: SnapTrade user secret (sensitive!)
-            
+
         Returns:
             Dict with authentication headers
         """
@@ -117,8 +115,8 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
     async def get_holdings(
         self,
         access_token: str,
-        account_ids: Optional[List[str]] = None,
-    ) -> List[Holding]:
+        account_ids: list[str] | None = None,
+    ) -> list[Holding]:
         """Fetch investment holdings from SnapTrade.
 
         Note: SnapTrade uses user_id + user_secret, passed as access_token in format "user_id:user_secret"
@@ -158,9 +156,7 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
             all_holdings = []
             for account in accounts:
                 account_id = account["id"]
-                positions_url = (
-                    f"{self.base_url}/accounts/{account_id}/positions"
-                )
+                positions_url = f"{self.base_url}/accounts/{account_id}/positions"
                 pos_response = await self.client.get(positions_url, headers=auth_headers)
                 pos_response.raise_for_status()
                 positions = await pos_response.json()
@@ -175,15 +171,15 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
         except httpx.HTTPStatusError as e:
             raise self._transform_error(e)
         except Exception as e:
-            raise ValueError(f"SnapTrade API error: {str(e)}")
+            raise ValueError(f"SnapTrade API error: {e!s}")
 
     async def get_transactions(
         self,
         access_token: str,
         start_date: date,
         end_date: date,
-        account_ids: Optional[List[str]] = None,
-    ) -> List[InvestmentTransaction]:
+        account_ids: list[str] | None = None,
+    ) -> list[InvestmentTransaction]:
         """Fetch investment transactions from SnapTrade.
 
         Args:
@@ -226,15 +222,15 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
             all_transactions = []
             for account in accounts:
                 account_id = account["id"]
-                transactions_url = (
-                    f"{self.base_url}/accounts/{account_id}/transactions"
-                )
+                transactions_url = f"{self.base_url}/accounts/{account_id}/transactions"
                 # Date params are non-sensitive, only auth goes in headers
                 tx_params = {
                     "startDate": start_date.isoformat(),
                     "endDate": end_date.isoformat(),
                 }
-                tx_response = await self.client.get(transactions_url, params=tx_params, headers=auth_headers)
+                tx_response = await self.client.get(
+                    transactions_url, params=tx_params, headers=auth_headers
+                )
                 tx_response.raise_for_status()
                 transactions = await tx_response.json()
 
@@ -248,11 +244,9 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
         except httpx.HTTPStatusError as e:
             raise self._transform_error(e)
         except Exception as e:
-            raise ValueError(f"SnapTrade API error: {str(e)}")
+            raise ValueError(f"SnapTrade API error: {e!s}")
 
-    async def get_securities(
-        self, access_token: str, security_ids: List[str]
-    ) -> List[Security]:
+    async def get_securities(self, access_token: str, security_ids: list[str]) -> list[Security]:
         """Fetch security details from SnapTrade positions.
 
         Note: SnapTrade doesn't have a dedicated securities endpoint.
@@ -273,7 +267,7 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
             >>> for security in securities:
             ...     print(f"{security.ticker_symbol}: ${security.close_price}")
         """
-        user_id, user_secret = self._parse_access_token(access_token)
+        _user_id, _user_secret = self._parse_access_token(access_token)
 
         try:
             # Get all holdings to extract securities
@@ -288,11 +282,9 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
             return list(securities_map.values())
 
         except Exception as e:
-            raise ValueError(f"SnapTrade API error: {str(e)}")
+            raise ValueError(f"SnapTrade API error: {e!s}")
 
-    async def get_investment_accounts(
-        self, access_token: str
-    ) -> List[InvestmentAccount]:
+    async def get_investment_accounts(self, access_token: str) -> list[InvestmentAccount]:
         """Fetch investment accounts with aggregated holdings.
 
         Returns accounts with total value, cost basis, and unrealized P&L.
@@ -328,9 +320,7 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
                 account_id = account["id"]
 
                 # Get positions for this account
-                positions_url = (
-                    f"{self.base_url}/accounts/{account_id}/positions"
-                )
+                positions_url = f"{self.base_url}/accounts/{account_id}/positions"
                 pos_response = await self.client.get(positions_url, headers=auth_headers)
                 pos_response.raise_for_status()
                 positions = await pos_response.json()
@@ -354,8 +344,8 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
                     type=account.get("type", "investment"),
                     subtype=account.get("account_type"),
                     balances={
-                        "current": float(balances.get("total", {}).get("amount", 0)),
-                        "available": float(balances.get("cash", {}).get("amount", 0)),
+                        "current": Decimal(str(balances.get("total", {}).get("amount", 0))),
+                        "available": Decimal(str(balances.get("cash", {}).get("amount", 0))),
                     },
                     holdings=holdings,
                 )
@@ -366,11 +356,9 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
         except httpx.HTTPStatusError as e:
             raise self._transform_error(e)
         except Exception as e:
-            raise ValueError(f"SnapTrade API error: {str(e)}")
+            raise ValueError(f"SnapTrade API error: {e!s}")
 
-    async def list_connections(
-        self, access_token: str
-    ) -> List[Dict[str, Any]]:
+    async def list_connections(self, access_token: str) -> list[dict[str, Any]]:
         """List brokerage connections for a user.
 
         Returns which brokerages the user has connected (E*TRADE, Robinhood, etc.).
@@ -393,14 +381,14 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
             url = f"{self.base_url}/connections"
             response = await self.client.get(url, headers=auth_headers)
             response.raise_for_status()
-            return await response.json()
+            return cast("list[dict[str, Any]]", await response.json())
 
         except httpx.HTTPStatusError as e:
             raise self._transform_error(e)
         except Exception as e:
-            raise ValueError(f"SnapTrade API error: {str(e)}")
+            raise ValueError(f"SnapTrade API error: {e!s}")
 
-    def get_brokerage_capabilities(self, brokerage_name: str) -> Dict[str, Any]:
+    def get_brokerage_capabilities(self, brokerage_name: str) -> dict[str, Any]:
         """Get capabilities for a specific brokerage.
 
         Important: Robinhood is READ-ONLY (no trading support).
@@ -490,16 +478,12 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
             user_id, user_secret = access_token.split(":", 1)
             return user_id, user_secret
         except ValueError:
-            raise ValueError(
-                "Invalid access_token format. Expected 'user_id:user_secret'"
-            )
+            raise ValueError("Invalid access_token format. Expected 'user_id:user_secret'")
 
-    def _transform_holding(
-        self, snaptrade_position: Dict[str, Any], account_id: str
-    ) -> Holding:
+    def _transform_holding(self, snaptrade_position: dict[str, Any], account_id: str) -> Holding:
         """Transform SnapTrade position data to Holding model."""
         symbol_data = snaptrade_position.get("symbol", {})
-        
+
         # Create Security from symbol data
         security = Security(
             security_id=symbol_data.get("id", symbol_data.get("symbol", "")),
@@ -513,9 +497,7 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
         # SnapTrade uses "average_purchase_price" for cost basis
         avg_price = snaptrade_position.get("average_purchase_price")
         quantity = Decimal(str(snaptrade_position.get("units", 0)))
-        cost_basis = (
-            Decimal(str(avg_price)) * quantity if avg_price is not None else None
-        )
+        cost_basis = Decimal(str(avg_price)) * quantity if avg_price is not None else None
 
         return Holding(
             account_id=account_id,
@@ -528,11 +510,11 @@ class SnapTradeInvestmentProvider(InvestmentProvider):
         )
 
     def _transform_transaction(
-        self, snaptrade_tx: Dict[str, Any], account_id: str
+        self, snaptrade_tx: dict[str, Any], account_id: str
     ) -> InvestmentTransaction:
         """Transform SnapTrade transaction to InvestmentTransaction model."""
         symbol_data = snaptrade_tx.get("symbol", {})
-        
+
         # Create Security from symbol data
         security = Security(
             security_id=symbol_data.get("id", symbol_data.get("symbol", "")),

fin_infra/markets/__init__.py

@@ -20,7 +20,10 @@ if TYPE_CHECKING:
     from fastapi import FastAPI
 
 from ..providers.base import MarketDataProvider
-from ..clients.base import MarketDataClient
+
+# Deprecated: MarketDataClient alias for backward compatibility
+# Use MarketDataProvider instead
+MarketDataClient = MarketDataProvider  # type: ignore[misc]
 
 
 def easy_market(
@@ -93,12 +96,12 @@ def easy_market(
 
     else:
         raise ValueError(
-            f"Unknown market data provider: {provider_name}. " f"Supported: alphavantage, yahoo"
+            f"Unknown market data provider: {provider_name}. Supported: alphavantage, yahoo"
         )
 
 
 def add_market_data(
-    app: "FastAPI",
+    app: FastAPI,
     *,
     provider: str | MarketDataProvider | None = None,
     prefix: str = "/market",
@@ -178,22 +181,21 @@ def add_market_data(
     See Also:
         - easy_market(): For standalone provider usage without FastAPI
         - docs/market-data.md: API documentation and examples
-        - docs/adr/0004-market-data-integration.md: Architecture decisions
     """
     from fastapi import HTTPException, Query
-    from typing import TYPE_CHECKING, Optional
 
     # Import svc-infra public router (no auth required for market data)
     from svc_infra.api.fastapi.dual.public import public_router
 
-    if TYPE_CHECKING:
-        from fastapi import FastAPI
-
     # Create market provider instance (or use the provided one)
     if isinstance(provider, MarketDataProvider):
         market = provider
     else:
-        market = easy_market(provider=provider, **config)
+        # Cast provider to Literal type for type checker
+        provider_literal: Literal["alphavantage", "yahoo"] | None = (
+            provider if provider in ("alphavantage", "yahoo", None) else None  # type: ignore[assignment]
+        )
+        market = easy_market(provider=provider_literal, **config)
 
     # Create router (public - no auth required)
     router = public_router(prefix=prefix, tags=["Market Data"])
@@ -223,14 +225,17 @@ def add_market_data(
         try:
             candles = market.history(symbol, period=period, interval=interval)
             # Convert to dicts if they're Pydantic models
-            candles_list = []
+            candles_list: list[dict] = []
             for candle in candles:
                 if hasattr(candle, "model_dump"):
                     candles_list.append(candle.model_dump())
                 elif hasattr(candle, "dict"):
                     candles_list.append(candle.dict())
                 else:
-                    candles_list.append(candle)
+                    # Cast to dict for type compatibility
+                    candles_list.append(
+                        dict(candle) if hasattr(candle, "__iter__") else {"data": candle}
+                    )
             return {"candles": candles_list}
         except Exception as e:
             raise HTTPException(status_code=400, detail=str(e))

fin_infra/models/__init__.py

@@ -1,21 +1,21 @@
 from .accounts import Account, AccountType
-from .transactions import Transaction
-from .quotes import Quote
-from .money import Money
-from .candle import Candle
-from .brokerage import Order, Position, PortfolioHistory
 from .brokerage import Account as BrokerageAccount  # Avoid name conflict
+from .brokerage import Order, PortfolioHistory, Position
+from .candle import Candle
+from .money import Money
+from .quotes import Quote
 from .tax import (
+    CryptoTaxReport,
+    CryptoTransaction,
     TaxDocument,
-    TaxFormW2,
-    TaxForm1099INT,
-    TaxForm1099DIV,
     TaxForm1099B,
+    TaxForm1099DIV,
+    TaxForm1099INT,
     TaxForm1099MISC,
-    CryptoTransaction,
-    CryptoTaxReport,
+    TaxFormW2,
     TaxLiability,
 )
+from .transactions import Transaction
 
 __all__ = [
     "Account",

fin_infra/models/accounts.py

@@ -18,10 +18,11 @@ class AccountType(str, Enum):
 
 class Account(BaseModel):
     """Financial account model.
-    
+
     Uses Decimal for balance fields to prevent floating-point precision errors
     in financial calculations (e.g., $0.01 + $0.02 != $0.03 with float).
     """
+
     id: str
     name: str
     type: AccountType

fin_infra/models/brokerage.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from decimal import Decimal
 from datetime import datetime
+from decimal import Decimal
 from typing import Literal
+
 from pydantic import BaseModel, Field
 
 

fin_infra/models/candle.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from decimal import Decimal
+
 from pydantic import BaseModel, field_validator
 
 

fin_infra/models/money.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from decimal import Decimal
+
 from pydantic import BaseModel, field_validator
 
 

fin_infra/models/quotes.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from decimal import Decimal
+
 from pydantic import BaseModel, field_validator
 
 
@@ -16,5 +17,5 @@ class Quote(BaseModel):
     def _ensure_tzaware(cls, v: datetime) -> datetime:
         # Normalize to timezone-aware (UTC) for consistency
         if v.tzinfo is None:
-            return v.replace(tzinfo=timezone.utc)
-        return v.astimezone(timezone.utc)
+            return v.replace(tzinfo=UTC)
+        return v.astimezone(UTC)

fin_infra/models/tax.py

@@ -37,7 +37,8 @@ Example:
 
 from datetime import date, datetime
 from decimal import Decimal
-from pydantic import BaseModel, Field, ConfigDict
+
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class TaxDocument(BaseModel):

fin_infra/models/transactions.py

@@ -2,24 +2,24 @@ from __future__ import annotations
 
 from datetime import date
 from decimal import Decimal
-from typing import Optional
 
 from pydantic import BaseModel, field_validator
 
 
 class Transaction(BaseModel):
     """Financial transaction model.
-    
+
     Uses Decimal for amount to prevent floating-point precision errors
     in financial calculations (e.g., $0.01 + $0.02 != $0.03 with float).
     """
+
     id: str
     account_id: str
     date: date
     amount: Decimal
     currency: str = "USD"
-    description: Optional[str] = None
-    category: Optional[str] = None
+    description: str | None = None
+    category: str | None = None
 
     @field_validator("amount", mode="before")
     @classmethod

fin_infra/net_worth/__init__.py

@@ -4,6 +4,13 @@ Net Worth Tracking Module
 Calculates net worth by aggregating balances from multiple financial providers
 (banking, brokerage, crypto) with historical snapshots and change detection.
 
+**Feature Status**:
+    ✅ STABLE: Core calculation (works with provided data)
+    ✅ STABLE: Banking integration (Plaid, Teller)
+    ⚠️  INTEGRATION: Brokerage integration (requires provider setup)
+    ⚠️  INTEGRATION: Crypto integration (requires provider setup)
+    ⚠️  INTEGRATION: Currency conversion (pass exchange_rate manually)
+
 **Key Features**:
 - Multi-provider aggregation (banking + brokerage + crypto)
 - Currency normalization (all currencies → USD)

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

@@ -30,6 +30,7 @@ print(f"Net Worth: ${snapshot.total_net_worth:,.2f}")
 """
 
 import asyncio
+import logging
 import uuid
 from datetime import datetime
 from typing import Any
@@ -47,6 +48,8 @@ from fin_infra.net_worth.models import (
     NetWorthSnapshot,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class NetWorthAggregator:
     """
@@ -213,16 +216,16 @@ 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):
-                # Log error but continue (graceful degradation)
-                print(f"Provider {providers_used[i]} failed: {result}")
+            if isinstance(result, BaseException):
+                logger.warning("Provider %s failed: %s", providers_used[i], 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/calculator.py

@@ -30,7 +30,6 @@ print(f"Net Worth: ${net_worth:,.2f}")  # $55,000.00
 ```
 """
 
-
 from fin_infra.net_worth.models import (
     AssetAllocation,
     AssetCategory,
@@ -100,18 +99,19 @@ def calculate_net_worth(
 
     Returns:
         Net worth in base currency
-        
+
     Raises:
         ValueError: If assets or liabilities contain non-base currencies and no
             exchange rate conversion is available. This prevents silent data loss.
     """
     import logging
+
     logger = logging.getLogger(__name__)
-    
+
     # Collect any non-base currency items for error reporting
     non_base_assets: list[tuple[str, str, float]] = []
     non_base_liabilities: list[tuple[str, str, float]] = []
-    
+
     # Sum all assets (use market_value if available, otherwise balance)
     total_assets = 0.0
     for asset in assets:
@@ -130,7 +130,9 @@ def calculate_net_worth(
     for liability in liabilities:
         # Check for non-base currency
         if liability.currency != base_currency:
-            non_base_liabilities.append((liability.name or liability.account_id, liability.currency, liability.balance))
+            non_base_liabilities.append(
+                (liability.name or liability.account_id, liability.currency, liability.balance)
+            )
             continue
 
         total_liabilities += liability.balance
@@ -143,7 +145,7 @@ def calculate_net_worth(
             items_msg.append(f"Assets: {non_base_assets}")
         if non_base_liabilities:
             items_msg.append(f"Liabilities: {non_base_liabilities}")
-        
+
         error_msg = (
             f"Cannot calculate net worth: found accounts in non-{base_currency} currencies. "
             f"Currency conversion not yet implemented. {'; '.join(items_msg)}. "