zipfolio 0.1.0__py3-none-any.whl

zipfolio/__init__.py

@@ -0,0 +1,58 @@
+"""Zipfolio: what a strategy does with its portfolio, position by position.
+
+Part of the ZipLime ecosystem: the report ZipLime builds beside the QuantStats
+tearsheet for every backtest, starting where a returns tearsheet stops. QuantStats and
+its kind describe the return series; Zipfolio describes the book behind it --
+positions and exposure, instruments and sectors, factor exposures, risk by
+holding, how orders were executed and how far to believe those fills, trading
+costs and the cost model, round trips, capacity -- as one self-contained HTML
+page in the QuantStats Pro look.
+
+It computes with pyfolio-reloaded, skfolio and statsmodels, reads the
+Fama-French factors from Kenneth French's data library, and draws every chart
+and table itself. Its inputs are the frames a ziplime run produces, as plain
+pandas::
+
+    from zipfolio import build_tearsheet
+
+    build_tearsheet(
+        "report.html",
+        returns,                      # per-period strategy returns
+        benchmark,                    # benchmark returns, or None
+        position_records=positions,   # date, symbol, quantity, last_sale_price
+        cash=ending_cash,             # cash at the end of each period
+        transactions=fills,           # dt, symbol, quantity, price
+        market_data=daily_bars,       # symbol, day, price, volume (optional)
+        orders=orders,                # id, dt, symbol, commission (optional)
+        cost_settings={...},          # commission / slippage settings (optional)
+        fill_bars=fill_bars,          # OHLCV of each fill's bar, by fill id (optional)
+        decision_prices=decisions,    # close at each order's creation, by order id (optional)
+        factor_model="ff5_mom",       # or "ff5", "ff3", "ff3_mom", None
+        sector_mappings={"AAPL": "Information Technology"},  # optional
+    )
+
+pyfolio and skfolio are imported when a page is built, not on import: a host
+without skfolio loses that one section, not the report.
+"""
+
+__version__ = "0.1.0"
+
+from .inputs import daily_returns, market_data_frame, positions_in_dollars, transactions_frame  # noqa: E402
+from .page import DEFAULT_TITLE, REPOSITORY_URL  # noqa: E402
+from .sectors import GICS_SECTORS, UNCLASSIFIED, US_MICS, us_sector_mappings  # noqa: E402
+from .tearsheet import build_tearsheet  # noqa: E402
+
+__all__ = [
+    "DEFAULT_TITLE",
+    "GICS_SECTORS",
+    "REPOSITORY_URL",
+    "UNCLASSIFIED",
+    "US_MICS",
+    "__version__",
+    "build_tearsheet",
+    "daily_returns",
+    "market_data_frame",
+    "positions_in_dollars",
+    "transactions_frame",
+    "us_sector_mappings",
+]

zipfolio/factors.py

