investment-python 0.1.0b1__py3-none-any.whl

investment/marketquote/yahoo_finance_fetcher.py

@@ -0,0 +1,166 @@
+"""Fetch market quote data from Yahoo Finance via the ``yfinance`` package.
+
+This mirrors the Java `YahooFinanceFetcher`, but delegates all the HTTP
+plumbing (cookies, crumbs, endpoint URLs) to ``yfinance`` instead of talking
+to the Yahoo Finance REST API directly. Price lookups return raw
+``(price, currency, timestamp)`` tuples, leaving ``Price`` value-object
+construction (e.g. cent-value conversion) to the caller;
+``fetch_fundamental_metrics`` returns a plain ``dict`` keyed by metric name,
+since those metric values can be of any type.
+"""
+from collections.abc import Collection
+from datetime import date, timedelta
+from typing import Any
+
+import numpy
+import pandas
+import yfinance as yf
+
+REGULAR_MARKET_CHANGE_PERCENT = "regularMarketChangePercent"
+
+
+def fetch_current_price(symbol: str) -> tuple[float, str, int]:
+    """Fetch the latest quoted price for ``symbol``.
+
+    Returns a ``(price, currency, timestamp)`` tuple: ``price`` is the
+    fetched price as returned by ``yfinance`` (a ``float``), ``currency``
+    is the quote currency, and ``timestamp`` is the quote time as Unix
+    epoch seconds.
+    """
+    info = yf.Ticker(symbol).info
+    price = info.get("regularMarketPrice")
+    if price is None:
+        raise ValueError(f"Cannot fetch any price with the given company symbol {symbol}")
+
+    currency:str|None = info.get("currency")
+    regular_market_time = info.get("regularMarketTime")
+    if currency is None or regular_market_time is None:
+        raise ValueError(
+            f"Cannot determine the price currency or the timestamp for company symbol {symbol}"
+        )
+
+    return price, currency, regular_market_time
+
+
+def fetcher_close_price(
+    symbol: str, target_date: date
+) -> tuple[numpy.float64, str, pandas.Timestamp]:
+    """Fetch the closing price for ``symbol`` on or before ``target_date``.
+
+    Returns a ``(price, currency, timestamp)`` tuple: ``price`` is the
+    closing price as returned by ``yfinance``, ``currency`` is the quote
+    currency, and ``timestamp`` is the close date/time.
+    """
+    ticker = yf.Ticker(symbol)
+    history = ticker.history(
+        start=target_date - timedelta(days=7),
+        end=target_date + timedelta(days=1),
+        interval="1d",
+    )
+    history = history[pandas.DatetimeIndex(history.index).date <= target_date]
+    if history.empty:
+        raise ValueError(
+            f"No historical price found for company symbol {symbol} on or before {target_date}"
+        )
+
+    last_close = history["Close"].iloc[-1]
+    timestamp = history.index[-1]
+
+    currency = ticker.info.get("currency")
+    if currency is None:
+        raise ValueError(f"Cannot determine the price currency for company symbol {symbol}")
+
+    return last_close, currency, timestamp
+
+def fetcher_close_prices(
+    symbols: list[str], target_date: date
+) -> dict[str, tuple[numpy.float64, str, pandas.Timestamp]]:
+    """Fetch the closing price for each of ``symbols`` on or before ``target_date``.
+
+    Unlike :func:`fetcher_close_price`, this batches the price history fetch
+    for all ``symbols`` into a single ``yfinance.download`` call. Returns a
+    dict mapping each symbol to a ``(price, currency, timestamp)`` tuple, the
+    same shape returned by :func:`fetcher_close_price`.
+    """
+    if not symbols:
+        return {}
+
+    data = yf.download(
+        symbols,
+        start=target_date - timedelta(days=7),
+        end=target_date + timedelta(days=1),
+        interval="1d",
+        group_by="ticker",
+        progress=False,
+    )
+    if data is None:
+        raise ValueError(
+            f"No historical price found for company symbols {symbols} on or before {target_date}"
+        )
+
+    result: dict[str, tuple[numpy.float64, str, pandas.Timestamp]] = {}
+    for symbol in symbols:
+        history = data[symbol]
+        history = history[pandas.DatetimeIndex(history.index).date <= target_date]
+        history = history[history["Close"].notna()]
+        if history.empty:
+            raise ValueError(
+                f"No historical price found for company symbol {symbol} on or before {target_date}"
+            )
+
+        last_close = history["Close"].iloc[-1]
+        timestamp = history.index[-1]
+
+        currency = yf.Ticker(symbol).info.get("currency")
+        if currency is None:
+            raise ValueError(f"Cannot determine the price currency for company symbol {symbol}")
+
+        result[symbol] = (last_close, currency, timestamp)
+
+    return result
+
+
+def fetch_price_history(symbol: str, start: date, end: date) -> tuple[dict[date, float], str]:
+    """Fetch daily closing prices for ``symbol`` between ``start`` and ``end`` (inclusive).
+
+    Returns a ``(prices, currency)`` tuple: ``prices`` maps each trading date
+    in the range to its closing price, and ``currency`` is the quote currency.
+    """
+    ticker = yf.Ticker(symbol)
+    history = ticker.history(
+        start=start,
+        end=end + timedelta(days=1),
+        interval="1d",
+    )
+    if history.empty:
+        raise ValueError(
+            f"No historical price found for company symbol {symbol} between {start} and {end}"
+        )
+
+    dates = pandas.DatetimeIndex(history.index).date
+    prices = {
+        trading_date: float(close)
+        for trading_date, close in zip(dates, history["Close"], strict=True)
+    }
+
+    currency = ticker.info.get("currency")
+    if currency is None:
+        raise ValueError(f"Cannot determine the price currency for company symbol {symbol}")
+
+    return prices, currency
+
+
+def fetch_fundamental_metrics(symbol: str, metrics: Collection[str]) -> dict[str, Any]:
+    """Fetch fundamental metrics (e.g. ``trailingPE``, ``dividendYield``,
+    ``returnOnEquity``, ``regularMarketChangePercent``) for ``symbol``.
+
+    Unlike the Yahoo Finance REST API, ``yfinance``'s ``Ticker.info`` already
+    flattens the various quote-summary modules (summaryDetail, financialData,
+    price, ...) into a single dict, so metric names can be looked up directly
+    without mapping each one to its containing section.
+    """
+    if not metrics:
+        return {}
+
+    info = yf.Ticker(symbol).info
+    return {metric_name: info.get(metric_name) for metric_name in metrics}

