investment-python 0.1.0b2__tar.gz → 0.1.0b4__tar.gz

{investment_python-0.1.0b2 → investment_python-0.1.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: investment-python
-Version: 0.1.0b2
+Version: 0.1.0b4
 Summary: Add your description here
 Author: Rui Xue
 Author-email: Rui Xue <ruixue.fi@gmail.com>

{investment_python-0.1.0b2 → investment_python-0.1.0b4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "investment-python"
-version = "0.1.0b2"
+version = "0.1.0b4"
 description = "Add your description here"
 readme = "README.md"
 license = "MIT"

investment_python-0.1.0b4/src/investment/benchmark/chart_data.py

@@ -0,0 +1,66 @@
+import itertools
+import statistics
+from datetime import date
+from typing import NamedTuple
+
+from investment.marketquote.repository import fetch_historical_prices
+from investment.vo.value_objects import IndexSeries, Period, PriceSeries
+
+
+class ChartData(NamedTuple):
+    benchmark: tuple[str,PriceSeries]
+    stock: tuple[str,PriceSeries]
+    base:float=100
+
+
+    def _to_index(self, price_series:PriceSeries) -> dict[date,float]:
+        first_price:int = next(iter(price_series.cent_prices.values()))
+        return {date:price/first_price*100 for date,price in price_series.cent_prices.items()}
+
+    def benchmark_index(self) -> IndexSeries:
+        """Return the benchmark's price series rebased to ``base`` at its first date."""
+        benchmark_id = self.benchmark[0]
+        price_series = self.benchmark[1]
+        return IndexSeries(benchmark_id, self._to_index(price_series))
+
+    def stock_index(self) -> IndexSeries:
+        """Return the stock's price series rebased to ``base`` at its first date."""
+        security_id = self.stock[0]
+        price_series = self.stock[1]
+        return IndexSeries(security_id, self._to_index(price_series))
+
+    def coefficient(self)->float:
+        """Return the stock's beta relative to the benchmark over the period.
+
+        Beta = Cov(stock returns, benchmark returns) / Var(benchmark returns),
+        computed from daily returns over the trading dates common to both series.
+        """
+        benchmark_prices = self.benchmark[1].cent_prices
+        stock_prices = self.stock[1].cent_prices
+        common_dates = sorted(benchmark_prices.keys() & stock_prices.keys())
+        if len(common_dates) < 2:
+            raise ValueError(
+                "Not enough overlapping trading dates between benchmark and stock to compute a beta"
+            )
+
+        benchmark_returns = [
+            benchmark_prices[curr] / benchmark_prices[prev] - 1
+            for prev, curr in itertools.pairwise(common_dates)
+        ]
+        stock_returns = [
+            stock_prices[curr] / stock_prices[prev] - 1
+            for prev, curr in itertools.pairwise(common_dates)
+        ]
+
+        benchmark_variance = statistics.variance(benchmark_returns)
+        if benchmark_variance == 0:
+            raise ValueError("Benchmark returns have zero variance; beta is undefined")
+
+        return statistics.covariance(stock_returns, benchmark_returns) / benchmark_variance
+
+    @staticmethod
+    def generate(benchmark_id:str, company_id:str, period:Period) -> "ChartData":
+        benchmark_price_series:PriceSeries = fetch_historical_prices(benchmark_id, period)
+        stock_price_series: PriceSeries = fetch_historical_prices(company_id, period, currency=(
+            benchmark_price_series.currency))
+        return ChartData((benchmark_id, benchmark_price_series), (company_id, stock_price_series))

{investment_python-0.1.0b2 → investment_python-0.1.0b4}/src/investment/cli/main.py

@@ -26,6 +26,11 @@ def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="investment", description="Fetch market quotes and fundamentals."
     )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Print log messages (INFO and above) to stdout. Suppressed by default.",
+    )
     subparsers = parser.add_subparsers(dest="command", required=True)
     def _build_metrics_parser() -> None:
         metrics_parser = subparsers.add_parser(
@@ -93,13 +98,16 @@ def _build_parser() -> argparse.ArgumentParser:
 
 
 def main(argv: Sequence[str] | None = None) -> None:
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s %(levelname)s %(name)s.%(funcName)s: %(message)s",
-        stream=sys.stdout,
-    )
     parser = _build_parser()
     args = parser.parse_args(argv)
