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

fin_infra/investments/models.py

@@ -17,17 +17,17 @@ 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, Optional
 
 from pydantic import BaseModel, ConfigDict, Field, computed_field
 
 
 class SecurityType(str, Enum):
     """Security type classification.
-    
+
     Categories:
     - equity: Common stock (AAPL, GOOGL, etc.)
     - etf: Exchange-traded fund (SPY, QQQ, etc.)
@@ -49,7 +49,7 @@ class SecurityType(str, Enum):
 
 class TransactionType(str, Enum):
     """Investment transaction type.
-    
+
     Categories:
     - buy: Purchase of security
     - sell: Sale of security
@@ -71,7 +71,7 @@ class TransactionType(str, Enum):
     fee = "fee"
     tax = "tax"
     transfer = "transfer"
-    split = "split"
+    split = "split"  # type: ignore[assignment]  # str.split() name conflict
     merger = "merger"
     cancel = "cancel"
     other = "other"
@@ -79,10 +79,10 @@ class TransactionType(str, Enum):
 
 class Security(BaseModel):
     """Security details (stock, bond, ETF, etc.).
-    
+
     Represents a tradable security with identifying information and current market data.
     Normalized across providers (Plaid, SnapTrade).
-    
+
     Example:
         >>> security = Security(
         ...     security_id="plaid_sec_123",
@@ -129,7 +129,9 @@ class Security(BaseModel):
     # Basic info
     name: str = Field(..., description="Security name")
     type: SecurityType = Field(..., description="Security type (equity, etf, bond, etc.)")
-    sector: Optional[str] = Field(None, description="Sector classification (Technology, Healthcare)")
+    sector: Optional[str] = Field(
+        None, description="Sector classification (Technology, Healthcare)"
+    )
 
     # Market data
     close_price: Optional[Decimal] = Field(None, ge=0, description="Latest closing price")
@@ -140,10 +142,10 @@ class Security(BaseModel):
 
 class Holding(BaseModel):
     """Investment holding with current value and cost basis.
-    
+
     Represents a position in a specific security within an investment account.
     Includes quantity, current value, cost basis, and calculated P&L.
-    
+
     Example:
         >>> holding = Holding(
         ...     account_id="acct_123",
@@ -193,38 +195,61 @@ class Holding(BaseModel):
     # Position data
     quantity: Decimal = Field(..., ge=0, description="Number of shares/units held")
     institution_price: Decimal = Field(..., ge=0, description="Current price per share")
-    institution_value: Decimal = Field(..., ge=0, description="Current market value (quantity × price)")
-    cost_basis: Optional[Decimal] = Field(None, ge=0, description="Total cost basis (original purchase price)")
+    institution_value: Decimal = Field(
+        ..., ge=0, description="Current market value (quantity × price)"
+    )
+    cost_basis: Optional[Decimal] = Field(
+        None, ge=0, description="Total cost basis (original purchase price)"
+    )
 
     # Additional data
     currency: str = Field("USD", description="Currency code")
     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):
     """Investment transaction (buy, sell, dividend, etc.).
-    
+
     Represents a single transaction in an investment account.
     Used to calculate realized gains and track transaction history.
-    
+
     Example:
         >>> transaction = InvestmentTransaction(
         ...     transaction_id="tx_123",
@@ -276,7 +301,9 @@ class InvestmentTransaction(BaseModel):
     # Transaction details
     transaction_date: date = Field(..., alias="date", description="Transaction date")
     name: str = Field(..., description="Transaction description")
-    transaction_type: TransactionType = Field(..., alias="type", description="Transaction type (buy, sell, dividend)")
+    transaction_type: TransactionType = Field(
+        ..., alias="type", description="Transaction type (buy, sell, dividend)"
+    )
     subtype: Optional[str] = Field(None, description="Provider-specific subtype")
 
     # Amounts
@@ -292,10 +319,10 @@ class InvestmentTransaction(BaseModel):
 
 class InvestmentAccount(BaseModel):
     """Investment account with aggregated holdings and metrics.
-    
+
     Represents a complete investment account with all holdings, balances, and P&L.
     Includes calculated fields for total value, cost basis, and unrealized gains.