investment/portfolio/transaction.py

@@ -0,0 +1,58 @@
+from datetime import date
+from decimal import ROUND_HALF_UP, Decimal
+from enum import Enum, auto
+from typing import NamedTuple, Protocol
+
+
+def _money_to_cent_value(money: Decimal) -> int:
+    return int((money * 100).to_integral_value(rounding=ROUND_HALF_UP))
+
+
+class Transaction(Protocol):
+    date:date
+    money:Decimal
+    def cent_value(self) -> int: ...
+    def is_external_cashflow(self) -> bool: ...
+
+
+class Action(Enum):
+    BUY = auto()
+    SELL = auto()
+
+
+class Trade(NamedTuple):
+    security_id: str
+    action:Action
+    share_amount:int
+    date: date
+    money:Decimal
+    def cent_value(self) -> int:
+        return _money_to_cent_value(self.money)
+    def is_external_cashflow(self) -> bool:
+        return False
+
+class Dividend(NamedTuple):
+    security_id: str
+    share_amount:int
+    date: date
+    money:Decimal
+    def cent_value(self) -> int:
+        return _money_to_cent_value(self.money)
+    def is_external_cashflow(self) -> bool:
+        return False
+
+class Deposit(NamedTuple):
+    date: date
+    money:Decimal
+    def cent_value(self) -> int:
+        return _money_to_cent_value(self.money)
+    def is_external_cashflow(self) -> bool:
+        return True
+
+class Expense(NamedTuple):
+    date: date
+    money:Decimal
+    def cent_value(self) -> int:
+        return _money_to_cent_value(self.money)
+    def is_external_cashflow(self) -> bool:
+        return True

investment/portfolio/twr/_market_price_repository.py

