laytime 0.1.0__tar.gz

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

@@ -0,0 +1,23 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: uv sync --group dev
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+      - run: uv run pytest -q
+      - run: uv build

laytime-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.DS_Store

laytime-0.1.0/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 0.1.0 — 2026-09-03
+
+First public release. Extracted unchanged from the laytime engine that has run
+inside [MarOps](https://zdeck.tech/case-study-marops.html) since Phase 0.
+
+- `compute_laytime(basis)`: SHINC / SHEX / WWD, `unless used`, holidays,
+  NOR-to-start offset, fixed days or cargo ÷ rate allowance, explicit
+  interruption records, once-on-demurrage with charter-party override,
+  half or full despatch on working time saved or all time saved,
+  reversible or per-port laytime.
+- `laytime` command line: JSON basis in, JSON result out.
+- Golden test suite with hand-verified expected values.

laytime-0.1.0/LICENSE

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

laytime-0.1.0/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.5
+Name: laytime
+Version: 0.1.0
+Summary: GENCON-style laytime, demurrage and despatch calculator for dry-bulk voyage charters
+Project-URL: Homepage, https://github.com/oktaybobus/laytime
+Project-URL: Issues, https://github.com/oktaybobus/laytime/issues
+Project-URL: Case study, https://zdeck.tech/case-study-marops.html
+Author: Ali Oktay
+License-Expression: MIT
+License-File: LICENSE
+Keywords: charter party,demurrage,despatch,gencon,laytime,maritime,shipping
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Other Audience
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# laytime
+
+GENCON-style laytime, demurrage and despatch calculator for dry-bulk voyage
+charters. One pure function, no dependencies, no floats.
+
+```python
+from laytime import compute_laytime
+
+result = compute_laytime(basis)
+result["net_amount"]  # "8000.00"  (positive: demurrage due; negative: despatch due)
+```
+
+The engine was extracted unchanged from [MarOps](https://zdeck.tech/case-study-marops.html),
+a back-office system for small shipowners, where it has produced every laytime
+statement since the first release. It is published so that the calculation can
+be read, checked and re-run by anyone who receives one of those statements.
+
+## Install
+
+```bash
+pip install laytime
+```
+
+Python 3.12 or newer. No runtime dependencies.
+
+## Command line
+
+```bash
+laytime basis.json            # pretty JSON result
+laytime basis.json --compact  # one line
+cat basis.json | laytime -    # from stdin
+```
+
+Exit code 1 and a message naming the missing field when the basis is
+incomplete; the engine never guesses a value.
+
+## The basis
+
+Everything the calculation needs is in one JSON document. Store it next to the
+result: replaying the same basis gives the same result, which is what you want
+when the claim is disputed months later.
+
+```json
+{
+  "cp": {
+    "laytime_basis": "SHEX",
+    "unless_used": false,
+    "reversible": false,
+    "nor_to_start_hours": 12,
+    "holidays": ["2026-03-03"],
+    "demurrage_rate_per_day": "8000",
+    "currency": "USD",
+    "despatch_fraction": "half",
+    "despatch_on": "working_time_saved",
+    "interruptions_count_on_demurrage": false
+  },
+  "ports": [
+    {
+      "name": "Samsun",
+      "purpose": "loading",
+      "nor_tendered": "2026-03-01T06:00",
+      "nor_accepted": "2026-03-01T06:00",
+      "completed_at": "2026-03-06T06:00",
+      "allowed": {"kind": "rate", "cargo_qty": "6000", "rate_per_day": "2000"},
+      "interruptions": [
+        {"from": "2026-03-02T06:00", "to": "2026-03-02T18:00", "reason": "rain"}
+      ]
+    }
+  ]
+}
+```
+
+### `cp` — charter-party terms
+
+| Field | Values | Meaning |
+|---|---|---|
+| `laytime_basis` | `SHINC`, `SHEX`, `WWD` | `SHINC` counts every hour. `SHEX` and `WWD` skip Sundays and `holidays`. Weather stoppages are explicit interruptions, so `WWD` behaves like `SHEX` inside the engine. |
+| `unless_used` | bool | Excepted days count anyway; idle time on them is deducted through interruptions. |
+| `reversible` | bool | Pool the allowance of all ports into one ledger (time saved at loading carries to discharge) instead of settling each port on its own. |
+| `nor_to_start_hours` | int | Hours between NOR acceptance and the start of laytime. |
+| `holidays` | list of `YYYY-MM-DD` | Local-calendar holidays treated like Sundays. |
+| `demurrage_rate_per_day` | decimal string | Per day, pro rata. |
+| `currency` | string | Echoed into the result. |
+| `despatch_fraction` | `half`, `full` | Half despatch is the dry-bulk default. |
+| `despatch_on` | `working_time_saved`, `all_time_saved` | Under SHEX, all-time-saved projects the unused allowance across the calendar, Sundays included. |
+| `interruptions_count_on_demurrage` | bool | Default `false`: *once on demurrage, always on demurrage*. Set `true` only when the charter party says interruptions are deducted after demurrage starts. |
+
+### `ports[]`
+
+| Field | Meaning |
+|---|---|
+| `name`, `purpose` | Free text; `purpose` is echoed, not interpreted. |
+| `nor_tendered`, `nor_accepted` | Port-local naive ISO 8601. `nor_accepted` wins when both are present. |
+| `completed_at` | End of cargo operations. |
+| `allowed` | `{"kind": "fixed_days", "days": "2"}` or `{"kind": "rate", "cargo_qty": "6000", "rate_per_day": "2000"}`. |
+| `interruptions[]` | Explicit `from`/`to`/`reason` records: rain, shifting, breakdown, waiting. There is no "deduct N hours" shortcut; every deduction has a start and an end. |
+
+All timestamps are **port local time**, naive. Sunday and holiday exclusions
+are applied on the local calendar day. Convert from UTC before building the
+basis; the engine does not know about time zones on purpose.
+
+## The result
+
+```json
+{
+  "reversible": false,
+  "laytime_basis": "SHEX",
+  "allowed_days": "3.00000",
+  "used_days": "3.00000",
+  "demurrage_days": "1.00000",
+  "despatch_days": "0.00000",
+  "demurrage_amount": "8000.00",
+  "despatch_amount": "0.00",
+  "net_amount": "8000.00",
+  "currency": "USD",
+  "ports": [
+    {
+      "name": "Samsun",
+      "laytime_start": "2026-03-01T18:00",
+      "completed_at": "2026-03-06T06:00",
+      "used_days": "3.00000",
+      "demurrage_start": "2026-03-05T06:00",
+      "demurrage_days": "1.00000",
+      "allowed_days": "3.00000",
+      "despatch_days": "0.00000"
+    }
+  ]
+}
+```
+
+Days are strings with five decimals, money is a string with two decimals,
+both rounded half-up from exact `Decimal` arithmetic on whole seconds. Nothing
+in the result is a float. Under `reversible: true` the per-port rows omit
+`allowed_days` and `despatch_days` because those only exist for the pool.
+
+## Rules the engine commits to
+
+- **Once on demurrage, always on demurrage.** After the allowance is
+  exhausted nothing is deducted, unless `interruptions_count_on_demurrage`
+  says the charter party carves out an exception.
+- **Deductions are records, not numbers.** Every interruption has a start and
+  an end. Overlapping interruptions and excepted days are merged before
+  counting, so a rain stoppage on a Sunday is not deducted twice.
+- **Half despatch by default**, on working time saved by default.
+- **No time zones.** The basis is port-local; the caller converts.
+- **No guessing.** A missing field raises `KeyError` rather than defaulting.
+
+## Golden tests
+
+`tests/test_golden.py` pins every rule to a hand-verified example. The policy
+is simple: a golden test is never fixed by updating the expected value. If a
+change to the engine makes one fail, the engine is wrong or the rule has
+changed, and the second case needs a new test with its own hand-verified
+number.
+
+## Scope
+
+GENCON-type voyage charters only. Time charter, hire and off-hire are out of
+scope, as are SOF parsing, PDF statements and charter-party text
+interpretation; those live in the applications that use this package.
+
+## License
+
+MIT.

laytime-0.1.0/README.md

@@ -0,0 +1,164 @@
+# laytime
+
+GENCON-style laytime, demurrage and despatch calculator for dry-bulk voyage
+charters. One pure function, no dependencies, no floats.
+
+```python
+from laytime import compute_laytime
+
+result = compute_laytime(basis)
+result["net_amount"]  # "8000.00"  (positive: demurrage due; negative: despatch due)
+```
+
+The engine was extracted unchanged from [MarOps](https://zdeck.tech/case-study-marops.html),
+a back-office system for small shipowners, where it has produced every laytime
+statement since the first release. It is published so that the calculation can
+be read, checked and re-run by anyone who receives one of those statements.
+
+## Install
+
+```bash
+pip install laytime
+```
+
+Python 3.12 or newer. No runtime dependencies.
+
+## Command line
+
+```bash
+laytime basis.json            # pretty JSON result
+laytime basis.json --compact  # one line
+cat basis.json | laytime -    # from stdin
+```
+
+Exit code 1 and a message naming the missing field when the basis is
+incomplete; the engine never guesses a value.
+
+## The basis
+
+Everything the calculation needs is in one JSON document. Store it next to the
+result: replaying the same basis gives the same result, which is what you want
+when the claim is disputed months later.
+
+```json
+{
+  "cp": {
+    "laytime_basis": "SHEX",
+    "unless_used": false,
+    "reversible": false,
+    "nor_to_start_hours": 12,
+    "holidays": ["2026-03-03"],
+    "demurrage_rate_per_day": "8000",
+    "currency": "USD",
+    "despatch_fraction": "half",
+    "despatch_on": "working_time_saved",
+    "interruptions_count_on_demurrage": false
+  },
+  "ports": [
+    {
+      "name": "Samsun",
+      "purpose": "loading",
+      "nor_tendered": "2026-03-01T06:00",
+      "nor_accepted": "2026-03-01T06:00",
+      "completed_at": "2026-03-06T06:00",
+      "allowed": {"kind": "rate", "cargo_qty": "6000", "rate_per_day": "2000"},
+      "interruptions": [
+        {"from": "2026-03-02T06:00", "to": "2026-03-02T18:00", "reason": "rain"}
+      ]
+    }
+  ]
+}
+```
+
+### `cp` — charter-party terms
+
+| Field | Values | Meaning |
+|---|---|---|
+| `laytime_basis` | `SHINC`, `SHEX`, `WWD` | `SHINC` counts every hour. `SHEX` and `WWD` skip Sundays and `holidays`. Weather stoppages are explicit interruptions, so `WWD` behaves like `SHEX` inside the engine. |
+| `unless_used` | bool | Excepted days count anyway; idle time on them is deducted through interruptions. |
+| `reversible` | bool | Pool the allowance of all ports into one ledger (time saved at loading carries to discharge) instead of settling each port on its own. |
+| `nor_to_start_hours` | int | Hours between NOR acceptance and the start of laytime. |
+| `holidays` | list of `YYYY-MM-DD` | Local-calendar holidays treated like Sundays. |
+| `demurrage_rate_per_day` | decimal string | Per day, pro rata. |
+| `currency` | string | Echoed into the result. |
+| `despatch_fraction` | `half`, `full` | Half despatch is the dry-bulk default. |
+| `despatch_on` | `working_time_saved`, `all_time_saved` | Under SHEX, all-time-saved projects the unused allowance across the calendar, Sundays included. |
+| `interruptions_count_on_demurrage` | bool | Default `false`: *once on demurrage, always on demurrage*. Set `true` only when the charter party says interruptions are deducted after demurrage starts. |
+
+### `ports[]`
+
+| Field | Meaning |
+|---|---|
+| `name`, `purpose` | Free text; `purpose` is echoed, not interpreted. |
+| `nor_tendered`, `nor_accepted` | Port-local naive ISO 8601. `nor_accepted` wins when both are present. |
+| `completed_at` | End of cargo operations. |
+| `allowed` | `{"kind": "fixed_days", "days": "2"}` or `{"kind": "rate", "cargo_qty": "6000", "rate_per_day": "2000"}`. |
+| `interruptions[]` | Explicit `from`/`to`/`reason` records: rain, shifting, breakdown, waiting. There is no "deduct N hours" shortcut; every deduction has a start and an end. |
+
+All timestamps are **port local time**, naive. Sunday and holiday exclusions
+are applied on the local calendar day. Convert from UTC before building the
+basis; the engine does not know about time zones on purpose.
+
+## The result
+
+```json
+{
+  "reversible": false,
+  "laytime_basis": "SHEX",
+  "allowed_days": "3.00000",
+  "used_days": "3.00000",
+  "demurrage_days": "1.00000",
+  "despatch_days": "0.00000",
+  "demurrage_amount": "8000.00",
+  "despatch_amount": "0.00",
+  "net_amount": "8000.00",
+  "currency": "USD",
+  "ports": [
+    {
+      "name": "Samsun",
+      "laytime_start": "2026-03-01T18:00",
+      "completed_at": "2026-03-06T06:00",
+      "used_days": "3.00000",
+      "demurrage_start": "2026-03-05T06:00",
+      "demurrage_days": "1.00000",
+      "allowed_days": "3.00000",
+      "despatch_days": "0.00000"
+    }
+  ]
+}
+```
+
+Days are strings with five decimals, money is a string with two decimals,
+both rounded half-up from exact `Decimal` arithmetic on whole seconds. Nothing
+in the result is a float. Under `reversible: true` the per-port rows omit
+`allowed_days` and `despatch_days` because those only exist for the pool.
+
+## Rules the engine commits to
+
+- **Once on demurrage, always on demurrage.** After the allowance is
+  exhausted nothing is deducted, unless `interruptions_count_on_demurrage`
+  says the charter party carves out an exception.
+- **Deductions are records, not numbers.** Every interruption has a start and
+  an end. Overlapping interruptions and excepted days are merged before
+  counting, so a rain stoppage on a Sunday is not deducted twice.
+- **Half despatch by default**, on working time saved by default.
+- **No time zones.** The basis is port-local; the caller converts.
+- **No guessing.** A missing field raises `KeyError` rather than defaulting.
+
+## Golden tests
+
+`tests/test_golden.py` pins every rule to a hand-verified example. The policy
+is simple: a golden test is never fixed by updating the expected value. If a
+change to the engine makes one fail, the engine is wrong or the rule has
+changed, and the second case needs a new test with its own hand-verified
+number.
+
+## Scope
+
+GENCON-type voyage charters only. Time charter, hire and off-hire are out of
+scope, as are SOF parsing, PDF statements and charter-party text
+interpretation; those live in the applications that use this package.
+
+## License
+
+MIT.

laytime-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "laytime"
+version = "0.1.0"
+description = "GENCON-style laytime, demurrage and despatch calculator for dry-bulk voyage charters"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [{ name = "Ali Oktay" }]
+keywords = ["laytime", "demurrage", "despatch", "gencon", "shipping", "charter party", "maritime"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Other Audience",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/oktaybobus/laytime"
+Issues = "https://github.com/oktaybobus/laytime/issues"
+"Case study" = "https://zdeck.tech/case-study-marops.html"
+
+[project.scripts]
+laytime = "laytime.cli:main"
+
+[dependency-groups]
+dev = ["pytest>=8", "ruff>=0.6"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/laytime"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "UP", "B", "T20"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

laytime-0.1.0/src/laytime/__init__.py

@@ -0,0 +1,12 @@
+"""GENCON-style laytime, demurrage and despatch calculator.
+
+The public surface is one pure function, ``compute_laytime``. It takes a
+``basis`` mapping (charter-party terms plus one entry per port) and returns a
+``result`` mapping. Nothing is read from or written to any external system, so
+the same basis produces the same result whenever it is replayed.
+"""
+
+from .engine import compute_laytime
+
+__all__ = ["compute_laytime", "__version__"]
+__version__ = "0.1.0"

laytime-0.1.0/src/laytime/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

laytime-0.1.0/src/laytime/cli.py

@@ -0,0 +1,42 @@
+"""``laytime`` command line: JSON basis in, JSON result out."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import __version__
+from .engine import compute_laytime
+
+
+def _read(path: str) -> dict:
+    if path == "-":
+        return json.load(sys.stdin)
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="laytime",
+        description="Compute laytime, demurrage and despatch from a JSON basis file.",
+    )
+    parser.add_argument("basis", help="path to a basis JSON file, or '-' for stdin")
+    parser.add_argument("--compact", action="store_true", help="single-line JSON output")
+    parser.add_argument("--version", action="version", version=f"laytime {__version__}")
+    args = parser.parse_args(argv)
+
+    try:
+        basis = _read(args.basis)
+    except (OSError, json.JSONDecodeError) as exc:
+        parser.exit(2, f"laytime: cannot read basis: {exc}\n")
+
+    try:
+        result = compute_laytime(basis)
+    except KeyError as exc:
+        parser.exit(1, f"laytime: missing field {exc} in basis\n")
+
+    indent = None if args.compact else 2
+    sys.stdout.write(json.dumps(result, indent=indent, ensure_ascii=False) + "\n")
+    return 0

laytime-0.1.0/src/laytime/engine.py

@@ -0,0 +1,290 @@
+"""GENCON laytime engine.
+
+Pure function: input is a ``basis`` dict, output is a ``result`` dict. No I/O,
+no clocks, no randomness. The same basis gives the same result six months
+later; in a dispute the stored basis is the evidence.
+
+Time convention: every timestamp in the basis is PORT LOCAL time as a naive
+ISO 8601 string (``2026-03-01T06:00``). Sunday and holiday exclusions are
+applied on the local calendar day.
+
+Counting regimes (``cp.laytime_basis``):
+
+- ``SHINC``: every hour counts.
+- ``SHEX`` / ``WWD``: Sundays and the days listed in ``cp.holidays`` do not
+  count. Weather and other stoppages are explicit interruption records, so
+  ``WWD`` behaves like ``SHEX`` inside the engine.
+- ``cp.unless_used``: excepted days do count (the ship is assumed to have
+  worked); idle periods are then deducted through interruption records.
+
+Demurrage: once the allowed time is exhausted every hour counts from that
+moment on (*once on demurrage, always on demurrage*). If the charter party
+says otherwise, ``cp.interruptions_count_on_demurrage`` keeps deducting
+interruption records after demurrage has started.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from datetime import date, datetime, time, timedelta
+from decimal import ROUND_HALF_UP, Decimal
+
+DAY_SECONDS = Decimal(86400)
+EXCLUDING_BASES = frozenset({"SHEX", "WWD"})
+
+Interval = tuple[datetime, datetime]
+
+
+def _dt(value: str) -> datetime:
+    return datetime.fromisoformat(value)
+
+
+def _iso(value: datetime) -> str:
+    return value.isoformat(timespec="minutes")
+
+
+def _secs(delta: timedelta) -> int:
+    return int(delta.total_seconds())
+
+
+def _days(seconds: int) -> str:
+    return str((Decimal(seconds) / DAY_SECONDS).quantize(Decimal("0.00001"), ROUND_HALF_UP))
+
+
+def _money(seconds: int, rate_per_day: Decimal) -> Decimal:
+    amount = Decimal(seconds) * rate_per_day / DAY_SECONDS
+    return amount.quantize(Decimal("0.01"), ROUND_HALF_UP)
+
+
+def _merge(intervals: Iterable[Interval]) -> list[Interval]:
+    ordered = sorted((s, e) for s, e in intervals if e > s)
+    merged: list[Interval] = []
+    for start, end in ordered:
+        if merged and start <= merged[-1][1]:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], end))
+        else:
+            merged.append((start, end))
+    return merged
+
+
+def _clip(intervals: Iterable[Interval], lo: datetime, hi: datetime) -> list[Interval]:
+    clipped: list[Interval] = []
+    for start, end in intervals:
+        s, e = max(start, lo), min(end, hi)
+        if s < e:
+            clipped.append((s, e))
+    return clipped
+
+
+def _is_excepted_day(day: date, holidays: set[str]) -> bool:
+    return day.weekday() == 6 or day.isoformat() in holidays
+
+
+def _excepted_day_intervals(lo: datetime, hi: datetime, holidays: set[str]) -> list[Interval]:
+    intervals: list[Interval] = []
+    day = lo.date()
+    while day <= hi.date():
+        if _is_excepted_day(day, holidays):
+            start = datetime.combine(day, time.min)
+            intervals.append((start, start + timedelta(days=1)))
+        day += timedelta(days=1)
+    return intervals
+
+
+def _countable_segments(
+    lo: datetime, hi: datetime, exclusions: Iterable[Interval]
+) -> list[Interval]:
+    merged = _merge(_clip(exclusions, lo, hi))
+    segments: list[Interval] = []
+    cursor = lo
+    for start, end in merged:
+        if start > cursor:
+            segments.append((cursor, start))
+        cursor = max(cursor, end)
+    if cursor < hi:
+        segments.append((cursor, hi))
+    return segments
+
+
+def _overlap_seconds(intervals: Iterable[Interval], lo: datetime, hi: datetime) -> int:
+    return sum(_secs(e - s) for s, e in _merge(_clip(intervals, lo, hi)))
+
+
+def _allowed_seconds(allowed: dict) -> int:
+    if allowed["kind"] == "fixed_days":
+        days = Decimal(str(allowed["days"]))
+    else:
+        days = Decimal(str(allowed["cargo_qty"])) / Decimal(str(allowed["rate_per_day"]))
+    return int((days * DAY_SECONDS).quantize(Decimal("1"), ROUND_HALF_UP))
+
+
+def _prepare_port(port: dict, cp: dict) -> dict:
+    nor = port.get("nor_accepted") or port["nor_tendered"]
+    start = _dt(nor) + timedelta(hours=cp.get("nor_to_start_hours", 0))
+    end = _dt(port["completed_at"])
+    start = min(start, end)
+
+    interruptions = [(_dt(item["from"]), _dt(item["to"])) for item in port.get("interruptions", [])]
+    exclusions = list(interruptions)
+    holidays = set(cp.get("holidays", []))
+    if cp["laytime_basis"] in EXCLUDING_BASES and not cp.get("unless_used", False):
+        exclusions += _excepted_day_intervals(start, end, holidays)
+
+    return {
+        "name": port["name"],
+        "start": start,
+        "end": end,
+        "interruptions": interruptions,
+        "exclusions": exclusions,
+        "allowed_seconds": _allowed_seconds(port["allowed"]),
+    }
+
+
+def _run_ledger(windows: list[dict], allowed_seconds: int, cp: dict):
+    counted = 0
+    demurrage_seconds = 0
+    demurrage_start: datetime | None = None
+    per_window: list[dict] = []
+
+    for window in windows:
+        w_counted = 0
+        w_demurrage = 0
+        w_demurrage_start: datetime | None = None
+
+        if demurrage_start is None:
+            for seg_start, seg_end in _countable_segments(
+                window["start"], window["end"], window["exclusions"]
+            ):
+                seg = _secs(seg_end - seg_start)
+                if counted + seg >= allowed_seconds:
+                    offset = allowed_seconds - counted
+                    moment = seg_start + timedelta(seconds=offset)
+                    w_counted += offset
+                    counted = allowed_seconds
+                    demurrage_start = moment
+                    w_demurrage_start = moment
+                    w_demurrage = _secs(window["end"] - moment)
+                    if cp.get("interruptions_count_on_demurrage", False):
+                        w_demurrage -= _overlap_seconds(
+                            window["interruptions"], moment, window["end"]
+                        )
+                    demurrage_seconds += w_demurrage
+                    break
+                counted += seg
+                w_counted += seg
+        else:
+            w_demurrage = _secs(window["end"] - window["start"])
+            if cp.get("interruptions_count_on_demurrage", False):
+                w_demurrage -= _overlap_seconds(
+                    window["interruptions"], window["start"], window["end"]
+                )
+            demurrage_seconds += w_demurrage
+
+        per_window.append(
+            {
+                "name": window["name"],
+                "laytime_start": _iso(window["start"]),
+                "completed_at": _iso(window["end"]),
+                "used_days": _days(w_counted),
+                "demurrage_start": _iso(w_demurrage_start) if w_demurrage_start else None,
+                "demurrage_days": _days(w_demurrage),
+            }
+        )
+
+    return counted, demurrage_seconds, demurrage_start, per_window
+
+
+def _project_expiry(start: datetime, remaining_seconds: int, cp: dict) -> datetime:
+    """Where the unused allowance would have expired on the calendar.
+
+    Needed for ``despatch_on = all_time_saved`` under SHEX: the saved time
+    includes the Sundays and holidays the ship would otherwise have sat through.
+    """
+    excluding = cp["laytime_basis"] in EXCLUDING_BASES and not cp.get("unless_used", False)
+    holidays = set(cp.get("holidays", []))
+    cursor = start
+    remaining = remaining_seconds
+    while remaining > 0:
+        if excluding and _is_excepted_day(cursor.date(), holidays):
+            cursor = datetime.combine(cursor.date() + timedelta(days=1), time.min)
+            continue
+        next_midnight = datetime.combine(cursor.date() + timedelta(days=1), time.min)
+        chunk = min(remaining, _secs(next_midnight - cursor))
+        cursor += timedelta(seconds=chunk)
+        remaining -= chunk
+    return cursor
+
+
+def _settle(counted, allowed, demurrage_seconds, demurrage_start, last_end, cp, rate):
+    despatch_seconds = 0
+    if demurrage_start is None and counted < allowed:
+        remaining = allowed - counted
+        if cp.get("despatch_on", "working_time_saved") == "all_time_saved":
+            despatch_seconds = _secs(_project_expiry(last_end, remaining, cp) - last_end)
+        else:
+            despatch_seconds = remaining
+
+    fraction = Decimal("0.5") if cp.get("despatch_fraction", "half") == "half" else Decimal("1")
+    demurrage_amount = _money(demurrage_seconds, rate)
+    despatch_amount = _money(despatch_seconds, rate * fraction)
+    return despatch_seconds, demurrage_amount, despatch_amount
+
+
+def compute_laytime(basis: dict) -> dict:
+    """Compute laytime used, demurrage and despatch for one voyage charter.
+
+    See the module docstring and README for the ``basis`` schema. Raises
+    ``KeyError`` when a required field is missing; the engine never guesses.
+    """
+    cp = basis["cp"]
+    rate = Decimal(str(cp["demurrage_rate_per_day"]))
+    windows = [_prepare_port(port, cp) for port in basis["ports"]]
+
+    ports_out: list[dict] = []
+    total_allowed = 0
+    total_counted = 0
+    total_demurrage = 0
+    total_despatch = 0
+    demurrage_amount = Decimal("0")
+    despatch_amount = Decimal("0")
+
+    if cp.get("reversible", False):
+        total_allowed = sum(w["allowed_seconds"] for w in windows)
+        counted, dem_secs, dem_start, ports_out = _run_ledger(windows, total_allowed, cp)
+        total_counted, total_demurrage = counted, dem_secs
+        despatch_secs, demurrage_amount, despatch_amount = _settle(
+            counted, total_allowed, dem_secs, dem_start, windows[-1]["end"], cp, rate
+        )
+        total_despatch = despatch_secs
+    else:
+        for window in windows:
+            allowed = window["allowed_seconds"]
+            counted, dem_secs, dem_start, port_rows = _run_ledger([window], allowed, cp)
+            despatch_secs, dem_amount, desp_amount = _settle(
+                counted, allowed, dem_secs, dem_start, window["end"], cp, rate
+            )
+            row = port_rows[0]
+            row["allowed_days"] = _days(allowed)
+            row["despatch_days"] = _days(despatch_secs)
+            ports_out.append(row)
+            total_allowed += allowed
+            total_counted += counted
+            total_demurrage += dem_secs
+            total_despatch += despatch_secs
+            demurrage_amount += dem_amount
+            despatch_amount += desp_amount
+
+    net = demurrage_amount - despatch_amount
+    return {
+        "reversible": bool(cp.get("reversible", False)),
+        "laytime_basis": cp["laytime_basis"],
+        "allowed_days": _days(total_allowed),
+        "used_days": _days(total_counted),
+        "demurrage_days": _days(total_demurrage),
+        "despatch_days": _days(total_despatch),
+        "demurrage_amount": str(demurrage_amount),
+        "despatch_amount": str(despatch_amount),
+        "net_amount": str(net),
+        "currency": cp.get("currency", "USD"),
+        "ports": ports_out,
+    }

laytime-0.1.0/tests/test_cli.py

@@ -0,0 +1,65 @@
+import json
+
+import pytest
+
+from laytime.cli import main
+
+BASIS = {
+    "cp": {
+        "laytime_basis": "SHEX",
+        "demurrage_rate_per_day": "6000",
+        "currency": "USD",
+        "despatch_fraction": "half",
+        "despatch_on": "working_time_saved",
+        "nor_to_start_hours": 0,
+        "holidays": [],
+    },
+    "ports": [
+        {
+            "name": "Samsun",
+            "purpose": "loading",
+            "nor_tendered": "2026-03-02T08:00",
+            "nor_accepted": "2026-03-02T08:00",
+            "completed_at": "2026-03-04T08:00",
+            "allowed": {"kind": "fixed_days", "days": "6"},
+            "interruptions": [],
+        }
+    ],
+}
+
+
+def test_cli_reads_file_and_prints_result(tmp_path, capsys):
+    path = tmp_path / "basis.json"
+    path.write_text(json.dumps(BASIS), encoding="utf-8")
+
+    assert main([str(path), "--compact"]) == 0
+
+    out = json.loads(capsys.readouterr().out)
+    assert out["despatch_amount"] == "12000.00"
+    assert out["net_amount"] == "-12000.00"
+
+
+def test_cli_reads_stdin(monkeypatch, capsys):
+    import io
+
+    monkeypatch.setattr("sys.stdin", io.StringIO(json.dumps(BASIS)))
+    assert main(["-"]) == 0
+    assert '"despatch_days": "4.00000"' in capsys.readouterr().out
+
+
+def test_cli_reports_missing_field(tmp_path, capsys):
+    broken = {"cp": {"laytime_basis": "SHINC"}, "ports": []}
+    path = tmp_path / "broken.json"
+    path.write_text(json.dumps(broken), encoding="utf-8")
+
+    with pytest.raises(SystemExit) as exc:
+        main([str(path)])
+    assert exc.value.code == 1
+    assert "demurrage_rate_per_day" in capsys.readouterr().err
+
+
+def test_cli_reports_unreadable_file(tmp_path, capsys):
+    with pytest.raises(SystemExit) as exc:
+        main([str(tmp_path / "missing.json")])
+    assert exc.value.code == 2
+    assert "cannot read basis" in capsys.readouterr().err

laytime-0.1.0/tests/test_golden.py

@@ -0,0 +1,245 @@
+"""Golden laytime tests.
+
+Every expected value was verified by hand against the charter-party rule it
+exercises. If the engine changes and one of these fails, the engine is wrong;
+these tests are never "fixed" by updating the expected value.
+
+Calendar anchor: 2026-03-01 is a Sunday; 02 Mon, 08 Sun, 09 Mon.
+"""
+
+import pytest
+
+from laytime import compute_laytime
+
+
+def basis(cp_extra=None, ports=None):
+    cp = {
+        "laytime_basis": "SHINC",
+        "unless_used": False,
+        "reversible": False,
+        "demurrage_rate_per_day": "8000",
+        "currency": "USD",
+        "despatch_fraction": "half",
+        "despatch_on": "working_time_saved",
+        "nor_to_start_hours": 0,
+        "holidays": [],
+    }
+    cp.update(cp_extra or {})
+    return {"cp": cp, "ports": ports or []}
+
+
+def port(name="Samsun", nor="2026-03-02T08:00", completed="2026-03-04T08:00", **kwargs):
+    data = {
+        "name": name,
+        "purpose": "loading",
+        "nor_tendered": nor,
+        "nor_accepted": nor,
+        "completed_at": completed,
+        "allowed": {"kind": "fixed_days", "days": "2"},
+        "interruptions": [],
+    }
+    data.update(kwargs)
+    return data
+
+
+def test_golden_demurrage_shinc_with_interruption():
+    """6000 mt at 2000 mt/day = 3 days allowed; a 12 h rain stoppage shifts the count."""
+    result = compute_laytime(
+        basis(
+            {"nor_to_start_hours": 12},
+            [
+                port(
+                    nor="2026-03-01T06:00",
+                    completed="2026-03-06T06:00",
+                    allowed={"kind": "rate", "cargo_qty": "6000", "rate_per_day": "2000"},
+                    interruptions=[
+                        {"from": "2026-03-02T06:00", "to": "2026-03-02T18:00", "reason": "rain"}
+                    ],
+                )
+            ],
+        )
+    )
+    assert result["allowed_days"] == "3.00000"
+    assert result["used_days"] == "3.00000"
+    assert result["ports"][0]["laytime_start"] == "2026-03-01T18:00"
+    assert result["ports"][0]["demurrage_start"] == "2026-03-05T06:00"
+    assert result["demurrage_days"] == "1.00000"
+    assert result["demurrage_amount"] == "8000.00"
+    assert result["despatch_amount"] == "0.00"
+    assert result["net_amount"] == "8000.00"
+
+
+def test_golden_despatch_shex_half():
+    """6 days allowed, done in 2; WTS saves 4 days, ATS skips the Sunday and saves 5."""
+    common_port = port(completed="2026-03-04T08:00", allowed={"kind": "fixed_days", "days": "6"})
+
+    wts = compute_laytime(
+        basis({"laytime_basis": "SHEX", "demurrage_rate_per_day": "6000"}, [common_port])
+    )
+    assert wts["used_days"] == "2.00000"
+    assert wts["despatch_days"] == "4.00000"
+    assert wts["despatch_amount"] == "12000.00"
+    assert wts["demurrage_amount"] == "0.00"
+    assert wts["net_amount"] == "-12000.00"
+
+    ats = compute_laytime(
+        basis(
+            {
+                "laytime_basis": "SHEX",
+                "demurrage_rate_per_day": "6000",
+                "despatch_on": "all_time_saved",
+            },
+            [common_port],
+        )
+    )
+    assert ats["despatch_days"] == "5.00000"
+    assert ats["despatch_amount"] == "15000.00"
+
+
+def test_golden_once_on_demurrage():
+    """After demurrage starts neither rain nor Sunday is deducted."""
+    rain_after = {"from": "2026-03-04T10:00", "to": "2026-03-04T16:00", "reason": "rain"}
+    result = compute_laytime(
+        basis(
+            {"laytime_basis": "SHEX"},
+            [
+                port(
+                    completed="2026-03-09T08:00",
+                    allowed={"kind": "fixed_days", "days": "1"},
+                    interruptions=[rain_after],
+                )
+            ],
+        )
+    )
+    assert result["ports"][0]["demurrage_start"] == "2026-03-03T08:00"
+    assert result["demurrage_days"] == "6.00000"
+    assert result["demurrage_amount"] == "48000.00"
+
+
+def test_same_rain_before_demurrage_does_reduce():
+    result = compute_laytime(
+        basis(
+            {"laytime_basis": "SHEX"},
+            [
+                port(
+                    completed="2026-03-09T08:00",
+                    allowed={"kind": "fixed_days", "days": "1"},
+                    interruptions=[
+                        {"from": "2026-03-02T10:00", "to": "2026-03-02T16:00", "reason": "rain"}
+                    ],
+                )
+            ],
+        )
+    )
+    assert result["ports"][0]["demurrage_start"] == "2026-03-03T14:00"
+    assert result["demurrage_days"] == "5.75000"
+    assert result["demurrage_amount"] == "46000.00"
+
+
+def test_cp_exception_lets_interruptions_count_on_demurrage():
+    result = compute_laytime(
+        basis(
+            {"laytime_basis": "SHEX", "interruptions_count_on_demurrage": True},
+            [
+                port(
+                    completed="2026-03-09T08:00",
+                    allowed={"kind": "fixed_days", "days": "1"},
+                    interruptions=[
+                        {"from": "2026-03-04T10:00", "to": "2026-03-04T16:00", "reason": "rain"}
+                    ],
+                )
+            ],
+        )
+    )
+    assert result["demurrage_days"] == "5.75000"
+
+
+def test_shex_excludes_sunday_before_demurrage():
+    result = compute_laytime(
+        basis(
+            {"laytime_basis": "SHEX"},
+            [port(nor="2026-03-06T08:00", completed="2026-03-10T08:00")],
+        )
+    )
+    assert result["ports"][0]["demurrage_start"] == "2026-03-09T08:00"
+    assert result["used_days"] == "2.00000"
+    assert result["demurrage_days"] == "1.00000"
+
+
+def test_unless_used_counts_sunday():
+    result = compute_laytime(
+        basis(
+            {"laytime_basis": "SHEX", "unless_used": True},
+            [port(nor="2026-03-06T08:00", completed="2026-03-09T08:00")],
+        )
+    )
+    assert result["ports"][0]["demurrage_start"] == "2026-03-08T08:00"
+    assert result["demurrage_days"] == "1.00000"
+
+
+def test_holiday_is_excepted_like_sunday():
+    """A listed holiday (Tuesday 2026-03-03) is skipped under SHEX."""
+    result = compute_laytime(
+        basis(
+            {"laytime_basis": "SHEX", "holidays": ["2026-03-03"]},
+            [port(nor="2026-03-02T08:00", completed="2026-03-05T08:00")],
+        )
+    )
+    assert result["ports"][0]["demurrage_start"] == "2026-03-05T08:00"
+    assert result["used_days"] == "2.00000"
+    assert result["demurrage_days"] == "0.00000"
+
+
+def test_reversible_combines_ports():
+    """Time saved at the load port carries over to discharge under reversible laytime."""
+    ports = [
+        port(name="Samsun", nor="2026-03-02T08:00", completed="2026-03-03T08:00"),
+        port(
+            name="İskenderun",
+            purpose="discharging",
+            nor="2026-03-05T08:00",
+            nor_accepted="2026-03-05T08:00",
+            nor_tendered="2026-03-05T08:00",
+            completed="2026-03-08T20:00",
+        ),
+    ]
+    result = compute_laytime(basis({"reversible": True}, ports))
+    assert result["allowed_days"] == "4.00000"
+    assert result["ports"][1]["demurrage_start"] == "2026-03-08T08:00"
+    assert result["demurrage_days"] == "0.50000"
+    assert result["demurrage_amount"] == "4000.00"
+
+    split = compute_laytime(basis({"reversible": False}, ports))
+    assert split["demurrage_days"] == "1.50000"
+    assert split["despatch_days"] == "1.00000"
+
+
+def test_result_is_reproducible():
+    payload = basis(
+        {"laytime_basis": "SHEX", "nor_to_start_hours": 12},
+        [
+            port(
+                nor="2026-03-01T06:00",
+                completed="2026-03-06T06:00",
+                allowed={"kind": "rate", "cargo_qty": "6000", "rate_per_day": "2000"},
+                interruptions=[
+                    {"from": "2026-03-02T06:00", "to": "2026-03-02T18:00", "reason": "rain"}
+                ],
+            )
+        ],
+    )
+    assert compute_laytime(payload) == compute_laytime(payload)
+
+
+def test_result_is_json_serialisable_without_floats():
+    import json
+
+    result = compute_laytime(basis(None, [port()]))
+    text = json.dumps(result)
+    assert '"demurrage_amount": "0.00"' in text
+    assert "float" not in {type(v).__name__ for v in result.values()}
+
+
+def test_invalid_allowed_kind_raises():
+    with pytest.raises(KeyError):
+        compute_laytime(basis(None, [port(allowed={"kind": "rate"})]))

laytime-0.1.0/uv.lock

@@ -0,0 +1,108 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "laytime"
+version = "0.1.0"
+source = { editable = "." }
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest", specifier = ">=8" },
+    { name = "ruff", specifier = ">=0.6" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.16.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/85/c8e12473c93018f92d19dd988a294202e1c27426c47ec4de53ffb847b8d8/ruff-0.16.5.tar.gz", hash = "sha256:1b88500f9ffbcab3dedb0082c9f9492e91ec3d618aac1236a3e0189938f7040b", size = 4912003, upload-time = "2026-08-27T16:34:18.258Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c6/b6/77c90a970fe2dae17a723acbd011043ea97c98d7deacccefdc4ba74ec512/ruff-0.16.5-py3-none-linux_armv6l.whl", hash = "sha256:12e5f673e774c35fbb62f288809c7653b73445f8ecec6b6063fd6ea3521aa14b", size = 10011941, upload-time = "2026-08-27T16:33:41.287Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/46/6cf67cf6411885a1d6f7f6d801682f155536a85176d10b605e2ceffed8bd/ruff-0.16.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:eda58a5802de40e7ed5b32b64e0b32539338cc6fcd2c78f61e3ad6a0d79f51c3", size = 10204049, upload-time = "2026-08-27T16:33:44.056Z" },
+    { url = "https://files.pythonhosted.org/packages/46/fd/c8720ca7a090abf0c2fef4abe8a5ef6e5127ed15196d8886ff75a2b370e2/ruff-0.16.5-py3-none-macosx_11_0_arm64.whl", hash = "sha256:c5ae9a7b9a8875131f40f8fe967cc86abf899779efd663cb7ce3d572d01da7eb", size = 9809037, upload-time = "2026-08-27T16:33:46.257Z" },
+    { url = "https://files.pythonhosted.org/packages/43/45/a684caacdedaca180f52bacccc40bf0789d2c5a7c75f25324853e9eaedb5/ruff-0.16.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b719b0a1f4d59710d283ab2965f621684a108a9e41da622e3b23f0326cd0025", size = 9964129, upload-time = "2026-08-27T16:33:48.352Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/5d2bcdaca6b5b93d1b4dfc166cd2aebf7680143a1b38a28759df13a94d31/ruff-0.16.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2298f2780ed1be0c5cb1361e32ab7b1467f3cce7dabe101d2210a314f2fe42e9", size = 9821518, upload-time = "2026-08-27T16:33:50.57Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/ff/011cce29accf9257d5974145b733fc653a37985ed6825413a3987cefbfe0/ruff-0.16.5-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:258f29035a2dd021e7861e631b227a5b3f14e50c1184c9a6a122c5f4576154d7", size = 10534835, upload-time = "2026-08-27T16:33:52.522Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/5a/f0cf109bada9bba0e96c90c21c9f9251803f57225c32d293327a03c710d6/ruff-0.16.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b9a4f0432966834019c74d1b7e5c51224305d7713f3d7faf3e7451f1a3be3cde", size = 11252550, upload-time = "2026-08-27T16:33:54.521Z" },
+    { url = "https://files.pythonhosted.org/packages/63/4d/1d481aaea2046c6a7ed7c291f9004c669cce3c087b6b376ed5b08271e3fe/ruff-0.16.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b5eb3a8c3d0ade9cea42b591fd530368e8798380e30e0a308b85a5cf718f09ea", size = 10777949, upload-time = "2026-08-27T16:33:56.88Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/34/ee245ca55f64443233034b3d02b03236b19242004281247c079390b7facd/ruff-0.16.5-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef0f69e191a13a3c9816f63163c88790cb12cd157bbbb384e9c44745702ab105", size = 10311656, upload-time = "2026-08-27T16:33:59.12Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/4d/c33a333e341c0a2b96c715b52d89a606f5a34cd4ac493cd9b8d0187186b8/ruff-0.16.5-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:0eeab41fbea2c42f98dfb9822cdccda9d24ba38d49f6dc945b5c236d48f0ef29", size = 10532125, upload-time = "2026-08-27T16:34:01.166Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e1/a64cef78b40192497bb98a27a8aa8f2c98ee9ee15bc97f7712d94ef32937/ruff-0.16.5-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:f0768e9df4300713fff30733c87575f68b6f1d8de41184e505b7fdd9c0c95eaf", size = 10097648, upload-time = "2026-08-27T16:34:03.16Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/4e/4cdc9ed3c3e109d2f71e62572a37457298d7bc7501ec3138babb7ed32bbd/ruff-0.16.5-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:95cc70cdc7aa80c338de356279d2adbeb2de0f520b9ecd8aba75b94e95e02f91", size = 9829344, upload-time = "2026-08-27T16:34:05.134Z" },
+    { url = "https://files.pythonhosted.org/packages/39/4a/31ed35ce31729955fc583ee0d176d6e784c1290cb0b0a75cb2134c1ab72a/ruff-0.16.5-py3-none-musllinux_1_2_i686.whl", hash = "sha256:d185c8398ded1bfd91c0c2cb258346307571eccc473a8490af8c3977399c384a", size = 10277117, upload-time = "2026-08-27T16:34:07.425Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/a0/60356d86687b4b666d593df213f4dc3041750d024cb7bf2cfa81cfd65c2e/ruff-0.16.5-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:fb8e3a3c4c6a784150a7ced53b015f4b253fc2bf97a610886419ead64b4756ef", size = 10711653, upload-time = "2026-08-27T16:34:09.712Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/20/656d67f5b25ca9bda4e02b1de25867b2954e1d19e03648060f167ad0f4cc/ruff-0.16.5-py3-none-win32.whl", hash = "sha256:288b0a5f080492fe5635db849f9e2e84aa3cce7b7f0e955997d416c507c76a26", size = 10034250, upload-time = "2026-08-27T16:34:11.8Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/42/ee8e68a207b9127fcde6c3d7e197def432f346cb1af159e1fa14ca0d1cdc/ruff-0.16.5-py3-none-win_amd64.whl", hash = "sha256:ddc6385fb2137f616357ca03d6c74f4be987f80fed4008566b754f6032b8546f", size = 10516714, upload-time = "2026-08-27T16:34:13.963Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e3/7df5a396e445b9ba49ce9a9437439a4d80042c61c0ade199abf8d16de1ac/ruff-0.16.5-py3-none-win_arm64.whl", hash = "sha256:a64abe90968719b851bb7cedffaa8753fbdbdadab483089682db623f3edc587e", size = 10391564, upload-time = "2026-08-27T16:34:16.064Z" },
+]