fin-infra 0.1.64__py3-none-any.whl → 0.1.66__py3-none-any.whl

fin_infra/analytics/cash_flow.py

@@ -6,6 +6,7 @@ Provides income vs expense analysis, breakdowns by source/category, and forecast
 from __future__ import annotations
 
 from datetime import datetime, timedelta
+from decimal import Decimal
 from typing import Any, Optional
 
 from ..models import Transaction
@@ -219,7 +220,7 @@ async def forecast_cash_flow(
 def _categorize_transactions(
     transactions: list[Transaction],
     categorization_provider=None,
-) -> tuple[dict[str, float], dict[str, float]]:
+) -> tuple[dict[str, Decimal], dict[str, Decimal]]:
     """Helper to categorize transactions into income sources and expense categories.
 
     Args:
@@ -229,19 +230,19 @@ def _categorize_transactions(
     Returns:
         Tuple of (income_by_source, expenses_by_category) dicts
     """
-    income_by_source: dict[str, float] = {}
-    expenses_by_category: dict[str, float] = {}
+    income_by_source: dict[str, Decimal] = {}
+    expenses_by_category: dict[str, Decimal] = {}
 
     for txn in transactions:
         if txn.amount > 0:
             # Income transaction
             source = _determine_income_source(txn)
-            income_by_source[source] = income_by_source.get(source, 0) + txn.amount
+            income_by_source[source] = income_by_source.get(source, Decimal(0)) + txn.amount
         else:
             # Expense transaction
             category = _get_expense_category(txn, categorization_provider)
             amount = abs(txn.amount)
-            expenses_by_category[category] = expenses_by_category.get(category, 0) + amount
+            expenses_by_category[category] = expenses_by_category.get(category, Decimal(0)) + amount
 
     return income_by_source, expenses_by_category
 

fin_infra/analytics/portfolio.py

@@ -565,7 +565,6 @@ def portfolio_metrics_with_holdings(holdings: list) -> PortfolioMetrics:
         >>> metrics = portfolio_metrics_with_holdings(holdings)
     """
     # Import here to avoid circular dependency
-    from decimal import Decimal
 
     # Calculate total portfolio value and cost basis
     total_value = float(sum(
@@ -739,7 +738,7 @@ def _calculate_allocation_from_holdings(
     }
 
     # Sum values by asset class
-    allocation_values = defaultdict(float)
+    allocation_values: dict[str, float] = defaultdict(float)
     for holding in holdings:
         security_type = holding.security.type.value if hasattr(holding.security.type, 'value') else holding.security.type
         asset_class = type_to_class.get(security_type, "Other")

fin_infra/analytics/spending.py

@@ -292,10 +292,10 @@ async def _calculate_spending_trends(
         # In reality, would fetch historical data
         previous_amount = current_amount * Decimal("0.9")
 
-        change_percent = (
-            ((current_amount - previous_amount) / previous_amount) * 100
+        change_percent: float = (
+            float((current_amount - previous_amount) / previous_amount) * 100
             if previous_amount > 0
-            else 0
+            else 0.0
         )
 
         # Threshold for "stable" is within 5%
@@ -343,8 +343,8 @@ async def _detect_spending_anomalies(
         # In reality, would calculate from historical data
         average_amount = current_amount * Decimal("0.8")
 
-        deviation_percent = (
-            ((current_amount - average_amount) / average_amount) * 100 if average_amount > 0 else 0
+        deviation_percent: float = (
+            float((current_amount - average_amount) / average_amount) * 100 if average_amount > 0 else 0.0
         )
 
         # Detect anomalies based on deviation

fin_infra/banking/__init__.py

@@ -592,7 +592,7 @@ def add_banking(
 
 
 # Import utilities at end to avoid circular imports
-from .utils import (
+from .utils import (  # noqa: E402
     validate_plaid_token,
     validate_teller_token,
     validate_mx_token,

fin_infra/banking/utils.py

@@ -8,11 +8,9 @@ Apps still manage user-to-token mappings, but these utilities simplify common op
 from __future__ import annotations
 
 import re
-from datetime import datetime, timezone, timedelta
+from datetime import datetime, timezone
 from typing import Any, Dict, Optional, Literal
 from pydantic import BaseModel, ConfigDict, Field
-from pydantic.json_schema import JsonSchemaValue
-from pydantic_core import core_schema
 
 from ..providers.base import BankingProvider
 
@@ -270,7 +268,7 @@ def sanitize_connection_status(status: BankingConnectionStatus) -> Dict[str, Any
         >>> safe_data = sanitize_connection_status(status)
         >>> return {"connections": safe_data}  # Safe to return to client
     """