@@ -0,0 +1,33 @@
+from datetime import date, datetime
+
+from investment.marketquote.repository import fetch_historical_prices, fetch_price_in_euro
+from investment.util.constants import EUR
+from investment.vo.value_objects import Period, Price, PriceSeries
+
+
+def _find_historical_euro_price_series(security_id:str, period:Period) -> PriceSeries:
+    price_series = fetch_historical_prices(security_id, period)
+
+    euro_cent_prices = {
+        trading_date: fetch_price_in_euro(
+            Price(
+                cent_value,
+                price_series.currency,
+                datetime.combine(trading_date, datetime.min.time()),
+            )
+        ).cent_value
+        for trading_date, cent_value in price_series.cent_prices.items()
+    }
+    return PriceSeries(currency=EUR, cent_prices=euro_cent_prices)
+
+class MarketPriceRepository:
+    def __init__(self, end_date: date) -> None:
+        self.end_date = end_date
+        self.series_cache: dict[str, PriceSeries] = {}
+    def find_euro_price(self, security_id:str, date:date) -> Price:
+        price_series = self.series_cache.get(security_id)
+        if price_series is None:
+            period = Period(from_date=date, to_date=self.end_date)
+            price_series = _find_historical_euro_price_series(security_id, period)
+            self.series_cache[security_id] = price_series
+        return price_series.get_price(date)

investment/portfolio/twr/calculation.py

