marketmyna 0.2.0__py3-none-any.whl

marketmyna/portfolio/manager.py

@@ -0,0 +1,383 @@
+"""Portfolio management functionality."""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from marketmyna.core.home import app_home
+
+from ..core.constants import Markets
+from ..data.crypto import CryptoDataFetcher
+from ..data.india import IndiaDataFetcher
+from ..data.stocks import StockDataFetcher
+from ..storage import DatabaseManager, HoldingRecord, PortfolioRecord, TransactionRecord, get_db_url
+from .models import Holding, Portfolio, Transaction, TransactionType
+
+
+class PortfolioManager:
+    """Manages portfolio operations."""
+
+    def __init__(self, data_dir: Optional[Path] = None, config=None):
+        # data_dir is kept for backwards compatibility with existing call sites
+        # and as a per-instance db override (e.g. test isolation); persistence
+        # itself now lives in SQLite via storage.DatabaseManager, not JSON files.
+        self.data_dir = data_dir or app_home() / "portfolios"
+        self.config = config
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+        db_url = get_db_url(config=config, override_dir=self.data_dir, filename="portfolios.db")
+        self._db = DatabaseManager.instance(db_url)
+
+        self.portfolios: dict[str, Portfolio] = {}
+        self._fetchers = {
+            Markets.US: StockDataFetcher(),
+            Markets.GLOBAL: StockDataFetcher(),
+            Markets.INDIA: IndiaDataFetcher(),
+            Markets.CRYPTO: CryptoDataFetcher(),
+        }
+
+        self._load_portfolios()
+
+    def _record_to_portfolio(self, record: PortfolioRecord) -> Portfolio:
+        """Convert a PortfolioRecord (+ its holdings/transactions) to a Portfolio."""
+        holdings = {
+            h.symbol: Holding(
+                symbol=h.symbol,
+                quantity=h.quantity,
+                avg_cost=h.avg_cost,
+                current_price=h.current_price,
+                market=h.market or "US",
+            )
+            for h in record.holdings
+        }
+
+        transactions = [
+            Transaction(
+                symbol=t.symbol,
+                transaction_type=TransactionType(t.transaction_type),
+                quantity=t.quantity,
+                price=t.price,
+                date=t.date,
+                fees=t.fees or 0.0,
+                notes=t.notes or "",
+                id=t.id,
+                market=t.market or "",
+            )
+            for t in record.transactions
+        ]
+
+        return Portfolio(
+            name=record.name,
+            holdings=holdings,
+            transactions=transactions,
+            cash_balance=record.cash_balance or 0.0,
+            currency=record.currency or "USD",
+            id=record.id,
+            created_at=record.created_at or datetime.now(),
+            kind=record.kind,
+        )
+
+    def _load_portfolios(self) -> None:
+        """Load portfolios from the database."""
+        try:
+            with self._db.get_session() as session:
+                for record in session.query(PortfolioRecord).all():
+                    portfolio = self._record_to_portfolio(record)
+                    self.portfolios[portfolio.name] = portfolio
+        except Exception as e:
+            print(f"Error loading portfolios: {e}")
+
+    def save_portfolio(self, portfolio: Portfolio) -> None:
+        """Persist a portfolio: full replace of its holdings/transactions,
+        mirroring the previous "overwrite the whole JSON file" semantics."""
+        with self._db.get_session() as session:
+            record = session.query(PortfolioRecord).filter_by(name=portfolio.name).one_or_none()
+            if record is None:
+                record = PortfolioRecord(name=portfolio.name, created_at=portfolio.created_at)
+                session.add(record)
+                session.flush()
+
+            record.cash_balance = portfolio.cash_balance
+            record.currency = portfolio.currency
+            if portfolio.kind:
+                record.kind = portfolio.kind
+
+            record.holdings.clear()
+            # Flush the deletes now: SQLAlchemy's unit-of-work would otherwise
+            # emit the re-inserts (below, same portfolio_id+symbol) before the
+            # deletes within one flush and trip the unique constraint.
+            session.flush()
+            for holding in portfolio.holdings.values():
+                record.holdings.append(
+                    HoldingRecord(
+                        symbol=holding.symbol,
+                        quantity=holding.quantity,
+                        avg_cost=holding.avg_cost,
+                        current_price=holding.current_price,
+                        market=holding.market,
+                    )
+                )
+
+            record.transactions.clear()
+            for tx in portfolio.transactions:
+                record.transactions.append(
+                    TransactionRecord(
+                        symbol=tx.symbol,
+                        transaction_type=tx.transaction_type.value,
+                        quantity=tx.quantity,
+                        price=tx.price,
+                        date=tx.date,
+                        fees=tx.fees,
+                        notes=tx.notes,
+                        market=tx.market or None,
+                    )
+                )
+
+            session.flush()
+            portfolio.id = record.id
+
+    def create_portfolio(self, name: str, currency: str = "USD", kind: Optional[str] = None) -> Portfolio:
+        """Create a new portfolio ("stocks" or "funds")."""
+        if name in self.portfolios:
+            raise ValueError(f"Portfolio '{name}' already exists")
+
+        portfolio = Portfolio(name=name, currency=currency, kind=kind)
+        self.portfolios[name] = portfolio
+        self.save_portfolio(portfolio)
+        return portfolio
+
+    def delete_portfolio(self, name: str) -> None:
+        """Delete a portfolio."""
+        if name not in self.portfolios:
+            raise ValueError(f"Portfolio '{name}' not found")
+
+        with self._db.get_session() as session:
+            record = session.query(PortfolioRecord).filter_by(name=name).one_or_none()
+            if record is not None:
+                session.delete(record)
+
+        del self.portfolios[name]
+
+    def rename_portfolio(self, name: str, new_name: str) -> Portfolio:
+        """Rename a portfolio, keeping its holdings and history."""
+        new_name = new_name.strip()
+        if name not in self.portfolios:
+            raise ValueError(f"Portfolio '{name}' not found")
+        if not new_name:
+            raise ValueError("Portfolio name cannot be empty")
+        if new_name == name:
+            return self.portfolios[name]
+        if new_name in self.portfolios:
+            raise ValueError(f"Portfolio '{new_name}' already exists")
+
+        with self._db.get_session() as session:
+            record = session.query(PortfolioRecord).filter_by(name=name).one()
+            record.name = new_name
+
+        portfolio = self.portfolios.pop(name)
+        portfolio.name = new_name
+        self.portfolios[new_name] = portfolio
+        return portfolio
+
+    @staticmethod
+    def _replay(transactions: list[Transaction], previous: dict[str, Holding]) -> dict[str, Holding]:
+        """Rebuild holdings from the transaction history, in order. Raises
+        ValueError if a sell would exceed what was held at that point."""
+        holdings: dict[str, Holding] = {}
+        for t in transactions:
+            if t.transaction_type == TransactionType.BUY:
+                h = holdings.get(t.symbol)
+                if h is None:
+                    old = previous.get(t.symbol)
+                    holdings[t.symbol] = Holding(
+                        symbol=t.symbol,
+                        quantity=t.quantity,
+                        avg_cost=t.price,
+                        current_price=old.current_price if old else 0.0,
+                        market=t.market or (old.market if old else "US"),
+                    )
+                else:
+                    total_cost = h.cost_basis + t.total_cost
+                    h.quantity += t.quantity
+                    h.avg_cost = total_cost / h.quantity
+            elif t.transaction_type == TransactionType.SELL:
+                h = holdings.get(t.symbol)
+                if h is None or t.quantity > h.quantity + 1e-9:
+                    held = h.quantity if h else 0
+                    raise ValueError(
+                        f"Can't remove it: the later sell of {t.quantity:g} {t.symbol} would have only "
+                        f"{held:g} shares to sell - delete that sell first"
+                    )
+                h.quantity -= t.quantity
+                if h.quantity <= 1e-9:
+                    del holdings[t.symbol]
+            elif t.transaction_type == TransactionType.SPLIT and t.symbol in holdings:
+                _apply_split(holdings[t.symbol], t.quantity)
+        return holdings
+
+    def delete_transaction(self, portfolio_name: str, index: int) -> None:
+        """Remove one transaction (e.g. a typo) and rebuild the holdings
+        from the remaining history."""
+        if portfolio_name not in self.portfolios:
+            raise ValueError(f"Portfolio '{portfolio_name}' not found")
+        portfolio = self.portfolios[portfolio_name]
+        if not 0 <= index < len(portfolio.transactions):
+            raise IndexError(f"Transaction {index} not found")
+
+        remaining = portfolio.transactions[:index] + portfolio.transactions[index + 1:]
+        portfolio.holdings = self._replay(remaining, portfolio.holdings)
+        portfolio.transactions = remaining
+        self.save_portfolio(portfolio)
+
+    def add_transaction(
+        self,
+        portfolio_name: str,
+        symbol: str,
+        transaction_type: TransactionType,
+        quantity: float,
+        price: float,
+        date: Optional[datetime] = None,
+        fees: float = 0.0,
+        notes: str = "",
+        market: str = "US",
+    ) -> None:
+        """Add a transaction to a portfolio."""
+        if portfolio_name not in self.portfolios:
+            raise ValueError(f"Portfolio '{portfolio_name}' not found")
+
+        portfolio = self.portfolios[portfolio_name]
+
+        # Validate first: a rejected sell or split must not stay in the in-memory
+        # history, where the next save would write it to the database.
+        if transaction_type == TransactionType.SELL:
+            if symbol not in portfolio.holdings:
+                raise ValueError(f"No holding for {symbol}")
+            if quantity > portfolio.holdings[symbol].quantity:
+                raise ValueError(f"Cannot sell {quantity} shares, only {portfolio.holdings[symbol].quantity} available")
+        elif transaction_type == TransactionType.SPLIT:
+            if symbol not in portfolio.holdings:
+                raise ValueError(f"No holding for {symbol} to split")
+            if quantity <= 0:
+                raise ValueError("Split ratio must be above 0")
+
+        transaction = Transaction(
+            symbol=symbol,
+            transaction_type=transaction_type,
+            quantity=quantity,
+            price=price,
+            date=date or datetime.now(),
+            fees=fees,
+            notes=notes,
+            market=market,
+        )
+        portfolio.transactions.append(transaction)
+
+        # Update holdings
+        if transaction_type == TransactionType.BUY:
+            if symbol in portfolio.holdings:
+                holding = portfolio.holdings[symbol]
+                total_cost = holding.cost_basis + transaction.total_cost
+                total_qty = holding.quantity + quantity
+                holding.avg_cost = total_cost / total_qty
+                holding.quantity = total_qty
+            else:
+                portfolio.holdings[symbol] = Holding(
+                    symbol=symbol,
+                    quantity=quantity,
+                    avg_cost=price,
+                    market=market,
+                )
+        elif transaction_type == TransactionType.SELL:
+            holding = portfolio.holdings[symbol]
+            holding.quantity -= quantity
+            if holding.quantity == 0:
+                del portfolio.holdings[symbol]
+        elif transaction_type == TransactionType.SPLIT:
+            _apply_split(portfolio.holdings[symbol], quantity)
+
+        self.save_portfolio(portfolio)
+
+    def update_prices(self, portfolio_name: str) -> None:
+        """Update current prices for all holdings in a portfolio."""
+        if portfolio_name not in self.portfolios:
+            raise ValueError(f"Portfolio '{portfolio_name}' not found")
+
+        portfolio = self.portfolios[portfolio_name]
+
+        for symbol, holding in portfolio.holdings.items():
+            if (holding.market or "").lower() == "mf":
+                from ..services.mf_holdings import latest
+
+                info = latest(symbol)
+                if info:
+                    holding.current_price = info["nav"]
+                continue
+            if (holding.market or "").lower() == "india":
+                close = nse_official_close(symbol)
+                if close:
+                    holding.current_price = close
+                    continue
+            try:
+                market = Markets(holding.market.lower()) if holding.market else Markets.US
+                fetcher = self._fetchers.get(market, self._fetchers[Markets.US])
+                quote = fetcher.get_quote(symbol)
+                holding.current_price = quote["price"]
+            except Exception as e:
+                print(f"Error updating price for {symbol}: {e}")
+
+    def get_portfolio_summary(self, portfolio_name: str) -> dict:
+        """Get a summary of the portfolio."""
+        if portfolio_name not in self.portfolios:
+            raise ValueError(f"Portfolio '{portfolio_name}' not found")
+
+        portfolio = self.portfolios[portfolio_name]
+        self.update_prices(portfolio_name)
+
+        return portfolio.to_dict()
+
+    def get_all_portfolios(self) -> list[str]:
+        """Get list of all portfolio names."""
+        return list(self.portfolios.keys())
+
+
+def nse_official_close(symbol: str, now: Optional[datetime] = None, rows: Optional[dict] = None) -> Optional[float]:
+    """NSE's official closing price while the market is shut, else None.
+
+    After the close, brokers show the official close (the volume-weighted
+    price of the last 30 minutes) rather than the last single trade that a
+    live quote returns, so a valuation at the last trade drifts a few paise
+    a share from the broker's. Uses the bhavcopy close from the listing,
+    but only once it is the latest session's: between 15:30 and the evening
+    publication the listing still holds yesterday's close, so return None
+    and let the live quote stand. Exchange holidays are not modelled, so on
+    a weekday holiday evening this also returns None.
+    """
+    from zoneinfo import ZoneInfo
+
+    from ..trading.market_hours import is_open
+
+    tz = ZoneInfo("Asia/Kolkata")
+    local = now.astimezone(tz) if now else datetime.now(tz)
+    if is_open("india", local):
+        return None
+    if rows is None:
+        from ..data.listings import get_store
+
+        found = get_store().lookup([("india", "stock", symbol), ("india", "etf", symbol)])
+        rows = {k[2]: v for k, v in found.items()}
+    row = rows.get(symbol)
+    if not row or not row.get("price") or not row.get("close_date"):
+        return None
+    after_close_today = local.weekday() < 5 and local.time() > datetime.strptime("15:30", "%H:%M").time()
+    if after_close_today and row["close_date"] != local.date().isoformat():
+        return None  # today's official close is not published yet
+    return float(row["price"])
+
+
+def _apply_split(holding: Holding, ratio: float) -> None:
+    """Split or bonus: `ratio` = shares held now for each share before (5 for a
+    1:5 split, 2 for a 1:1 bonus). Same money invested, so the average cost falls."""
+    if ratio <= 0:
+        raise ValueError("Split ratio must be above 0")
+    holding.quantity *= ratio
+    holding.avg_cost /= ratio

