tradeguard-oss 0.7.0__tar.gz

tradeguard_oss-0.7.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hesam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tradeguard_oss-0.7.0/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: tradeguard-oss
+Version: 0.7.0
+Summary: Open-source trade journal validation, risk analytics, and data-quality toolkit for traders and trading systems.
+Author: TradeGuard OSS contributors
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Dynamic: license-file
+
+# TradeGuard OSS
+
+[![CI](https://github.com/hesam1111111111/tradeguard-oss/actions/workflows/ci.yml/badge.svg)](https://github.com/hesam1111111111/tradeguard-oss/actions/workflows/ci.yml)
+[![Latest release](https://img.shields.io/github/v/release/hesam1111111111/tradeguard-oss)](https://github.com/hesam1111111111/tradeguard-oss/releases/latest)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python 3.10–3.13](https://img.shields.io/badge/Python-3.10%E2%80%933.13-blue.svg)](.github/workflows/ci.yml)
+
+TradeGuard OSS is an open-source toolkit for validating trading journals, checking risk hygiene, and computing reproducible performance and journal-integrity diagnostics from closed trades.
+
+> Status: active early development (`v0.7.0`). The project is intended for research, education, journaling, and system-quality checks. It is not financial advice and it does not place trades.
+
+## Why TradeGuard?
+
+Trading journals often contain missing stop losses, inconsistent direction labels, invalid timestamps, duplicate records, incomplete position sizing, or performance statistics that cannot be reproduced. TradeGuard turns those checks into dependency-light, testable rules and deterministic reports.
+
+## Current capabilities
+
+- Versioned CSV journal schema and row-level diagnostics
+- Long/short PnL, initial risk, and R-multiple calculation
+- Win rate, net PnL, expectancy, gross profit/loss, profit factor, breakeven count, best/worst trade, and closed-trade maximum drawdown
+- Stop-loss and data-quality validation
+- Deterministic SHA-256 journal fingerprints
+- Exact duplicate-trade detection and blocking integrity diagnostics
+- Entry-notional portfolio exposure by normalized symbol and side
+- Gross/net notional exposure and configurable portfolio, symbol, and trade notional limits
+- Stop-based historical risk budgets with explicit incomplete-data diagnostics
+- Deterministic segmented analytics by symbol and side
+- Optional deterministic closed-at grouping by calendar day or month
+- Explicit mapped CSV imports with source-row provenance and rejection diagnostics
+- Stable additive `tradeguard.report.v1` contract with explicit compatibility rules
+- Human-readable or versioned JSON CLI output
+- Deterministic JSON report export
+- Automated tests across Python 3.10–3.13 plus distribution wheel smoke-install validation
+
+## Install for development
+
+```bash
+git clone https://github.com/hesam1111111111/tradeguard-oss.git
+cd tradeguard-oss
+python -m venv .venv
+# Windows: .venv\Scripts\activate
+# macOS/Linux: source .venv/bin/activate
+pip install -e .[dev]
+pytest -q
+```
+
+## CSV format
+
+Required columns:
+
+```text
+symbol,side,entry,exit
+```
+
+Optional columns:
+
+```text
+stop_loss,quantity,opened_at,closed_at
+```
+
+Example:
+
+```csv
+symbol,side,entry,exit,stop_loss,quantity,opened_at,closed_at
+BTCUSDT,long,60000,61500,59000,0.1,2026-01-01T10:00:00,2026-01-01T13:00:00
+ETHUSDT,short,3200,3100,3260,1.0,2026-01-02T09:00:00,2026-01-02T12:00:00
+```
+
+## CLI
+
+Native TradeGuard CSV:
+
+```bash
+tradeguard examples/sample_journal.csv
+tradeguard examples/sample_journal.csv --json
+tradeguard examples/sample_journal.csv --output report.json
+```
+
+Explicit mapped import from a differently named CSV:
+
+```bash
+tradeguard examples/mapped_journal.csv \
+  --map symbol=Ticker \
+  --map side=Direction \
+  --map entry=OpenPrice \
+  --map exit=ClosePrice \
+  --map stop_loss=Stop \
+  --map quantity=Size \
+  --json
+```
+
+Mappings are explicit by design. TradeGuard does not guess aliases or infer ambiguous columns. The report adds an `import` provenance section with source/imported/rejected row counts, the exact mapping, completeness, and source-indexed diagnostics. If mapped import is incomplete, metrics/risk/segments are suppressed rather than computed from a partial dataset.
+
+Add deterministic temporal analytics based on the recorded `closed_at` value:
+
+```bash
+tradeguard examples/sample_journal.csv --group-closed-by day --json
+tradeguard examples/sample_journal.csv --group-closed-by month --output report.json
+```
+
+The report retains the `tradeguard.report.v1` envelope and includes source, metrics, validation issues, journal fingerprint, structured integrity diagnostics, risk analysis, segmented analytics, and optional import provenance. Metrics are skipped when blocking validation, duplicate-record errors, or incomplete mapped import make analysis unsafe.
+
+The stable machine-readable contract and compatibility rules are documented in [`docs/report-contract-v1.md`](docs/report-contract-v1.md).
+
+## Python API
+
+```python
+from tradeguard import (
+    RiskLimits,
+    Trade,
+    aggregate_exposure,
+    analyze_by_closed_period,
+    analyze_trades,
+    check_risk_limits,
+    import_mapped_csv,
+    journal_fingerprint,
+    validate_trades,
+)
+
+trades = [Trade("BTCUSDT", "long", entry=60000, exit=61500, stop_loss=59000, quantity=0.1)]
+print(validate_trades(trades))
+print(journal_fingerprint(trades))
+print(analyze_trades(trades))
+print(analyze_by_closed_period(trades, "month"))
+print(aggregate_exposure(trades))
+print(check_risk_limits(trades, RiskLimits(max_gross_notional=10000)))
+
+mapped = import_mapped_csv(
+    "examples/mapped_journal.csv",
+    {"symbol": "Ticker", "side": "Direction", "entry": "OpenPrice", "exit": "ClosePrice"},
+)
+print(mapped.imported_rows, mapped.rejected_rows)
+```
+
+### Exposure semantics
+
+`aggregate_exposure` and notional risk limits use absolute `entry * quantity` values from the supplied journal. They describe historical entry-notional concentration; they are **not** live positions, mark-to-market exposure, margin usage, or broker account state.
+
+### Temporal semantics
+
+Temporal grouping uses the recorded `closed_at` value exactly as supplied. TradeGuard does not guess or convert timezones; callers combining timestamps from different zones should normalize them before calendar grouping.
+
+## Development policy
+
+Behavioral changes should arrive through scoped branches and pull requests with regression tests. CI runs the test suite across supported Python versions before changes are merged. Public examples must be synthetic or privacy-safe.
+
+## Roadmap
+
+Near-term work includes additional offline import adapters, stronger source-data integrity diagnostics, and broader report-consumer fixtures. Live brokerage connectivity and order execution are outside the current core scope.
+
+## Contributing
+
+Contributions are welcome. Please read [`CONTRIBUTING.md`](CONTRIBUTING.md), follow the [`CODE_OF_CONDUCT.md`](CODE_OF_CONDUCT.md), open an issue for material changes, and include tests for behavioral changes.
+
+Repository-maintainer review criteria and evidence are tracked in [`docs/oss-application-readiness.md`](docs/oss-application-readiness.md).
+
+## Security and privacy
+
+TradeGuard does not require API keys for its core journal analytics. Do not commit broker credentials, exchange keys, private trade exports, or personal financial data. See [`SECURITY.md`](SECURITY.md).
+
+## License
+
+MIT. See [`LICENSE`](LICENSE).

tradeguard_oss-0.7.0/README.md

@@ -0,0 +1,163 @@
+# TradeGuard OSS
+
+[![CI](https://github.com/hesam1111111111/tradeguard-oss/actions/workflows/ci.yml/badge.svg)](https://github.com/hesam1111111111/tradeguard-oss/actions/workflows/ci.yml)
+[![Latest release](https://img.shields.io/github/v/release/hesam1111111111/tradeguard-oss)](https://github.com/hesam1111111111/tradeguard-oss/releases/latest)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python 3.10–3.13](https://img.shields.io/badge/Python-3.10%E2%80%933.13-blue.svg)](.github/workflows/ci.yml)
+
+TradeGuard OSS is an open-source toolkit for validating trading journals, checking risk hygiene, and computing reproducible performance and journal-integrity diagnostics from closed trades.
+
+> Status: active early development (`v0.7.0`). The project is intended for research, education, journaling, and system-quality checks. It is not financial advice and it does not place trades.
+
+## Why TradeGuard?
+
+Trading journals often contain missing stop losses, inconsistent direction labels, invalid timestamps, duplicate records, incomplete position sizing, or performance statistics that cannot be reproduced. TradeGuard turns those checks into dependency-light, testable rules and deterministic reports.
+
+## Current capabilities
+
+- Versioned CSV journal schema and row-level diagnostics
+- Long/short PnL, initial risk, and R-multiple calculation
+- Win rate, net PnL, expectancy, gross profit/loss, profit factor, breakeven count, best/worst trade, and closed-trade maximum drawdown
+- Stop-loss and data-quality validation
+- Deterministic SHA-256 journal fingerprints
+- Exact duplicate-trade detection and blocking integrity diagnostics
+- Entry-notional portfolio exposure by normalized symbol and side
+- Gross/net notional exposure and configurable portfolio, symbol, and trade notional limits
+- Stop-based historical risk budgets with explicit incomplete-data diagnostics
+- Deterministic segmented analytics by symbol and side
+- Optional deterministic closed-at grouping by calendar day or month
+- Explicit mapped CSV imports with source-row provenance and rejection diagnostics
+- Stable additive `tradeguard.report.v1` contract with explicit compatibility rules
+- Human-readable or versioned JSON CLI output
+- Deterministic JSON report export
+- Automated tests across Python 3.10–3.13 plus distribution wheel smoke-install validation
+
+## Install for development
+
+```bash
+git clone https://github.com/hesam1111111111/tradeguard-oss.git
+cd tradeguard-oss
+python -m venv .venv
+# Windows: .venv\Scripts\activate
+# macOS/Linux: source .venv/bin/activate
+pip install -e .[dev]
+pytest -q
+```
+
+## CSV format
+
+Required columns:
+
+```text
+symbol,side,entry,exit
+```
+
+Optional columns:
+
+```text
+stop_loss,quantity,opened_at,closed_at
+```
+
+Example:
+
+```csv
+symbol,side,entry,exit,stop_loss,quantity,opened_at,closed_at
+BTCUSDT,long,60000,61500,59000,0.1,2026-01-01T10:00:00,2026-01-01T13:00:00
+ETHUSDT,short,3200,3100,3260,1.0,2026-01-02T09:00:00,2026-01-02T12:00:00
+```
+
+## CLI
+
+Native TradeGuard CSV:
+
+```bash
+tradeguard examples/sample_journal.csv
+tradeguard examples/sample_journal.csv --json
+tradeguard examples/sample_journal.csv --output report.json
+```
+
+Explicit mapped import from a differently named CSV:
+
+```bash
+tradeguard examples/mapped_journal.csv \
+  --map symbol=Ticker \
+  --map side=Direction \
+  --map entry=OpenPrice \
+  --map exit=ClosePrice \
+  --map stop_loss=Stop \
+  --map quantity=Size \
+  --json
+```
+
+Mappings are explicit by design. TradeGuard does not guess aliases or infer ambiguous columns. The report adds an `import` provenance section with source/imported/rejected row counts, the exact mapping, completeness, and source-indexed diagnostics. If mapped import is incomplete, metrics/risk/segments are suppressed rather than computed from a partial dataset.
+
+Add deterministic temporal analytics based on the recorded `closed_at` value:
+
+```bash
+tradeguard examples/sample_journal.csv --group-closed-by day --json
+tradeguard examples/sample_journal.csv --group-closed-by month --output report.json
+```
+
+The report retains the `tradeguard.report.v1` envelope and includes source, metrics, validation issues, journal fingerprint, structured integrity diagnostics, risk analysis, segmented analytics, and optional import provenance. Metrics are skipped when blocking validation, duplicate-record errors, or incomplete mapped import make analysis unsafe.
+
+The stable machine-readable contract and compatibility rules are documented in [`docs/report-contract-v1.md`](docs/report-contract-v1.md).
+
+## Python API
+
+```python
+from tradeguard import (
+    RiskLimits,
+    Trade,
+    aggregate_exposure,
+    analyze_by_closed_period,
+    analyze_trades,
+    check_risk_limits,
+    import_mapped_csv,
+    journal_fingerprint,
+    validate_trades,
+)
+
+trades = [Trade("BTCUSDT", "long", entry=60000, exit=61500, stop_loss=59000, quantity=0.1)]
+print(validate_trades(trades))
+print(journal_fingerprint(trades))
+print(analyze_trades(trades))
+print(analyze_by_closed_period(trades, "month"))
+print(aggregate_exposure(trades))
+print(check_risk_limits(trades, RiskLimits(max_gross_notional=10000)))
+
+mapped = import_mapped_csv(
+    "examples/mapped_journal.csv",
+    {"symbol": "Ticker", "side": "Direction", "entry": "OpenPrice", "exit": "ClosePrice"},
+)
+print(mapped.imported_rows, mapped.rejected_rows)
+```
+
+### Exposure semantics
+
+`aggregate_exposure` and notional risk limits use absolute `entry * quantity` values from the supplied journal. They describe historical entry-notional concentration; they are **not** live positions, mark-to-market exposure, margin usage, or broker account state.
+
+### Temporal semantics
+
+Temporal grouping uses the recorded `closed_at` value exactly as supplied. TradeGuard does not guess or convert timezones; callers combining timestamps from different zones should normalize them before calendar grouping.
+
+## Development policy
+
+Behavioral changes should arrive through scoped branches and pull requests with regression tests. CI runs the test suite across supported Python versions before changes are merged. Public examples must be synthetic or privacy-safe.
+
+## Roadmap
+
+Near-term work includes additional offline import adapters, stronger source-data integrity diagnostics, and broader report-consumer fixtures. Live brokerage connectivity and order execution are outside the current core scope.
+
+## Contributing
+
+Contributions are welcome. Please read [`CONTRIBUTING.md`](CONTRIBUTING.md), follow the [`CODE_OF_CONDUCT.md`](CODE_OF_CONDUCT.md), open an issue for material changes, and include tests for behavioral changes.
+
+Repository-maintainer review criteria and evidence are tracked in [`docs/oss-application-readiness.md`](docs/oss-application-readiness.md).
+
+## Security and privacy
+
+TradeGuard does not require API keys for its core journal analytics. Do not commit broker credentials, exchange keys, private trade exports, or personal financial data. See [`SECURITY.md`](SECURITY.md).
+
+## License
+
+MIT. See [`LICENSE`](LICENSE).

tradeguard_oss-0.7.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tradeguard-oss"
+version = "0.7.0"
+description = "Open-source trade journal validation, risk analytics, and data-quality toolkit for traders and trading systems."
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [{name = "TradeGuard OSS contributors"}]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "build>=1.2"]
+
+[project.scripts]
+tradeguard = "tradeguard.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

tradeguard_oss-0.7.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tradeguard_oss-0.7.0/src/tradeguard/__init__.py

@@ -0,0 +1,68 @@
+"""TradeGuard OSS public package."""
+
+from .analytics import (
+    JournalMetrics,
+    JournalSegment,
+    TemporalAnalysis,
+    TemporalDiagnostic,
+    analyze_by_closed_period,
+    analyze_by_side,
+    analyze_by_symbol,
+    analyze_trades,
+)
+from .importers import ImportDiagnostic, ImportResult, import_mapped_csv
+from .integrity import DuplicateTrade, find_duplicate_trades, journal_fingerprint
+from .models import Trade
+from .risk import (
+    Exposure,
+    InitialRiskAnalysis,
+    InitialRiskDiagnostic,
+    RiskBreach,
+    RiskBudget,
+    RiskBudgetBreach,
+    RiskBudgetEvaluation,
+    RiskLimits,
+    aggregate_exposure,
+    analyze_initial_risk,
+    check_risk_limits,
+    evaluate_risk_budget,
+    trade_initial_risk,
+    trade_notional,
+)
+from .validation import ValidationIssue, validate_trades
+
+__all__ = [
+    "DuplicateTrade",
+    "Exposure",
+    "ImportDiagnostic",
+    "ImportResult",
+    "InitialRiskAnalysis",
+    "InitialRiskDiagnostic",
+    "JournalMetrics",
+    "JournalSegment",
+    "RiskBreach",
+    "RiskBudget",
+    "RiskBudgetBreach",
+    "RiskBudgetEvaluation",
+    "RiskLimits",
+    "TemporalAnalysis",
+    "TemporalDiagnostic",
+    "Trade",
+    "ValidationIssue",
+    "aggregate_exposure",
+    "analyze_by_closed_period",
+    "analyze_by_side",
+    "analyze_by_symbol",
+    "analyze_initial_risk",
+    "analyze_trades",
+    "check_risk_limits",
+    "evaluate_risk_budget",
+    "find_duplicate_trades",
+    "import_mapped_csv",
+    "journal_fingerprint",
+    "trade_initial_risk",
+    "trade_notional",
+    "validate_trades",
+]
+
+__version__ = "0.7.0"

tradeguard_oss-0.7.0/src/tradeguard/analytics.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Iterable, Literal
+
+from .models import Trade
+
+
+@dataclass(frozen=True, slots=True)
+class JournalMetrics:
+    trades: int
+    wins: int
+    losses: int
+    breakeven: int
+    win_rate: float
+    net_pnl: float
+    gross_profit: float
+    gross_loss: float
+    profit_factor: float | None
+    expectancy: float
+    max_drawdown: float
+    average_r_multiple: float | None
+    best_trade: float | None
+    worst_trade: float | None
+
+
+@dataclass(frozen=True, slots=True)
+class JournalSegment:
+    key: str
+    metrics: JournalMetrics
+
+
+@dataclass(frozen=True, slots=True)
+class TemporalDiagnostic:
+    code: str
+    message: str
+    trade_index: int
+    symbol: str
+
+
+@dataclass(frozen=True, slots=True)
+class TemporalAnalysis:
+    basis: str
+    period: str
+    measured_trades: int
+    segments: tuple[JournalSegment, ...]
+    diagnostics: tuple[TemporalDiagnostic, ...]
+
+    @property
+    def complete(self) -> bool:
+        return not self.diagnostics
+
+
+def _max_drawdown(pnls: list[float]) -> float:
+    equity = 0.0
+    peak = 0.0
+    max_dd = 0.0
+    for pnl in pnls:
+        equity += pnl
+        peak = max(peak, equity)
+        max_dd = max(max_dd, peak - equity)
+    return max_dd
+
+
+def analyze_trades(trades: Iterable[Trade]) -> JournalMetrics:
+    items = list(trades)
+    pnls = [t.pnl for t in items]
+    wins = sum(1 for pnl in pnls if pnl > 0)
+    losses = sum(1 for pnl in pnls if pnl < 0)
+    breakeven = sum(1 for pnl in pnls if pnl == 0)
+    total = len(items)
+    gross_profit = sum(pnl for pnl in pnls if pnl > 0)
+    gross_loss = abs(sum(pnl for pnl in pnls if pnl < 0))
+    r_values = [r for t in items if (r := t.r_multiple) is not None]
+
+    return JournalMetrics(
+        trades=total,
+        wins=wins,
+        losses=losses,
+        breakeven=breakeven,
+        win_rate=(wins / total) if total else 0.0,
+        net_pnl=sum(pnls),
+        gross_profit=gross_profit,
+        gross_loss=gross_loss,
+        profit_factor=(gross_profit / gross_loss) if gross_loss else None,
+        expectancy=(sum(pnls) / total) if total else 0.0,
+        max_drawdown=_max_drawdown(pnls),
+        average_r_multiple=(sum(r_values) / len(r_values)) if r_values else None,
+        best_trade=max(pnls) if pnls else None,
+        worst_trade=min(pnls) if pnls else None,
+    )
+
+
+def analyze_by_symbol(trades: Iterable[Trade]) -> tuple[JournalSegment, ...]:
+    groups: dict[str, list[Trade]] = {}
+    for trade in trades:
+        symbol = trade.symbol.strip().upper()
+        if not symbol:
+            raise ValueError("trade.symbol must not be empty")
+        groups.setdefault(symbol, []).append(trade)
+    return tuple(JournalSegment(key, analyze_trades(groups[key])) for key in sorted(groups))
+
+
+def analyze_by_side(trades: Iterable[Trade]) -> tuple[JournalSegment, ...]:
+    groups: dict[str, list[Trade]] = {}
+    for trade in trades:
+        side = trade.normalized_side
+        groups.setdefault(side, []).append(trade)
+    return tuple(JournalSegment(key, analyze_trades(groups[key])) for key in sorted(groups))
+
+
+def _period_key(timestamp: datetime, period: Literal["day", "month"]) -> str:
+    if period == "day":
+        return timestamp.date().isoformat()
+    if period == "month":
+        return f"{timestamp.year:04d}-{timestamp.month:02d}"
+    raise ValueError("period must be 'day' or 'month'")
+
+
+def analyze_by_closed_period(
+    trades: Iterable[Trade], period: Literal["day", "month"] = "day"
+) -> TemporalAnalysis:
+    """Group historical trades by their recorded close timestamp.
+
+    Timestamp values are used exactly as supplied. TradeGuard does not infer or
+    convert a timezone; callers must normalize timestamps before analysis when
+    cross-timezone calendar grouping is required.
+    """
+    if period not in {"day", "month"}:
+        raise ValueError("period must be 'day' or 'month'")
+
+    groups: dict[str, list[Trade]] = {}
+    diagnostics: list[TemporalDiagnostic] = []
+    measured = 0
+    for index, trade in enumerate(trades):
+        symbol = trade.symbol.strip().upper() or "<UNKNOWN>"
+        timestamp = trade.closed_at
+        if timestamp is None:
+            diagnostics.append(TemporalDiagnostic(
+                code="missing_closed_at",
+                message="trade.closed_at is required for temporal analytics",
+                trade_index=index,
+                symbol=symbol,
+            ))
+            continue
+        key = _period_key(timestamp, period)
+        groups.setdefault(key, []).append(trade)
+        measured += 1
+
+    segments = tuple(JournalSegment(key, analyze_trades(groups[key])) for key in sorted(groups))
+    return TemporalAnalysis(
+        basis="recorded_closed_at_no_timezone_conversion",
+        period=period,
+        measured_trades=measured,
+        segments=segments,
+        diagnostics=tuple(diagnostics),
+    )