nemo-cli 0.0.1__py3-none-any.whl

nemo_cli/commands/portfolio.py

@@ -0,0 +1,275 @@
+import json
+from dataclasses import asdict
+from datetime import date, timedelta
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from nemo_cli.portfolio.movements import (
+    Movements,
+    MovementsSummary,
+    get_movements,
+)
+from nemo_cli.portfolio.summary import (
+    Portfolio,
+    PortfolioTotals,
+    get_portfolio_summary,
+)
+
+app = typer.Typer(
+    help="Inspect your portfolio.",
+    no_args_is_help=True,
+)
+
+
+@app.command("summary")
+def summary(
+    account_id: int = typer.Option(
+        0, "--account-id", help="Account id to filter on (0 = all accounts)."
+    ),
+    currency: str = typer.Option(
+        "CLP", "--currency", help="Base currency for balances (codMonedaSld)."
+    ),
+    with_dividends: bool = typer.Option(
+        True,
+        "--with-dividends/--no-dividends",
+        help="Include dividends in the summary (conDividendos).",
+    ),
+    as_json: bool = typer.Option(
+        False, "--json", help="Emit JSON (holdings + totals) instead of a table."
+    ),
+) -> None:
+    """Show the portfolio summary: holdings, P&L, and totals by classification."""
+    try:
+        portfolio = get_portfolio_summary(
+            account_id=account_id,
+            currency=currency,
+            with_dividends=with_dividends,
+        )
+    except Exception as error:
+        typer.secho(str(error), fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from error
+
+    if as_json:
+        _print_json(portfolio)
+    else:
+        _print_table(portfolio)
+
+
+def _print_table(portfolio: Portfolio) -> None:
+    console = Console()
+    title = f"Portfolio summary — {portfolio.query_date or 'n/a'} ({portfolio.currency})"
+    if not portfolio.holdings:
+        console.print(f"[yellow]{title}: no holdings returned.[/yellow]")
+        return
+
+    holdings_table = Table(title=title)
+    holdings_table.add_column("Nemotécnico", style="cyan", no_wrap=True)
+    holdings_table.add_column("Descripción")
+    holdings_table.add_column("Subclasificación", style="yellow")
+    holdings_table.add_column("Cantidad", justify="right")
+    holdings_table.add_column("Costo", justify="right")
+    holdings_table.add_column("Mercado", justify="right")
+    holdings_table.add_column("P&L", justify="right")
+    holdings_table.add_column("P&L %", justify="right")
+
+    for holding in portfolio.holdings:
+        color = "green" if holding.pnl >= 0 else "red"
+        holdings_table.add_row(
+            holding.nemotecnico,
+            holding.descripcion,
+            holding.sub_classification,
+            f"{holding.quantity:,.2f}",
+            f"{holding.cost_basis:,.0f}",
+            f"{holding.market_value:,.0f}",
+            f"[{color}]{holding.pnl:+,.0f}[/{color}]",
+            f"[{color}]{holding.pnl_pct * 100:+.2f}%[/{color}]",
+        )
+    console.print(holdings_table)
+    console.print()
+
+    _print_totals(console, portfolio.totals, portfolio.currency)
+
+
+def _print_totals(console: Console, totals: PortfolioTotals, currency: str) -> None:
+    by_class_table = Table(title=f"By classification ({currency})")
+    by_class_table.add_column("Clasificación", style="bold")
+    by_class_table.add_column("Mercado", justify="right")
+    by_class_table.add_column("Costo", justify="right")
+    by_class_table.add_column("P&L", justify="right")
+    by_class_table.add_column("P&L %", justify="right")
+
+    for classification in totals.by_classification:
+        color = "green" if classification.pnl >= 0 else "red"
+        by_class_table.add_row(
+            classification.classification,
+            f"{classification.market_value:,.0f}",
+            f"{classification.cost_basis:,.0f}",
+            f"[{color}]{classification.pnl:+,.0f}[/{color}]",
+            f"[{color}]{classification.pnl_pct * 100:+.2f}%[/{color}]",
+        )
+    console.print(by_class_table)
+    console.print()
+
+    color = "green" if totals.pnl >= 0 else "red"
+    console.print(
+        f"[bold]Total:[/bold] {totals.market_value:,.0f} {currency}  "
+        f"(cost {totals.cost_basis:,.0f})  "
+        f"P&L [{color}]{totals.pnl:+,.0f}[/{color}] "
+        f"([{color}]{totals.pnl_pct * 100:+.2f}%[/{color}])"
+    )
+
+
+def _print_json(portfolio: Portfolio) -> None:
+    payload = {
+        "currency": portfolio.currency,
+        "query_date": portfolio.query_date,
+        "totals": asdict(portfolio.totals),
+        "holdings": [asdict(h) for h in portfolio.holdings],
+    }
+    typer.echo(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+def _default_desde() -> str:
+    return (date.today() - timedelta(days=365)).isoformat()
+
+
+def _default_hasta() -> str:
+    return date.today().isoformat()
+
+
+@app.command("movements")
+def movements(
+    desde: str = typer.Option(
+        None,
+        "--desde",
+        help="Start date YYYY-MM-DD. Default: 1 year ago.",
+    ),
+    hasta: str = typer.Option(
+        None,
+        "--hasta",
+        help="End date YYYY-MM-DD. Default: today.",
+    ),
+    account_id: int = typer.Option(
+        0, "--account-id", help="Account id to filter on (0 = all accounts)."
+    ),
+    as_json: bool = typer.Option(
+        False,
+        "--json",
+        help="Emit JSON (full movements + summaries) instead of a panel.",
+    ),
+) -> None:
+    """List cash movements over a date range, classified per kind.
+
+    Movement descriptions are parsed into structured `kind` values
+    (`dividend`, `buy`, `sell`, `commission`, `cash_in`, `cash_out`,
+    `other`) plus per-nemotécnico aggregates — handy for dividend yield
+    analysis. Default window is the last 365 days.
+    """
+    desde_value = desde or _default_desde()
+    hasta_value = hasta or _default_hasta()
+
+    try:
+        result = get_movements(
+            desde=desde_value,
+            hasta=hasta_value,
+            account_id=account_id,
+        )
+    except Exception as error:
+        typer.secho(str(error), fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from error
+
+    if as_json:
+        _print_json_movements(result)
+    else:
+        _print_movements_panel(result)
+
+
+def _print_movements_panel(result: Movements) -> None:
+    console = Console()
+    title = f"Movements — {result.desde} → {result.hasta}"
+    if not result.buckets:
+        console.print(f"[yellow]{title}: no movements returned.[/yellow]")
+        return
+
+    summary = result.summary
+    bucket_currencies = sorted({b.movements[0].currency for b in result.buckets if b.movements})
+    currency_label = " / ".join(bucket_currencies) or "—"
+
+    totals_table = Table(title=f"{title} ({currency_label})")
+    totals_table.add_column("Flow", style="bold")
+    totals_table.add_column("Amount", justify="right")
+    totals_table.add_row("Cash in", f"[green]+{summary.total_cash_in:,.0f}[/green]")
+    totals_table.add_row("Cash out", f"[red]-{summary.total_cash_out:,.0f}[/red]")
+    totals_table.add_row(
+        "Dividends",
+        f"[green]+{summary.total_dividends:,.0f}[/green]",
+    )
+    totals_table.add_row("Commissions", f"[red]-{summary.total_commissions:,.0f}[/red]")
+    totals_table.add_row("Buys", f"[red]-{summary.total_buys:,.0f}[/red]")
+    totals_table.add_row("Sells", f"[green]+{summary.total_sells:,.0f}[/green]")
+    console.print(totals_table)
+    console.print()
+
+    if summary.by_dividend:
+        div_table = Table(title="Dividends by instrument")
+        div_table.add_column("Nemotécnico", style="cyan", no_wrap=True)
+        div_table.add_column("Events", justify="right")
+        div_table.add_column("Total received", justify="right")
+        for item in summary.by_dividend:
+            div_table.add_row(
+                item.nemotecnico,
+                str(item.occurrences),
+                f"[green]+{item.total_received:,.0f}[/green]",
+            )
+        console.print(div_table)
+        console.print()
+
+    if summary.by_trade:
+        trade_table = Table(title="Trades by instrument")
+        trade_table.add_column("Nemotécnico", style="cyan", no_wrap=True)
+        trade_table.add_column("Side", style="magenta")
+        trade_table.add_column("Events", justify="right")
+        trade_table.add_column("Total amount", justify="right")
+        for item in summary.by_trade:
+            color = "red" if item.side == "buy" else "green"
+            sign = "-" if item.side == "buy" else "+"
+            trade_table.add_row(
+                item.nemotecnico,
+                item.side,
+                str(item.occurrences),
+                f"[{color}]{sign}{item.total_amount:,.0f}[/{color}]",
+            )
+        console.print(trade_table)
+
+
+def _print_json_movements(result: Movements) -> None:
+    payload: dict[str, object] = {
+        "desde": result.desde,
+        "hasta": result.hasta,
+        "summary": _summary_to_dict(result.summary),
+        "buckets": [
+            {
+                "bucket_id": bucket.bucket_id,
+                "name": bucket.name,
+                "summary": _summary_to_dict(bucket.summary),
+                "movements": [asdict(m) for m in bucket.movements],
+            }
+            for bucket in result.buckets
+        ],
+    }
+    typer.echo(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+def _summary_to_dict(summary: MovementsSummary) -> dict[str, object]:
+    return {
+        "total_cash_in": summary.total_cash_in,
+        "total_cash_out": summary.total_cash_out,
+        "total_dividends": summary.total_dividends,
+        "total_commissions": summary.total_commissions,
+        "total_buys": summary.total_buys,
+        "total_sells": summary.total_sells,
+        "by_dividend": [asdict(item) for item in summary.by_dividend],
+        "by_trade": [asdict(item) for item in summary.by_trade],
+    }

nemo_cli/commands/whoami.py

@@ -0,0 +1,18 @@
+import typer
+
+from nemo_cli.auth.token_store import get_token
+from nemo_cli.config import load_credentials
+
+
+def whoami() -> None:
+    """Show the configured user and whether a token is currently cached."""
+    try:
+        credentials = load_credentials()
+    except Exception as error:
+        typer.secho(str(error), fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from error
+    typer.echo(f"User:    {credentials.user_name}")
+    if get_token():
+        typer.secho("Token:   cached", fg=typer.colors.GREEN)
+    else:
+        typer.secho("Token:   not cached (run `nemo login`)", fg=typer.colors.YELLOW)

nemo_cli/config.py

@@ -0,0 +1,24 @@
+import os
+from dataclasses import dataclass
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+API_BASE_URL = "https://portalclientes.vectorcapital.cl/api"
+
+
+@dataclass(frozen=True)
+class Credentials:
+    user_name: str
+    password: str
+
+
+def load_credentials() -> Credentials:
+    user_name = (os.environ.get("NEMO_USERNAME") or "").strip()
+    password = os.environ.get("NEMO_PASSWORD") or ""
+    if not user_name or not password:
+        raise RuntimeError(
+            "Missing credentials. Set NEMO_USERNAME and NEMO_PASSWORD (e.g. in .env)."
+        )
+    return Credentials(user_name=user_name, password=password)

nemo_cli/instruments/international.py

@@ -0,0 +1,102 @@
+from dataclasses import dataclass
+from typing import Any, cast
+
+from nemo_cli.api.client import api_request
+
+
+@dataclass(frozen=True)
+class InternationalAsset:
+    asset_id: str
+    symbol: str
+    name: str
+    exchange: str
+    asset_class: str
+    status: str
+    tradable: bool
+    shortable: bool
+    fractionable: bool
+    volume: int
+    trade_count: int
+    cusip: str | None
+
+
+@dataclass(frozen=True)
+class InternationalAssetsPage:
+    items: tuple[InternationalAsset, ...]
+    total: int
+
+
+def list_international_assets(
+    *,
+    search: str = "",
+    exchange: str = "",
+    page: int = 1,
+    page_size: int = 30,
+) -> InternationalAssetsPage:
+    params: dict[str, Any] = {
+        "exchangeName": exchange,
+        "search": search,
+        "page": page,
+        "pageSize": page_size,
+    }
+    response = api_request("GET", "/frontoffice/shared/Asset", params=params)
+    if response.status_code >= 400:
+        raise RuntimeError(
+            f"Failed to list international assets "
+            f"({response.status_code} {response.reason_phrase}): {response.text}"
+        )
+
+    raw: object = response.json()
+    if not isinstance(raw, dict):
+        raise RuntimeError("International assets response was not a JSON object.")
+    payload = cast(dict[str, object], raw)
+
+    raw_items = payload.get("items")
+    raw_total = payload.get("totalCount")
+    if not isinstance(raw_items, list):
+        raise RuntimeError("International assets response missing 'items' array.")
+    if not isinstance(raw_total, int):
+        raise RuntimeError("International assets response missing integer 'totalCount'.")
+
+    items = tuple(
+        _to_asset(cast(dict[str, object], item))
+        for item in cast(list[object], raw_items)
+        if isinstance(item, dict)
+    )
+    return InternationalAssetsPage(items=items, total=raw_total)
+
+
+def _to_asset(item: dict[str, object]) -> InternationalAsset:
+    return InternationalAsset(
+        asset_id=_as_str(item.get("id")),
+        symbol=_as_str(item.get("symbol")),
+        name=_as_str(item.get("name")),
+        exchange=_as_str(item.get("exchangeName")),
+        asset_class=_as_str(item.get("assetClassName")),
+        status=_as_str(item.get("status")),
+        tradable=_as_bool(item.get("tradable")),
+        shortable=_as_bool(item.get("shortable")),
+        fractionable=_as_bool(item.get("fractionable")),
+        volume=_as_int(item.get("volume")),
+        trade_count=_as_int(item.get("tradeCount")),
+        cusip=_as_optional_str(item.get("cusip")),
+    )
+
+
+def _as_str(value: object) -> str:
+    return value.strip() if isinstance(value, str) else ""
+
+
+def _as_optional_str(value: object) -> str | None:
+    if isinstance(value, str):
+        cleaned = value.strip()
+        return cleaned or None
+    return None
+
+
+def _as_int(value: object) -> int:
+    return value if isinstance(value, int) else 0
+
+
+def _as_bool(value: object) -> bool:
+    return bool(value) if isinstance(value, bool) else False

nemo_cli/instruments/local.py

@@ -0,0 +1,94 @@
+from dataclasses import dataclass
+from typing import Any, cast
+
+from nemo_cli.api.client import api_request
+
+DEFAULT_SUBCLASSES: tuple[str, ...] = ("ACC", "ACC_INT", "CFI", "ETF", "OPC")
+
+
+@dataclass(frozen=True)
+class LocalInstrument:
+    id_instrumento: int
+    nemotecnico: str
+    descripcion: str
+    cod_sub_clase: str
+    cod_clase: str
+    codigo_familia: str
+    cod_moneda: str
+    cod_pais: str
+    isin: str | None
+
+
+@dataclass(frozen=True)
+class LocalInstrumentsPage:
+    items: tuple[LocalInstrument, ...]
+    total: int
+
+
+def list_local_instruments(
+    *,
+    search: str = "",
+    subclasses: tuple[str, ...] = DEFAULT_SUBCLASSES,
+    page: int = 1,
+    limit: int = 30,
+) -> LocalInstrumentsPage:
+    params: dict[str, Any] = {
+        "page": page,
+        "limit": limit,
+        "filterNemotecnico": search,
+        "codSubClaseInstrumentos": ",".join(subclasses),
+    }
+    response = api_request("GET", "/shared/Instrumentos/FiltrarInstrumentos", params=params)
+    if response.status_code >= 400:
+        raise RuntimeError(
+            f"Failed to list local instruments "
+            f"({response.status_code} {response.reason_phrase}): {response.text}"
+        )
+
+    raw: object = response.json()
+    if not isinstance(raw, dict):
+        raise RuntimeError("Local instruments response was not a JSON object.")
+    payload = cast(dict[str, object], raw)
+
+    raw_items = payload.get("result")
+    raw_total = payload.get("total")
+    if not isinstance(raw_items, list):
+        raise RuntimeError("Local instruments response missing 'result' array.")
+    if not isinstance(raw_total, int):
+        raise RuntimeError("Local instruments response missing integer 'total'.")
+
+    items = tuple(
+        _to_instrument(cast(dict[str, object], item))
+        for item in cast(list[object], raw_items)
+        if isinstance(item, dict)
+    )
+    return LocalInstrumentsPage(items=items, total=raw_total)
+
+
+def _to_instrument(item: dict[str, object]) -> LocalInstrument:
+    return LocalInstrument(
+        id_instrumento=_as_int(item.get("idInstrumento")),
+        nemotecnico=_as_str(item.get("nemotecnico")),
+        descripcion=_as_str(item.get("dscInstrumento")),
+        cod_sub_clase=_as_str(item.get("codSubClaseInstrumento")),
+        cod_clase=_as_str(item.get("codClaseInstrumento")),
+        codigo_familia=_as_str(item.get("codigoFamilia")),
+        cod_moneda=_as_str(item.get("codMoneda")),
+        cod_pais=_as_str(item.get("codPais")),
+        isin=_as_optional_str(item.get("isin")),
+    )
+
+
+def _as_str(value: object) -> str:
+    return value.strip() if isinstance(value, str) else ""
+
+
+def _as_optional_str(value: object) -> str | None:
+    if isinstance(value, str):
+        cleaned = value.strip()
+        return cleaned or None
+    return None
+
+
+def _as_int(value: object) -> int:
+    return value if isinstance(value, int) else 0

nemo_cli/instruments/prices.py

@@ -0,0 +1,139 @@
+import statistics
+from dataclasses import dataclass
+from typing import cast
+
+from nemo_cli.api.client import api_request
+
+
+@dataclass(frozen=True)
+class PricePoint:
+    date: str
+    price: float
+    updated_at: str | None
+
+
+@dataclass(frozen=True)
+class PriceHistoryStats:
+    first_date: str
+    last_date: str
+    first_price: float
+    last_price: float
+    min_price: float
+    min_date: str
+    max_price: float
+    max_date: str
+    mean_price: float
+    total_return_pct: float
+    daily_return_std_pct: float
+    days: int
+
+
+@dataclass(frozen=True)
+class PriceHistory:
+    instrument_id: int
+    points: tuple[PricePoint, ...]
+    stats: PriceHistoryStats | None
+
+
+def get_price_history(instrument_id: int) -> PriceHistory:
+    response = api_request(
+        "GET",
+        "/frontoffice/shared/PublicadorPrecio/GetPreciosInstrumento",
+        params={"idInstrumento": instrument_id},
+    )
+    if response.status_code >= 400:
+        raise RuntimeError(
+            f"Failed to load price history "
+            f"({response.status_code} {response.reason_phrase}): {response.text}"
+        )
+
+    raw: object = response.json()
+    if not isinstance(raw, list):
+        raise RuntimeError("Price history response was not a JSON array.")
+
+    points = tuple(
+        sorted(
+            (
+                _to_point(cast(dict[str, object], item))
+                for item in cast(list[object], raw)
+                if isinstance(item, dict)
+            ),
+            key=lambda p: p.date,
+        )
+    )
+    stats = _compute_stats(points)
+
+    return PriceHistory(
+        instrument_id=instrument_id,
+        points=points,
+        stats=stats,
+    )
+
+
+def _to_point(item: dict[str, object]) -> PricePoint:
+    return PricePoint(
+        date=_as_date(item.get("fecha")),
+        price=_as_float(item.get("precio")),
+        updated_at=_as_optional_str(item.get("fechaActualizacion")),
+    )
+
+
+def _compute_stats(points: tuple[PricePoint, ...]) -> PriceHistoryStats | None:
+    if not points:
+        return None
+
+    prices = [p.price for p in points]
+    first_point, last_point = points[0], points[-1]
+
+    min_idx = min(range(len(prices)), key=lambda i: prices[i])
+    max_idx = max(range(len(prices)), key=lambda i: prices[i])
+
+    total_return = (
+        (last_point.price - first_point.price) / first_point.price
+        if first_point.price > 0
+        else 0.0
+    )
+
+    if len(points) >= 2:
+        daily_returns = [
+            (prices[i] - prices[i - 1]) / prices[i - 1]
+            for i in range(1, len(prices))
+            if prices[i - 1] > 0
+        ]
+        daily_std = statistics.stdev(daily_returns) if len(daily_returns) >= 2 else 0.0
+    else:
+        daily_std = 0.0
+
+    return PriceHistoryStats(
+        first_date=first_point.date,
+        last_date=last_point.date,
+        first_price=first_point.price,
+        last_price=last_point.price,
+        min_price=points[min_idx].price,
+        min_date=points[min_idx].date,
+        max_price=points[max_idx].price,
+        max_date=points[max_idx].date,
+        mean_price=statistics.fmean(prices),
+        total_return_pct=total_return,
+        daily_return_std_pct=daily_std,
+        days=len(points),
+    )
+
+
+def _as_date(value: object) -> str:
+    if isinstance(value, str) and len(value) >= 10:
+        return value[:10]
+    return value if isinstance(value, str) else ""
+
+
+def _as_optional_str(value: object) -> str | None:
+    if isinstance(value, str):
+        cleaned = value.strip()
+        return cleaned or None
+    return None
+
+
+def _as_float(value: object) -> float:
+    if isinstance(value, (int, float)):
+        return float(value)
+    return 0.0