investment-python 0.1.0b1__py3-none-any.whl

investment/benchmark/chart_data.py

@@ -0,0 +1,56 @@
+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/cli/__main__.py

@@ -0,0 +1,7 @@
+"""Enables ``python -m investment.cli`` as an alternative to the
+``investment-python`` console script.
+"""
+from investment.cli.main import main
+
+if __name__ == "__main__":
+    main()

investment/cli/main.py

@@ -0,0 +1,161 @@
+"""Command-line entry point for the investment toolkit.
+
+Usage examples::
+
+    investment-python price AAPL
+    investment-python price AAPL --date 2026-08-01
+    investment-python metrics PRICE,TRAILING_PE --company-symbols AAPL
+"""
+import argparse
+import logging
+import os
+import sys
+from enum import StrEnum
+from typing import Sequence
+
+from investment.cli.program_runner import _generate_benchmark_chart, _run_benchmark, _run_metrics
+from investment.marketquote import repository
+
+
+class Command(StrEnum):
+    METRICS = "metrics"
+    BENCHMARK = "benchmark"
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="investment", description="Fetch market quotes and fundamentals."
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    def _build_metrics_parser() -> None:
+        metrics_parser = subparsers.add_parser(
+            Command.METRICS, help="Fetch metrics for symbols."
+        )
+        metrics_parser.add_argument(
+            "metric_names",
+            help="One or more metrics to fetch, delimited by comma, e.g. PRICE,TRAILING_PE. "
+            f"Choose from {', '.join(metric.name for metric in repository.Metric)}.",
+        )
+        company_source_group = metrics_parser.add_mutually_exclusive_group(required=True)
+        company_source_group.add_argument(
+            "--company-symbols",
+            help="Company ticker symbols delimited by comma, e.g. AAPL,ELISA.HE",
+        )
+        company_source_group.add_argument(
+            "--company-csv",
+            help="Path or URL to a company CSV file with a 'Yahoo Company Symbol' column, "
+            "e.g. https://gist.githubusercontent.com/rxue/7ec0914a8af1525d97e8dfd2ac5d61d7/raw/companies.csv",
+        )
+        metrics_parser.add_argument(
+            "--sort-by",
+            default=None,
+            help="Sort results by this metric, ascending. Must be one of the metrics in --names.",
+        )
+        metrics_parser.add_argument(
+            "--price-ranges",
+            default=None,
+            help="If given on the premises of price is also given, it should be in the format "
+            "like COMPANY_ID1:12:22,COMPANY_ID2:100:",
+        )
+        metrics_parser.add_argument(
+            "--output-csv-name",
+            default=None,
+            help="If given, also write the metrics result to this CSV file path.",
+        )
+    def _build_benchmark_parser() -> None:
+        benchmark_parser = subparsers.add_parser(
+            Command.BENCHMARK, help="Benchmark stocks against an index or another stock."
+        )
+        benchmark_parser.add_argument(
+            "benchmark_pair",
+            help="The benchmark and company ticker symbols, delimited by a colon, "
+            "e.g. VOO:T.",
+        )
+        benchmark_parser.add_argument(
+            "--start-date",
+            required=True,
+            help="Start date of the period, in ISO format, e.g. 2024-01-01.",
+        )
+        benchmark_parser.add_argument(
+            "--end-date",
+            required=True,
+            help="End date of the period, in ISO format, e.g. 2026-01-01.",
+        )
+        benchmark_parser.add_argument(
+            "--graph-directory",
+            default=None,
+            help="If given, save the chart as a PNG into this directory. "
+            "If omitted, the chart is not saved.",
+        )
+    _build_metrics_parser()
+    _build_benchmark_parser()
+    return parser
+
+
+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.command == Command.METRICS:
+        metrics, erratic_company_ids, metrics_records_out_of_range = _run_metrics(
+            names=args.metric_names,
+            company_symbols=args.company_symbols,
+            company_csv=args.company_csv,
+            sort_by=args.sort_by,
+            price_ranges_str=args.price_ranges,
+        )
+        print(metrics.to_string(index=False))
+        if not erratic_company_ids.empty:
+            print()
+            print("Companies fetched with error")
+            print(erratic_company_ids.to_string(index=False))
+        if metrics_records_out_of_range is not None:
+            print()
+            print("Stocks with price out of range")
+            print(metrics_records_out_of_range.to_string(index=False))
+
+        if args.output_csv_name:
+            metrics.to_csv(args.output_csv_name, index=False)
+            if not erratic_company_ids.empty:
+                erratic_company_ids.to_csv("companies_with_error.csv", index=False)
+            if not metrics_records_out_of_range.empty:
+                metrics_records_out_of_range.to_csv("alert_on_companies.csv", index=False)
+    elif args.command == Command.BENCHMARK:
+        try:
+            benchmark_id, company_id = args.benchmark_pair.split(":")
+        except ValueError:
+            parser.error(
+                f"argument benchmark_pair: invalid format: {args.benchmark_pair!r} "
+                "(expected BENCHMARK_ID:COMPANY_ID, e.g. VOO:T)"
+            )
+        chart_data = _run_benchmark(
+            benchmark_id=benchmark_id,
+            company_id=company_id,
+            start_date=args.start_date,
+            end_date=args.end_date,
+        )
+        benchmark_index = chart_data.benchmark_index()
+        stock_index = chart_data.stock_index()
+        print(
+            f"Coefficient ({stock_index.symbol} vs {benchmark_index.symbol}): "
+            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"
+            )
+        chart_path = _generate_benchmark_chart(chart_data, output_path=output_path)
+        if chart_path is not None:
+            print(f"Chart saved to {chart_path}")
+
+    else:  # pragma: no cover - guarded by argparse's `required=True`
+        parser.error(f"Unknown command: {args.command}")
+
+
+if __name__ == "__main__":
+    main()