@@ -0,0 +1,157 @@
+from datetime import date, timedelta
+from typing import Final, NamedTuple
+
+from investment.portfolio.transaction import Action, Deposit, Trade, Transaction
+from investment.portfolio.twr._market_price_repository import MarketPriceRepository
+from investment.portfolio.twr.portfolio import Holding, Holdings, PortfolioSnapshot
+from investment.vo.value_objects import Period
+
+
+class DailyReturn(NamedTuple):
+    date: date
+    value: float
+
+class DailyReturnSeries(NamedTuple):
+    series: list[DailyReturn]
+
+class _PortfolioSnapshotSeriesGenerator:
+    def __init__(self, transactions:list[Transaction]) -> None:
+        self.transactions = transactions
+        self.market_price_repository = MarketPriceRepository(transactions[-1].date)
+
+    def generate(self) -> dict[date,PortfolioSnapshot]:
+        # Assumes transactions is already sorted by date ascendingly: the last
+        # element is taken as the end date, and snapshots are chained in the
+        # order dates are first seen below.
+        def group_transactions_by_date() -> dict[date, list[Transaction]]:
+            transactions_by_date: dict[date, list[Transaction]] = {}
+            for transaction in self.transactions:
+                transactions_by_date.setdefault(transaction.date, []).append(transaction)
+            return transactions_by_date
+
+        transactions_by_date = group_transactions_by_date()
+
+        first_date = self.transactions[0].date
+        previous_portfolio_snapshot = PortfolioSnapshot(first_date, 0, Holdings({}), [])
+        portfolio_snapshots:dict[date,PortfolioSnapshot] = {}
+        for _date, daily_transactions in transactions_by_date.items():
+            snapshot = self._new_snapshot(daily_transactions, previous_portfolio_snapshot)
+            previous_portfolio_snapshot = portfolio_snapshots[_date] = snapshot
+        return self._add_missing_snapshots(portfolio_snapshots)
+
+    def _new_snapshot(
+        self, daily_transactions:list[Transaction], previous_snapshot:PortfolioSnapshot
+    ) -> PortfolioSnapshot:
+        # date
+        _date:Final[date] = daily_transactions[-1].date
+        # calculate remaining cash in cent
+        remaining_cash_in_cent:int = previous_snapshot.cash_in_cent
+        for transaction in daily_transactions:
+            remaining_cash_in_cent += transaction.cent_value()
+        # calculate holdings
+        holdings = Holdings(previous_snapshot.holdings.holding_by_security.copy())
+        for transaction in daily_transactions:
+            if isinstance(transaction, Trade):
+                trade = transaction
+                if trade.action == Action.BUY:
+                    holdings.add(trade.security_id, trade.share_amount)
+                elif trade.action == Action.SELL:
+                    holdings.remove(trade.security_id, trade.share_amount)
+        ## add price to holdings
+        holdings_with_price = self._reprice_holdings(holdings.holding_by_security, _date)
+        # calculate external cash flow
+        external_cash_flows = [
+            transaction.cent_value()
+            for transaction in daily_transactions
+            if isinstance(transaction, Deposit)
+        ]
+        return PortfolioSnapshot(
+            _date, remaining_cash_in_cent, Holdings(holdings_with_price), external_cash_flows
+        )
+
+    def _add_missing_snapshots(
+        self, existing_snapshots:dict[date,PortfolioSnapshot]
+    ) -> dict[date,PortfolioSnapshot]:
+        # Daily TWR needs a valuation for every day in the period, not just
+        # transaction days - a day with no transactions still has to reflect
+        # that day's market move. existing_snapshots[period.from_date] is
+        # guaranteed present since transactions[0].date is a transaction date.
+        period:Period = Period(self.transactions[0].date, self.transactions[-1].date)
+
+        def carry_forward_snapshot(
+            previous_snapshot:PortfolioSnapshot, _date:date
+        ) -> PortfolioSnapshot:
+            """A day with no transactions still needs a snapshot: carry the
+            previous day's cash and holdings forward, re-pricing the holdings
+            for ``_date`` (positions are unchanged, but market value isn't)."""
+            holding_by_security = previous_snapshot.holdings.holding_by_security
+            holdings_with_price = self._reprice_holdings(holding_by_security, _date)
+            return PortfolioSnapshot(
+                _date, previous_snapshot.cash_in_cent, Holdings(holdings_with_price), []
+            )
+
+        complete_snapshots: dict[date,PortfolioSnapshot] = {}
+        previous_snapshot = existing_snapshots[period.from_date]
+        current_date = period.from_date
+        while current_date <= period.to_date:
+            if current_date in existing_snapshots:
+                previous_snapshot = existing_snapshots[current_date]
+            else:
+                previous_snapshot = carry_forward_snapshot(previous_snapshot, current_date)
+            complete_snapshots[current_date] = previous_snapshot
+            current_date += timedelta(days=1)
+        return complete_snapshots
+
+    def _reprice_holdings(
+        self, holding_by_security:dict[str,Holding], _date:date
+    ) -> dict[str,Holding]:
+        return {
+            security_id: Holding(
+                holding.position,
+                self.market_price_repository.find_euro_price(security_id, _date).cent_value,
+            )
+            for security_id, holding in holding_by_security.items()
+        }
+
+def calculate_twr(
+    transactions: list[Transaction],
+) -> tuple[list[PortfolioSnapshot], list[DailyReturn]]:
+    """Compute a daily-linked time-weighted return series from a portfolio's
+    transaction history.
+
+    ``transactions`` MUST already be sorted by date, ascending. This is a
+    precondition the caller is responsible for, not something this function
+    (or ``_PortfolioSnapshotsGenerator``) checks or sorts for you - passing
+    unsorted transactions produces silently wrong snapshots and returns
+    rather than raising, since end date, first date, and the day-by-day
+    snapshot chain are all derived from list/insertion order rather than by
+    re-sorting internally.
+
+    Returns a ``(portfolio_snapshots, daily_return_series)`` tuple:
+    - ``portfolio_snapshots``: one ``PortfolioSnapshot`` per distinct
+      transaction date, in the same (assumed ascending) order.
+    - ``daily_return_series``: for each date after the first, the return
+      ``(value_today - external_cashflow_today) / value_yesterday - 1``,
+      so that deposits/withdrawals don't get counted as investment
+      performance. No return is produced for the first date, since there is
+      no prior snapshot to compare against.
+    """
+    # Step 1: form the map from date to portfolio snapshot for each day
+    snapshots = _PortfolioSnapshotSeriesGenerator(transactions).generate()
+    dates = list(snapshots)
+
+    # Step 2: chain daily returns, each day's cashflow-adjusted change over the previous day
+    daily_returns: list[DailyReturn] = []
+    for previous_date, current_date in zip(dates, dates[1:]):
+        previous_value = snapshots[previous_date].value_in_cent()
+        current_snapshot = snapshots[current_date]
+        current_value = current_snapshot.value_in_cent()
+        cash_flow = current_snapshot.external_cash_flow_value_in_cent()
+        daily_return = (
+            0.0 if previous_value == 0
+            else (current_value - cash_flow) / previous_value - 1
+        )
+        daily_returns.append(DailyReturn(current_date, daily_return))
+
+    return [snapshots[d] for d in dates], daily_returns
+