@@ -0,0 +1,104 @@
+"""Daily Fama-French factors, from Kenneth French's data library.
+
+The library publishes each factor set as a zipped CSV of percentages, updated
+monthly from CRSP. This is what ``pandas_datareader.famafrench`` reads, without
+the dependency: one request per file, cached for a week -- the files change
+once a month, and a backtest service builds many reports a day.
+"""
+
+from __future__ import annotations
+
+import io
+import os
+import re
+import time
+import urllib.request
+import zipfile
+from pathlib import Path
+
+import pandas as pd
+
+LIBRARY_URL = "https://mba.tuck.dartmouth.edu/pages/faculty/ken.french/ftp/{name}_CSV.zip"
+
+FIVE_FACTORS = "F-F_Research_Data_5_Factors_2x3_daily"
+THREE_FACTORS = "F-F_Research_Data_Factors_daily"
+MOMENTUM = "F-F_Momentum_Factor_daily"
+
+#: Model name -> (description, the library files it is made of).
+MODELS = {
+    "ff3": ("Fama-French 3 factors", (THREE_FACTORS,)),
+    "ff3_mom": ("Carhart 4 factors (Fama-French 3 + momentum)", (THREE_FACTORS, MOMENTUM)),
+    "ff5": ("Fama-French 5 factors", (FIVE_FACTORS,)),
+    "ff5_mom": ("Fama-French 5 factors + momentum", (FIVE_FACTORS, MOMENTUM)),
+}
+
+#: What each factor is long and short of, for the page's glossary.
+FACTOR_DESCRIPTIONS = {
+    "Mkt-RF": "the US stock market over the risk-free rate",
+    "SMB": "size: small companies minus big ones",
+    "HML": "value: high book-to-market (cheap) minus low (expensive)",
+    "RMW": "profitability: robust operating profitability minus weak",
+    "CMA": "investment: companies that invest conservatively minus aggressively",
+    "MOM": "momentum: the past year's winners minus its losers",
+}
+
+CACHE_MAX_AGE = 7 * 24 * 3600
+
+
+def fama_french_daily(model: str = "ff5_mom", cache_dir: str | Path | None = None,
+                      timeout: float = 8.0) -> pd.DataFrame:
+    """Daily factor returns as decimals, one row per day at midnight UTC, plus ``RF``.
+
+    Raises when a file can be neither downloaded nor found in the cache; a
+    stale cached copy is used when the download fails.
+    """
+    if model not in MODELS:
+        raise ValueError(f"unknown factor model {model!r}; one of {sorted(MODELS)}")
+    cache = Path(cache_dir or os.getenv("ZIPFOLIO_CACHE_DIR") or Path.home() / ".cache" / "zipfolio")
+    frames = [_parse(_fetch(name, cache, timeout)) for name in MODELS[model][1]]
+    factors = pd.concat(frames, axis="columns", join="inner")
+    return factors.loc[:, ~factors.columns.duplicated()] / 100.0
+
+
+def model_description(model: str) -> str:
+    return MODELS[model][0]
+
+
+def _fetch(name: str, cache: Path, timeout: float) -> bytes:
+    path = cache / f"{name}.zip"
+    if path.exists() and time.time() - path.stat().st_mtime < CACHE_MAX_AGE:
+        return path.read_bytes()
+    try:
+        with urllib.request.urlopen(LIBRARY_URL.format(name=name), timeout=timeout) as response:
+            payload = response.read()
+    except Exception:
+        if path.exists():
+            print(f"Warning: could not refresh {name}; using the cached copy from "
+                  f"{time.strftime('%Y-%m-%d', time.gmtime(path.stat().st_mtime))}.")
+            return path.read_bytes()
+        raise
+    try:
+        cache.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(payload)
+    except OSError as error:
+        print(f"Warning: could not cache {name}: {error}")
+    return payload
+
+
+def _parse(payload: bytes) -> pd.DataFrame:
+    """The daily table of one library file: a few lines of notes, a header, ``YYYYMMDD,...`` rows."""
+    with zipfile.ZipFile(io.BytesIO(payload)) as archive:
+        text = archive.read(archive.namelist()[0]).decode("latin-1")
+    lines = [line.strip() for line in text.splitlines()]
+    first = next(index for index, line in enumerate(lines) if re.match(r"^\d{8}\s*,", line))
+    header = next(lines[index] for index in range(first - 1, -1, -1) if lines[index].startswith(","))
+    columns = [column.strip() for column in header.split(",")[1:]]
+    rows = []
+    for line in lines[first:]:
+        if not re.match(r"^\d{8}\s*,", line):
+            break
+        cells = [cell.strip() for cell in line.split(",")]
+        rows.append([cells[0], *map(float, cells[1:len(columns) + 1])])
+    frame = pd.DataFrame(rows, columns=["date", *columns])
+    frame.index = pd.DatetimeIndex(pd.to_datetime(frame.pop("date"), format="%Y%m%d")).tz_localize("UTC")
+    return frame.rename(columns={"Mom": "MOM", "Mom   ": "MOM"})

zipfolio/inputs.py