investment/cli/program_runner.py

@@ -0,0 +1,153 @@
+"""Orchestration for the CLI ``metrics`` command."""
+
+import logging
+import time
+from datetime import date
+
+import matplotlib.pyplot as plt
+import pandas as pd
+
+from investment.benchmark.chart_data import ChartData
+from investment.marketquote import metrics, repository
+from investment.marketquote.filter import Range, records_out_of_range
+from investment.util.decorator import clock
+from investment.vo.value_objects import Period
+
+logger = logging.getLogger(__name__)
+
+
+@clock
+def _run_metrics(
+    names: str,
+    company_symbols: str | None = None,
+    company_csv: str | None = None,
+    sort_by: str | None = None,
+    price_ranges_str: str | None = None,
+) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    def extract_price_ranges() -> dict[str, Range]:
+        if not price_ranges_str:
+            return {}
+        result: dict[str, Range] = {}
+        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,
+            )
+        return result
+
+    def _load_company_symbols(csv_source: str) -> str:
+        """Load comma-delimited Yahoo ticker symbols from a company CSV file.
+
+        ``csv_source`` may be a local file path or an http(s) URL. The CSV must
+        contain a "Yahoo Company Symbol" column, e.g.
+        https://gist.githubusercontent.com/rxue/7ec0914a8af1525d97e8dfd2ac5d61d7/raw/companies.csv
+        """
+        companies = pd.read_csv(csv_source)
+        return ",".join(companies["Yahoo Company Symbol"].astype(str))
+
+    metric_names = [name.strip() for name in names.split(",")]
+    try:
+        metric_list = [repository.Metric[name] for name in metric_names]
+    except KeyError as exc:
+        valid_names = ", ".join(metric.name for metric in repository.Metric)
+        raise SystemExit(
+            f"investment metrics: error: argument --names: invalid choice: {exc.args[0]!r} "
+            f"(choose from {valid_names})"
+        ) from None
+
+    sort_by_metric = None
+    if sort_by is not None:
+        try:
+            sort_by_metric = repository.Metric[sort_by]
+        except KeyError:
+            valid_names = ", ".join(metric.name for metric in repository.Metric)
+            raise SystemExit(
+                f"investment metrics: error: argument --sort-by: invalid choice: {sort_by!r} "
+                f"(choose from {valid_names})"
+            ) from None
+        if sort_by_metric not in metric_list:
+            raise SystemExit(
+                f"investment metrics: error: argument --sort-by: {sort_by!r} must be one of the "
+                f"metrics in --names ({', '.join(metric_names)})"
+            )
+
+    if company_symbols:
+        company_ids = company_symbols
+    elif company_csv is not None:
+        company_ids = _load_company_symbols(company_csv)
+    else:
+        raise SystemExit(
+            "investment metrics: error: one of --company-symbols or --company-csv is required"
+        )
+    company_id_list = [symbol.strip() for symbol in company_ids.split(",")]
+    batch_size = 100
+    thread_amount = 10
+    if len(company_id_list) > batch_size:
+        rows = []
+        erratic_rows = []
+        for i in range(0, len(company_id_list), batch_size):
+            batch = company_id_list[i : i + batch_size]
+            metrics_records, erratic_metrics_records = repository.fetch_current_metrics_batch(
+                batch, metric_list, thread_amount
+            )
+            rows.extend(metrics_records)
+            erratic_metrics_records.extend(erratic_metrics_records)
+            logger.info("Executed one batch")
+            time.sleep(60)
+    else:
+        rows, erratic_rows = repository.fetch_current_metrics_batch(
+            company_id_list, metric_list, thread_amount
+        )
+
+    if sort_by_metric is not None:
+        rows = metrics.sort_records(rows, sort_by_metric)
+    records_out_of_range_df = pd.DataFrame()
+    if price_ranges_str is not None:
+        price_ranges = extract_price_ranges()
+        records_outside = records_out_of_range(rows, price_ranges)
+        records_out_of_range_df = pd.DataFrame([r.to_readable() for r in records_outside])
+    return (
+        pd.DataFrame([r.to_readable() for r in rows]),
+        pd.DataFrame([r.company_id for r in erratic_rows], columns=["non-existing company"]),
+        records_out_of_range_df,
+    )
+
+def _run_benchmark(benchmark_id:str,company_id:str,start_date:str,end_date:str) -> ChartData:
+    period = Period(from_date=date.fromisoformat(start_date), to_date=date.fromisoformat(end_date))
+    return ChartData.generate(benchmark_id, company_id, period)
+
+def _generate_benchmark_chart(
+    chart_data:ChartData, output_path:str|None=None, show:bool=True
+) -> str|None:
+    """Plot the benchmark's and stock's rebased index series.
+
+    Displays the chart in a window by default (``show=True``). Saved to
+    ``output_path`` only if given; returns that path, or ``None`` if not saved.
+    """
+    benchmark_index = chart_data.benchmark_index()
+    stock_index = chart_data.stock_index()
+
+    fig, ax = plt.subplots()
+    ax.plot(
+        benchmark_index.index_series.index.to_numpy(), benchmark_index.index_series.to_numpy(),
+        label=benchmark_index.symbol,
+    )
+    ax.plot(
+        stock_index.index_series.index.to_numpy(), stock_index.index_series.to_numpy(),
+        label=stock_index.symbol,
+    )
+    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}"
+    )
+    ax.set_ylabel("Index value")
+    ax.legend()
+    fig.autofmt_xdate()
+
+    if output_path is not None:
+        fig.savefig(output_path, dpi=150)
+    if show:
+        plt.show()
+    plt.close(fig)
+    return output_path