-    result = {
+    result: dict[str, Any] = {
         "has_any_connection": status.has_any_connection,
         "connected_providers": status.connected_providers,
         "primary_provider": status.primary_provider,
@@ -280,7 +278,8 @@ def sanitize_connection_status(status: BankingConnectionStatus) -> Dict[str, Any
     for provider_name in ["plaid", "teller", "mx"]:
         info = getattr(status, provider_name)
         if info:
-            result["providers"][provider_name] = {
+            providers_dict: dict[str, Any] = result["providers"]
+            providers_dict[provider_name] = {
                 "connected": info.connected,
                 "item_id": info.item_id,
                 "enrollment_id": info.enrollment_id,
@@ -415,7 +414,7 @@ async def test_connection_health(
     """
     try:
         # Try to fetch accounts (lightweight call)
-        accounts = provider.accounts(access_token)
+        provider.accounts(access_token)
         
         # If we got here, connection is healthy
         return True, None

fin_infra/cashflows/__init__.py

@@ -22,10 +22,13 @@ Example usage:
     rate = irr(cashflows)
 """
 
-from typing import Iterable
+from typing import TYPE_CHECKING
 
 import numpy_financial as npf
 
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
 from .core import npv, irr
 
 __all__ = ["npv", "irr", "pmt", "fv", "pv", "add_cashflows"]
@@ -110,7 +113,7 @@ def pv(rate: float, nper: int, pmt: float, fv: float = 0, when: str = "end") ->
 
 
 def add_cashflows(
-    app: "FastAPI",  # type: ignore
+    app: "FastAPI",
     *,
     prefix: str = "/cashflows",
 ) -> None:
@@ -169,11 +172,6 @@ def add_cashflows(
         - Integrated with svc-infra observability
         - Scoped docs at {prefix}/docs
     """
-    from typing import TYPE_CHECKING
-
-    if TYPE_CHECKING:
-        from fastapi import FastAPI
-
     from pydantic import BaseModel, Field
 
     # Import svc-infra public router (no auth - utility calculations)
@@ -254,4 +252,4 @@ def add_cashflows(
     # Mount router
     app.include_router(router, include_in_schema=True)
 
-    print(f"✅ Cashflow calculations enabled (NPV, IRR, PMT, FV, PV)")
+    print("✅ Cashflow calculations enabled (NPV, IRR, PMT, FV, PV)")

fin_infra/categorization/add.py

@@ -136,21 +136,19 @@ def add_categorization(
             categories = get_all_categories()
 
         # Return category metadata
-        return [
-            {
-                "name": cat.value,
-                "group": get_category_metadata(cat).group.value
-                if get_category_metadata(cat)
-                else None,
-                "display_name": get_category_metadata(cat).display_name
-                if get_category_metadata(cat)
-                else cat.value,
-                "description": get_category_metadata(cat).description
-                if get_category_metadata(cat)
-                else None,
-            }
-            for cat in categories
-        ]
+        result = []
+        for cat in categories:
+            meta = get_category_metadata(cat)
+            result.append(
+                {
+                    "name": cat.value,
+                    "group": meta.group.value if meta else None,
+                    "display_name": meta.display_name if meta else cat.value,
+                    "description": meta.description if meta else None,
+                }
+            )
+
+        return result
 
     @router.get("/stats", response_model=CategoryStats)
     async def get_stats():

fin_infra/categorization/engine.py

@@ -95,7 +95,7 @@ class CategorizationEngine:
         Returns:
             CategoryPrediction with category, confidence, and method
         """
-        start_time = time.perf_counter()
+        time.perf_counter()
 
         # Normalize merchant name
         normalized = self._normalize(merchant_name)
@@ -333,7 +333,7 @@ def get_engine() -> CategorizationEngine:
     return _default_engine
 
 
-def categorize(
+async def categorize(
     merchant_name: str,
     user_id: Optional[str] = None,
     include_alternatives: bool = False,
@@ -350,4 +350,4 @@ def categorize(
         CategoryPrediction with category, confidence, and method
     """
     engine = get_engine()
-    return engine.categorize(merchant_name, user_id, include_alternatives)
+    return await engine.categorize(merchant_name, user_id, include_alternatives)

fin_infra/categorization/llm_layer.py

@@ -15,13 +15,12 @@ Expected performance:
 
 import hashlib
 import logging
-from typing import Optional, List, Tuple, cast
+from typing import Any, List, Optional, Tuple, cast
 from pydantic import BaseModel, Field
 
 # ai-infra imports
 try:
     from ai_infra.llm import LLM
-    from ai_infra.llm.providers import Providers
 except ImportError:
     raise ImportError("ai-infra not installed. Install with: pip install ai-infra")
 
@@ -217,7 +216,7 @@ class LLMCategorizer:
         user_message = self._build_user_message(merchant_name, user_id)
 
         # Call LLM with retry logic
-        extra = {
+        extra: dict[str, Any] = {
             "retry": {
                 "max_tries": 3,
                 "base": 0.5,

fin_infra/categorization/models.py

@@ -44,7 +44,7 @@ class CategoryPrediction(BaseModel):
                 "category": "Coffee Shops",
                 "confidence": 0.98,
                 "method": "exact",
-                "alternatives": [("Restaurants", 0.15), ("Fast Food", 0.10)],
+                "alternatives": [["Restaurants", 0.15], ["Fast Food", 0.10]],
             }
         }
     )

fin_infra/chat/__init__.py

@@ -28,6 +28,11 @@ Example:
     )
 """
 
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
 from fin_infra.chat.planning import (
     FinancialPlanningConversation,
     ConversationResponse,
@@ -51,7 +56,7 @@ __all__ = [
 
 
 def add_financial_conversation(
-    app: "FastAPI",  # type: ignore
+    app: "FastAPI",
     *,
     prefix: str = "/chat",
     conversation: FinancialPlanningConversation | None = None,
@@ -110,11 +115,6 @@ def add_financial_conversation(
         - Includes financial advice disclaimer in all responses
         - Logs all LLM calls for compliance (via svc-infra logging)
     """
-    from typing import TYPE_CHECKING, Any
-
-    if TYPE_CHECKING:
-        from fastapi import FastAPI
-
     from pydantic import BaseModel, Field
 
     # Import svc-infra user router (requires auth)
@@ -149,15 +149,6 @@ def add_financial_conversation(
         # TODO: Get user_id from svc-infra auth context
         user_id = "demo_user"  # Placeholder
 
-        # Check for sensitive content
-        if is_sensitive_question(request.question):
-            return ConversationResponse(
-                answer="I cannot process requests containing sensitive information like SSNs, passwords, or account numbers. Please rephrase your question without this information.",
-                follow_up_questions=[],
-                conversation_id=f"{user_id}_denied",
-                disclaimer="This is an automated safety response.",
-            )
-
         # Ask conversation
         response = await conversation.ask(
             user_id=user_id,
@@ -173,7 +164,7 @@ def add_financial_conversation(
         # TODO: Get user_id from svc-infra auth context
         user_id = "demo_user"
         context = await conversation._get_context(user_id)
-        return context.exchanges if context else []
+        return context.previous_exchanges if context else []
 
     @router.delete("/history")
     async def clear_history():

fin_infra/chat/planning.py

@@ -338,8 +338,65 @@ class FinancialPlanningConversation:
         # Save updated context (24h TTL)
         await self._save_context(context)
 
+        # Track latest session id for convenience endpoints (history/clear).
+        # Best-effort: failures here must not break the chat response.
+        try:
+            await self.cache.set(
+                self._latest_session_key(user_id),
+                context.session_id,
+                ttl=86400,
+            )
+        except Exception:
+            pass
+
         return response
 
+    # ---------------------------------------------------------------------
+    # Backward-compatible context helpers
+    # ---------------------------------------------------------------------
+
+    def _latest_session_key(self, user_id: str) -> str:
+        return f"fin_infra:conversation_latest_session:{user_id}"
+
+    async def _get_latest_session_id(self, user_id: str) -> str | None:
+        try:
+            value = await self.cache.get(self._latest_session_key(user_id))
+        except Exception:
+            return None
+
+        if value is None:
+            return None
+        if isinstance(value, bytes):
+            try:
+                return value.decode("utf-8")
+            except Exception:
+                return None
+        if isinstance(value, str):
+            return value
+        return str(value)
+
+    async def _get_context(
+        self, user_id: str, session_id: str | None = None
+    ) -> ConversationContext | None:
+        if session_id is None:
+            session_id = await self._get_latest_session_id(user_id)
+        if session_id is None:
+            return None
+
+        return await self._load_context(user_id=user_id, session_id=session_id)
+
+    async def _clear_context(self, user_id: str, session_id: str | None = None) -> None:
+        if session_id is None:
+            session_id = await self._get_latest_session_id(user_id)
+
+        if session_id is not None:
+            await self.clear_session(user_id=user_id, session_id=session_id)
+
+        try:
+            await self.cache.delete(self._latest_session_key(user_id))
+        except Exception:
+            pass
+
     async def _load_context(
         self,
         user_id: str,

fin_infra/compliance/__init__.py

@@ -118,7 +118,6 @@ def add_compliance_tracking(
 
         # Track only GET requests (data access)
         if method != "GET":
-            from starlette.responses import Response as StarletteResponse
             return cast("Response", await call_next(request))
 
         # Determine if path is a compliance-tracked endpoint

fin_infra/crypto/insights.py

@@ -258,10 +258,8 @@ Provide your insight:"""
 
     try:
         # Use natural language conversation (no output_schema)
-        # Note: In tests, achat is mocked with messages= parameter
-        # In production, this should use user_msg, provider, model_name parameters
         response = await llm.achat(
-            messages=[{"role": "user", "content": prompt}],
+            user_msg=prompt,
         )
 
         # Parse response text

fin_infra/documents/add.py

@@ -104,7 +104,7 @@ def add_documents(
 
     # Step 1: Mount base endpoints (upload, list, get, delete) via svc-infra
     # This returns the base DocumentManager, but we'll create our own FinancialDocumentManager
-    if HAS_SVC_INFRA_DOCUMENTS and add_base_documents:
+    if HAS_SVC_INFRA_DOCUMENTS and add_base_documents is not None:
         add_base_documents(app, storage_backend=storage, prefix=prefix, tags=tags)
     else:
         # Legacy mode: mount basic endpoints inline (for svc-infra < 0.1.668)

fin_infra/insights/__init__.py

@@ -10,6 +10,11 @@ Aggregates insights from multiple sources:
 - Cash flow projections
 """
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
 from .models import Insight, InsightFeed, InsightPriority, InsightCategory
 from .aggregator import aggregate_insights, get_user_insights
 
@@ -25,7 +30,7 @@ __all__ = [
 
 
 def add_insights(
-    app: "FastAPI",  # type: ignore
+    app: "FastAPI",
     *,
     prefix: str = "/insights",
 ) -> None:
@@ -71,11 +76,6 @@ def add_insights(
         - Real-time aggregation from net worth, budgets, goals, etc.
         - Notification system for critical insights
     """
-    from typing import TYPE_CHECKING
-
-    if TYPE_CHECKING:
-        from fastapi import FastAPI
-
     from fastapi import Query
 
     # Import svc-infra user router (requires auth)
@@ -125,5 +125,5 @@ def add_insights(
     # Mount router
     app.include_router(router, include_in_schema=True)
 
-    print(f"✅ Insights feed enabled (unified financial insights)")
+    print("✅ Insights feed enabled (unified financial insights)")
 

fin_infra/investments/__init__.py

@@ -180,7 +180,7 @@ def add_investments(
     # Resolve provider from string Literal to actual InvestmentProvider instance
     resolved_provider: InvestmentProviderBase | None = None
     if provider is not None:
-        resolved_provider = easy_investments(provider=provider, **provider_config)  # type: ignore[assignment]
+        resolved_provider = easy_investments(provider=provider, **provider_config)
 
     return add_investments_impl(
         app,

fin_infra/investments/add.py

@@ -7,14 +7,13 @@ transactions, accounts, allocation, and securities data.
 from __future__ import annotations
 
 from datetime import date
-from typing import TYPE_CHECKING, Optional, Literal, Annotated
+from typing import TYPE_CHECKING, Optional
 
-from fastapi import HTTPException, Query, Depends
+from fastapi import HTTPException
 from pydantic import BaseModel, Field
 
 if TYPE_CHECKING:
     from fastapi import FastAPI
-    from svc_infra.api.fastapi.auth.security import Principal
 
 # Import Identity for dependency injection
 try:

fin_infra/investments/models.py

@@ -17,10 +17,10 @@ Models are provider-agnostic and normalize data from Plaid, SnapTrade, etc.
 
 from __future__ import annotations
 
-from datetime import date, datetime
+from datetime import date
 from decimal import Decimal
 from enum import Enum
-from typing import Dict, List, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional
 
 from pydantic import BaseModel, ConfigDict, Field, computed_field
 
@@ -201,22 +201,41 @@ class Holding(BaseModel):
     unofficial_currency_code: Optional[str] = Field(None, description="For crypto/alt currencies")
     as_of_date: Optional[date] = Field(None, description="Date of pricing data")
 
-    @computed_field
-    @property
-    def unrealized_gain_loss(self) -> Optional[Decimal]:
-        """Calculate unrealized gain/loss (current value - cost basis)."""
-        if self.cost_basis is None:
-            return None
-        return self.institution_value - self.cost_basis
-
-    @computed_field
-    @property
-    def unrealized_gain_loss_percent(self) -> Optional[Decimal]:
-        """Calculate unrealized gain/loss percentage."""
-        if self.cost_basis is None or self.cost_basis == 0:
-            return None
-        gain_loss = self.institution_value - self.cost_basis
-        return round((gain_loss / self.cost_basis) * 100, 2)
+    if TYPE_CHECKING:
+
+        @property
+        def unrealized_gain_loss(self) -> Optional[Decimal]:
+            """Calculate unrealized gain/loss (current value - cost basis)."""
+            if self.cost_basis is None:
+                return None
+            return self.institution_value - self.cost_basis
+
+        @property
+        def unrealized_gain_loss_percent(self) -> Optional[Decimal]:
+            """Calculate unrealized gain/loss percentage."""
+            if self.cost_basis is None or self.cost_basis == 0:
+                return None
+            gain_loss = self.institution_value - self.cost_basis
+            return round((gain_loss / self.cost_basis) * 100, 2)
+
+    else:
+
+        @computed_field
+        @property
+        def unrealized_gain_loss(self) -> Optional[Decimal]:
+            """Calculate unrealized gain/loss (current value - cost basis)."""
+            if self.cost_basis is None:
+                return None
+            return self.institution_value - self.cost_basis
+
+        @computed_field
+        @property
+        def unrealized_gain_loss_percent(self) -> Optional[Decimal]:
+            """Calculate unrealized gain/loss percentage."""
+            if self.cost_basis is None or self.cost_basis == 0:
+                return None
+            gain_loss = self.institution_value - self.cost_basis
+            return round((gain_loss / self.cost_basis) * 100, 2)
 
 
 class InvestmentTransaction(BaseModel):
@@ -350,34 +369,69 @@ class InvestmentAccount(BaseModel):
     # Holdings
     holdings: List[Holding] = Field(default_factory=list, description="List of holdings in account")
 
-    @computed_field
-    @property
-    def total_value(self) -> Decimal:
-        """Calculate total account value (sum of holdings + cash)."""
-        holdings_value = sum(h.institution_value for h in self.holdings)
-        cash_balance = self.balances.get("current") or Decimal(0)
-        return holdings_value + cash_balance
-
-    @computed_field
-    @property
-    def total_cost_basis(self) -> Decimal:
-        """Calculate total cost basis (sum of cost_basis across holdings)."""
-        return sum(h.cost_basis for h in self.holdings if h.cost_basis is not None)
-
-    @computed_field
-    @property
-    def total_unrealized_gain_loss(self) -> Decimal:
-        """Calculate total unrealized P&L (value - cost_basis)."""
-        holdings_value = sum(h.institution_value for h in self.holdings)
-        return holdings_value - self.total_cost_basis
-
-    @computed_field
-    @property
-    def total_unrealized_gain_loss_percent(self) -> Optional[Decimal]:
-        """Calculate total unrealized P&L percentage."""
-        if self.total_cost_basis == 0:
-            return None
-        return round((self.total_unrealized_gain_loss / self.total_cost_basis) * 100, 2)
+    if TYPE_CHECKING:
+
+        @property
+        def total_value(self) -> Decimal:
+            """Calculate total account value (sum of holdings + cash)."""
+            holdings_value = sum((h.institution_value for h in self.holdings), start=Decimal(0))
+            cash_balance = self.balances.get("current") or Decimal(0)
+            return holdings_value + cash_balance
+
+        @property
+        def total_cost_basis(self) -> Decimal:
+            """Calculate total cost basis (sum of cost_basis across holdings)."""
+            return sum(
+                (h.cost_basis for h in self.holdings if h.cost_basis is not None),
+                start=Decimal(0),
+            )
+
+        @property
+        def total_unrealized_gain_loss(self) -> Decimal:
+            """Calculate total unrealized P&L (value - cost_basis)."""
+            holdings_value = sum((h.institution_value for h in self.holdings), start=Decimal(0))
+            return holdings_value - self.total_cost_basis
+
+        @property
+        def total_unrealized_gain_loss_percent(self) -> Optional[Decimal]:
+            """Calculate total unrealized P&L percentage."""
+            if self.total_cost_basis == 0:
+                return None
+            return round((self.total_unrealized_gain_loss / self.total_cost_basis) * 100, 2)
+
+    else:
+
+        @computed_field
+        @property
+        def total_value(self) -> Decimal:
+            """Calculate total account value (sum of holdings + cash)."""
+            holdings_value = sum((h.institution_value for h in self.holdings), start=Decimal(0))
+            cash_balance = self.balances.get("current") or Decimal(0)
+            return holdings_value + cash_balance
+
+        @computed_field
+        @property
+        def total_cost_basis(self) -> Decimal:
+            """Calculate total cost basis (sum of cost_basis across holdings)."""
+            return sum(
+                (h.cost_basis for h in self.holdings if h.cost_basis is not None),
+                start=Decimal(0),
+            )
+
+        @computed_field
+        @property
+        def total_unrealized_gain_loss(self) -> Decimal:
+            """Calculate total unrealized P&L (value - cost_basis)."""
+            holdings_value = sum((h.institution_value for h in self.holdings), start=Decimal(0))
+            return holdings_value - self.total_cost_basis
+
+        @computed_field
+        @property
+        def total_unrealized_gain_loss_percent(self) -> Optional[Decimal]:
+            """Calculate total unrealized P&L percentage."""
+            if self.total_cost_basis == 0:
+                return None
+            return round((self.total_unrealized_gain_loss / self.total_cost_basis) * 100, 2)
 
 
 class AssetAllocation(BaseModel):