@@ -0,0 +1,153 @@
+"""Shaping a backtest into the frames pyfolio and skfolio read.
+
+Each function takes the plain frames a backtester already has -- per-period returns,
+one row per open position per day, one row per fill, daily bars -- and returns the
+shape the analytics expect: one row per session at midnight UTC, positions in
+dollars with a ``cash`` column, fills indexed by time.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+
+def daily_returns(returns: pd.Series) -> pd.Series:
+    """Return ``returns`` as one compounded return per calendar day, indexed in UTC.
+
+    pyfolio annualises with 252 periods and aligns returns, positions and
+    transactions by normalised date, so it needs exactly one row per session.
+    ziplime emits one already, but at the session close rather than at
+    midnight, and an intraday emission would emit several -- compounding them
+    is the only way that keeps the curve the same.
+
+    UTC because the fills pyfolio lines up against these dates carry a zone, and
+    pyfolio compares them as they are.
+    """
+    returns = pd.to_numeric(returns, errors="coerce").dropna()
+    if returns.empty:
+        return returns.astype(float)
+
+    dates = utc_dates(returns.index)
+    daily = (1.0 + returns.to_numpy()).astype(float)
+    compounded = pd.Series(daily, index=dates).groupby(level=0).prod() - 1.0
+    return compounded.rename(returns.name)
+
+
+def positions_in_dollars(
+    position_records: pd.DataFrame,
+    cash: pd.Series,
+    dates: pd.DatetimeIndex,
+) -> pd.DataFrame | None:
+    """Build pyfolio's positions frame: one column per symbol in dollars, plus ``cash``.
+
+    ``position_records`` is one row per open position per day, with ``date``,
+    ``symbol``, ``quantity`` and ``last_sale_price`` -- what a ziplime run
+    yields when its positions are snapshotted bar by bar. A day with no open
+    position has no row, so it comes back as zeros rather than missing.
+
+    The value is quantity times price. For a futures contract that leaves out
+    the multiplier, which understates its exposure; the records carry no
+    multiplier to correct it with.
+    """
+    if cash is None or cash.empty or len(dates) == 0:
+        return None
+
+    cash = pd.to_numeric(cash, errors="coerce")
+    cash.index = utc_dates(cash.index)
+    cash = cash[~cash.index.duplicated(keep="last")].reindex(dates).ffill()
+
+    if position_records is None or position_records.empty:
+        holdings = pd.DataFrame(index=dates)
+    else:
+        records = position_records.dropna(subset=["symbol"]).copy()
+        records["date"] = utc_dates(records["date"])
+        records["value"] = (
+            pd.to_numeric(records["quantity"], errors="coerce")
+            * pd.to_numeric(records["last_sale_price"], errors="coerce")
+        )
+        holdings = records.pivot_table(
+            index="date", columns="symbol", values="value", aggfunc="sum",
+        )
+        holdings = holdings.reindex(dates).fillna(0.0)
+        holdings.columns = [str(column) for column in holdings.columns]
+        holdings.columns.name = None
+
+    holdings["cash"] = cash.fillna(0.0)
+    return holdings
+
+
+def transactions_frame(transactions: pd.DataFrame) -> pd.DataFrame | None:
+    """Build pyfolio's transactions frame from the flattened ziplime transactions.
+
+    pyfolio wants the fill time as the index and ``amount``, ``price`` and
+    ``symbol`` as columns; the rest of what ziplime records is dropped.
+    """
+    if transactions is None or transactions.empty:
+        return None
+
+    frame = pd.DataFrame({
+        "amount": pd.to_numeric(transactions["quantity"], errors="coerce"),
+        "price": pd.to_numeric(transactions["price"], errors="coerce"),
+        "symbol": transactions["symbol"].astype(str),
+    })
+    frame.index = pd.DatetimeIndex(pd.to_datetime(transactions["dt"], errors="coerce", utc=True))
+    frame = frame[frame.index.notna()].dropna(subset=["amount", "price"])
+    frame = frame[frame["amount"] != 0].sort_index()
+    return frame if not frame.empty else None
+
+
+def market_data_frame(
+    bars: pd.DataFrame | None,
+    symbols,
+    dates: pd.DatetimeIndex,
+) -> pd.DataFrame | None:
+    """Build pyfolio's ``market_data``: rows ``(date, "price" | "volume")``, a column per symbol.
+
+    ``bars`` is one row per instrument per session with ``symbol``, ``day``,
+    ``price`` and ``volume`` -- what ``backtesting`` reads out of the market
+    bundle the simulation ran on. Only the traded symbols are kept: the bundle
+    also holds the benchmark and, for a universe, hundreds of names the
+    strategy never bought.
+    """
+    if bars is None or bars.empty or not len(symbols):
+        return None
+    bars = bars[bars["symbol"].astype(str).isin(set(symbols))]
+    if bars.empty:
+        return None
+
+    bars = bars.assign(date=utc_dates(bars["day"]))
+    wide = bars.pivot_table(index="date", columns="symbol", values=["price", "volume"], aggfunc="last")
+    wide = wide.reindex(index=dates)
+    frame = wide.stack(level=0, future_stack=True)
+    frame.index.names = ["date", "field"]
+    frame.columns.name = None
+    return frame.reindex(columns=sorted(set(symbols)))
+
+
+def utc_dates(values) -> pd.DatetimeIndex:
+    """Normalise timestamps to midnight UTC of their own calendar date.
+
+    The date is taken in the timestamp's own zone first: a Moscow session
+    closing at 18:50 local is that day, and so is a New York one at 16:00.
+    """
+    index = pd.DatetimeIndex(pd.to_datetime(values, errors="coerce"))
+    if index.tz is not None:
+        index = index.tz_localize(None)
+    return index.normalize().tz_localize("UTC")
+
+
+def usable_benchmark(benchmark: pd.Series | None, dates: pd.DatetimeIndex) -> pd.Series | None:
+    """Return the benchmark aligned to ``dates``, or ``None`` when there is none.
+
+    A backtester often hands a run without a benchmark a series of zeros, so
+    its own metrics have a column to fill. pyfolio would divide by its zero
+    variance for beta and draw a flat line, so that series counts as no
+    benchmark here.
+    """
+    if benchmark is None:
+        return None
+    benchmark = daily_returns(benchmark)
+    if benchmark.empty or np.allclose(benchmark.to_numpy(), 0.0):
+        return None
+    return benchmark.reindex(dates).fillna(0.0)

zipfolio/page.py

@@ -0,0 +1,145 @@
+"""The page: sections of charts and tables in QuantStats Pro's layout."""
+
+from __future__ import annotations
+
+import html
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+import pandas as pd
+
+from . import __version__
+from .tables import Table, table_html
+
+#: Tables wider than this many columns go under the charts rather than beside them.
+SIDE_TABLE_MAX_COLUMNS = 3
+
+#: Where Zipfolio lives; every report links to it, in the header and the footer,
+#: next to the version that built it.
+REPOSITORY_URL = "https://github.com/Limex-com/zipfolio"
+
+#: The report's title unless the caller names it.
+DEFAULT_TITLE = "Zipfolio Tearsheet: Portfolio, Execution & Cost Analysis"
+
+
+@dataclass
+class Section:
+    """One block of the page: charts on the left, narrow tables on the right, wide ones under both."""
+
+    title: str
+    charts: list[str] = field(default_factory=list)
+    side: list[str] = field(default_factory=list)
+    wide: list[str] = field(default_factory=list)
+    failed: bool = False
+
+    @property
+    def empty(self) -> bool:
+        return not (self.charts or self.side or self.wide)
+
+    def chart(self, svg: str | None) -> None:
+        if svg:
+            self.charts.append(svg)
+
+    def table(self, table: "Table", **kwargs) -> None:
+        rendered = table_html(table, **kwargs)
+        wide = len(table.frame.columns) > SIDE_TABLE_MAX_COLUMNS
+        (self.wide if wide else self.side).append(rendered)
+
+
+def _section_html(section: Section) -> str:
+    parts = [f'<section><h2>{html.escape(section.title)}</h2>']
+    if section.failed:
+        parts.append('<p class="note">This section could not be computed for this backtest.</p>')
+    else:
+        charts = "\n".join(f'<div class="chart">{svg}</div>' for svg in section.charts)
+        side = "\n".join(section.side)
+        parts.append(f'<div class="row"><div class="left">{charts}</div><div class="right">{side}</div></div>')
+        if section.wide:
+            parts.append(f'<div class="wide">{"".join(section.wide)}</div>')
+    parts.append("</section>")
+    return "\n".join(parts)
+
+
+def page_html(title: str, returns: pd.Series, benchmark, analytics: str, sections: list[Section]) -> str:
+    """The whole page. ``analytics`` names the libraries the numbers came from, with versions."""
+    period = f"{returns.index[0]:%-d %b, %Y} - {returns.index[-1]:%-d %b, %Y}"
+    generated = f"{datetime.now(timezone.utc):%-d %b, %Y %H:%M} UTC"
+    benchmark_name = html.escape(str(benchmark.name)) if benchmark is not None and benchmark.name else (
+        "Benchmark" if benchmark is not None else "none")
+    body = "\n<hr>\n".join(_section_html(section) for section in sections)
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="generator" content="Zipfolio">
+<meta name="robots" content="noindex, nofollow">
+<title>{html.escape(title)}</title>
+<style>
+  body {{ -webkit-font-smoothing: antialiased; -moz-osx-font-smoothing: grayscale;
+         margin: 30px; background: #fff; color: #000; }}
+  body, p, table, td, th {{ font: 13px/1.4 Arial, sans-serif; }}
+  .container {{ max-width: 960px; margin: auto; }}
+  h1, h2, h3, h4 {{ font-weight: 400; margin: 0; }}
+  h1 {{ font-size: 26px; }}
+  h1 dt {{ display: inline; margin-left: 10px; font-size: 14px; }}
+  h2 {{ font-size: 18px; font-weight: 700; margin-bottom: 18px; }}
+  h3 {{ margin-bottom: 10px; font-weight: 700; }}
+  h4 {{ color: grey; margin-top: 4px; }}
+  h4 strong {{ color: #333; }}
+  h4 a, h4 a strong, footer a {{ color: #09c; text-decoration: none; white-space: nowrap; }}
+  h4 a:hover, footer a:hover {{ color: #069; text-decoration: underline; }}
+  hr {{ margin: 25px 0 40px; height: 0; border: 0; border-top: 1px solid #ccc; }}
+  .row {{ display: flex; gap: 20px; align-items: flex-start; }}
+  .left {{ flex: 0 0 620px; min-width: 0; }}
+  .right {{ flex: 1 1 320px; min-width: 0; }}
+  .chart {{ margin: 0 0 22px; }}
+  .chart svg {{ display: block; width: 100%; height: auto; }}
+  table {{ margin: 0 0 30px; border: 0; border-spacing: 0; width: 100%; }}
+  table td, table th {{ text-align: right; padding: 4px 5px 3px 5px; }}
+  table th {{ padding: 6px 5px 5px 5px; }}
+  table td:first-of-type, table th:first-of-type {{ text-align: left; padding-left: 2px; }}
+  table td:last-of-type, table th:last-of-type {{ padding-right: 2px; }}
+  table thead th {{ font-weight: 700; background: #2d2d2d; color: #fff; }}
+  tr.sep td {{ padding: 0; }}
+  tr.sep hr {{ margin: 5px 0; }}
+  .table, .wide {{ overflow-x: auto; }}
+  .empty {{ color: grey; font-style: italic; margin: -4px 0 26px; }}
+  .caption {{ color: grey; margin: -14px 0 26px; }}
+  .explain {{ margin: 0 0 10px; }}
+  .explain:last-of-type {{ margin-bottom: 26px; }}
+  code {{ font: 12px Menlo, Consolas, monospace; background: #f3f3f3; padding: 0 3px; }}
+  .check {{ display: flex; gap: 10px; margin: 0 0 12px; align-items: flex-start; }}
+  .check:last-child {{ margin-bottom: 26px; }}
+  .mark {{ flex: 0 0 20px; height: 20px; border-radius: 50%; color: #fff; font-weight: 700;
+          font-size: 12px; line-height: 20px; text-align: center; }}
+  .mark.ok {{ background: #6B9E00; }}
+  .mark.warn {{ background: #D9A400; }}
+  .mark.bad {{ background: #BA516B; }}
+  .mark.info {{ background: #8A8A8A; font-style: italic; font-family: Georgia, serif; }}
+  .note {{ color: #9a6700; }}
+  footer {{ color: grey; font-size: 12px; margin-top: 10px; }}
+  @media (max-width: 1000px) {{
+    body {{ margin: 16px; }}
+    .row {{ flex-direction: column; }}
+    .left, .right {{ flex: 1 1 auto; width: 100%; }}
+  }}
+  @media print {{
+    body {{ margin: 0; }}
+    .container {{ max-width: 100%; }}
+    section {{ break-inside: avoid-page; }}
+  }}
+</style>
+</head>
+<body>
+<div class="container">
+<h1>{html.escape(title)} <dt>{period}</dt></h1>
+<h4>Benchmark: {benchmark_name} &bull; Sessions: {len(returns):,} &bull; Generated by <a href="{REPOSITORY_URL}" target="_blank" rel="noopener" title="{REPOSITORY_URL}"><strong>ZipLime Zipfolio v{__version__}</strong></a> on {generated}</h4>
+<hr>
+{body}
+<hr>
+<footer>Built with <a href="{REPOSITORY_URL}" target="_blank" rel="noopener">Zipfolio v{__version__}</a>, part of the ZipLime ecosystem &middot; generated on {generated} &middot; {analytics} &middot; <a href="{REPOSITORY_URL}" target="_blank" rel="noopener">github.com/Limex-com/zipfolio</a></footer>
+</div>
+</body>
+</html>
+"""

zipfolio/sections/__init__.py

@@ -0,0 +1 @@
+"""One module per section of the tearsheet; each exposes ``build_<section>``."""

zipfolio/sections/capacity.py

@@ -0,0 +1,70 @@
+"""How much capital the strategy could take before liquidity binds."""
+
+from __future__ import annotations
+
+import pandas as pd
+
+from ..page import Section
+from ..style import chart
+from ..tables import Table
+
+
+def build_capacity(returns, positions, transactions, market_data) -> Section:
+    """Days to liquidate, low-liquidity fills and the capital-base sweep.
+
+    The same analysis as ``create_capacity_tear_sheet``, with its daily-volume
+    join repaired: ``capacity.daily_txns_with_bar_data`` ends in
+    ``.set_index("date").asfreq("D")``, and the index it sets holds one row per
+    symbol per day -- so any strategy that trades two names on the same day
+    fails with "cannot reindex on an axis with duplicate labels". The ``asfreq``
+    only inserts empty days, which none of its callers need: the liquidity
+    tables group by symbol and the slippage sweep resamples by day. The repaired
+    copy is in place for this one call.
+    """
+    from pyfolio import capacity, plotting
+
+    section = Section("Capacity")
+    original = capacity.daily_txns_with_bar_data
+    capacity.daily_txns_with_bar_data = _daily_txns_with_bar_data
+    try:
+        last_n_days = 126
+        section.side.append(
+            '<p class="explain">At a constant $1m capital base, taking at most 20% of '
+            'a day\'s volume, with the trailing 5-day mean as that volume.</p>')
+        for label, window in (("Whole Backtest", None), (f"Last {last_n_days} Sessions", last_n_days)):
+            days = capacity.get_max_days_to_liquidate_by_ticker(
+                positions, market_data, max_bar_consumption=0.2, capital_base=1e6,
+                mean_volume_window=5, last_n_days=window)
+            section.table(
+                Table(days[days["days_to_liquidate"] > 1], None, None,
+                      {"days_to_liquidate": "{:.1f}".format, "pos_alloc_pct": "{:.2f}%".format}),
+                title=f"Over a Day to Liquidate: {label}", first_header="Symbol",
+                rename={"date": "Date", "days_to_liquidate": "Days", "pos_alloc_pct": "Allocation"})
+        for label, window in (("Whole Backtest", None), (f"Last {last_n_days} Sessions", last_n_days)):
+            fills = capacity.get_low_liquidity_transactions(transactions, market_data, last_n_days=window)
+            section.table(
+                Table(fills[fills["max_pct_bar_consumed"] > 5], None, None,
+                      {"max_pct_bar_consumed": "{:.2f}%".format}),
+                title=f"Fills Over 5% of Daily Volume: {label}", first_header="Symbol",
+                rename={"date": "Date", "max_pct_bar_consumed": "Of Volume"})
+
+        starting_capital = positions.iloc[0].sum() / (1 + returns.iloc[0])
+        section.chart(chart("Capital Base Performance Sweep", lambda ax: plotting.plot_capacity_sweep(
+            returns, transactions, market_data, starting_capital,
+            min_pv=100000, max_pv=300000000, step_size=1000000, ax=ax), height=3.5))
+    finally:
+        capacity.daily_txns_with_bar_data = original
+    return section
+
+
+def _daily_txns_with_bar_data(transactions, market_data):
+    """``pyfolio.capacity.daily_txns_with_bar_data`` without the ``asfreq`` -- see ``build_capacity``."""
+    transactions.index.name = "date"
+    txn_daily = pd.DataFrame(
+        transactions.assign(amount=abs(transactions.amount))
+        .groupby(["symbol", pd.Grouper(freq="D")])
+        .sum()["amount"]
+    )
+    txn_daily["price"] = market_data.xs("price", level=1).unstack()
+    txn_daily["volume"] = market_data.xs("volume", level=1).unstack()
+    return txn_daily.reset_index().set_index("date").sort_index()