investment/marketquote/_fx_rate_fetcher.py

@@ -0,0 +1,53 @@
+import csv
+import io
+import logging
+from datetime import date
+from functools import cache
+
+import requests
+
+from investment.util.constants import EUR
+
+logger = logging.getLogger(__name__)
+
+@cache
+def fetch_fx_rate_to_euro(base_currency: str, target_date: date) -> tuple[date, float]:
+    """Fetch the ``base_currency``-to-EUR exchange rate for ``date`` from the ECB
+    (European Central Bank).
+
+    Returns ``1.0`` for ``date`` unchanged when ``base_currency`` is already ``'EUR'``.
+    For a past ``date``, requests that day's rate from the ECB data API. For today
+    or a future ``date``, requests the latest available observation instead, since
+    the ECB has no rate published yet for those.
+
+    Because the ECB only publishes rates for business days, the returned date may
+    differ from the requested ``date`` (e.g. a weekend or holiday falls back to the
+    most recent prior business day).
+
+    :param base_currency: ISO 4217 currency code to convert from (e.g. ``'USD'``).
+    :param target_date: the date to fetch the rate for.
+    :return: a tuple of the actual observation date and the exchange rate.
+    :raises requests.HTTPError: if the ECB API request fails.
+    :raises StopIteration: if the API response contains no observations.
+    """
+    if base_currency == EUR:
+        return target_date, 1
+    url = f"https://data-api.ecb.europa.eu/service/data/EXR/D.{base_currency}.EUR.SP00.A"
+    today = date.today()
+    if target_date < today:
+        date_str = target_date.strftime("%Y-%m-%d")
+        response = requests.get(url, params={
+            "startPeriod": date_str,
+            "endPeriod": date_str,
+            "format": "csvdata",
+        })
+    else:
+        logger.info(f"Fetch FX rate for {target_date}")
+        response = requests.get(url, params={
+            "lastNObservations": 1,
+            "format": "csvdata",
+        })
+    response.raise_for_status()
+    reader = csv.DictReader(io.StringIO(response.text))
+    row = next(reader)
+    return target_date.fromisoformat(row["TIME_PERIOD"]), float(row["OBS_VALUE"])

