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

fin_infra/net_worth/ease.py

@@ -121,6 +121,15 @@ class NetWorthTracker:
         self.goal_tracker = goal_tracker
         self.conversation = conversation
 
+        # Configuration set by easy_net_worth(); declared here for type checkers.
+        self.snapshot_schedule: str = "daily"
+        self.change_threshold_percent: float = 5.0
+        self.change_threshold_amount: float = 10000.0
+        self.enable_llm: bool = False
+        self.llm_provider: str | None = None
+        self.llm_model: str | None = None
+        self.config: dict[str, Any] = {}
+
     async def calculate_net_worth(
         self,
         user_id: str,
@@ -368,12 +377,20 @@ def easy_net_worth(
 
     if enable_llm:
         try:
-            from ai_infra.llm import LLM
+            from ai_infra.llm.llm import LLM
         except ImportError:
             raise ImportError(
-                "LLM features require ai-infra package. " "Install with: pip install ai-infra"
+                "LLM features require ai-infra package. Install with: pip install ai-infra"
             )
 
+        cache = None
+        try:
+            from svc_infra.cache import get_cache
+
+            cache = get_cache()
+        except Exception:
+            cache = None
+
         # Determine default model
         default_models = {
             "google": "gemini-2.0-flash-exp",
@@ -384,7 +401,7 @@ def easy_net_worth(
 
         if not model_name:
             raise ValueError(
-                f"Unknown llm_provider: {llm_provider}. " f"Use 'google', 'openai', or 'anthropic'"
+                f"Unknown llm_provider: {llm_provider}. Use 'google', 'openai', or 'anthropic'"
             )
 
         # Create shared LLM instance
@@ -416,18 +433,22 @@ def easy_net_worth(
             # goals.management not yet implemented, skip
             pass
 
-        try:
-            from fin_infra.conversation import FinancialPlanningConversation
-
-            conversation = FinancialPlanningConversation(
-                llm=llm,
-                cache=cache,  # Required for context storage
-                provider=llm_provider,
-                model_name=model_name,
-            )
-        except ImportError:
-            # conversation module not yet implemented, skip
-            pass
+        if cache is not None:
+            try:
+                from fin_infra.conversation import FinancialPlanningConversation
+
+                conversation = FinancialPlanningConversation(
+                    llm=llm,
+                    cache=cache,  # Required for context storage
+                    provider=llm_provider,
+                    model_name=model_name,
+                )
+            except ImportError:
+                # conversation module not yet implemented, skip
+                pass
+            except Exception:
+                # Cache not configured or other runtime issue; skip optional conversation wiring.
+                pass
 
     # Create tracker
     tracker = NetWorthTracker(

fin_infra/net_worth/insights.py

@@ -31,7 +31,6 @@ from typing import Any
 
 from pydantic import BaseModel, Field
 
-
 # ============================================================================
 # Pydantic Schemas (Structured Output)
 # ============================================================================
@@ -479,13 +478,13 @@ class NetWorthInsightsGenerator:
 
         user_prompt = f"""Analyze wealth trends:
 
-Current net worth: ${current['total_net_worth']:,.0f}
-Previous net worth: ${previous['total_net_worth']:,.0f}
+Current net worth: ${current["total_net_worth"]:,.0f}
+Previous net worth: ${previous["total_net_worth"]:,.0f}
 Period: {period}
 Change: ${change_amount:,.0f} ({change_percent:.1%})
 
-Assets: ${current['total_assets']:,.0f}
-Liabilities: ${current['total_liabilities']:,.0f}
+Assets: ${current["total_assets"]:,.0f}
+Liabilities: ${current["total_liabilities"]:,.0f}
 
 Identify drivers of change, risk factors, and recommendations."""
 

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,17 +115,12 @@ 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
+    from fastapi import HTTPException, Query
+    from svc_infra.api.fastapi.docs.scoped import add_prefixed_docs
 
     # Import svc-infra public router (no auth - utility endpoints)
     from svc_infra.api.fastapi.dual.public import public_router
-    from svc_infra.api.fastapi.docs.scoped import add_prefixed_docs
 
     # Get normalization services
     resolver, converter = easy_normalization(api_key=api_key)
@@ -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 cast
 
 import httpx
 
@@ -19,7 +19,7 @@ __all__ = [
 class ExchangeRateClient:
     """Client for exchangerate-api.io API."""
 
-    def __init__(self, api_key: Optional[str] = None):
+    def __init__(self, api_key: str | None = None):
         """
         Initialize exchange rate client.
 
@@ -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}")
@@ -77,7 +77,7 @@ class ExchangeRateClient:
             raise ExchangeRateAPIError(f"Invalid API response: {e}")
 
     async def get_rate(
-        self, from_currency: str, to_currency: str, date: Optional[DateType] = None
+        self, from_currency: str, to_currency: str, date: DateType | None = None
     ) -> ExchangeRate:
         """
         Get exchange rate between two currencies.

fin_infra/obs/classifier.py

@@ -37,7 +37,7 @@ Usage:
 
 from __future__ import annotations
 
-from typing import Callable
+from collections.abc import Callable
 
 # Financial capability prefix patterns (extensible)
 FINANCIAL_ROUTE_PREFIXES = (
@@ -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.