propfirm-calc 0.1.0__tar.gz

propfirm_calc-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.11", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: pytest -q

propfirm_calc-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,28 @@
+name: Publish to PyPI
+
+# Publishes to PyPI via OIDC "trusted publishing" — no API token stored.
+# One-time setup on pypi.org (Account -> Publishing -> Add a pending publisher):
+#   PyPI Project Name: propfirm-calc
+#   Owner:             shootingallday
+#   Repository name:   propfirm-calc
+#   Workflow name:     release.yml
+#   Environment:       (leave blank)
+# Then publish a GitHub Release (tag vX.Y.Z) to trigger this workflow.
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write  # required for trusted publishing
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - run: python -m pip install --upgrade build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

propfirm_calc-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.pytest_cache/
+.ruff_cache/
+.venv/
+venv/
+.coverage
+htmlcov/

propfirm_calc-0.1.0/LICENSE

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

propfirm_calc-0.1.0/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: propfirm-calc
+Version: 0.1.0
+Summary: Tiny, dependency-free math for funded-trader (prop firm) futures accounts: trailing drawdown, consistency rule, payout eligibility.
+Project-URL: Homepage, https://github.com/shootingallday/propfirm-calc
+Project-URL: Repository, https://github.com/shootingallday/propfirm-calc
+Project-URL: Issues, https://github.com/shootingallday/propfirm-calc/issues
+Author: shootingallday
+License: MIT License
+        
+        Copyright (c) 2026 shootingallday
+        
+        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.
+License-File: LICENSE
+Keywords: apex,drawdown,funded-trader,futures,prop-firm,topstep,trading
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# propfirm-calc
+
+Tiny, dependency-free Python math for **funded-trader (prop firm) futures accounts**.
+
+Three calculations every prop-futures trader needs and most journals get subtly
+wrong:
+
+1. **Trailing drawdown floor** — the equity level at which your account blows,
+   under trailing, end-of-day-trailing, or static drawdown rules.
+2. **The consistency rule** — whether your best day is within the cap, and the
+   *total profit* a big day forces you to reach before it's withdrawable.
+3. **Payout eligibility** — target, minimum winning days, and consistency rolled
+   into one answer with human-readable blockers.
+
+No dependencies. No bundled firm data — you pass the numbers, so it works for
+**any** firm (Topstep, Apex, Take Profit Trader, My Funded Futures, Lucid, …)
+and never goes stale when a firm changes its rules.
+
+## Install
+
+```bash
+pip install propfirm-calc
+```
+
+## Drawdown floor — the one people get wrong
+
+The floor depends on the firm's drawdown regime. For trailing accounts it
+follows your high-water mark *up* — until it locks at your starting balance
+(the Topstep/Apex behavior), after which the account can never blow above
+break-even.
+
+```python
+from propfirm_calc import drawdown_floor, is_blown, cushion
+
+# $50k account, $2k max loss limit, currently up $1k (peak equity $51k).
+drawdown_floor(50_000, 2_000, peak_equity=51_000)        # 49_000  (still trailing)
+
+# Up $3k (peak $53k): the trail has locked at the $50k start.
+drawdown_floor(50_000, 2_000, peak_equity=53_000)        # 50_000  (locked)
+
+# Static plans never trail:
+drawdown_floor(50_000, 2_000, peak_equity=53_000, dd_type="static")   # 48_000
+
+# End-of-day trailing? Same math — just pass your highest *EOD* balance:
+drawdown_floor(50_000, 2_000, peak_equity=51_000, dd_type="eod_trailing")  # 49_000
+
+is_blown(current_equity=48_900, starting_balance=50_000,
+         max_drawdown=2_000, peak_equity=51_000)          # True
+cushion(49_500, 50_000, 2_000, peak_equity=51_000)        # 500.0  ($ before you blow)
+```
+
+Some firms lock the trail somewhere other than the start, or never lock at all:
+
+```python
+drawdown_floor(50_000, 2_000, peak_equity=53_000, lock_at=50_100)        # 50_100
+drawdown_floor(50_000, 2_000, peak_equity=60_000, lock_at=float("inf"))  # 58_000
+```
+
+## Consistency rule
+
+```python
+from propfirm_calc import consistency_ok, best_day_pct, required_profit
+
+best_day_pct(2_000, total_profit=5_000)        # 40.0
+consistency_ok(2_000, 5_000, consistency_pct=50)   # True  (40% <= 50%)
+consistency_ok(3_000, 5_000, consistency_pct=50)   # False (60% > 50%)
+
+# A $1,500 day under a 50% rule can't be withdrawn until total profit hits $3,000:
+required_profit(1_500, consistency_pct=50)     # 3_000.0
+```
+
+## Payout eligibility
+
+Pass only the constraints your firm imposes — anything omitted is skipped.
+
+```python
+from propfirm_calc import payout_eligibility
+
+r = payout_eligibility(
+    current_profit=4_000,
+    profit_target=3_000,
+    winning_days=4,
+    min_winning_days=5,
+    best_day_profit=3_000,
+    consistency_pct=50,
+)
+r.eligible            # False
+r.blockers            # ('4 of 5 required winning days',
+                      #  'Best day 75% over the 50% consistency limit')
+r.consistency_required_profit   # 6_000.0
+```
+
+## Why this exists
+
+Prop-firm rules are simple to state and easy to mis-implement — trailing
+drawdown that should lock but doesn't, a consistency check that ignores the
+"effective target" a big day creates, a payout gate that forgets minimum days.
+`propfirm-calc` is the small, well-tested core so trading journals, dashboards,
+and bots don't each reinvent (and re-bug) it.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest -q
+ruff check .
+```
+
+## License
+
+MIT

propfirm_calc-0.1.0/README.md

@@ -0,0 +1,111 @@
+# propfirm-calc
+
+Tiny, dependency-free Python math for **funded-trader (prop firm) futures accounts**.
+
+Three calculations every prop-futures trader needs and most journals get subtly
+wrong:
+
+1. **Trailing drawdown floor** — the equity level at which your account blows,
+   under trailing, end-of-day-trailing, or static drawdown rules.
+2. **The consistency rule** — whether your best day is within the cap, and the
+   *total profit* a big day forces you to reach before it's withdrawable.
+3. **Payout eligibility** — target, minimum winning days, and consistency rolled
+   into one answer with human-readable blockers.
+
+No dependencies. No bundled firm data — you pass the numbers, so it works for
+**any** firm (Topstep, Apex, Take Profit Trader, My Funded Futures, Lucid, …)
+and never goes stale when a firm changes its rules.
+
+## Install
+
+```bash
+pip install propfirm-calc
+```
+
+## Drawdown floor — the one people get wrong
+
+The floor depends on the firm's drawdown regime. For trailing accounts it
+follows your high-water mark *up* — until it locks at your starting balance
+(the Topstep/Apex behavior), after which the account can never blow above
+break-even.
+
+```python
+from propfirm_calc import drawdown_floor, is_blown, cushion
+
+# $50k account, $2k max loss limit, currently up $1k (peak equity $51k).
+drawdown_floor(50_000, 2_000, peak_equity=51_000)        # 49_000  (still trailing)
+
+# Up $3k (peak $53k): the trail has locked at the $50k start.
+drawdown_floor(50_000, 2_000, peak_equity=53_000)        # 50_000  (locked)
+
+# Static plans never trail:
+drawdown_floor(50_000, 2_000, peak_equity=53_000, dd_type="static")   # 48_000
+
+# End-of-day trailing? Same math — just pass your highest *EOD* balance:
+drawdown_floor(50_000, 2_000, peak_equity=51_000, dd_type="eod_trailing")  # 49_000
+
+is_blown(current_equity=48_900, starting_balance=50_000,
+         max_drawdown=2_000, peak_equity=51_000)          # True
+cushion(49_500, 50_000, 2_000, peak_equity=51_000)        # 500.0  ($ before you blow)
+```
+
+Some firms lock the trail somewhere other than the start, or never lock at all:
+
+```python
+drawdown_floor(50_000, 2_000, peak_equity=53_000, lock_at=50_100)        # 50_100
+drawdown_floor(50_000, 2_000, peak_equity=60_000, lock_at=float("inf"))  # 58_000
+```
+
+## Consistency rule
+
+```python
+from propfirm_calc import consistency_ok, best_day_pct, required_profit
+
+best_day_pct(2_000, total_profit=5_000)        # 40.0
+consistency_ok(2_000, 5_000, consistency_pct=50)   # True  (40% <= 50%)
+consistency_ok(3_000, 5_000, consistency_pct=50)   # False (60% > 50%)
+
+# A $1,500 day under a 50% rule can't be withdrawn until total profit hits $3,000:
+required_profit(1_500, consistency_pct=50)     # 3_000.0
+```
+
+## Payout eligibility
+
+Pass only the constraints your firm imposes — anything omitted is skipped.
+
+```python
+from propfirm_calc import payout_eligibility
+
+r = payout_eligibility(
+    current_profit=4_000,
+    profit_target=3_000,
+    winning_days=4,
+    min_winning_days=5,
+    best_day_profit=3_000,
+    consistency_pct=50,
+)
+r.eligible            # False
+r.blockers            # ('4 of 5 required winning days',
+                      #  'Best day 75% over the 50% consistency limit')
+r.consistency_required_profit   # 6_000.0
+```
+
+## Why this exists
+
+Prop-firm rules are simple to state and easy to mis-implement — trailing
+drawdown that should lock but doesn't, a consistency check that ignores the
+"effective target" a big day creates, a payout gate that forgets minimum days.
+`propfirm-calc` is the small, well-tested core so trading journals, dashboards,
+and bots don't each reinvent (and re-bug) it.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest -q
+ruff check .
+```
+
+## License
+
+MIT