investment/marketquote/filter.py

@@ -0,0 +1,34 @@
+import math
+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 = self.start if self.start else 0
+        end = self.end if self.end else math.inf
+        return start <= value <= end
+
+def records_out_of_range(
+    all_metric_records: list[MetricsRecord], ranges: dict[str, Range]
+) -> list[MetricsRecord]:
+    """Return the records whose ``Metric.PRICE`` falls outside its configured range.
+
+    A record is skipped (not returned) when its company has no configured
+    range, no ``Metric.PRICE`` value, or that value is an error rather than a
+    ``Price``.
+    """
+    result = []
+    for record in all_metric_records:
+        price_range = ranges.get(record.company_id)
+        if price_range is None:
+            continue
+        price = record.metrics.get(Metric.PRICE)
+        if price is None or isinstance(price, Exception):
+            continue
+        if not price_range.has(price.amount()):
+            result.append(record)
+    return result

investment/marketquote/metrics.py

@@ -0,0 +1,74 @@
+import logging
+import math
+from collections.abc import Mapping
+from enum import Enum
+from typing import Any, NamedTuple
+
+logger = logging.getLogger(__name__)
+
+class Metric(Enum):
+    COMPANY_NAME = ("shortName", "Company Name")
+    PRICE = (None, "Price")
+    PRICE_IN_EURO = (None, "Price in EURO")
+    MARKET_STATE = ("marketState", "Market State")
+    TRAILING_PE = ("trailingPE", "Trailing P/E")
+    DIVIDEND_YIELD = ("dividendYield", "Dividend Yield %")
+    DIVIDEND_PAYOUT_RATIO = ("payoutRatio", "Dividend Payout Ratio %")
+    RETURN_ON_EQUITY = ("returnOnEquity", "Return on Equity %")
+    REGULAR_MARKET_CHANGE_PERCENT = ("regularMarketChangePercent", "Regular Market Change %")
+    PRICE_TO_BOOK = ("priceToBook", "Price to Book")
+
+    def __init__(self, yahoo_metric_name: str | None, label: str) -> None:
+        self.yahoo_metric_name = yahoo_metric_name
+        self.label = label
+
+
+class MetricsRecord(NamedTuple):
+    company_id: str
+    metrics: Mapping[Metric, Any]
+    def has_errors(self) -> bool:
+        return any(isinstance(value, Exception) for value in self.metrics.values())
+    def to_readable(self) -> dict[str,Any]:
+        if self.has_errors():
+            errors = {
+                metric.label: str(value)
+                for metric, value in self.metrics.items()
+                if isinstance(value, Exception)
+            }
+            raise ValueError(
+                f"Cannot make metrics for {self.company_id} readable due to error(s): {errors}"
+            )
+        result:dict[str,Any] = {"company":self.company_id}
+        logger.info(f"Company: {self.company_id}")
+        for metric,value in self.metrics.items():
+            if metric == Metric.PRICE:
+                result[metric.label] = value.value_with_currency()
+            elif metric == Metric.PRICE_IN_EURO:
+                result[metric.label] = value.amount()
+            elif metric.label.endswith("%") and value is not None:
+                logger.info(f"Metric, {metric}, with percent or fraction value: {value}")
+                result[metric.label] = value.percent_value()
+            elif metric == Metric.TRAILING_PE:
+                if value is not None:
+                    result[metric.label] = int(value*10)/10
+            elif metric == Metric.PRICE_TO_BOOK:
+                if value is not None:
+                    result[metric.label] = int(value*100)/100
+            else:
+                result[metric.label] = value
+        return result
+
+def sort_records(records: list[MetricsRecord], sort_by: Metric) -> list[MetricsRecord]:
+    """Sort ``records`` by their ``sort_by`` metric value, ascending.
+
+    Records missing ``sort_by`` (absent key, ``None``, or ``NaN``) sort last,
+    regardless of the metric's type.
+    """
+    def sort_key(record: MetricsRecord) -> tuple[bool, Any]:
+        value = record.metrics.get(sort_by)
+        if sort_by in (Metric.PRICE, Metric.PRICE_IN_EURO) and value is not None:
+            value = value.amount()
+        is_missing = value is None or (isinstance(value, float) and math.isnan(value))
+        return (is_missing, 0.0 if is_missing else value)
+
+    return sorted(records, key=sort_key)