+    if args.verbose:
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s %(levelname)s %(name)s.%(funcName)s: %(message)s",
+            stream=sys.stdout,
+        )
+    else:
+        logging.disable(logging.CRITICAL)
     if args.command == Command.METRICS:
         metrics, erratic_company_ids, metrics_records_out_of_range = _run_metrics(
             names=args.metric_names,
@@ -141,13 +149,13 @@ def main(argv: Sequence[str] | None = None) -> None:
         benchmark_index = chart_data.benchmark_index()
         stock_index = chart_data.stock_index()
         print(
-            f"Coefficient ({stock_index.symbol} vs {benchmark_index.symbol}): "
+            f"Coefficient ({stock_index.label} vs {benchmark_index.label}): "
             f"{chart_data.coefficient():.4f}"
         )
         output_path = None
         if args.graph_directory:
             output_path = os.path.join(
-                args.graph_directory, f"{stock_index.symbol}_vs_{benchmark_index.symbol}.png"
+                args.graph_directory, f"{stock_index.label}_vs_{benchmark_index.label}.png"
             )
         chart_path = _generate_benchmark_chart(chart_data, output_path=output_path)
         if chart_path is not None:

{investment_python-0.1.0b2 → investment_python-0.1.0b4}/src/investment/cli/program_runner.py

@@ -3,8 +3,10 @@
 import logging
 import time
 from datetime import date
+from decimal import Decimal
 
 import matplotlib.pyplot as plt
+import numpy
 import pandas as pd
 
 from investment.benchmark.chart_data import ChartData
@@ -31,8 +33,8 @@ def _run_metrics(
         for entry in price_ranges_str.split(","):
             company_id, start, end = entry.split(":")
             result[company_id] = Range(
-                start=float(start) if start else None,
-                end=float(end) if end else None,
+                start=Decimal(start) if start else None,
+                end=Decimal(end) if end else None,
             )
         return result
 
@@ -130,16 +132,18 @@ def _generate_benchmark_chart(
 
     fig, ax = plt.subplots()
     ax.plot(
-        benchmark_index.index_series.index.to_numpy(), benchmark_index.index_series.to_numpy(),
-        label=benchmark_index.symbol,
+        numpy.array(list(benchmark_index.dates())),
+        numpy.array(list(benchmark_index.index_values())),
+        label=benchmark_index.label,
     )
     ax.plot(
-        stock_index.index_series.index.to_numpy(), stock_index.index_series.to_numpy(),
-        label=stock_index.symbol,
+        numpy.array(list(stock_index.dates())),
+        numpy.array(list(stock_index.index_values())),
+        label=stock_index.label,
     )
     ax.axhline(chart_data.base, color="gray", linestyle="--", linewidth=0.8)
     ax.set_title(
-        f"{stock_index.symbol} vs {benchmark_index.symbol} — indexed to {chart_data.base:.0f}"
+        f"{stock_index.label} vs {benchmark_index.label} — indexed to {chart_data.base:.0f}"
     )
     ax.set_ylabel("Index value")
     ax.legend()

investment_python-0.1.0b2/src/investment/marketquote/yahoo_finance_fetcher.py → investment_python-0.1.0b4/src/investment/marketquote/_yahoo_finance_fetcher.py

@@ -42,7 +42,7 @@ def fetch_current_price(symbol: str) -> tuple[float, str, int]:
     return price, currency, regular_market_time
 
 
-def fetcher_close_price(
+def fetch_close_price(
     symbol: str, target_date: date
 ) -> tuple[numpy.float64, str, pandas.Timestamp]:
     """Fetch the closing price for ``symbol`` on or before ``target_date``.
@@ -72,7 +72,7 @@ def fetcher_close_price(
 
     return last_close, currency, timestamp
 
-def fetcher_close_prices(
+def fetch_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``.

{investment_python-0.1.0b2 → investment_python-0.1.0b4}/src/investment/marketquote/filter.py

@@ -1,13 +1,14 @@
 import math
+from decimal import Decimal
 from typing import NamedTuple
 
 from investment.marketquote.metrics import Metric, MetricsRecord
 
 
 class Range(NamedTuple):
-    start: float | None
-    end: float | None
-    def has(self, value:float) -> bool:
+    start: Decimal | None
+    end: Decimal | None
+    def has(self, value: Decimal) -> bool:
         start = self.start if self.start else 0
         end = self.end if self.end else math.inf
         return start <= value <= end

{investment_python-0.1.0b2 → investment_python-0.1.0b4}/src/investment/marketquote/repository.py

@@ -5,7 +5,7 @@ from decimal import ROUND_HALF_UP, Decimal
 from types import MappingProxyType
 from typing import Any, Final
 
-from investment.marketquote import yahoo_finance_fetcher
+from investment.marketquote import _yahoo_finance_fetcher as yahoo_finance_fetcher
 from investment.marketquote._fx_rate_fetcher import fetch_fx_rate_from_euro
 from investment.marketquote._fx_rate_fetcher import (
     fetch_fx_rate_series_from_euro as _fetch_fx_rate_series_from_euro,
@@ -14,7 +14,7 @@ from investment.marketquote.metrics import Metric, MetricsRecord
 from investment.util.util import EUR, convert_to_euro_cent
 from investment.vo.value_objects import FxRateSeries, Percentage, Period, Price, PriceSeries
 
-
+_fx_rate_series_from_euro_cache:dict[str,FxRateSeries] = dict()
 def fetch_price(symbol: str, target_date: date | None = None) -> Price:
     """Fetch the price for ``symbol``.
 
@@ -29,7 +29,7 @@ def fetch_price(symbol: str, target_date: date | None = None) -> Price:
             currency=currency,
             timestamp=datetime.fromtimestamp(epoch_seconds, tz=timezone.utc),
         )
-    last_close, currency, timestamp = yahoo_finance_fetcher.fetcher_close_price(symbol, target_date)
+    last_close, currency, timestamp = yahoo_finance_fetcher.fetch_close_price(symbol, target_date)
     cent_value = int((Decimal(str(last_close)) * 100).to_integral_value(rounding=ROUND_HALF_UP))
     return Price(
         cent_value=cent_value,
@@ -116,11 +116,16 @@ def fetch_current_metrics_batch(
     records_with_errors = [record for record in records if record.has_errors()]
     return records_without_errors, records_with_errors
 
-def fetch_historical_prices(company_id:str, period:Period) -> PriceSeries:
+def fetch_historical_prices(company_id:str, period:Period, currency:str=EUR) -> PriceSeries:
     """Fetch the daily closing price series for ``company_id`` over ``period``."""
-    prices, currency = yahoo_finance_fetcher.fetch_price_history(
+    float_prices, original_currency = yahoo_finance_fetcher.fetch_price_history(
         company_id, period.from_date, period.to_date
     )
+    prices: dict[date, Decimal] = {d:Decimal(price) for d, price in float_prices.items()}
+    if original_currency != currency:
+        fx_rate_series = fetch_fx_rate_series(original_currency,currency, period)
+        prices = {date:fx_rate_series.get(date)*price for date, price in prices.items()}
+
     cent_prices = {
         trading_date: int((Decimal(str(price)) * 100).to_integral_value(rounding=ROUND_HALF_UP))
         for trading_date, price in prices.items()
@@ -136,3 +141,28 @@ def fetch_fx_rate_series_from_euro(currency:str, period:Period) -> FxRateSeries:
         quote_currency=currency,
         values=dict(rate_pairs),
     )
+
+def fetch_fx_rate_series(base_currency:str, quote_currency:str, period:Period) -> FxRateSeries:
+    """Fetch the ``base_currency``-to-``quote_currency`` exchange rate for every
+    day the ECB published a rate for both currencies within ``period`` (both
+    dates inclusive).
+
+    The ECB only publishes EUR-denominated reference rates, so a non-EUR pair
+    is triangulated through EUR: rate = (EUR-to-``quote_currency``) /
+    (EUR-to-``base_currency``). This also covers ``base_currency`` or
+    ``quote_currency`` being EUR, and ``base_currency == quote_currency``,
+    without any special-casing, since ``fetch_fx_rate_series_from_euro``
+    already returns an identity (rate ``1``) series for EUR.
+    """
+    base_rates = fetch_fx_rate_series_from_euro(base_currency, period)
+    quote_rates = fetch_fx_rate_series_from_euro(quote_currency, period)
+    common_dates = base_rates.values.keys() & quote_rates.values.keys()
+    values = {
+        rate_date: quote_rates.values[rate_date] / base_rates.values[rate_date]
+        for rate_date in common_dates
+    }
+    return FxRateSeries(
+        base_currency=base_currency,
+        quote_currency=quote_currency,
+        values=values,
+    )

{investment_python-0.1.0b2 → investment_python-0.1.0b4}/src/investment/portfolio/transaction.py

@@ -49,10 +49,29 @@ class Deposit(NamedTuple):
     def is_external_cashflow(self) -> bool:
         return True
 
-class Expense(NamedTuple):
+class ExpenseType(Enum):
+    INVESTMENT = auto()
+    NON_INVESTMENT = auto()
+
+class Expense(Transaction, Protocol):
+    def type(self) -> ExpenseType:...
+
+class InvestmentExpense(NamedTuple):
+    date: date
+    money:Decimal
+    def cent_value(self) -> int:
+        return _money_to_cent_value(self.money)
+    def is_external_cashflow(self) -> bool:
+        return False
+    def type(self):
+        return ExpenseType.INVESTMENT
+
+class NonInvestmentExpense(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
+    def type(self):
+        return ExpenseType.NON_INVESTMENT

investment_python-0.1.0b4/src/investment/portfolio/twr/_market_price_repository.py

@@ -0,0 +1,19 @@
+from datetime import date
+
+from investment.marketquote.repository import fetch_historical_prices
+from investment.util.util import EUR
+from investment.vo.value_objects import FxRateSeries, Period, Price, PriceSeries
+
+_fx_rate_series_cache:dict[str,FxRateSeries] = dict()
+
+class MarketPriceRepository:
+    def __init__(self, end_date: date) -> None:
+        self.end_date = end_date
+        self.series_cache: dict[str, PriceSeries] = {}
+    def find_price(self, security_id:str, date:date, currency:str=EUR) -> 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 = fetch_historical_prices(security_id, period, currency)
+            self.series_cache[security_id] = price_series
+        return price_series.get_price(date)

{investment_python-0.1.0b2 → investment_python-0.1.0b4}/src/investment/portfolio/twr/calculation.py

@@ -5,6 +5,8 @@ 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.returns.returns import DailyReturnSeries
+from investment.util.util import EUR
 from investment.vo.value_objects import Period
 
 
@@ -12,13 +14,16 @@ class DailyReturn(NamedTuple):
     date: date
     value: float
 
-class DailyReturnSeries(NamedTuple):
-    series: list[DailyReturn]
-
 class _PortfolioSnapshotSeriesGenerator:
-    def __init__(self, transactions:list[Transaction]) -> None:
+    def __init__(self, transactions:list[Transaction], reporting_currency:str=EUR) -> None:
         self.transactions = transactions
+        self.reporting_currency = reporting_currency
         self.market_price_repository = MarketPriceRepository(self._get_end_date())
+        self.reporting_currency:str = reporting_currency
+    def _get_end_date(self) -> date:
+        last_date = self.transactions[-1].date
+        last_day_of_month = calendar.monthrange(last_date.year, last_date.month)[1]
+        return last_date.replace(day=last_day_of_month)
     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
@@ -39,18 +44,13 @@ class _PortfolioSnapshotSeriesGenerator:
             previous_portfolio_snapshot = portfolio_snapshots[_date] = snapshot
         return self._add_missing_snapshots(portfolio_snapshots)
 
-    def _get_end_date(self) -> date:
-        last_date = self.transactions[-1].date
-        last_day_of_month = calendar.monthrange(last_date.year, last_date.month)[1]
-        return last_date.replace(day=last_day_of_month)
-
     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
+        remaining_cash_in_cent:int = previous_snapshot.cash_balance_in_cent
         for transaction in daily_transactions:
             remaining_cash_in_cent += transaction.cent_value()
         # calculate holdings
@@ -92,7 +92,7 @@ class _PortfolioSnapshotSeriesGenerator:
             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), []
+                _date, previous_snapshot.cash_balance_in_cent, Holdings(holdings_with_price), []
             )
 
         complete_snapshots: dict[date,PortfolioSnapshot] = {}
@@ -113,14 +113,16 @@ class _PortfolioSnapshotSeriesGenerator:
         return {
             security_id: Holding(
                 holding.position,
-                self.market_price_repository.find_euro_price(security_id, _date).cent_value,
+                self.market_price_repository.find_price(
+                    security_id, _date, currency=self.reporting_currency
+                ).cent_value,
             )
             for security_id, holding in holding_by_security.items()
         }
 
 def calculate_twr(
-    transactions: list[Transaction],
-) -> tuple[list[PortfolioSnapshot], list[DailyReturn]]:
+    transactions: list[Transaction], reporting_currency:str=EUR
+) -> tuple[list[PortfolioSnapshot], DailyReturnSeries]:
     """Compute a daily-linked time-weighted return series from a portfolio's
     transaction history.
 
@@ -142,21 +144,21 @@ def calculate_twr(
       no prior snapshot to compare against.
     """
     # Step 1: form the map from date to portfolio snapshot for each day
-    snapshots = _PortfolioSnapshotSeriesGenerator(transactions).generate()
+    snapshots = _PortfolioSnapshotSeriesGenerator(transactions, reporting_currency).generate()
     dates = list(snapshots)
 
     # Step 2: chain daily returns, each day's cashflow-adjusted change over the previous day
-    daily_returns: list[DailyReturn] = []
+    daily_returns: dict[date,float] = dict()
     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()
+        cash_flow = current_snapshot.total_external_cash_flow_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))
+        daily_returns[current_date] = daily_return
 
-    return [snapshots[d] for d in dates], daily_returns
+    return [snapshots[d] for d in dates], DailyReturnSeries(daily_returns)
 

{investment_python-0.1.0b2 → investment_python-0.1.0b4}/src/investment/portfolio/twr/portfolio.py

@@ -23,14 +23,23 @@ class Holdings:
 
 class PortfolioSnapshot(NamedTuple):
     date:date
-    cash_in_cent:int
+    # Running cash balance as of `date` - carried forward and adjusted from
+    # the previous snapshot, not reset per day.
+    cash_balance_in_cent:int
     holdings:Holdings
+    # External cash-flow transaction amounts (deposits, non-investment
+    # expenses) that occurred on the `date` only - NOT cumulative; reset to []
+    # for every snapshot, including carried-forward no-transaction days.
     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 self.cash_balance_in_cent + holdings_value
+    def total_external_cash_flow_in_cent(self) -> int:
         return sum(self.external_cash_flows)
 
+class PortfolioSnapshotSeries(NamedTuple):
+    currency:str
+    snapshots:list[PortfolioSnapshot]
+
 

investment_python-0.1.0b4/src/investment/returns/returns.py

@@ -0,0 +1,30 @@
+from datetime import date
+from typing import NamedTuple
+
+from investment.vo.value_objects import IndexSeries
+
+
+class DailyReturnSeries(NamedTuple):
+    value_by_date:dict[date,float]
+    def to_index_series(self, label:str, base:float=100) -> IndexSeries:
+        """Compound this series' daily returns into a rebased index series.
+
+        Starts from ``base`` (before the first date in ``value_by_date``)
+        and multiplies by ``(1 + daily_return)`` for each date in turn, so
+        the result is directly comparable to a price-based index series
+        (e.g. ``ChartData``'s benchmark/stock indices) rebased to the same
+        ``base``. ``label`` identifies this series (e.g. a portfolio name),
+        matching how ``ChartData.benchmark_index()``/``stock_index()`` label
+        theirs with a ticker.
+
+        ``value_by_date`` MUST already be ordered by date, ascending - this
+        is a precondition the caller is responsible for, not something this
+        method checks or sorts for you, since the running value is compounded
+        strictly in dict-iteration order.
+        """
+        value_by_date: dict[date, float] = {}
+        running_value = base
+        for return_date, daily_return in self.value_by_date.items():
+            running_value *= 1 + daily_return
+            value_by_date[return_date] = running_value
+        return IndexSeries(label=label, value_by_date=value_by_date)

{investment_python-0.1.0b2 → investment_python-0.1.0b4}/src/investment/vo/value_objects.py

@@ -7,8 +7,8 @@ class Price(NamedTuple):
     cent_value:int
     currency: str
     timestamp: datetime
-    def amount(self) -> float:
-        return self.cent_value / 100
+    def amount(self) -> Decimal:
+        return Decimal(self.cent_value) / 100
     def value_with_currency(self) -> str:
         return f"{self.amount()} {self.currency}"
     def date(self) -> date:
@@ -55,3 +55,11 @@ class PriceSeries(NamedTuple):
             currency=self.currency,
             timestamp=datetime.combine(search_date, datetime.min.time()),
         )
+
+class IndexSeries(NamedTuple):
+    label: str
+    value_by_date: dict[date, float]
+    def dates(self):
+        return self.value_by_date.keys()
+    def index_values(self):
+        return self.value_by_date.values()

investment_python-0.1.0b2/src/investment/benchmark/chart_data.py

@@ -1,56 +0,0 @@
-from typing import NamedTuple
-
-import pandas as pd
-
-from investment.marketquote.repository import fetch_historical_prices
-from investment.vo.value_objects import Period, PriceSeries
-
-
-class LabeledIndexSeries(NamedTuple):
-    symbol: str
-    index_series: pd.Series
-
-class ChartData(NamedTuple):
-    benchmark: tuple[str,PriceSeries]
-    stock: tuple[str,PriceSeries]
-    base:float=100
-
-
-    def _to_index(self, price_series:PriceSeries) -> pd.Series:
-        prices = pd.Series(price_series.cent_prices).sort_index()
-        return prices / prices.iloc[0] * self.base
-
-    def benchmark_index(self) -> LabeledIndexSeries:
-        """Return the benchmark's price series rebased to ``base`` at its first date."""
-        benchmark_id = self.benchmark[0]
-        price_series = self.benchmark[1]
-        return LabeledIndexSeries(benchmark_id, self._to_index(price_series))
-
-    def stock_index(self) -> LabeledIndexSeries:
-        """Return the stock's price series rebased to ``base`` at its first date."""
-        company_id = self.stock[0]
-        price_series = self.stock[1]
-        return LabeledIndexSeries(company_id, self._to_index(price_series))
-
-    def coefficient(self)->float:
-        """Return the stock's beta relative to the benchmark over the period.
-
-        Beta = Cov(stock returns, benchmark returns) / Var(benchmark returns),
-        computed from daily returns of the raw price series.
-        """
-        benchmark_prices = pd.Series(self.benchmark[1].cent_prices).sort_index()
-        stock_prices = pd.Series(self.stock[1].cent_prices).sort_index()
-        benchmark_returns = benchmark_prices.pct_change().dropna()
-        stock_returns = stock_prices.pct_change().dropna()
-        aligned = pd.concat(
-            [benchmark_returns, stock_returns], axis=1, join="inner", keys=["benchmark", "stock"]
-        )
-        covariance = aligned["stock"].cov(aligned["benchmark"])
-        variance = aligned["benchmark"].var()
-        return covariance / variance
-
-    @staticmethod
-    def generate(benchmark_id:str, company_id:str, period:Period) -> "ChartData":
-        benchmark_price_series = fetch_historical_prices(benchmark_id, period)
-        stock_price_series = fetch_historical_prices(company_id, period)
-        return ChartData((benchmark_id, benchmark_price_series), (company_id, stock_price_series))

investment_python-0.1.0b2/src/investment/portfolio/twr/_market_price_repository.py

@@ -1,46 +0,0 @@
-from datetime import date, datetime
-from typing import Final
-
-from investment.marketquote.repository import (
-    fetch_fx_rate_series_from_euro,
-    fetch_historical_prices,
-)
-from investment.util.util import EUR, convert_to_euro_cent
-from investment.vo.value_objects import FxRateSeries, Period, Price, PriceSeries
-
-_fx_rate_series_cache:dict[str,FxRateSeries] = dict()
-def _find_historical_euro_price_series(security_id:str, period:Period) -> PriceSeries:
-    price_series = fetch_historical_prices(security_id, period)
-    def fetch_price_in_euro(existing_price: Price) -> Price:
-        currency: Final = existing_price.currency
-        if currency == EUR:
-            return existing_price
-        else:
-            if currency not in _fx_rate_series_cache:
-                _fx_rate_series_cache[currency] = fetch_fx_rate_series_from_euro(currency, period)
-            fx_rate = _fx_rate_series_cache[currency].get(existing_price.date())
-            price_value_in_euro = convert_to_euro_cent(existing_price, fx_rate)
-            return Price(price_value_in_euro, EUR, existing_price.timestamp)
-    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)