marketmyna/portfolio/models.py

@@ -0,0 +1,155 @@
+"""Portfolio data models."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+
+class TransactionType(Enum):
+    """Transaction types."""
+    BUY = "buy"
+    SELL = "sell"
+    DIVIDEND = "dividend"
+    SPLIT = "split"
+
+
+@dataclass
+class Transaction:
+    """Represents a single transaction."""
+
+    symbol: str
+    transaction_type: TransactionType
+    quantity: float
+    price: float
+    date: datetime
+    fees: float = 0.0
+    notes: str = ""
+    id: Optional[int] = None
+    market: str = ""
+
+    @property
+    def total_cost(self) -> float:
+        """Total cost including fees."""
+        if self.transaction_type == TransactionType.BUY:
+            return (self.quantity * self.price) + self.fees
+        elif self.transaction_type == TransactionType.SELL:
+            return (self.quantity * self.price) - self.fees
+        return 0.0
+
+    def to_dict(self) -> dict:
+        return {
+            "symbol": self.symbol,
+            "transaction_type": self.transaction_type.value,
+            "quantity": self.quantity,
+            "price": self.price,
+            "date": self.date.isoformat() if self.date else None,
+            "fees": self.fees,
+            "notes": self.notes,
+            "market": self.market,
+            "total": self.total_cost,
+        }
+
+
+@dataclass
+class Holding:
+    """Represents a current holding in the portfolio."""
+
+    symbol: str
+    quantity: float
+    avg_cost: float
+    current_price: float = 0.0
+    market: str = "US"
+
+    @property
+    def market_value(self) -> float:
+        """Current market value of the holding."""
+        return self.quantity * self.current_price
+
+    @property
+    def cost_basis(self) -> float:
+        """Total cost basis of the holding."""
+        return self.quantity * self.avg_cost
+
+    @property
+    def unrealized_gain(self) -> float:
+        """Unrealized gain/loss."""
+        return self.market_value - self.cost_basis
+
+    @property
+    def unrealized_gain_percent(self) -> float:
+        """Unrealized gain/loss as percentage."""
+        if self.cost_basis == 0:
+            return 0.0
+        return (self.unrealized_gain / self.cost_basis) * 100
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "symbol": self.symbol,
+            "quantity": self.quantity,
+            "avg_cost": self.avg_cost,
+            "current_price": self.current_price,
+            "market_value": self.market_value,
+            "cost_basis": self.cost_basis,
+            "unrealized_gain": self.unrealized_gain,
+            "unrealized_gain_percent": self.unrealized_gain_percent,
+            "market": self.market,
+        }
+
+
+@dataclass
+class Portfolio:
+    """Represents a user's portfolio."""
+
+    name: str
+    holdings: dict[str, Holding] = field(default_factory=dict)
+    transactions: list[Transaction] = field(default_factory=list)
+    cash_balance: float = 0.0
+    currency: str = "USD"
+    id: Optional[int] = None
+    created_at: datetime = field(default_factory=datetime.now)
+    kind: Optional[str] = None  # "stocks" | "funds"; None = inferred from the holdings
+
+    @property
+    def total_market_value(self) -> float:
+        """Total market value of all holdings."""
+        return sum(h.market_value for h in self.holdings.values())
+
+    @property
+    def total_cost_basis(self) -> float:
+        """Total cost basis of all holdings."""
+        return sum(h.cost_basis for h in self.holdings.values())
+
+    @property
+    def total_unrealized_gain(self) -> float:
+        """Total unrealized gain/loss."""
+        return self.total_market_value - self.total_cost_basis
+
+    @property
+    def total_unrealized_gain_percent(self) -> float:
+        """Total unrealized gain/loss as percentage."""
+        if self.total_cost_basis == 0:
+            return 0.0
+        return (self.total_unrealized_gain / self.total_cost_basis) * 100
+
+    @property
+    def total_value(self) -> float:
+        """Total portfolio value including cash."""
+        return self.total_market_value + self.cash_balance
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "name": self.name,
+            "holdings": {s: h.to_dict() for s, h in self.holdings.items()},
+            "cash_balance": self.cash_balance,
+            "currency": self.currency,
+            "total_market_value": self.total_market_value,
+            "total_cost_basis": self.total_cost_basis,
+            "total_unrealized_gain": self.total_unrealized_gain,
+            "total_unrealized_gain_percent": self.total_unrealized_gain_percent,
+            "total_value": self.total_value,
+            # index = position in the list, which is what delete_transaction takes.
+            "transactions": [{"index": i, **t.to_dict()} for i, t in enumerate(self.transactions)],
+        }