investment/portfolio/twr/portfolio.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+from datetime import date
+from typing import NamedTuple
+
+
+class Holding(NamedTuple):
+    position:int
+    price_in_cent:int | None = None
+    def market_value_in_cent(self) -> int:
+        return self.position * (self.price_in_cent or 0)
+
+@dataclass
+class Holdings:
+    holding_by_security: dict[str,Holding]
+    def add(self, security_id:str, position:int):
+        existing = self.holding_by_security.get(security_id, Holding(0))
+        updated_position = existing.position + position
+        self.holding_by_security[security_id] = Holding(updated_position, existing.price_in_cent)
+    def remove(self, security_id:str, position:int):
+        existing = self.holding_by_security.get(security_id, Holding(0))
+        updated_position = existing.position - position
+        self.holding_by_security[security_id] = Holding(updated_position, existing.price_in_cent)
+
+class PortfolioSnapshot(NamedTuple):
+    date:date
+    cash_in_cent:int
+    holdings:Holdings
+    external_cash_flows:list[int]
+    def value_in_cent(self) -> int:
+        holdings = self.holdings.holding_by_security.values()
+        holdings_value = sum(h.market_value_in_cent() for h in holdings)
+        return self.cash_in_cent + holdings_value
+    def external_cash_flow_value_in_cent(self) -> int:
+        return sum(self.external_cash_flows)
+
+

investment/util/constants.py

@@ -0,0 +1,3 @@
+from typing import Final
+
+EUR:Final[str] = "EUR"

investment/util/decorator.py

@@ -0,0 +1,15 @@
+import time
+
+
+def clock(func):
+    def clocked(*args, **kwargs):
+        t0 = time.perf_counter()
+        result = func(*args, **kwargs)
+        elapsed = time.perf_counter() - t0
+        name = func.__name__
+        arg_str = ', '.join(repr(arg) for arg in args)
+        kwarg_str = ', '.join(f'{k}={v!r}' for k, v in kwargs.items())
+        all_args = ', '.join(filter(None, [arg_str, kwarg_str]))
+        print(f'[{elapsed:0.1f}s] {name}({all_args})')
+        return result
+    return clocked

investment/vo/value_objects.py

@@ -0,0 +1,43 @@
+from datetime import date, datetime, timedelta
+from typing import NamedTuple
+
+
+class Price(NamedTuple):
+    cent_value:int
+    currency: str
+    timestamp: datetime
+    def amount(self) -> float:
+        return self.cent_value / 100
+    def value_with_currency(self) -> str:
+        return f"{self.amount()} {self.currency}"
+    def currency_value(self) -> str:
+        return self.currency.upper()
+    def date(self) -> date:
+        return self.timestamp.date()
+
+class Percentage(NamedTuple):
+    fraction_value:float
+    def percent_value(self) -> float:
+        return round(self.fraction_value * 100, 2)
+
+class Period(NamedTuple):
+    from_date:date
+    to_date:date
+
+class PriceSeries(NamedTuple):
+    currency:str
+    cent_prices:dict[date,int]
+    def get_price(self, date:date) -> Price:
+        """Return the price on ``date``, falling back to the most recent
+        earlier date in the series (e.g. a weekend or holiday has no price
+        of its own, so this walks backwards to the last trading day)."""
+        search_date = date
+        while search_date not in self.cent_prices:
+            search_date -= timedelta(days=1)
+            if search_date < min(self.cent_prices):
+                raise KeyError(f"no price on or before {date} in the series")
+        return Price(
+            cent_value=self.cent_prices[search_date],
+            currency=self.currency,
+            timestamp=datetime.combine(search_date, datetime.min.time()),
+        )