propfirm_calc-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "propfirm-calc"
+version = "0.1.0"
+description = "Tiny, dependency-free math for funded-trader (prop firm) futures accounts: trailing drawdown, consistency rule, payout eligibility."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { file = "LICENSE" }
+authors = [{ name = "shootingallday" }]
+keywords = ["trading", "futures", "prop-firm", "funded-trader", "drawdown", "topstep", "apex"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Office/Business :: Financial :: Investment",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/shootingallday/propfirm-calc"
+Repository = "https://github.com/shootingallday/propfirm-calc"
+Issues = "https://github.com/shootingallday/propfirm-calc/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "ruff>=0.4"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/propfirm_calc"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

propfirm_calc-0.1.0/src/propfirm_calc/__init__.py

@@ -0,0 +1,34 @@
+"""propfirm-calc — tiny, dependency-free math for funded-trader (prop firm) accounts.
+
+Drawdown floors, the consistency rule, and payout eligibility — the three
+calculations every prop-futures trader needs and most journals get subtly
+wrong. Bring your own numbers; this library has no opinion about any specific
+firm and bundles no firm data.
+"""
+
+from __future__ import annotations
+
+from .consistency import best_day_pct, consistency_ok, required_profit
+from .drawdown import cushion, drawdown_floor, is_blown
+from .target import (
+    EligibilityResult,
+    payout_eligibility,
+    target_reached,
+    target_remaining,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "drawdown_floor",
+    "is_blown",
+    "cushion",
+    "best_day_pct",
+    "consistency_ok",
+    "required_profit",
+    "target_remaining",
+    "target_reached",
+    "payout_eligibility",
+    "EligibilityResult",
+    "__version__",
+]

propfirm_calc-0.1.0/src/propfirm_calc/consistency.py

@@ -0,0 +1,49 @@
+"""Consistency-rule math.
+
+Most funded-trader firms cap how much of your *total* profit a single day may
+represent — e.g. a 50% consistency rule means your best day can be at most 50%
+of cumulative profit. The practical consequence traders miss: a big day raises
+the *total profit you must reach* before that day becomes withdrawable.
+"""
+
+from __future__ import annotations
+
+import math
+
+
+def best_day_pct(best_day_profit: float, total_profit: float) -> float:
+    """Best single day as a percentage of total profit.
+
+    Returns ``math.inf`` when ``total_profit`` is zero or negative, since the
+    consistency rule cannot be satisfied without positive total profit.
+    """
+    if total_profit <= 0:
+        return math.inf
+    return best_day_profit / total_profit * 100.0
+
+
+def consistency_ok(
+    best_day_profit: float, total_profit: float, consistency_pct: float
+) -> bool:
+    """True if the best day is within the consistency cap.
+
+    Requires positive total profit and ``best_day_pct <= consistency_pct``.
+    """
+    if total_profit <= 0:
+        return False
+    return best_day_pct(best_day_profit, total_profit) <= consistency_pct
+
+
+def required_profit(best_day_profit: float, consistency_pct: float) -> float:
+    """Minimum total profit at which ``best_day_profit`` satisfies the rule.
+
+    A day worth ``best_day_profit`` can only ever be ``consistency_pct`` of the
+    total, so it sets a floor on the profit you must reach:
+    ``best_day_profit / (consistency_pct / 100)``.
+
+    Raises:
+        ValueError: If ``consistency_pct`` is not positive.
+    """
+    if consistency_pct <= 0:
+        raise ValueError("consistency_pct must be a positive percentage")
+    return best_day_profit / (consistency_pct / 100.0)

propfirm_calc-0.1.0/src/propfirm_calc/drawdown.py

@@ -0,0 +1,101 @@
+"""Trailing / EOD-trailing / static drawdown math for funded-trader accounts.
+
+The number traders most often get wrong is the *current* drawdown floor — the
+equity level at which the account is breached ("blown"). It depends on the
+firm's drawdown regime:
+
+- ``"static"``        — a fixed floor at ``starting_balance - max_drawdown``
+                        that never moves.
+- ``"trailing"``      — the floor follows the account's highest equity point
+                        (including intraday peaks), so it trails *up* as you
+                        make new highs.
+- ``"eod_trailing"``  — identical math, but the peak is the highest
+                        *end-of-day* balance rather than the intraday high.
+                        The only difference is what you pass as ``peak_equity``.
+
+Most firms (Topstep, Apex, …) stop trailing once the floor reaches the starting
+balance: from then on the floor is *locked* and the account can never blow
+above break-even. That lock level is configurable via ``lock_at``.
+"""
+
+from __future__ import annotations
+
+_TRAILING = {"trailing", "eod_trailing"}
+_VALID = _TRAILING | {"static"}
+
+
+def drawdown_floor(
+    starting_balance: float,
+    max_drawdown: float,
+    peak_equity: float,
+    dd_type: str = "trailing",
+    lock_at: float | None = None,
+) -> float:
+    """Return the equity level at or below which the account is breached.
+
+    Args:
+        starting_balance: The account's starting balance.
+        max_drawdown: The maximum loss limit, as a positive dollar amount.
+        peak_equity: The high-water mark. For ``"trailing"`` pass the highest
+            equity ever touched (intraday included); for ``"eod_trailing"``
+            pass the highest end-of-day balance. Ignored for ``"static"``.
+        dd_type: One of ``"trailing"``, ``"eod_trailing"``, ``"static"``.
+        lock_at: The equity level at which a trailing floor stops rising and
+            locks. ``None`` (default) locks at ``starting_balance`` — the
+            common Topstep/Apex behavior. Pass ``math.inf`` for a floor that
+            never locks (keeps trailing forever).
+
+    Returns:
+        The drawdown floor as an equity level (not a distance).
+
+    Raises:
+        ValueError: If ``dd_type`` is unknown or ``max_drawdown`` is negative.
+    """
+    if dd_type not in _VALID:
+        raise ValueError(f"dd_type must be one of {sorted(_VALID)}, got {dd_type!r}")
+    if max_drawdown < 0:
+        raise ValueError("max_drawdown must be a positive dollar amount")
+
+    if dd_type == "static":
+        return starting_balance - max_drawdown
+
+    raw = peak_equity - max_drawdown
+    cap = starting_balance if lock_at is None else lock_at
+    return min(raw, cap)
+
+
+def is_blown(
+    current_equity: float,
+    starting_balance: float,
+    max_drawdown: float,
+    peak_equity: float,
+    dd_type: str = "trailing",
+    lock_at: float | None = None,
+) -> bool:
+    """True if ``current_equity`` has reached or fallen below the floor.
+
+    Touching the floor exactly counts as a breach (``<=``), matching how most
+    firms enforce their maximum loss limit.
+    """
+    floor = drawdown_floor(
+        starting_balance, max_drawdown, peak_equity, dd_type=dd_type, lock_at=lock_at
+    )
+    return current_equity <= floor
+
+
+def cushion(
+    current_equity: float,
+    starting_balance: float,
+    max_drawdown: float,
+    peak_equity: float,
+    dd_type: str = "trailing",
+    lock_at: float | None = None,
+) -> float:
+    """Dollars of room before the account blows.
+
+    Positive means safe; zero or negative means the floor has been reached.
+    """
+    floor = drawdown_floor(
+        starting_balance, max_drawdown, peak_equity, dd_type=dd_type, lock_at=lock_at
+    )
+    return current_equity - floor

propfirm_calc-0.1.0/src/propfirm_calc/target.py

@@ -0,0 +1,108 @@
+"""Profit-target progress and payout eligibility.
+
+``payout_eligibility`` combines the target, minimum-winning-days, and
+consistency checks into a single answer plus human-readable blockers. Pass
+only the constraints your firm imposes; anything left as ``None`` is skipped.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .consistency import best_day_pct, consistency_ok, required_profit
+
+
+def target_remaining(current_profit: float, profit_target: float) -> float:
+    """Dollars still needed to reach the profit target (never negative)."""
+    return max(0.0, profit_target - current_profit)
+
+
+def target_reached(current_profit: float, profit_target: float) -> bool:
+    """True once cumulative profit meets or exceeds the target."""
+    return current_profit >= profit_target
+
+
+@dataclass(frozen=True)
+class EligibilityResult:
+    """Outcome of :func:`payout_eligibility`.
+
+    ``*_met`` fields are ``None`` when that check was not requested.
+    """
+
+    eligible: bool
+    blockers: tuple[str, ...]
+    target_met: bool | None = None
+    days_met: bool | None = None
+    consistency_met: bool | None = None
+    profit_remaining: float | None = None
+    consistency_required_profit: float | None = None
+
+
+def payout_eligibility(
+    current_profit: float,
+    *,
+    profit_target: float | None = None,
+    winning_days: int | None = None,
+    min_winning_days: int | None = None,
+    best_day_profit: float | None = None,
+    consistency_pct: float | None = None,
+) -> EligibilityResult:
+    """Evaluate whether a funded account currently qualifies for a payout.
+
+    Only the constraints you supply are enforced. The result is ``eligible``
+    when no blockers remain.
+
+    Args:
+        current_profit: Cumulative net profit on the account.
+        profit_target: Profit target to clear, if the firm sets one.
+        winning_days / min_winning_days: Count of qualifying winning days and
+            the minimum required. Both must be given for the check to apply.
+        best_day_profit / consistency_pct: Largest single-day profit and the
+            consistency cap. Both must be given for the check to apply.
+    """
+    blockers: list[str] = []
+
+    target_met: bool | None = None
+    profit_remaining: float | None = None
+    if profit_target is not None:
+        target_met = target_reached(current_profit, profit_target)
+        profit_remaining = target_remaining(current_profit, profit_target)
+        if not target_met:
+            blockers.append(
+                f"Profit ${current_profit:,.0f} below target ${profit_target:,.0f} "
+                f"(${profit_remaining:,.0f} to go)"
+            )
+
+    days_met: bool | None = None
+    if winning_days is not None and min_winning_days is not None:
+        days_met = winning_days >= min_winning_days
+        if not days_met:
+            blockers.append(
+                f"{winning_days} of {min_winning_days} required winning days"
+            )
+
+    consistency_met: bool | None = None
+    consistency_required_profit: float | None = None
+    if best_day_profit is not None and consistency_pct is not None:
+        consistency_met = consistency_ok(
+            best_day_profit, current_profit, consistency_pct
+        )
+        consistency_required_profit = required_profit(
+            best_day_profit, consistency_pct
+        )
+        if not consistency_met:
+            pct = best_day_pct(best_day_profit, current_profit)
+            shown = "∞" if pct == float("inf") else f"{pct:.0f}%"
+            blockers.append(
+                f"Best day {shown} over the {consistency_pct:.0f}% consistency limit"
+            )
+
+    return EligibilityResult(
+        eligible=not blockers,
+        blockers=tuple(blockers),
+        target_met=target_met,
+        days_met=days_met,
+        consistency_met=consistency_met,
+        profit_remaining=profit_remaining,
+        consistency_required_profit=consistency_required_profit,
+    )

propfirm_calc-0.1.0/tests/test_consistency.py

@@ -0,0 +1,45 @@
+import math
+
+import pytest
+
+from propfirm_calc import best_day_pct, consistency_ok, required_profit
+
+
+class TestBestDayPct:
+    def test_basic_share(self):
+        assert best_day_pct(1_500, 3_000) == 50.0
+
+    def test_zero_total_is_infinite(self):
+        assert best_day_pct(500, 0) == math.inf
+
+    def test_negative_total_is_infinite(self):
+        assert best_day_pct(500, -200) == math.inf
+
+
+class TestConsistencyOk:
+    def test_within_cap_passes(self):
+        # Best day is 40% of total, under a 50% cap.
+        assert consistency_ok(2_000, 5_000, 50) is True
+
+    def test_at_cap_passes(self):
+        assert consistency_ok(2_500, 5_000, 50) is True
+
+    def test_over_cap_fails(self):
+        assert consistency_ok(3_000, 5_000, 50) is False
+
+    def test_zero_total_fails(self):
+        assert consistency_ok(0, 0, 50) is False
+
+
+class TestRequiredProfit:
+    def test_effective_target_floor(self):
+        # A $1,500 day under a 50% rule needs $3,000 total before it's clean.
+        assert required_profit(1_500, 50) == 3_000
+
+    def test_tighter_rule_needs_more(self):
+        # Same day under a 30% rule needs $5,000.
+        assert required_profit(1_500, 30) == pytest.approx(5_000)
+
+    def test_non_positive_pct_raises(self):
+        with pytest.raises(ValueError):
+            required_profit(1_500, 0)

propfirm_calc-0.1.0/tests/test_drawdown.py

@@ -0,0 +1,75 @@
+import math
+
+import pytest
+
+from propfirm_calc import cushion, drawdown_floor, is_blown
+
+
+class TestStatic:
+    def test_floor_is_fixed_at_start_minus_dd(self):
+        # A static $50k account with a $2k drawdown: floor never moves off 48k.
+        assert drawdown_floor(50_000, 2_000, peak_equity=60_000, dd_type="static") == 48_000
+
+    def test_peak_is_ignored_for_static(self):
+        low = drawdown_floor(50_000, 2_000, peak_equity=50_000, dd_type="static")
+        high = drawdown_floor(50_000, 2_000, peak_equity=99_000, dd_type="static")
+        assert low == high == 48_000
+
+
+class TestTrailing:
+    def test_floor_trails_the_peak_before_locking(self):
+        # Up $1k (peak 51k) on a 50k/2k account: floor = 51k - 2k = 49k, still
+        # below the 50k lock, so it trails.
+        assert drawdown_floor(50_000, 2_000, peak_equity=51_000) == 49_000
+
+    def test_floor_locks_at_starting_balance(self):
+        # Once peak - dd would exceed the start, the floor locks at start.
+        # peak 53k -> raw 51k, capped at 50k.
+        assert drawdown_floor(50_000, 2_000, peak_equity=53_000) == 50_000
+
+    def test_floor_at_exactly_the_lock_point(self):
+        # peak 52k -> raw 50k == start: locked exactly at start.
+        assert drawdown_floor(50_000, 2_000, peak_equity=52_000) == 50_000
+
+    def test_initial_floor_when_peak_equals_start(self):
+        assert drawdown_floor(50_000, 2_000, peak_equity=50_000) == 48_000
+
+    def test_custom_lock_level(self):
+        # A firm that locks the trail at start + $100 instead of start.
+        assert drawdown_floor(50_000, 2_000, peak_equity=53_000, lock_at=50_100) == 50_100
+
+    def test_never_locking_floor_keeps_trailing(self):
+        # lock_at=inf -> pure trailing, floor can rise into profit.
+        assert drawdown_floor(50_000, 2_000, peak_equity=60_000, lock_at=math.inf) == 58_000
+
+
+class TestEodTrailing:
+    def test_same_math_as_trailing_given_eod_peak(self):
+        # eod_trailing differs only in *which* peak you pass; the math matches.
+        intraday = drawdown_floor(100_000, 3_000, peak_equity=104_000, dd_type="trailing")
+        eod = drawdown_floor(100_000, 3_000, peak_equity=104_000, dd_type="eod_trailing")
+        assert intraday == eod == 100_000  # raw 101k capped at 100k start
+
+
+class TestIsBlownAndCushion:
+    def test_not_blown_with_room(self):
+        assert is_blown(49_500, 50_000, 2_000, peak_equity=51_000) is False
+        assert cushion(49_500, 50_000, 2_000, peak_equity=51_000) == 500
+
+    def test_blown_below_floor(self):
+        assert is_blown(48_900, 50_000, 2_000, peak_equity=51_000) is True
+
+    def test_touching_floor_exactly_is_a_breach(self):
+        floor = drawdown_floor(50_000, 2_000, peak_equity=51_000)  # 49_000
+        assert is_blown(floor, 50_000, 2_000, peak_equity=51_000) is True
+        assert cushion(floor, 50_000, 2_000, peak_equity=51_000) == 0
+
+
+class TestValidation:
+    def test_unknown_dd_type_raises(self):
+        with pytest.raises(ValueError):
+            drawdown_floor(50_000, 2_000, 50_000, dd_type="weird")
+
+    def test_negative_max_drawdown_raises(self):
+        with pytest.raises(ValueError):
+            drawdown_floor(50_000, -1, 50_000)

propfirm_calc-0.1.0/tests/test_target.py

@@ -0,0 +1,66 @@
+from propfirm_calc import payout_eligibility, target_reached, target_remaining
+
+
+class TestTarget:
+    def test_remaining_never_negative(self):
+        assert target_remaining(2_500, 3_000) == 500
+        assert target_remaining(4_000, 3_000) == 0
+
+    def test_reached(self):
+        assert target_reached(3_000, 3_000) is True
+        assert target_reached(2_999, 3_000) is False
+
+
+class TestPayoutEligibility:
+    def test_all_checks_pass(self):
+        r = payout_eligibility(
+            6_000,
+            profit_target=3_000,
+            winning_days=10,
+            min_winning_days=5,
+            best_day_profit=2_000,
+            consistency_pct=50,
+        )
+        assert r.eligible is True
+        assert r.blockers == ()
+        assert r.target_met is True
+        assert r.days_met is True
+        assert r.consistency_met is True
+
+    def test_target_blocker(self):
+        r = payout_eligibility(2_000, profit_target=3_000)
+        assert r.eligible is False
+        assert r.target_met is False
+        assert r.profit_remaining == 1_000
+        assert "below target" in r.blockers[0]
+
+    def test_winning_days_blocker(self):
+        r = payout_eligibility(5_000, winning_days=3, min_winning_days=5)
+        assert r.eligible is False
+        assert r.days_met is False
+        assert "3 of 5" in r.blockers[0]
+
+    def test_consistency_blocker_reports_required_profit(self):
+        r = payout_eligibility(4_000, best_day_profit=3_000, consistency_pct=50)
+        assert r.eligible is False
+        assert r.consistency_met is False
+        # $3k day under 50% needs $6k total before it's clean.
+        assert r.consistency_required_profit == 6_000
+        assert "consistency limit" in r.blockers[0]
+
+    def test_unrequested_checks_are_none(self):
+        r = payout_eligibility(5_000)
+        assert r.eligible is True
+        assert r.target_met is None
+        assert r.days_met is None
+        assert r.consistency_met is None
+
+    def test_multiple_blockers_accumulate(self):
+        r = payout_eligibility(
+            1_000,
+            profit_target=3_000,
+            winning_days=2,
+            min_winning_days=5,
+        )
+        assert r.eligible is False
+        assert len(r.blockers) == 2