marketmyna/portfolio/optimizers.py

@@ -0,0 +1,88 @@
+"""Two portfolio construction methods from the literature, on daily returns.
+
+- Hierarchical risk parity (López de Prado, "Building Diversified Portfolios
+  that Outperform Out of Sample", 2016): cluster holdings by correlation,
+  order them so similar ones sit together, then split weight top-down
+  between clusters in inverse proportion to each cluster's variance. Needs
+  no covariance inversion, so it is stable with few observations.
+- Minimum CVaR (Rockafellar & Uryasev, "Optimization of Conditional
+  Value-at-Risk", 2000): the long-only mix whose average loss on its worst
+  5% of days, in the history given, is smallest; solved as a linear programme.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from scipy.cluster.hierarchy import leaves_list, linkage
+from scipy.optimize import linprog
+from scipy.spatial.distance import squareform
+
+
+def _ivp(cov: np.ndarray) -> np.ndarray:
+    w = 1 / np.diag(cov)
+    return w / w.sum()
+
+
+def _cluster_var(cov: pd.DataFrame, items: list) -> float:
+    sub = cov.loc[items, items].to_numpy()
+    w = _ivp(sub)
+    return float(w @ sub @ w)
+
+
+def hrp(returns: pd.DataFrame) -> pd.Series:
+    """Weights summing to 1, indexed like returns.columns."""
+    cols = list(returns.columns)
+    if len(cols) == 1:
+        return pd.Series([1.0], index=cols)
+    cov, corr = returns.cov(), returns.corr().clip(-1, 1)
+    # a writable copy: with pandas copy-on-write, DataFrame.values is read-only
+    dist = np.sqrt(((1 - corr) / 2).clip(lower=0)).to_numpy(copy=True)
+    np.fill_diagonal(dist, 0)
+    order = [cols[i] for i in leaves_list(linkage(squareform(dist, checks=False), method="single"))]
+    w = pd.Series(1.0, index=order)
+    clusters = [order]
+    while clusters:
+        nxt = []
+        for c in clusters:
+            if len(c) < 2:
+                continue
+            half = len(c) // 2
+            left, right = c[:half], c[half:]
+            v_l, v_r = _cluster_var(cov, left), _cluster_var(cov, right)
+            alpha = 1 - v_l / (v_l + v_r)
+            w[left] *= alpha
+            w[right] *= 1 - alpha
+            nxt += [left, right]
+        clusters = nxt
+    return w.reindex(cols) / w.sum()
+
+
+def min_cvar(returns: pd.DataFrame, beta: float = 0.95, max_weight: float = 1.0) -> pd.Series:
+    """Long-only weights minimising the historical CVaR at `beta` (Rockafellar-Uryasev LP).
+
+    Variables: n weights, VaR level a, T excess losses u_t >= 0.
+    minimise a + sum(u) / ((1 - beta) T)
+    subject to u_t >= -r_t . w - a,  sum(w) = 1,  0 <= w <= max_weight.
+    """
+    r = returns.to_numpy()
+    t, n = r.shape
+    cap = max(max_weight, 1.0 / n)
+    c = np.concatenate([np.zeros(n), [1.0], np.full(t, 1.0 / ((1 - beta) * t))])
+    # -r_t.w - a - u_t <= 0
+    a_ub = np.hstack([-r, -np.ones((t, 1)), -np.eye(t)])
+    b_ub = np.zeros(t)
+    a_eq = np.concatenate([np.ones(n), [0.0], np.zeros(t)])[None, :]
+    bounds = [(0, cap)] * n + [(None, None)] + [(0, None)] * t
+    res = linprog(c, A_ub=a_ub, b_ub=b_ub, A_eq=a_eq, b_eq=[1.0], bounds=bounds, method="highs")
+    if not res.success:
+        raise ValueError(f"Minimum-CVaR solve failed: {res.message}")
+    w = np.clip(res.x[:n], 0, None)
+    return pd.Series(w / w.sum(), index=returns.columns)
+
+
+def cvar(port_returns: pd.Series | np.ndarray, beta: float = 0.95) -> float:
+    """Average daily loss on the worst (1 - beta) of days, as a positive fraction."""
+    x = np.sort(np.asarray(port_returns, dtype=float))
+    k = max(1, int(np.ceil(round((1 - beta) * len(x), 9))))  # round: 0.05 * 40 is 2.0000000000000018
+    return float(-x[:k].mean())