riskkit-quant 0.4.0__py3-none-any.whl

riskkit/validator.py

@@ -0,0 +1,197 @@
+"""Pre-trade validator — the final gate before an order goes out.
+
+A composable checklist that runs every rule against a proposed trade and vetoes
+it if *any* rule fails. The point is to make "should I take this trade?" a
+single, auditable function call whose output records exactly which rules passed
+and which failed.
+
+The checks span market quality, position sizing, risk limits, signal quality,
+and timing. The validator is framework-agnostic: you assemble a
+:class:`TradeProposal` from whatever your system knows, and you get back a
+:class:`ValidationResult`.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Mapping
+
+
+@dataclass
+class CheckResult:
+    name: str
+    ok: bool
+    details: str = ""
+
+
+@dataclass
+class ValidationResult:
+    passed: bool
+    failures: list[CheckResult]
+    details: list[CheckResult] = field(default_factory=list)
+    market_quality_failed: bool = False  # if True, the caller may retry shortly
+
+
+@dataclass
+class TradeProposal:
+    symbol: str
+    side: str                   # "long" | "short"
+    entry_price: float
+    stop_price: float
+    target_price: float
+    size_units: float
+    notional: float
+    strategy: str
+    score: int                  # signal-quality score (0-100)
+    regime: str = ""
+
+    # Market-quality snapshot
+    spread_pct: float = 0.0
+    orderbook_depth: float = float("inf")   # quote-currency depth near touch
+    recent_atr_spike_x: float = 1.0         # current_atr / baseline_atr
+    last_quote_age_sec: float = 0.0
+
+    # Portfolio state
+    equity: float = 0.0
+    free_balance: float = float("inf")
+    current_total_exposure_pct: float = 0.0
+    current_portfolio_heat_pct: float = 0.0   # open risk-at-stop, excl. this trade
+    sector: str = ""                          # sector / asset-class tag (for per-sector cap)
+    current_sector_exposure_pct: float = 0.0  # this sector's open notional %, excl. this trade
+    open_concurrent_positions: int = 0
+    daily_loss_pct: float = 0.0
+    daily_trade_count: int = 0
+    drawdown_halted: bool = False
+    cooldown_active: bool = False
+    correlation_blocked: bool = False
+    at_max_concurrent: bool = False
+    seconds_since_last_trade: float = float("inf")
+
+
+class PreTradeValidator:
+    def __init__(
+        self,
+        max_spread_pct_tight: float = 0.05,
+        max_spread_pct_default: float = 0.1,
+        tight_spread_symbols: set[str] | None = None,
+        depth_multiplier: float = 2.0,
+        max_recent_atr_spike: float = 3.0,
+        max_quote_age_sec: float = 120.0,
+        max_notional_pct: float = 4.0,
+        max_total_exposure_pct: float = 10.0,
+        max_portfolio_heat_pct: float = float("inf"),
+        max_exposure_per_sector_pct: float = float("inf"),
+        max_daily_loss_pct: float = 1.5,
+        max_daily_trades: int = 5,
+        min_score: int = 70,
+        min_rr_ratio: float = 2.0,
+        min_seconds_between_trades: float = 15 * 60,
+        regime_strategies: Mapping[str, set[str]] | None = None,
+    ) -> None:
+        self.max_spread_tight = max_spread_pct_tight
+        self.max_spread_default = max_spread_pct_default
+        self.tight_spread_symbols = tight_spread_symbols or set()
+        self.depth_mult = depth_multiplier
+        self.max_atr_spike = max_recent_atr_spike
+        self.max_quote_age = max_quote_age_sec
+        self.max_notional_pct = max_notional_pct
+        self.max_total_exposure_pct = max_total_exposure_pct
+        self.max_portfolio_heat_pct = max_portfolio_heat_pct
+        self.max_sector_exposure_pct = max_exposure_per_sector_pct
+        self.max_daily_loss_pct = max_daily_loss_pct
+        self.max_daily_trades = max_daily_trades
+        self.min_score = min_score
+        self.min_rr = min_rr_ratio
+        self.min_secs_between = min_seconds_between_trades
+        self.regime_strategies = regime_strategies
+
+    def validate(self, p: TradeProposal, *, min_score_override: int | None = None) -> ValidationResult:
+        results: list[CheckResult] = []
+        min_score = max(min_score_override or 0, self.min_score)
+
+        # ── MARKET QUALITY ──
+        max_spread = (
+            self.max_spread_tight if p.symbol in self.tight_spread_symbols
+            else self.max_spread_default
+        )
+        results.append(CheckResult("spread_ok", p.spread_pct < max_spread,
+                                   f"spread={p.spread_pct:.4f}% < {max_spread}%"))
+        results.append(CheckResult("orderbook_depth_ok",
+                                   p.orderbook_depth >= self.depth_mult * p.notional,
+                                   f"depth={p.orderbook_depth:.0f} vs {self.depth_mult}x notional {p.notional:.0f}"))
+        results.append(CheckResult("no_recent_volatility_spike",
+                                   p.recent_atr_spike_x < self.max_atr_spike,
+                                   f"atr_spike_x={p.recent_atr_spike_x:.2f} < {self.max_atr_spike}"))
+        results.append(CheckResult("data_fresh", p.last_quote_age_sec < self.max_quote_age,
+                                   f"quote_age={p.last_quote_age_sec:.0f}s"))
+
+        # ── POSITION SIZING ──
+        results.append(CheckResult("size_positive", p.size_units > 0 and p.notional > 0,
+                                   "size must be > 0"))
+        notional_pct = (p.notional / p.equity * 100.0) if p.equity else 100.0
+        results.append(CheckResult("notional_cap", notional_pct <= self.max_notional_pct,
+                                   f"notional {notional_pct:.2f}% of equity vs cap {self.max_notional_pct}%"))
+        projected = p.current_total_exposure_pct + notional_pct
+        results.append(CheckResult("total_exposure_cap", projected <= self.max_total_exposure_pct,
+                                   f"projected exposure {projected:.2f}% vs cap {self.max_total_exposure_pct}%"))
+        # Per-sector exposure: keep any single sector / asset-class from dominating the
+        # book. Only checked when a cap is configured and the trade carries a sector tag.
+        if self.max_sector_exposure_pct != float("inf") and p.sector:
+            projected_sector = p.current_sector_exposure_pct + notional_pct
+            results.append(CheckResult(
+                "sector_exposure_ok",
+                projected_sector <= self.max_sector_exposure_pct,
+                f"sector '{p.sector}' projected {projected_sector:.2f}% vs cap {self.max_sector_exposure_pct}%"))
+        # Portfolio heat: total risk-at-stop across open positions plus this one.
+        # Only checked when a cap is configured (off by default).
+        if self.max_portfolio_heat_pct != float("inf"):
+            trade_risk = abs(p.entry_price - p.stop_price) * p.size_units
+            trade_risk_pct = (trade_risk / p.equity * 100.0) if p.equity else 0.0
+            projected_heat = p.current_portfolio_heat_pct + trade_risk_pct
+            results.append(CheckResult("portfolio_heat_ok",
+                                       projected_heat <= self.max_portfolio_heat_pct,
+                                       f"projected heat {projected_heat:.2f}% vs cap {self.max_portfolio_heat_pct}%"))
+        results.append(CheckResult("sufficient_balance", p.free_balance >= p.notional * 1.01,
+                                   f"free={p.free_balance:.2f} need={p.notional * 1.01:.2f}"))
+
+        # ── RISK LIMITS ──
+        results.append(CheckResult("daily_loss_ok", p.daily_loss_pct < self.max_daily_loss_pct,
+                                   f"daily_loss={p.daily_loss_pct:.2f}% < {self.max_daily_loss_pct}%"))
+        results.append(CheckResult("daily_trade_count_ok", p.daily_trade_count < self.max_daily_trades,
+                                   f"trades_today={p.daily_trade_count} < {self.max_daily_trades}"))
+        results.append(CheckResult("not_in_drawdown_halt", not p.drawdown_halted,
+                                   "drawdown halt active" if p.drawdown_halted else "ok"))
+        results.append(CheckResult("not_in_cooldown", not p.cooldown_active,
+                                   "in cooldown" if p.cooldown_active else "ok"))
+        results.append(CheckResult("correlation_ok", not p.correlation_blocked,
+                                   "correlated position open" if p.correlation_blocked else "ok"))
+        results.append(CheckResult("max_concurrent_ok", not p.at_max_concurrent,
+                                   f"open={p.open_concurrent_positions} at cap" if p.at_max_concurrent else "ok"))
+
+        # ── SIGNAL QUALITY ──
+        results.append(CheckResult("score_ok", p.score >= min_score,
+                                   f"score={p.score} >= {min_score}"))
+        risk = abs(p.entry_price - p.stop_price)
+        reward = abs(p.target_price - p.entry_price)
+        rr = reward / risk if risk else 0.0
+        results.append(CheckResult("rr_ratio_ok", rr >= self.min_rr,
+                                   f"R:R {rr:.2f} >= {self.min_rr}"))
+        if self.regime_strategies is not None:
+            allowed = p.strategy in self.regime_strategies.get(p.regime, set())
+            results.append(CheckResult("regime_allows_strategy", allowed,
+                                       f"strategy={p.strategy} regime={p.regime}"))
+
+        # ── TIMING ──
+        results.append(CheckResult("min_time_between_trades",
+                                   p.seconds_since_last_trade >= self.min_secs_between,
+                                   f"{p.seconds_since_last_trade:.0f}s >= {self.min_secs_between}s"))
+
+        failures = [r for r in results if not r.ok]
+        market_quality_names = {
+            "spread_ok", "orderbook_depth_ok", "no_recent_volatility_spike", "data_fresh",
+        }
+        return ValidationResult(
+            passed=len(failures) == 0,
+            failures=failures,
+            details=results,
+            market_quality_failed=any(r.name in market_quality_names for r in failures),
+        )

riskkit_quant-0.4.0.dist-info/METADATA

@@ -0,0 +1,260 @@
+Metadata-Version: 2.4
+Name: riskkit-quant
+Version: 0.4.0
+Summary: A framework-agnostic risk-management toolkit for systematic traders: position sizing, drawdown laddering, and more.
+Project-URL: Homepage, https://github.com/HasibDaddy/riskkit
+Project-URL: Repository, https://github.com/HasibDaddy/riskkit
+Project-URL: Issues, https://github.com/HasibDaddy/riskkit/issues
+Author: Hasib
+License: MIT
+License-File: LICENSE
+Keywords: algotrading,backtesting,drawdown,kelly-criterion,position-sizing,quant,risk-management,trading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: backtesting
+Requires-Dist: backtesting>=0.3; extra == 'backtesting'
+Provides-Extra: dev
+Requires-Dist: backtesting>=0.3; extra == 'dev'
+Requires-Dist: hypothesis>=6.0; extra == 'dev'
+Requires-Dist: pandas>=1.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: pyyaml>=5.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.0; extra == 'docs'
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.0; extra == 'pandas'
+Provides-Extra: yaml
+Requires-Dist: pyyaml>=5.0; extra == 'yaml'
+Description-Content-Type: text/markdown
+
+# riskkit
+
+[![CI](https://github.com/HasibDaddy/riskkit/actions/workflows/ci.yml/badge.svg)](https://github.com/HasibDaddy/riskkit/actions/workflows/ci.yml)
+[![Docs](https://img.shields.io/badge/docs-mkdocs-1f6feb)](https://hasibdaddy.github.io/riskkit/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+![Python](https://img.shields.io/badge/python-3.9%E2%80%933.12-blue.svg)
+![Dependencies](https://img.shields.io/badge/runtime%20deps-0-brightgreen.svg)
+
+**A framework-agnostic risk-management toolkit for systematic traders.**
+
+Most open-source trading tools focus on the fun part — signals, indicators,
+backtesting engines. They leave the part that actually decides whether you
+survive thin or absent: *how big a position to take, when to cut size, and when
+to stop trading altogether.* That's what blows up retail algo traders, not a
+bad entry signal.
+
+`riskkit` is that missing layer. The components are pure Python with **no
+dependency on any exchange, data provider, or backtesting framework**. They
+don't know what CCXT is. You feed them numbers; they hand back decisions you can
+audit. Drop them into [backtesting.py](https://github.com/kernc/backtesting.py),
+[vectorbt](https://github.com/polakowo/vectorbt), [backtrader](https://github.com/mementum/backtrader),
+[freqtrade](https://github.com/freqtrade/freqtrade), or your own loop.
+
+> ⚠️ **Not financial advice.** `riskkit` helps you *implement* a risk policy you
+> have chosen. It does not choose one for you, and it cannot make a losing
+> strategy profitable. Test everything on paper first.
+
+---
+
+## Install
+
+```bash
+pip install "git+https://github.com/HasibDaddy/riskkit.git"
+```
+
+Zero runtime dependencies. Python 3.9+. *(A PyPI release is on the way — until
+then, install straight from GitHub with the line above.)*
+
+---
+
+## What's in the box
+
+| Component | What it does |
+|---|---|
+| `PositionSizer` | Volatility-adjusted fixed-fractional sizing with an optional half-Kelly ceiling, a reduction ladder for losing streaks / drawdowns, and a hard notional cap. |
+| `DrawdownManager` | Tracks high-water-mark drawdown, maps it onto a tier ladder (cut size → raise the bar → halt), with a recovery ramp and a rolling weekly-loss pause. |
+| `StopEngine` | A composable stop *stack* per position — initial, break-even, ATR/EMA trailing, chandelier, structure (swing), PSAR, time, and volatility stops. The tightest one wins; stops only ever move closer. |
+| `CorrelationGuard` | At most one open position per correlation group. Groups can be static (you define them) or computed dynamically from a rolling return-correlation matrix. |
+| `SessionManager` | Daily trade/loss caps, profit-taking stops, minimum spacing, escalating cooldowns after losing streaks, and tilt detection. |
+| `PreTradeValidator` | The composable final gate: runs every rule against a proposed trade and vetoes it if any fails — returning exactly which checks passed and failed. |
+
+Every decision is **auditable** — the sizer returns which multipliers fired,
+the stop engine logs each adjustment, and the validator returns a pass/fail line
+for every single check.
+
+Beyond the six components, riskkit ships a few **portfolio-level controls** and
+**standalone sizers** you can reach for on their own:
+
+- **Portfolio caps** (enforced by `RiskManager` as the book fills): total open
+  notional, total **heat** (risk-at-stop), and **per-sector / asset-class**
+  exposure — so no single sector can dominate the book.
+- **Composable sizers** (pure functions): `volatility_target_size`,
+  `inverse_vol_weights` (naive risk parity), and `kelly_fraction`.
+- **Risk metrics**: historical `value_at_risk` and `conditional_value_at_risk`.
+
+---
+
+## Quick start
+
+### The whole stack, one call
+
+`RiskManager` is the façade: wire all six components from a single config, push
+equity in as your account moves, and ask one question per trade. It keeps the
+drawdown, session, and open-position state in sync for you.
+
+```python
+from riskkit import RiskManager, RiskConfig, TradeIntent
+
+risk = RiskManager(RiskConfig(
+    base_risk_pct=1.0, max_notional_pct=4.0,
+    drawdown=dict(tier1_pct=3, halt_pct=10),
+    session=dict(max_trades_per_day=5),
+    correlation=dict(static_groups={"majors": {"BTC/USDT", "ETH/USDT"}}),
+))
+
+risk.on_equity(10_000)                              # refresh drawdown/session state
+decision = risk.evaluate(TradeIntent(
+    symbol="BTC/USDT", side="long",
+    entry_price=100.0, stop_price=98.0, target_price=104.0,
+    score=82, atr=2.0, atr_baseline=2.0,
+))
+
+if decision.ok:
+    place(decision.units, decision.stop)           # your execution layer
+    risk.on_fill(decision)                          # tell riskkit it filled
+else:
+    print("skip:", *decision.reasons, sep="\n  ")   # every gate that vetoed it
+```
+
+Reach past the façade to any single component when you need to — they're all
+exposed (`risk.sizer`, `risk.drawdown`, `risk.stops`, …) and usable standalone.
+
+Don't want to tune every knob? Start from a preset, or load policy from YAML:
+
+```python
+risk = RiskManager(RiskConfig.conservative())   # or .balanced() / .aggressive()
+cfg  = RiskConfig.from_yaml("risk.yaml")         # needs riskkit[yaml]
+```
+
+### Sizing a trade
+
+```python
+from riskkit import PositionSizer, SizingInputs
+
+sizer = PositionSizer(
+    base_risk_pct=1.0,      # risk 1% of equity per trade, before adjustments
+    max_risk_pct=1.5,       # never risk more than 1.5%
+    max_notional_pct=4.0,   # never let a position exceed 4% of equity
+)
+
+result = sizer.size(SizingInputs(
+    equity=10_000,
+    entry_price=100.0,
+    stop_price=98.0,        # the stop distance defines your risk per unit
+    atr=2.5,                # current volatility
+    atr_baseline=2.0,       # "normal" volatility -> scales risk down when choppy
+    consecutive_losses=2,   # reduction ladder kicks in
+    drawdown_pct=4.0,
+))
+
+if result.units > 0:
+    print(f"Buy {result.units:.4f} units (risk {result.risk_pct:.2%})")
+    print("adjustments:", result.multipliers_applied)
+else:
+    print("Skip:", result.reason_for_zero)
+```
+
+### Adapting to drawdown
+
+```python
+from riskkit import DrawdownManager
+
+dm = DrawdownManager(tier1_pct=3, tier2_pct=5, tier3_pct=7, halt_pct=10)
+
+state = dm.update(current_equity)   # call once per equity refresh
+if state.halted:
+    print("No new trades:", state.reason)
+else:
+    size = base_size * state.size_multiplier   # scale every position by the tier
+```
+
+The two compose naturally: feed `DrawdownManager`'s `drawdown_pct` and
+`size_multiplier` straight into the sizer.
+
+---
+
+## Design principles
+
+- **Framework-agnostic.** No exchange SDK, no pandas requirement in the core,
+  no global state. Just dataclasses in, dataclasses out.
+- **Auditable, not magic.** Every adjustment is named and returned. You can log
+  the exact reason a trade was sized down or skipped.
+- **Conservative by default.** Floors, ceilings, and hard caps bound every knob.
+  The math can recommend; it can never exceed the limits you set.
+- **Anti-martingale.** Size goes *down* after losses and during drawdowns, never
+  up. There is no "average down" path anywhere in this library.
+
+---
+
+## Integrations
+
+riskkit slots into whatever you already use — the [examples](examples/) are
+runnable:
+
+- **backtesting.py** — subclass the `RiskkitStrategy` adapter
+  (`from riskkit.adapters.backtesting import RiskkitStrategy`) and call
+  `risk_long()` / `risk_short()`; every entry is sized **and** validated by one
+  `RiskConfig`, with closed trades fed back to the session manager. See
+  [`examples/backtesting_riskmanager.py`](examples/backtesting_riskmanager.py)
+  (full façade) or [`examples/backtesting_py_strategy.py`](examples/backtesting_py_strategy.py)
+  (just `PositionSizer`, by hand).
+- **freqtrade** — `FreqtradeRiskManager`
+  (`from riskkit.adapters.freqtrade import FreqtradeRiskManager`) drives
+  `custom_stake_amount` + `confirm_trade_entry` from one `RiskConfig`; see
+  [`examples/freqtrade_callbacks.py`](examples/freqtrade_callbacks.py).
+- **vectorbt** — `size_signals`
+  (`from riskkit.adapters.vectorbt import size_signals`) turns entry signals into
+  a riskkit-sized array for `Portfolio.from_signals`; see
+  [`examples/vectorbt_sizing.py`](examples/vectorbt_sizing.py).
+- **your own loop** — [`examples/risk_manager.py`](examples/risk_manager.py)
+  drives the full `RiskManager` façade end-to-end;
+  [`examples/multi_asset_book.py`](examples/multi_asset_book.py) allocates,
+  vol-targets, and vets a cross-sector book through the portfolio caps;
+  [`examples/pipeline.py`](examples/pipeline.py) shows the same flow wired by hand.
+
+📖 **Full docs: https://hasibdaddy.github.io/riskkit/**
+
+## Roadmap
+
+`riskkit` is extracted and generalized from a working risk-first trading bot.
+The core six components are in place; next up is making them effortless to drop
+into the popular frameworks:
+
+- [x] `PositionSizer`, `DrawdownManager`, `StopEngine`
+- [x] `CorrelationGuard`, `SessionManager`, `PreTradeValidator`
+- [x] A single `RiskManager` façade that wires all six together with one config
+- [x] Config presets (conservative / balanced / aggressive) + dict/YAML loading
+- [x] First-class adapters for backtesting.py, freqtrade, and vectorbt
+- [x] A [hosted docs site](https://hasibdaddy.github.io/riskkit/) with component recipes
+- [x] Portfolio caps (total-exposure, heat, per-sector) + standalone sizers (vol-target, risk-parity, Kelly) + VaR/CVaR
+- [ ] A PyPI release (`pip install riskkit-quant`, then `import riskkit`)
+
+Feedback on the API is genuinely welcome — open an issue. See the full
+[ROADMAP.md](ROADMAP.md), [CONTRIBUTING.md](CONTRIBUTING.md), and the
+[examples](examples/).
+
+---
+
+## License
+
+MIT © 2026 Hasib. See [LICENSE](LICENSE).

riskkit_quant-0.4.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+riskkit/__init__.py,sha256=9gsMtPovsgwKT25gyGnBVbPy2lIrb_KK5Z05qnP-3mo,2651
+riskkit/correlation.py,sha256=FHmCYuyhdmZzCT695cIZOTSgdPV9W3Rve3YkE9kU-UQ,4230
+riskkit/drawdown.py,sha256=kfmeQord_vl9rHjikEvvWrQa7LHFCbUISX74pyayJxI,5977
+riskkit/manager.py,sha256=649JeReCiIgxaFllhx0kX5g6yJXtM29Vq4-vMVVItvA,25677
+riskkit/metrics.py,sha256=D9EOwwCEHKgWIEVRnJAbx-kxnFfbr532cwZTy7kIUNU,1694
+riskkit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+riskkit/session.py,sha256=mAqcOQybTl6zkk4cbZ1o9aDe9SV4mr0xALCIZbP4Bd8,6877
+riskkit/sizing.py,sha256=0y02WR0itWQyJAdfhUOFAV8B_5pqGhnpFpxOWBzSb5U,10157
+riskkit/stops.py,sha256=im_vObTohLqJiQfYxatdTZWcrTNib-8ChHp5t7z8AVI,10192
+riskkit/validator.py,sha256=MmjIkebfcIA6I18GuIGNi6jZ-7ycX5vPY9M67v0okdo,9923
+riskkit/adapters/__init__.py,sha256=-a58ATahRvWrRRNb8WLv12s_Se_RbXeXpisTeQKljkg,295
+riskkit/adapters/backtesting.py,sha256=uJRthhAJDLFvbmd6bobBT9XPZ1cHOl4X-Tl6Epg0Hlc,6837
+riskkit/adapters/freqtrade.py,sha256=1rDBz4aGuT_Bfc_2y3pzCY3hjFGL5emPjulBYHZ5smY,6188
+riskkit/adapters/vectorbt.py,sha256=Ii1ip2yL0QrrMxPzBtf3L8Y5Av0jamhHnqZ5RY5IhLY,4711
+riskkit_quant-0.4.0.dist-info/METADATA,sha256=dkBA_wEqtgOVAPo0Rbb4WIDQSxOIDZ6Zv6uoza8t13U,11441
+riskkit_quant-0.4.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+riskkit_quant-0.4.0.dist-info/licenses/LICENSE,sha256=yNlpPgqTSHw3GbzxIlF5ndbtwb1eEJmTlyet0zxILH4,1062
+riskkit_quant-0.4.0.dist-info/RECORD,,

riskkit_quant-0.4.0.dist-info/WHEEL

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

riskkit_quant-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hasib
+
+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.