investment_python-0.1.0b1.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: investment-python
+Version: 0.1.0b1
+Summary: Add your description here
+Author: Rui Xue
+Author-email: Rui Xue <ruixue.fi@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.11.1
+Requires-Dist: pandas>=3.0.5
+Requires-Dist: requests>=2.34.2
+Requires-Dist: yfinance>=1.6.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# investment-python
+
+A command-line tool for pulling stock market quotes and fundamentals (price,
+P/E, ROE, P/B, dividend yield, and more) for a watch list of companies given
+as ticker symbols or a CSV file. It can sort the results, flag stocks trading
+outside a given price range, and export everything to CSV.
+
+## Requirements
+
+- Python 3.13+
+- [`uv`](https://docs.astral.sh/uv/) for dependency management and running the tool
+
+Install dependencies with:
+
+```
+uv sync
+```
+
+Then run the tool with `uv run investment ...`.
+
+## Usage
+### Fetch Metrics
+
+```
+uv run investment metrics METRIC_NAMES (--company-symbols SYMBOLS | --company-csv PATH_OR_URL) [options]
+```
+
+- `METRIC_NAMES` — required, positional. One or more metrics delimited by
+  comma, e.g. `PRICE,TRAILING_PE`. Choose from: `COMPANY_NAME`, `PRICE`,
+  `PRICE_IN_EURO`, `MARKET_STATE`, `TRAILING_PE`, `DIVIDEND_YIELD`,
+  `DIVIDEND_PAYOUT_RATIO`, `RETURN_ON_EQUITY`, `REGULAR_MARKET_CHANGE_PERCENT`,
+  `PRICE_TO_BOOK`.
+- `--company-symbols` — company ticker symbols as used on *Yahoo Finance*,
+  delimited by comma, e.g. `AAPL,ELISA.HE`. Mutually exclusive with
+  `--company-csv`; one of the two is required.
+- `--company-csv` — path or URL to a CSV file with a `Yahoo Company Symbol`
+  column.
+- `--sort-by` — optional. Sort results ascending by this metric; must be one
+  of the metrics given in `METRIC_NAMES`.
+- `--price-ranges` — optional. Flag companies whose price falls outside a
+  range, formatted as `COMPANY_ID1:MIN:MAX,COMPANY_ID2:MIN:`, e.g.
+  `AAPL:150:200,ELISA.HE:30:`. Leave `MIN` or `MAX` empty for no lower/upper
+  bound.
+- `--output-csv-name` — optional. Also write the metrics result to this CSV
+  file. When given, any companies that failed to fetch are additionally
+  written to `companies_with_error.csv`, and any companies outside their
+  price range (per `--price-ranges`) are written to `alert_on_companies.csv`.
+
+#### Example Command
+
+`uv run investment metrics COMPANY_NAME,PRICE,REGULAR_MARKET_CHANGE_PERCENT,PRICE_IN_EURO,TRAILING_PE,RETURN_ON_EQUITY,PRICE_TO_BOOK,DIVIDEND_YIELD --sort-by REGULAR_MARKET_CHANGE_PERCENT --company-symbols ELISA.HE,FIA1S.HE,NOVO-B.CO`
+
+### Benchmarking
+
+Compare a stock's price performance against a benchmark (an index or another
+stock) over a given period: both series are rebased to an index of 100 at the
+start date, and a beta coefficient (`Cov(stock, benchmark) / Var(benchmark)`,
+from daily returns) is printed.
+
+```
+uv run investment benchmark BENCHMARK_ID:COMPANY_ID --start-date START_DATE --end-date END_DATE [--graph-directory DIRECTORY]
+```
+
+- `BENCHMARK_ID:COMPANY_ID` — required, positional. The benchmark and company
+  ticker symbols, delimited by a colon, e.g. `VOO:T`.
+- `--start-date` — required. Start date of the period, in ISO format, e.g.
+  `2021-08-30`.
+- `--end-date` — required. End date of the period, in ISO format, e.g.
+  `2026-08-30`.
+- `--graph-directory` — optional. Save the chart as a PNG named
+  `COMPANY_ID_vs_BENCHMARK_ID.png` in this directory. If omitted, the chart is
+  not saved.
+
+The chart is always displayed in a window (this blocks until the window is
+closed).
+
+#### Example Command
+
+`uv run investment benchmark VOO:T --start-date 2021-08-30 --end-date 2026-08-30 --graph-directory ./charts`