-    
+
     Example:
         >>> account = InvestmentAccount(
         ...     account_id="acct_123",
@@ -321,7 +348,11 @@ class InvestmentAccount(BaseModel):
                 "holdings": [
                     {
                         "account_id": "acct_abc123",
-                        "security": {"ticker_symbol": "AAPL", "name": "Apple Inc.", "type": "equity"},
+                        "security": {
+                            "ticker_symbol": "AAPL",
+                            "name": "Apple Inc.",
+                            "type": "equity",
+                        },
                         "quantity": 10.5,
                         "institution_price": 150.25,
                         "institution_value": 1577.63,
@@ -343,49 +374,84 @@ class InvestmentAccount(BaseModel):
     subtype: Optional[str] = Field(None, description="Account subtype (401k, ira, brokerage)")
 
     # Balances
-    balances: Dict[str, Optional[Decimal]] = Field(
+    balances: dict[str, Optional[Decimal]] = Field(
         ..., description="Current, available, and limit balances"
     )
 
     # 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)
+    holdings: list[Holding] = Field(default_factory=list, description="List of holdings in account")
+
+    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):
     """Asset allocation breakdown by security type and sector.
-    
+
     Provides percentage breakdown of portfolio by security type and sector.
     Used for diversification analysis and portfolio visualization.
-    
+
     Example:
         >>> allocation = AssetAllocation(
         ...     by_security_type={
@@ -421,11 +487,11 @@ class AssetAllocation(BaseModel):
         },
     )
 
-    by_security_type: Dict[SecurityType, float] = Field(
+    by_security_type: dict[SecurityType, float] = Field(
         default_factory=dict,
         description="Percentage breakdown by security type (equity, bond, etc.)",
     )
-    by_sector: Dict[str, float] = Field(
+    by_sector: dict[str, float] = Field(
         default_factory=dict,
         description="Percentage breakdown by sector (Technology, Healthcare, etc.)",
     )

fin_infra/investments/providers/base.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from datetime import date
-from typing import List, Optional
 
 # Import will work once models.py is fully implemented in Task 3
 # For now, using TYPE_CHECKING to avoid circular imports
@@ -30,8 +29,8 @@ class InvestmentProvider(ABC):
 
     @abstractmethod
     async def get_holdings(
-        self, access_token: str, account_ids: Optional[List[str]] = None
-    ) -> List[Holding]:
+        self, access_token: str, account_ids: list[str] | None = None
+    ) -> list[Holding]:
         """Fetch holdings for investment accounts.
 
         Args:
@@ -54,8 +53,8 @@ class InvestmentProvider(ABC):
         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 within date range.
 
         Args:
@@ -77,9 +76,7 @@ class InvestmentProvider(ABC):
         pass
 
     @abstractmethod
-    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 (ticker, name, type, current price).
 
         Args:
@@ -97,9 +94,7 @@ class InvestmentProvider(ABC):
         pass
 
     @abstractmethod
-    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.
 
         Args:
@@ -117,7 +112,7 @@ class InvestmentProvider(ABC):
 
     # Helper methods (concrete - shared across all providers)
 
-    def calculate_allocation(self, holdings: List[Holding]) -> AssetAllocation:
+    def calculate_allocation(self, holdings: list[Holding]) -> AssetAllocation:
         """Calculate asset allocation by security type and sector.
 
         Groups holdings by security type (equity, bond, ETF, etc.) and calculates
@@ -176,8 +171,7 @@ class InvestmentProvider(ABC):
         }
 
         by_sector_percent = {
-            sector: round((value / total_value) * 100, 2)
-            for sector, value in sector_values.items()
+            sector: round((value / total_value) * 100, 2) for sector, value in sector_values.items()
         }
 
         cash_percent = round((cash_value / total_value) * 100, 2)
@@ -188,7 +182,7 @@ class InvestmentProvider(ABC):
             cash_percent=cash_percent,
         )
 
-    def calculate_portfolio_metrics(self, holdings: List[Holding]) -> dict:
+    def calculate_portfolio_metrics(self, holdings: list[Holding]) -> dict:
         """Calculate total value, cost basis, unrealized gain/loss.
 
         Aggregates holdings to calculate portfolio-level metrics.

fin_infra/investments/providers/plaid.py

@@ -10,33 +10,55 @@ from __future__ import annotations
 
 from datetime import date
 from decimal import Decimal
-from typing import Any, Dict, List, Optional
-
-from plaid.api import plaid_api
-from plaid.model.investments_holdings_get_request import InvestmentsHoldingsGetRequest
-from plaid.model.investments_transactions_get_request import (
-    InvestmentsTransactionsGetRequest,
-)
-from plaid.model.investments_holdings_get_response import InvestmentsHoldingsGetResponse
-from plaid.model.investments_transactions_get_response import (
-    InvestmentsTransactionsGetResponse,
-)
-from plaid.exceptions import ApiException
-import plaid
-from plaid.api_client import ApiClient
-from plaid.configuration import Configuration
+from typing import Any, cast
+
+try:
+    import plaid
+    from plaid.api import plaid_api
+    from plaid.api_client import ApiClient
+    from plaid.configuration import Configuration
+    from plaid.exceptions import ApiException
+    from plaid.model.investments_holdings_get_request import InvestmentsHoldingsGetRequest
+    from plaid.model.investments_holdings_get_response import InvestmentsHoldingsGetResponse
+    from plaid.model.investments_transactions_get_request import (
+        InvestmentsTransactionsGetRequest,
+    )
+    from plaid.model.investments_transactions_get_response import (
+        InvestmentsTransactionsGetResponse,
+    )
+
+    HAS_PLAID = True
+except ImportError:  # pragma: no cover
+    HAS_PLAID = False
+    plaid_api = None
+    plaid = None
+    ApiClient = None
+    Configuration = None
+    ApiException = Exception
+    InvestmentsHoldingsGetRequest = Any
+    InvestmentsTransactionsGetRequest = Any
+    InvestmentsHoldingsGetResponse = Any
+    InvestmentsTransactionsGetResponse = Any
 
 from ..models import (
     Holding,
     InvestmentAccount,
     InvestmentTransaction,
     Security,
-    SecurityType,
     TransactionType,
 )
 from .base import InvestmentProvider
 
 
+def _require_plaid() -> None:
+    """Raise ImportError if plaid-python is not installed."""
+    if not HAS_PLAID:
+        raise ImportError(
+            "Plaid support requires the 'plaid-python' package. "
+            "Install with: pip install fin-infra[plaid] or pip install fin-infra[banking]"
+        )
+
+
 class PlaidInvestmentProvider(InvestmentProvider):
     """Plaid Investment API provider.
 
@@ -77,7 +99,10 @@ class PlaidInvestmentProvider(InvestmentProvider):
 
         Raises:
             ValueError: If client_id or secret is missing
+            ImportError: If plaid-python is not installed
         """
+        _require_plaid()
+
         if not client_id or not secret:
             raise ValueError("client_id and secret are required for Plaid provider")
 
@@ -103,11 +128,11 @@ class PlaidInvestmentProvider(InvestmentProvider):
             "development": plaid.Environment.Sandbox,  # Map development to sandbox
             "production": plaid.Environment.Production,
         }
-        return hosts.get(environment.lower(), plaid.Environment.Sandbox)
+        return cast("str", hosts.get(environment.lower(), plaid.Environment.Sandbox))
 
     async def get_holdings(
-        self, access_token: str, account_ids: Optional[List[str]] = None
-    ) -> List[Holding]:
+        self, access_token: str, account_ids: list[str] | None = None
+    ) -> list[Holding]:
         """Fetch investment holdings from Plaid.
 
         Retrieves holdings with security details, quantity, cost basis, and current value.
@@ -136,9 +161,7 @@ class PlaidInvestmentProvider(InvestmentProvider):
             if account_ids:
                 request.options = {"account_ids": account_ids}
 
-            response: InvestmentsHoldingsGetResponse = (
-                self.client.investments_holdings_get(request)
-            )
+            response: InvestmentsHoldingsGetResponse = self.client.investments_holdings_get(request)
 
             # Build security lookup map
             securities_map = {
@@ -166,8 +189,8 @@ class PlaidInvestmentProvider(InvestmentProvider):
         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 Plaid.
 
         Retrieves buy/sell/dividend transactions within the specified date range.
@@ -204,8 +227,8 @@ class PlaidInvestmentProvider(InvestmentProvider):
             if account_ids:
                 request.options = {"account_ids": account_ids}
 
-            response: InvestmentsTransactionsGetResponse = (
-                self.client.investments_transactions_get(request)
+            response: InvestmentsTransactionsGetResponse = self.client.investments_transactions_get(
+                request
             )
 
             # Build security lookup map
@@ -229,9 +252,7 @@ class PlaidInvestmentProvider(InvestmentProvider):
         except ApiException as e:
             raise self._transform_error(e)
 
-    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 Plaid holdings.
 
         Note: Plaid doesn't have a dedicated securities endpoint.
@@ -254,9 +275,7 @@ class PlaidInvestmentProvider(InvestmentProvider):
         """
         try:
             request = InvestmentsHoldingsGetRequest(access_token=access_token)
-            response: InvestmentsHoldingsGetResponse = (
-                self.client.investments_holdings_get(request)
-            )
+            response: InvestmentsHoldingsGetResponse = self.client.investments_holdings_get(request)
 
             # Filter securities by requested IDs
             securities = []
@@ -271,9 +290,7 @@ class PlaidInvestmentProvider(InvestmentProvider):
         except ApiException as e:
             raise self._transform_error(e)
 
-    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.
@@ -295,9 +312,7 @@ class PlaidInvestmentProvider(InvestmentProvider):
         """
         try:
             request = InvestmentsHoldingsGetRequest(access_token=access_token)
-            response: InvestmentsHoldingsGetResponse = (
-                self.client.investments_holdings_get(request)
-            )
+            response: InvestmentsHoldingsGetResponse = self.client.investments_holdings_get(request)
 
             # Build security lookup map
             securities_map = {
@@ -306,7 +321,7 @@ class PlaidInvestmentProvider(InvestmentProvider):
             }
 
             # Group holdings by account
-            accounts_map: Dict[str, Dict[str, Any]] = {}
+            accounts_map: dict[str, dict[str, Any]] = {}
             for plaid_holding in response.holdings:
                 holding_dict = plaid_holding.to_dict()
                 account_id = holding_dict["account_id"]
@@ -318,11 +333,7 @@ class PlaidInvestmentProvider(InvestmentProvider):
                     if account_id not in accounts_map:
                         # Find account metadata
                         plaid_account = next(
-                            (
-                                acc
-                                for acc in response.accounts
-                                if acc.account_id == account_id
-                            ),
+                            (acc for acc in response.accounts if acc.account_id == account_id),
                             None,
                         )
                         accounts_map[account_id] = {
@@ -340,12 +351,16 @@ class PlaidInvestmentProvider(InvestmentProvider):
 
                 investment_account = InvestmentAccount(
                     account_id=account_id,
-                    name=account_dict.get("name", account_dict.get("official_name", "Unknown Account")),
+                    name=account_dict.get(
+                        "name", account_dict.get("official_name", "Unknown Account")
+                    ),
                     type=account_dict.get("type", "investment"),
                     subtype=account_dict.get("subtype"),
                     balances={
-                        "current": float(account_dict.get("balances", {}).get("current", 0)),
-                        "available": float(account_dict.get("balances", {}).get("available")),
+                        "current": Decimal(str(account_dict.get("balances", {}).get("current", 0))),
+                        "available": Decimal(
+                            str(account_dict.get("balances", {}).get("available") or 0)
+                        ),
                     },
                     holdings=holdings,
                 )
@@ -358,19 +373,19 @@ class PlaidInvestmentProvider(InvestmentProvider):
 
     # Helper methods for data transformation
 
-    def _transform_security(self, plaid_security: Dict[str, Any]) -> Security:
+    def _transform_security(self, plaid_security: dict[str, Any]) -> Security:
         """Transform Plaid security data to Security model."""
         # Handle close_price - Plaid may return None for securities without recent pricing
         close_price_raw = plaid_security.get("close_price")
         close_price = Decimal(str(close_price_raw)) if close_price_raw is not None else Decimal("0")
-        
+
         return Security(
             security_id=plaid_security["security_id"],
             cusip=plaid_security.get("cusip"),
             isin=plaid_security.get("isin"),
             sedol=plaid_security.get("sedol"),
             ticker_symbol=plaid_security.get("ticker_symbol"),
-            name=plaid_security.get("name"),
+            name=plaid_security.get("name") or "Unknown Security",
             type=self._normalize_security_type(plaid_security.get("type", "other")),
             sector=plaid_security.get("sector"),
             close_price=close_price,
@@ -379,9 +394,7 @@ class PlaidInvestmentProvider(InvestmentProvider):
             currency=plaid_security.get("iso_currency_code", "USD"),
         )
 
-    def _transform_holding(
-        self, plaid_holding: Dict[str, Any], security: Security
-    ) -> Holding:
+    def _transform_holding(self, plaid_holding: dict[str, Any], security: Security) -> Holding:
         """Transform Plaid holding data to Holding model."""
         return Holding(
             account_id=plaid_holding["account_id"],
@@ -389,13 +402,15 @@ class PlaidInvestmentProvider(InvestmentProvider):
             quantity=Decimal(str(plaid_holding.get("quantity", 0))),
             institution_price=Decimal(str(plaid_holding.get("institution_price", 0))),
             institution_value=Decimal(str(plaid_holding.get("institution_value", 0))),
-            cost_basis=Decimal(str(plaid_holding.get("cost_basis"))) if plaid_holding.get("cost_basis") else None,
+            cost_basis=Decimal(str(plaid_holding.get("cost_basis")))
+            if plaid_holding.get("cost_basis")
+            else None,
             currency=plaid_holding.get("iso_currency_code", "USD"),
             unofficial_currency_code=plaid_holding.get("unofficial_currency_code"),
         )
 
     def _transform_transaction(
-        self, plaid_transaction: Dict[str, Any], security: Security
+        self, plaid_transaction: dict[str, Any], security: Security
     ) -> InvestmentTransaction:
         """Transform Plaid investment transaction to InvestmentTransaction model."""
         # Map Plaid transaction type to our enum