investment/marketquote/repository.py

@@ -0,0 +1,124 @@
+from collections.abc import Collection
+from concurrent.futures import ThreadPoolExecutor
+from datetime import date, datetime, timezone
+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._fx_rate_fetcher import fetch_fx_rate_to_euro
+from investment.marketquote.metrics import Metric, MetricsRecord
+from investment.util.constants import EUR
+from investment.vo.value_objects import Percentage, Period, Price, PriceSeries
+
+
+def fetch_price(symbol: str, target_date: date | None = None) -> Price:
+    """Fetch the price for ``symbol``.
+
+    Returns the current quoted price when ``target_date`` is ``None``,
+    otherwise the closing price on or before ``target_date``.
+    """
+    if target_date is None:
+        price, currency, epoch_seconds = yahoo_finance_fetcher.fetch_current_price(symbol)
+        cent_value = int((Decimal(str(price)) * 100).to_integral_value(rounding=ROUND_HALF_UP))
+        return Price(
+            cent_value=cent_value,
+            currency=currency,
+            timestamp=datetime.fromtimestamp(epoch_seconds, tz=timezone.utc),
+        )
+    last_close, currency, timestamp = yahoo_finance_fetcher.fetcher_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,
+        currency=currency,
+        timestamp=timestamp,
+    )
+
+def fetch_price_in_euro(existing_price: Price) -> Price:
+    currency:Final = existing_price.currency_value()
+    if currency == EUR:
+        return existing_price
+    else:
+        _, fx_rate = fetch_fx_rate_to_euro(currency, existing_price.date())
+        price_value = round(existing_price.cent_value / fx_rate)
+        return Price(price_value, EUR, existing_price.timestamp)
+
+def fetch_current_metrics(
+        company_id: str, metrics: Collection[Metric]
+) -> MetricsRecord:
+    def fetch_fundamental_metrics() -> dict[Metric,Any]:
+        fundamental_metrics_by_yahoo_name = {
+            metric.yahoo_metric_name: metric
+            for metric in metrics
+            if metric not in [Metric.PRICE, Metric.PRICE_IN_EURO]
+            and metric.yahoo_metric_name is not None
+        }
+        fundamental_metrics_values = yahoo_finance_fetcher.fetch_fundamental_metrics(
+            company_id, fundamental_metrics_by_yahoo_name.keys()
+        )
+        fundamenal_metrics: dict[Metric, Any] = {
+            fundamental_metrics_by_yahoo_name[yahoo_metric_name]: value
+            for yahoo_metric_name, value in fundamental_metrics_values.items()
+        }
+        for metric in metrics:
+            if metric in (Metric.RETURN_ON_EQUITY, Metric.DIVIDEND_PAYOUT_RATIO):
+                fraction_value = fundamenal_metrics[metric]
+                if fraction_value is not None:
+                    fundamenal_metrics[metric] = Percentage(fraction_value)
+            elif metric.label.endswith("%"):
+                percent_value = fundamenal_metrics[metric]
+                if percent_value is not None:
+                    fundamenal_metrics[metric] = Percentage(percent_value / 100)
+        return fundamenal_metrics
+    combined_metrics: dict[Metric,Any] = fetch_fundamental_metrics()
+    if Metric.PRICE in metrics:
+        try:
+            combined_metrics[Metric.PRICE] = fetch_price(company_id)
+        except Exception as e:
+            combined_metrics[Metric.PRICE] = e
+    if Metric.PRICE_IN_EURO in metrics:
+        existing_price = combined_metrics.get(Metric.PRICE)
+        if not isinstance(existing_price, Price):
+            existing_price = None
+        try:
+            price = existing_price if existing_price is not None else fetch_price(company_id)
+            combined_metrics[Metric.PRICE_IN_EURO] = fetch_price_in_euro(price)
+        except Exception as e:
+            combined_metrics[Metric.PRICE_IN_EURO] = e
+    return MetricsRecord(company_id=company_id, metrics=MappingProxyType(combined_metrics))
+
+def fetch_current_metrics_batch(
+        company_ids: Collection[str], metrics: Collection[Metric], thread_amount: int | None
+) -> tuple[list[MetricsRecord], list[MetricsRecord]]:
+    """Fetch metrics for ``company_ids``, split into records without errors and
+    records with errors.
+
+    Returns a ``(records_without_errors, records_with_errors)`` tuple.
+    """
+    if thread_amount is not None:
+        company_ids = list(company_ids)
+        if not company_ids:
+            return [], []
+        with ThreadPoolExecutor(max_workers=min(len(company_ids), thread_amount)) as executor:
+            records = list(
+                executor.map(
+                    lambda company_id: fetch_current_metrics(company_id, metrics), company_ids
+                )
+            )
+    else:
+        records = [fetch_current_metrics(company_id, metrics) for company_id in company_ids]
+
+    records_without_errors = [record for record in records if not record.has_errors()]
+    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:
+    """Fetch the daily closing price series for ``company_id`` over ``period``."""
+    prices, currency = yahoo_finance_fetcher.fetch_price_history(
+        company_id, period.from_date, period.to_date
+    )
+    cent_prices = {
+        trading_date: int((Decimal(str(price)) * 100).to_integral_value(rounding=ROUND_HALF_UP))
+        for trading_date, price in prices.items()
+    }
+    return PriceSeries(currency=currency, cent_prices=cent_prices)