investment_python-0.1.0b1.dist-info/RECORD

@@ -0,0 +1,29 @@
+investment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investment/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investment/benchmark/chart_data.py,sha256=c0rSu2v90NKDQHhk-Yv4H65QlYELfJ8xpP5xIFJ4vuM,2338
+investment/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investment/cli/__main__.py,sha256=KyBNSWmYIKBeNl17W6vHRNFOh6aOmDrT5_apkNnKJg4,183
+investment/cli/main.py,sha256=LOpXBNEHBGBXNlkQ3n0gzIJN6eQ6jOv6Ln_ThIMgbX0,6213
+investment/cli/program_runner.py,sha256=uCWd2RuqdgPly8G4xjnHIuJ9wypCXMt7MPcBKFn_Ol4,5872
+investment/marketquote/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investment/marketquote/_fx_rate_fetcher.py,sha256=ilhsCyQ5bLLuE_BWYfdjtUuzje6OY88qwLb4BokbYi0,2062
+investment/marketquote/filter.py,sha256=2v3Pwp1nGvIn9SMTCfzd29258zf27svBRGTlVdVtz3M,1126
+investment/marketquote/metrics.py,sha256=MkErauplj-94xq3-7YTshLtA7CyUAG4N1ZMfj5tkqZo,3158
+investment/marketquote/repository.py,sha256=D_vxl1AsHv3v1_eg-UzWuKstPhI0mylgPf_XtkhDKn8,5678
+investment/marketquote/yahoo_finance_fetcher.py,sha256=B4_HEvxISB-D_8T2k7PEb8LnAhxoVrWgjZc0wB_Th90,6167
+investment/portfolio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investment/portfolio/transaction.py,sha256=f7FBIGAf07ovSAFe5B0i2HIKNBCYsmafz1HdR-9Uhg0,1393
+investment/portfolio/twr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investment/portfolio/twr/_market_price_repository.py,sha256=3B1RCZCQuZA2JmNjYKW5obs3t1cjWwaHOPTFR6VOREI,1372
+investment/portfolio/twr/calculation.py,sha256=fzw_faFJ_t6E_2HpcSto1Ql1lSxWT4_04H75NnpYBxU,7571
+investment/portfolio/twr/portfolio.py,sha256=UXO8BmJDtgTDALw2fEXq85wQy0RGn-MIE4Fi48yisG4,1352
+investment/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investment/util/constants.py,sha256=XV8I2JVuIw7jGoKoqfgHp-O8zTPLUbe-SkcHQ0lZB7U,49
+investment/util/decorator.py,sha256=VnfsUBSJKwdU_KKYN4YkstVomzvJ6B9-CgqeIaru_eo,496
+investment/vo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investment/vo/value_objects.py,sha256=t7wTTIZnrqnix-Hn1EZmhUWiB00hNBD56SI-crTiLiE,1467
+investment_python-0.1.0b1.dist-info/licenses/LICENSE,sha256=UPg_bWlyzbvWouUMDRsNRU2Zh5ztICAPqr2dc8Ri0KA,1064
+investment_python-0.1.0b1.dist-info/WHEEL,sha256=s_zqWxHFEH8b58BCtf46hFCqPaISurdB9R1XJ8za6XI,80
+investment_python-0.1.0b1.dist-info/entry_points.txt,sha256=jZ65dwNXZ429z9NdQRP-AlSSj5C_EV2WrNbOnpT-NoE,57
+investment_python-0.1.0b1.dist-info/METADATA,sha256=s_yT_GhxGcDT2CQUOqM0LpiVRDV2Pl7Fl5CJoW8LEh0,3677
+investment_python-0.1.0b1.dist-info/RECORD,,

investment_python-0.1.0b1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.6
+Root-Is-Purelib: true
+Tag: py3-none-any

investment_python-0.1.0b1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+investment = investment.cli.main:main
+