courtdays 0.1.0__tar.gz

courtdays-0.1.0/LICENSE

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

courtdays-0.1.0/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: courtdays
+Version: 0.1.0
+Summary: Compute court and legal deadlines (FRCP Rule 6 style) with holiday calendars and audit trails
+Author: SybilGambleyyu
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SybilGambleyyu/courtdays
+Project-URL: Repository, https://github.com/SybilGambleyyu/courtdays
+Project-URL: Issues, https://github.com/SybilGambleyyu/courtdays/issues
+Keywords: legal,law,court,deadline,FRCP,Rule 6,business-days,paralegal,docket
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Legal Industry
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: holidays>=0.40
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# courtdays
+
+**Compute court and legal deadlines with an audit trail.**
+
+FRCP Rule 6–style day counting for lawyers, paralegals, and docketing tools — not a black box, not a SaaS calendar. Every deadline comes with the steps that produced it so a human can check the math.
+
+```bash
+pip install courtdays
+
+courtdays deadline 2024-06-03 30
+courtdays deadline 2024-06-03 14 --service mail
+courtdays deadline 2024-06-07 10 --mode business --calendar CA
+courtdays check 2024-07-04
+```
+
+## Why this exists
+
+Missed response deadlines are costly. Commercial docketing products (CourtDeadline, DocketBird, firm practice-management suites) handle this at enterprise prices and often as closed systems.
+
+Open-source date libraries know weekends and holidays. Almost none implement the **legal counting rules** docket clerks actually use:
+
+1. Exclude the day of the triggering event  
+2. Count intermediate days (calendar mode — modern FRCP Rule 6)  
+3. If the last day is a Saturday, Sunday, or legal holiday, continue to the next business day  
+4. Optionally add service-method days (e.g. +3 for mail under FRCP 6(d))
+
+**courtdays** is that engine: installable, scriptable, and honest about what it does and does not decide.
+
+## Install
+
+```bash
+pip install courtdays
+```
+
+Requires Python 3.10+.
+
+## CLI
+
+### FRCP-style calendar deadline
+
+```bash
+courtdays deadline 2024-06-03 30
+```
+
+Example output:
+
+```
+Deadline:  2024-07-03  (Wednesday)
+Trigger:   2024-06-03
+Period:    30 day(s) [calendar]
+Calendar:  US-Federal
+
+Computation steps:
+  1. Trigger date: 2024-06-03
+  2. Period: 30 day(s), mode=calendar, calendar=US-Federal
+  3. Exclude trigger day → counting starts 2024-06-04
+  4. Count 30 calendar day(s) inclusive from 2024-06-04 → raw last day 2024-07-03
+  5. Last day 2024-07-03 is a business day — final
+```
+
+### Mail service (+3)
+
+```bash
+courtdays deadline 2024-06-03 14 --service mail
+```
+
+### Business days only (contracts / SLAs)
+
+```bash
+courtdays deadline 2024-06-07 5 --mode business
+courtdays business 2024-06-07 5
+```
+
+### State holiday calendars
+
+```bash
+courtdays deadline 2024-06-03 30 --calendar CA
+courtdays check 2024-11-28 --calendar NY
+```
+
+### JSON for tools
+
+```bash
+courtdays deadline 2024-06-03 30 --json
+```
+
+## Python API
+
+```python
+from courtdays import compute_deadline, us_federal_calendar, us_state_calendar
+
+result = compute_deadline(
+    "2024-06-03",
+    14,
+    service="mail",
+    calendar=us_federal_calendar(),
+)
+
+print(result.deadline)   # datetime.date
+print(result.steps)      # human-readable audit trail
+print(result.to_dict())  # JSON-serializable
+```
+
+### Business-day helper
+
+```python
+from courtdays import add_business_days
+
+due = add_business_days("2024-06-07", 3)  # skips weekend
+```
+
+### Custom calendars
+
+```python
+from datetime import date
+from courtdays import CourtCalendar, compute_deadline
+
+cal = CourtCalendar(
+    name="MyCourt",
+    holiday_dates={date(2024, 7, 5)},  # local court closure
+    holiday_names={date(2024, 7, 5): "Local court holiday"},
+)
+result = compute_deadline("2024-06-15", 20, calendar=cal)
+```
+
+## Counting rules (defaults)
+
+| Setting | Default | Meaning |
+|---------|---------|---------|
+| `mode` | `calendar` | Count all intermediate days (Rule 6 style) |
+| `exclude_trigger_day` | `True` | Day of event is not day 1 |
+| `extend_if_nonbusiness` | `True` | Last day on weekend/holiday → next business day |
+| `service=mail` | +3 days | FRCP 6(d) style add-on after the period |
+| `service=electronic` | +0 | Modern e-service default (override with `--service-days`) |
+
+**This is not legal advice.** Local rules, standing orders, and state codes differ (some still use older “less than 11 days” intermediate-weekend rules; some courts close on different days). Always verify against the controlling authority for the matter. courtdays makes the arithmetic explicit so that verification is faster.
+
+## What this is not
+
+- Not a full docketing / calendar product  
+- Not a substitute for counsel or the court clerk  
+- Not automatic multi-jurisdiction conflict detection  
+
+It is the date engine you can put under a checklist, a script, or a small firm’s internal tool.
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest -q
+```
+
+## License
+
+MIT

courtdays-0.1.0/README.md

@@ -0,0 +1,156 @@
+# courtdays
+
+**Compute court and legal deadlines with an audit trail.**
+
+FRCP Rule 6–style day counting for lawyers, paralegals, and docketing tools — not a black box, not a SaaS calendar. Every deadline comes with the steps that produced it so a human can check the math.
+
+```bash
+pip install courtdays
+
+courtdays deadline 2024-06-03 30
+courtdays deadline 2024-06-03 14 --service mail
+courtdays deadline 2024-06-07 10 --mode business --calendar CA
+courtdays check 2024-07-04
+```
+
+## Why this exists
+
+Missed response deadlines are costly. Commercial docketing products (CourtDeadline, DocketBird, firm practice-management suites) handle this at enterprise prices and often as closed systems.
+
+Open-source date libraries know weekends and holidays. Almost none implement the **legal counting rules** docket clerks actually use:
+
+1. Exclude the day of the triggering event  
+2. Count intermediate days (calendar mode — modern FRCP Rule 6)  
+3. If the last day is a Saturday, Sunday, or legal holiday, continue to the next business day  
+4. Optionally add service-method days (e.g. +3 for mail under FRCP 6(d))
+
+**courtdays** is that engine: installable, scriptable, and honest about what it does and does not decide.
+
+## Install
+
+```bash
+pip install courtdays
+```
+
+Requires Python 3.10+.
+
+## CLI
+
+### FRCP-style calendar deadline
+
+```bash
+courtdays deadline 2024-06-03 30
+```
+
+Example output:
+
+```
+Deadline:  2024-07-03  (Wednesday)
+Trigger:   2024-06-03
+Period:    30 day(s) [calendar]
+Calendar:  US-Federal
+
+Computation steps:
+  1. Trigger date: 2024-06-03
+  2. Period: 30 day(s), mode=calendar, calendar=US-Federal
+  3. Exclude trigger day → counting starts 2024-06-04
+  4. Count 30 calendar day(s) inclusive from 2024-06-04 → raw last day 2024-07-03
+  5. Last day 2024-07-03 is a business day — final
+```
+
+### Mail service (+3)
+
+```bash
+courtdays deadline 2024-06-03 14 --service mail
+```
+
+### Business days only (contracts / SLAs)
+
+```bash
+courtdays deadline 2024-06-07 5 --mode business
+courtdays business 2024-06-07 5
+```
+
+### State holiday calendars
+
+```bash
+courtdays deadline 2024-06-03 30 --calendar CA
+courtdays check 2024-11-28 --calendar NY
+```
+
+### JSON for tools
+
+```bash
+courtdays deadline 2024-06-03 30 --json
+```
+
+## Python API
+
+```python
+from courtdays import compute_deadline, us_federal_calendar, us_state_calendar
+
+result = compute_deadline(
+    "2024-06-03",
+    14,
+    service="mail",
+    calendar=us_federal_calendar(),
+)
+
+print(result.deadline)   # datetime.date
+print(result.steps)      # human-readable audit trail
+print(result.to_dict())  # JSON-serializable
+```
+
+### Business-day helper
+
+```python
+from courtdays import add_business_days
+
+due = add_business_days("2024-06-07", 3)  # skips weekend
+```
+
+### Custom calendars
+
+```python
+from datetime import date
+from courtdays import CourtCalendar, compute_deadline
+
+cal = CourtCalendar(
+    name="MyCourt",
+    holiday_dates={date(2024, 7, 5)},  # local court closure
+    holiday_names={date(2024, 7, 5): "Local court holiday"},
+)
+result = compute_deadline("2024-06-15", 20, calendar=cal)
+```
+
+## Counting rules (defaults)
+
+| Setting | Default | Meaning |
+|---------|---------|---------|
+| `mode` | `calendar` | Count all intermediate days (Rule 6 style) |
+| `exclude_trigger_day` | `True` | Day of event is not day 1 |
+| `extend_if_nonbusiness` | `True` | Last day on weekend/holiday → next business day |
+| `service=mail` | +3 days | FRCP 6(d) style add-on after the period |
+| `service=electronic` | +0 | Modern e-service default (override with `--service-days`) |
+
+**This is not legal advice.** Local rules, standing orders, and state codes differ (some still use older “less than 11 days” intermediate-weekend rules; some courts close on different days). Always verify against the controlling authority for the matter. courtdays makes the arithmetic explicit so that verification is faster.
+
+## What this is not
+
+- Not a full docketing / calendar product  
+- Not a substitute for counsel or the court clerk  
+- Not automatic multi-jurisdiction conflict detection  
+
+It is the date engine you can put under a checklist, a script, or a small firm’s internal tool.
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest -q
+```
+
+## License
+
+MIT

courtdays-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "courtdays"
+version = "0.1.0"
+description = "Compute court and legal deadlines (FRCP Rule 6 style) with holiday calendars and audit trails"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "SybilGambleyyu" }]
+keywords = [
+    "legal",
+    "law",
+    "court",
+    "deadline",
+    "FRCP",
+    "Rule 6",
+    "business-days",
+    "paralegal",
+    "docket",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Legal Industry",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business",
+]
+dependencies = [
+    "holidays>=0.40",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "build", "twine"]
+
+[project.scripts]
+courtdays = "courtdays.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/SybilGambleyyu/courtdays"
+Repository = "https://github.com/SybilGambleyyu/courtdays"
+Issues = "https://github.com/SybilGambleyyu/courtdays/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

courtdays-0.1.0/setup.cfg

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

courtdays-0.1.0/src/courtdays/__init__.py

@@ -0,0 +1,21 @@
+"""
+courtdays — compute legal and court deadlines with an auditable trail.
+
+Implements FRCP Rule 6–style counting (exclude trigger day, count intermediate
+days, extend if the last day is a weekend or legal holiday) plus pure business-
+day arithmetic and optional service-method add-ons (e.g. +3 for mail).
+"""
+
+from courtdays.calendar import CourtCalendar, us_federal_calendar, us_state_calendar
+from courtdays.compute import DeadlineResult, add_business_days, compute_deadline
+
+__version__ = "0.1.0"
+__all__ = [
+    "CourtCalendar",
+    "us_federal_calendar",
+    "us_state_calendar",
+    "DeadlineResult",
+    "compute_deadline",
+    "add_business_days",
+    "__version__",
+]

courtdays-0.1.0/src/courtdays/calendar.py

@@ -0,0 +1,114 @@
+"""Holiday calendars for court and business-day computation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from typing import Iterable, Optional, Set, Union
+
+import holidays as holidays_lib
+
+
+@dataclass
+class CourtCalendar:
+    """
+    A set of non-business (holiday) dates plus weekend rules.
+
+    Weekends default to Saturday and Sunday. Pass custom weekend weekdays
+    (0=Mon … 6=Sun) if a jurisdiction differs.
+    """
+
+    name: str
+    holiday_dates: Set[date] = field(default_factory=set)
+    holiday_names: dict[date, str] = field(default_factory=dict)
+    weekend: Set[int] = field(default_factory=lambda: {5, 6})  # Sat, Sun
+
+    def is_weekend(self, d: date) -> bool:
+        return d.weekday() in self.weekend
+
+    def is_holiday(self, d: date) -> bool:
+        return d in self.holiday_dates
+
+    def is_business_day(self, d: date) -> bool:
+        return not self.is_weekend(d) and not self.is_holiday(d)
+
+    def holiday_name(self, d: date) -> Optional[str]:
+        return self.holiday_names.get(d)
+
+    def next_business_day(self, d: date) -> date:
+        cur = d
+        while not self.is_business_day(cur):
+            cur += timedelta(days=1)
+        return cur
+
+    def previous_business_day(self, d: date) -> date:
+        cur = d
+        while not self.is_business_day(cur):
+            cur -= timedelta(days=1)
+        return cur
+
+    def extend_range(self, years: Iterable[int]) -> None:
+        """No-op hook for calendars that lazy-load by year; federal is preloaded."""
+        return None
+
+
+def _default_years() -> range:
+    # Wide window so historical and near-future dockets both work out of the box.
+    y = date.today().year
+    return range(y - 15, y + 16)
+
+
+def us_federal_calendar(
+    years: Optional[Union[int, Iterable[int]]] = None,
+) -> CourtCalendar:
+    """
+    U.S. federal legal holidays (as observed), suitable for FRCP Rule 6(a)(6)
+    “legal holiday” treatment in federal court.
+
+    Includes New Year's, MLK Day, Washington's Birthday, Memorial Day,
+    Juneteenth, Independence Day, Labor Day, Columbus Day, Veterans Day,
+    Thanksgiving, and Christmas — with observed shifts when they fall on
+    weekends (per the `holidays` package / OPM-style observance).
+    """
+    if years is None:
+        years = _default_years()
+    elif isinstance(years, int):
+        years = [years]
+
+    h = holidays_lib.country_holidays("US", years=list(years))
+    dates: set[date] = set(h.keys())
+    names = {d: str(n) for d, n in h.items()}
+    return CourtCalendar(
+        name="US-Federal",
+        holiday_dates=dates,
+        holiday_names=names,
+    )
+
+
+def us_state_calendar(
+    state: str,
+    years: Optional[Union[int, Iterable[int]]] = None,
+) -> CourtCalendar:
+    """
+    U.S. state holiday calendar (federal + state-specific where the holidays
+    package provides them). *state* is a two-letter code, e.g. ``"CA"``, ``"NY"``.
+    """
+    if years is None:
+        years = _default_years()
+    elif isinstance(years, int):
+        years = [years]
+
+    code = state.strip().upper()
+    h = holidays_lib.country_holidays("US", subdiv=code, years=list(years))
+    dates: set[date] = set(h.keys())
+    names = {d: str(n) for d, n in h.items()}
+    return CourtCalendar(
+        name=f"US-{code}",
+        holiday_dates=dates,
+        holiday_names=names,
+    )
+
+
+def empty_calendar(name: str = "empty") -> CourtCalendar:
+    """Weekends only — no holidays. Useful for pure weekend-aware math."""
+    return CourtCalendar(name=name)

courtdays-0.1.0/src/courtdays/cli.py

@@ -0,0 +1,164 @@
+"""Command-line interface for courtdays."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import date
+
+from courtdays import __version__
+from courtdays.calendar import us_federal_calendar, us_state_calendar
+from courtdays.compute import compute_deadline, parse_date
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="courtdays",
+        description=(
+            "Compute court/legal deadlines (FRCP Rule 6 style) with holiday "
+            "calendars and a step-by-step audit trail."
+        ),
+    )
+    parser.add_argument("--version", action="version", version=f"courtdays {__version__}")
+
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("deadline", help="Compute a deadline from a trigger date")
+    p.add_argument("trigger", help="Trigger date (YYYY-MM-DD or MM/DD/YYYY)")
+    p.add_argument("days", type=int, help="Number of days in the period")
+    p.add_argument(
+        "--mode",
+        choices=["calendar", "business"],
+        default="calendar",
+        help="calendar = FRCP Rule 6 style (default); business = business days only",
+    )
+    p.add_argument(
+        "--calendar",
+        default="federal",
+        help="Holiday calendar: federal (default) or US state code e.g. CA, NY",
+    )
+    p.add_argument(
+        "--service",
+        choices=["none", "mail", "electronic", "personal", "other"],
+        default="none",
+        help="Service method (mail adds +3 calendar days under FRCP 6(d) default)",
+    )
+    p.add_argument(
+        "--service-days",
+        type=int,
+        default=None,
+        help="Override service extra days (default depends on --service)",
+    )
+    p.add_argument(
+        "--include-trigger",
+        action="store_true",
+        help="Count the trigger day as day 1 (default: exclude trigger day)",
+    )
+    p.add_argument(
+        "--no-extend",
+        action="store_true",
+        help="Do not extend when last day is weekend/holiday",
+    )
+    p.add_argument("--json", action="store_true", help="Emit JSON")
+    p.add_argument("-q", "--quiet", action="store_true", help="Print only the deadline date")
+
+    p_biz = sub.add_parser("business", help="Add N business days to a date")
+    p_biz.add_argument("start", help="Start date")
+    p_biz.add_argument("days", type=int, help="Business days to add")
+    p_biz.add_argument("--calendar", default="federal")
+    p_biz.add_argument("--json", action="store_true")
+
+    p_check = sub.add_parser("check", help="Is this date a business day?")
+    p_check.add_argument("date", help="Date to check")
+    p_check.add_argument("--calendar", default="federal")
+
+    args = parser.parse_args(argv)
+
+    if args.command == "deadline":
+        return _cmd_deadline(args)
+    if args.command == "business":
+        return _cmd_business(args)
+    if args.command == "check":
+        return _cmd_check(args)
+    return 2
+
+
+def _load_calendar(spec: str):
+    s = (spec or "federal").strip().lower()
+    if s in {"federal", "us", "us-federal", "fed"}:
+        return us_federal_calendar()
+    if len(s) == 2:
+        return us_state_calendar(s.upper())
+    raise SystemExit(f"Unknown calendar {spec!r}; use 'federal' or a state code like CA")
+
+
+def _cmd_deadline(args: argparse.Namespace) -> int:
+    cal = _load_calendar(args.calendar)
+    result = compute_deadline(
+        args.trigger,
+        args.days,
+        mode=args.mode,
+        calendar=cal,
+        exclude_trigger_day=not args.include_trigger,
+        extend_if_nonbusiness=not args.no_extend,
+        service=args.service,
+        service_extra_days=args.service_days,
+    )
+    if args.quiet:
+        print(result.deadline.isoformat())
+        return 0
+    if args.json:
+        print(json.dumps(result.to_dict(), indent=2))
+        return 0
+
+    print(f"Deadline:  {result.deadline.isoformat()}  ({result.deadline.strftime('%A')})")
+    print(f"Trigger:   {result.trigger_date.isoformat()}")
+    print(f"Period:    {result.period_days} day(s) [{result.mode}]")
+    print(f"Calendar:  {result.calendar_name}")
+    if result.service_extra_days:
+        print(f"Service:   {result.service_method} (+{result.service_extra_days})")
+    print()
+    print("Computation steps:")
+    for i, step in enumerate(result.steps, 1):
+        print(f"  {i}. {step}")
+    print()
+    print(
+        "Disclaimer: not legal advice. Verify against the controlling rules, "
+        "local orders, and court holiday lists for your matter."
+    )
+    return 0
+
+
+def _cmd_business(args: argparse.Namespace) -> int:
+    cal = _load_calendar(args.calendar)
+    result = compute_deadline(
+        args.start,
+        args.days,
+        mode="business",
+        calendar=cal,
+        exclude_trigger_day=True,
+        extend_if_nonbusiness=False,
+    )
+    if args.json:
+        print(json.dumps(result.to_dict(), indent=2))
+    else:
+        print(result.deadline.isoformat())
+    return 0
+
+
+def _cmd_check(args: argparse.Namespace) -> int:
+    cal = _load_calendar(args.calendar)
+    d = parse_date(args.date)
+    biz = cal.is_business_day(d)
+    print(f"{d.isoformat()} ({d.strftime('%A')})")
+    print(f"  calendar:     {cal.name}")
+    print(f"  weekend:      {cal.is_weekend(d)}")
+    print(f"  holiday:      {cal.is_holiday(d)}"
+          + (f" — {cal.holiday_name(d)}" if cal.is_holiday(d) else ""))
+    print(f"  business day: {biz}")
+    return 0 if biz else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

courtdays-0.1.0/src/courtdays/compute.py

@@ -0,0 +1,305 @@
+"""Deadline computation engines."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, datetime, timedelta
+from typing import Any, Literal, Optional, Union
+
+from courtdays.calendar import CourtCalendar, us_federal_calendar
+
+CountMode = Literal["calendar", "business"]
+ServiceMethod = Literal["none", "mail", "electronic", "personal", "other"]
+
+
+# FRCP Rule 6(d): when service is made under Rule 5(b)(2)(C), (D), (E), or (F)
+# (mail, leaving with clerk, electronic if consented under older practice, etc.)
+# — 3 days are added after the period would otherwise expire.
+# Modern e-service often does NOT get +3; callers choose.
+SERVICE_EXTRA_DAYS: dict[str, int] = {
+    "none": 0,
+    "personal": 0,
+    "electronic": 0,  # default modern e-filing: no +3
+    "mail": 3,
+    "other": 0,
+}
+
+
+@dataclass
+class DeadlineResult:
+    """Full result of a deadline computation, including an audit trail."""
+
+    trigger_date: date
+    period_days: int
+    deadline: date
+    mode: str
+    calendar_name: str
+    service_method: str
+    service_extra_days: int
+    steps: list[str] = field(default_factory=list)
+    meta: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "trigger_date": self.trigger_date.isoformat(),
+            "period_days": self.period_days,
+            "deadline": self.deadline.isoformat(),
+            "mode": self.mode,
+            "calendar": self.calendar_name,
+            "service_method": self.service_method,
+            "service_extra_days": self.service_extra_days,
+            "steps": list(self.steps),
+            "meta": dict(self.meta),
+        }
+
+
+def parse_date(value: Union[str, date, datetime]) -> date:
+    if isinstance(value, datetime):
+        return value.date()
+    if isinstance(value, date):
+        return value
+    s = str(value).strip()
+    for fmt in ("%Y-%m-%d", "%m/%d/%Y", "%m/%d/%y", "%Y/%m/%d", "%d-%b-%Y", "%b %d, %Y"):
+        try:
+            return datetime.strptime(s, fmt).date()
+        except ValueError:
+            continue
+    raise ValueError(f"Cannot parse date: {value!r}")
+
+
+def compute_deadline(
+    trigger: Union[str, date, datetime],
+    days: int,
+    *,
+    mode: CountMode = "calendar",
+    calendar: Optional[CourtCalendar] = None,
+    exclude_trigger_day: bool = True,
+    extend_if_nonbusiness: bool = True,
+    service: ServiceMethod = "none",
+    service_extra_days: Optional[int] = None,
+) -> DeadlineResult:
+    """
+    Compute a legal deadline.
+
+    **FRCP Rule 6–style calendar mode** (default ``mode="calendar"``):
+
+    1. Start from the trigger event date (e.g. date of service / order).
+    2. Exclude the trigger day itself when ``exclude_trigger_day`` is True.
+    3. Count every calendar day (weekends and holidays included as intermediate days).
+    4. If the last day is a Saturday, Sunday, or legal holiday and
+       ``extend_if_nonbusiness`` is True, continue to the next business day.
+    5. Optionally add service-method days (FRCP 6(d) mail = +3 after the period).
+
+    **Business-day mode** (``mode="business"``):
+
+    Count only business days (skip weekends and holidays). Common for contract
+    SLAs and some administrative deadlines — *not* the general FRCP day-count rule.
+
+    Parameters
+    ----------
+    trigger:
+        Date the period starts from (day of the event that triggers the clock).
+    days:
+        Number of days in the period (must be >= 0).
+    mode:
+        ``"calendar"`` (Rule 6 style) or ``"business"``.
+    calendar:
+        Holiday calendar. Defaults to U.S. federal legal holidays.
+    exclude_trigger_day:
+        If True (default), counting begins the day *after* the trigger.
+    extend_if_nonbusiness:
+        If True (default), when the raw last day is a weekend/holiday, move to
+        the next business day.
+    service:
+        Named service method; sets default extra days (mail → 3).
+    service_extra_days:
+        Override the extra days added after the period (FRCP 6(d) style).
+    """
+    if days < 0:
+        raise ValueError("days must be >= 0")
+
+    cal = calendar or us_federal_calendar()
+    trigger_d = parse_date(trigger)
+    steps: list[str] = []
+    steps.append(f"Trigger date: {trigger_d.isoformat()}")
+    steps.append(f"Period: {days} day(s), mode={mode}, calendar={cal.name}")
+
+    if service_extra_days is None:
+        service_extra_days = SERVICE_EXTRA_DAYS.get(service, 0)
+    else:
+        service_extra_days = int(service_extra_days)
+
+    if mode == "calendar":
+        deadline, mode_steps = _count_calendar(
+            trigger_d,
+            days,
+            cal,
+            exclude_trigger_day=exclude_trigger_day,
+            extend_if_nonbusiness=extend_if_nonbusiness,
+        )
+    elif mode == "business":
+        deadline, mode_steps = _count_business(
+            trigger_d,
+            days,
+            cal,
+            exclude_trigger_day=exclude_trigger_day,
+        )
+    else:
+        raise ValueError(f"Unknown mode: {mode!r}")
+    steps.extend(mode_steps)
+
+    if service_extra_days:
+        before = deadline
+        # FRCP 6(d): 3 days added after the period would otherwise expire.
+        # Those 3 are calendar days, then extend if landing on non-business.
+        deadline = before + timedelta(days=service_extra_days)
+        steps.append(
+            f"Service method {service!r}: add {service_extra_days} day(s) "
+            f"→ {deadline.isoformat()}"
+        )
+        if extend_if_nonbusiness and not cal.is_business_day(deadline):
+            extended = cal.next_business_day(deadline)
+            reason = _nonbusiness_reason(cal, deadline)
+            steps.append(
+                f"Service-adjusted last day {deadline.isoformat()} is {reason}; "
+                f"extended to {extended.isoformat()}"
+            )
+            deadline = extended
+
+    return DeadlineResult(
+        trigger_date=trigger_d,
+        period_days=days,
+        deadline=deadline,
+        mode=mode,
+        calendar_name=cal.name,
+        service_method=service,
+        service_extra_days=service_extra_days,
+        steps=steps,
+        meta={
+            "exclude_trigger_day": exclude_trigger_day,
+            "extend_if_nonbusiness": extend_if_nonbusiness,
+        },
+    )
+
+
+def add_business_days(
+    start: Union[str, date, datetime],
+    days: int,
+    *,
+    calendar: Optional[CourtCalendar] = None,
+    exclude_start: bool = True,
+) -> date:
+    """Convenience: pure business-day addition, returns the date only."""
+    result = compute_deadline(
+        start,
+        days,
+        mode="business",
+        calendar=calendar,
+        exclude_trigger_day=exclude_start,
+        extend_if_nonbusiness=False,
+        service="none",
+    )
+    return result.deadline
+
+
+def _count_calendar(
+    trigger: date,
+    days: int,
+    cal: CourtCalendar,
+    *,
+    exclude_trigger_day: bool,
+    extend_if_nonbusiness: bool,
+) -> tuple[date, list[str]]:
+    steps: list[str] = []
+    if days == 0:
+        deadline = trigger if not exclude_trigger_day else trigger
+        steps.append("Zero-day period; deadline is the trigger date")
+        if extend_if_nonbusiness and not cal.is_business_day(deadline):
+            ext = cal.next_business_day(deadline)
+            steps.append(
+                f"Zero-day falls on {_nonbusiness_reason(cal, deadline)}; "
+                f"extended to {ext.isoformat()}"
+            )
+            deadline = ext
+        return deadline, steps
+
+    # Exclude trigger day: first counted day is trigger+1
+    start = trigger + timedelta(days=1) if exclude_trigger_day else trigger
+    if exclude_trigger_day:
+        steps.append(
+            f"Exclude trigger day → counting starts {start.isoformat()}"
+        )
+    else:
+        steps.append(f"Include trigger day → counting starts {start.isoformat()}")
+
+    # Count `days` calendar days from start inclusive
+    # If start is day 1, deadline is start + (days - 1)
+    deadline = start + timedelta(days=days - 1)
+    steps.append(
+        f"Count {days} calendar day(s) inclusive from {start.isoformat()} "
+        f"→ raw last day {deadline.isoformat()}"
+    )
+
+    if extend_if_nonbusiness and not cal.is_business_day(deadline):
+        ext = cal.next_business_day(deadline)
+        steps.append(
+            f"Last day {deadline.isoformat()} is {_nonbusiness_reason(cal, deadline)}; "
+            f"period continues to next business day {ext.isoformat()}"
+        )
+        deadline = ext
+    elif cal.is_business_day(deadline):
+        steps.append(f"Last day {deadline.isoformat()} is a business day — final")
+
+    return deadline, steps
+
+
+def _count_business(
+    trigger: date,
+    days: int,
+    cal: CourtCalendar,
+    *,
+    exclude_trigger_day: bool,
+) -> tuple[date, list[str]]:
+    steps: list[str] = []
+    if days == 0:
+        d = trigger
+        if not cal.is_business_day(d):
+            d = cal.next_business_day(d)
+            steps.append(f"Zero business days; snap to business day {d.isoformat()}")
+        else:
+            steps.append(f"Zero business days; deadline {d.isoformat()}")
+        return d, steps
+
+    cur = trigger
+    if exclude_trigger_day:
+        cur = trigger + timedelta(days=1)
+        steps.append(f"Exclude trigger day → begin search at {cur.isoformat()}")
+
+    # Advance to first business day if needed when include-trigger? 
+    # For exclude path: start counting business days from `cur` forward
+    counted = 0
+    # If we land on non-business at start of counting, skip forward first
+    while not cal.is_business_day(cur):
+        cur += timedelta(days=1)
+
+    while counted < days:
+        if cal.is_business_day(cur):
+            counted += 1
+            if counted == days:
+                break
+        cur += timedelta(days=1)
+
+    steps.append(
+        f"Counted {days} business day(s) → {cur.isoformat()}"
+    )
+    return cur, steps
+
+
+def _nonbusiness_reason(cal: CourtCalendar, d: date) -> str:
+    parts = []
+    if cal.is_weekend(d):
+        parts.append(d.strftime("%A"))
+    if cal.is_holiday(d):
+        name = cal.holiday_name(d) or "legal holiday"
+        parts.append(name)
+    return " / ".join(parts) if parts else "non-business day"

courtdays-0.1.0/src/courtdays.egg-info/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: courtdays
+Version: 0.1.0
+Summary: Compute court and legal deadlines (FRCP Rule 6 style) with holiday calendars and audit trails
+Author: SybilGambleyyu
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SybilGambleyyu/courtdays
+Project-URL: Repository, https://github.com/SybilGambleyyu/courtdays
+Project-URL: Issues, https://github.com/SybilGambleyyu/courtdays/issues
+Keywords: legal,law,court,deadline,FRCP,Rule 6,business-days,paralegal,docket
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Legal Industry
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: holidays>=0.40
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# courtdays
+
+**Compute court and legal deadlines with an audit trail.**
+
+FRCP Rule 6–style day counting for lawyers, paralegals, and docketing tools — not a black box, not a SaaS calendar. Every deadline comes with the steps that produced it so a human can check the math.
+
+```bash
+pip install courtdays
+
+courtdays deadline 2024-06-03 30
+courtdays deadline 2024-06-03 14 --service mail
+courtdays deadline 2024-06-07 10 --mode business --calendar CA
+courtdays check 2024-07-04
+```
+
+## Why this exists
+
+Missed response deadlines are costly. Commercial docketing products (CourtDeadline, DocketBird, firm practice-management suites) handle this at enterprise prices and often as closed systems.
+
+Open-source date libraries know weekends and holidays. Almost none implement the **legal counting rules** docket clerks actually use:
+
+1. Exclude the day of the triggering event  
+2. Count intermediate days (calendar mode — modern FRCP Rule 6)  
+3. If the last day is a Saturday, Sunday, or legal holiday, continue to the next business day  
+4. Optionally add service-method days (e.g. +3 for mail under FRCP 6(d))
+
+**courtdays** is that engine: installable, scriptable, and honest about what it does and does not decide.
+
+## Install
+
+```bash
+pip install courtdays
+```
+
+Requires Python 3.10+.
+
+## CLI
+
+### FRCP-style calendar deadline
+
+```bash
+courtdays deadline 2024-06-03 30
+```
+
+Example output:
+
+```
+Deadline:  2024-07-03  (Wednesday)
+Trigger:   2024-06-03
+Period:    30 day(s) [calendar]
+Calendar:  US-Federal
+
+Computation steps:
+  1. Trigger date: 2024-06-03
+  2. Period: 30 day(s), mode=calendar, calendar=US-Federal
+  3. Exclude trigger day → counting starts 2024-06-04
+  4. Count 30 calendar day(s) inclusive from 2024-06-04 → raw last day 2024-07-03
+  5. Last day 2024-07-03 is a business day — final
+```
+
+### Mail service (+3)
+
+```bash
+courtdays deadline 2024-06-03 14 --service mail
+```
+
+### Business days only (contracts / SLAs)
+
+```bash
+courtdays deadline 2024-06-07 5 --mode business
+courtdays business 2024-06-07 5
+```
+
+### State holiday calendars
+
+```bash
+courtdays deadline 2024-06-03 30 --calendar CA
+courtdays check 2024-11-28 --calendar NY
+```
+
+### JSON for tools
+
+```bash
+courtdays deadline 2024-06-03 30 --json
+```
+
+## Python API
+
+```python
+from courtdays import compute_deadline, us_federal_calendar, us_state_calendar
+
+result = compute_deadline(
+    "2024-06-03",
+    14,
+    service="mail",
+    calendar=us_federal_calendar(),
+)
+
+print(result.deadline)   # datetime.date
+print(result.steps)      # human-readable audit trail
+print(result.to_dict())  # JSON-serializable
+```
+
+### Business-day helper
+
+```python
+from courtdays import add_business_days
+
+due = add_business_days("2024-06-07", 3)  # skips weekend
+```
+
+### Custom calendars
+
+```python
+from datetime import date
+from courtdays import CourtCalendar, compute_deadline
+
+cal = CourtCalendar(
+    name="MyCourt",
+    holiday_dates={date(2024, 7, 5)},  # local court closure
+    holiday_names={date(2024, 7, 5): "Local court holiday"},
+)
+result = compute_deadline("2024-06-15", 20, calendar=cal)
+```
+
+## Counting rules (defaults)
+
+| Setting | Default | Meaning |
+|---------|---------|---------|
+| `mode` | `calendar` | Count all intermediate days (Rule 6 style) |
+| `exclude_trigger_day` | `True` | Day of event is not day 1 |
+| `extend_if_nonbusiness` | `True` | Last day on weekend/holiday → next business day |
+| `service=mail` | +3 days | FRCP 6(d) style add-on after the period |
+| `service=electronic` | +0 | Modern e-service default (override with `--service-days`) |
+
+**This is not legal advice.** Local rules, standing orders, and state codes differ (some still use older “less than 11 days” intermediate-weekend rules; some courts close on different days). Always verify against the controlling authority for the matter. courtdays makes the arithmetic explicit so that verification is faster.
+
+## What this is not
+
+- Not a full docketing / calendar product  
+- Not a substitute for counsel or the court clerk  
+- Not automatic multi-jurisdiction conflict detection  
+
+It is the date engine you can put under a checklist, a script, or a small firm’s internal tool.
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest -q
+```
+
+## License
+
+MIT

courtdays-0.1.0/src/courtdays.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/courtdays/__init__.py
+src/courtdays/calendar.py
+src/courtdays/cli.py
+src/courtdays/compute.py
+src/courtdays.egg-info/PKG-INFO
+src/courtdays.egg-info/SOURCES.txt
+src/courtdays.egg-info/dependency_links.txt
+src/courtdays.egg-info/entry_points.txt
+src/courtdays.egg-info/requires.txt
+src/courtdays.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_compute.py

courtdays-0.1.0/src/courtdays.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

courtdays-0.1.0/src/courtdays.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+courtdays = courtdays.cli:main

courtdays-0.1.0/src/courtdays.egg-info/requires.txt

@@ -0,0 +1,6 @@
+holidays>=0.40
+
+[dev]
+pytest>=7.0
+build
+twine

courtdays-0.1.0/src/courtdays.egg-info/top_level.txt

@@ -0,0 +1 @@
+courtdays

courtdays-0.1.0/tests/test_cli.py

@@ -0,0 +1,31 @@
+import json
+
+from courtdays.cli import main
+
+
+def test_cli_deadline_quiet(capsys):
+    rc = main(["deadline", "2024-06-03", "30", "-q", "--calendar", "federal"])
+    assert rc == 0
+    out = capsys.readouterr().out.strip()
+    assert out == "2024-07-03"
+
+
+def test_cli_deadline_json(capsys):
+    rc = main(["deadline", "2024-06-03", "14", "--json", "--service", "mail"])
+    assert rc == 0
+    data = json.loads(capsys.readouterr().out)
+    assert data["service_extra_days"] == 3
+    assert "deadline" in data
+    assert data["steps"]
+
+
+def test_cli_check_weekend(capsys):
+    rc = main(["check", "2024-06-08"])  # Saturday
+    assert rc == 1
+    assert "business day: False" in capsys.readouterr().out
+
+
+def test_cli_business(capsys):
+    rc = main(["business", "2024-06-07", "1"])
+    assert rc == 0
+    assert capsys.readouterr().out.strip() == "2024-06-10"

courtdays-0.1.0/tests/test_compute.py

@@ -0,0 +1,89 @@
+from datetime import date, timedelta
+
+from courtdays import compute_deadline, us_federal_calendar, add_business_days
+from courtdays.calendar import empty_calendar
+
+
+def test_simple_30_day_period_no_holiday_end():
+    # Trigger Monday 2024-06-03; +30 calendar days, exclude trigger
+    # start 2024-06-04, +29 = 2024-07-03 Wednesday
+    r = compute_deadline("2024-06-03", 30, calendar=us_federal_calendar(2024))
+    assert r.deadline == date(2024, 7, 3)
+    assert r.deadline.strftime("%A") == "Wednesday"
+
+
+def test_last_day_saturday_extends_to_monday():
+    # Find a period whose raw last day is Saturday
+    # Trigger Fri 2024-06-07; exclude → start Sat 6/8; 1 day → Sat 6/8 → Mon 6/10
+    r = compute_deadline("2024-06-07", 1, calendar=us_federal_calendar(2024))
+    assert r.deadline == date(2024, 6, 10)
+    assert any("Saturday" in s or "extended" in s.lower() for s in r.steps)
+
+
+def test_independence_day_extension():
+    # If last day is July 4 holiday, extend
+    # Trigger 2024-06-04; 30 days: start 6/5 +29 = 7/4 Thursday holiday 2024
+    # 2024-07-04 is Thursday Independence Day → next business 2024-07-05
+    r = compute_deadline("2024-06-04", 30, calendar=us_federal_calendar(2024))
+    assert r.deadline == date(2024, 7, 5)
+    assert any("Independence" in s or "holiday" in s.lower() or "extended" in s.lower() for s in r.steps)
+
+
+def test_mail_service_adds_three():
+    r = compute_deadline(
+        "2024-06-03",
+        14,
+        service="mail",
+        calendar=us_federal_calendar(2024),
+    )
+    base = compute_deadline("2024-06-03", 14, calendar=us_federal_calendar(2024))
+    # mail adds 3 calendar days then possibly extends
+    assert r.deadline >= base.deadline + timedelta(days=3) or r.service_extra_days == 3
+    assert r.service_extra_days == 3
+    assert r.deadline >= base.deadline
+
+
+def test_business_day_mode_skips_weekend():
+    # Trigger Friday; 1 business day → Monday
+    r = compute_deadline(
+        "2024-06-07",  # Friday
+        1,
+        mode="business",
+        calendar=empty_calendar(),
+    )
+    assert r.deadline == date(2024, 6, 10)  # Monday
+
+
+def test_add_business_days_helper():
+    d = add_business_days("2024-06-07", 2, calendar=empty_calendar())
+    assert d == date(2024, 6, 11)  # Fri→Mon=1, Tue=2
+
+
+def test_include_trigger_day():
+    r = compute_deadline(
+        "2024-06-03",
+        1,
+        exclude_trigger_day=False,
+        calendar=empty_calendar(),
+        extend_if_nonbusiness=False,
+    )
+    assert r.deadline == date(2024, 6, 3)
+
+
+def test_audit_trail_present():
+    r = compute_deadline("2024-01-02", 10, calendar=us_federal_calendar(2024))
+    assert len(r.steps) >= 3
+    d = r.to_dict()
+    assert d["deadline"] == r.deadline.isoformat()
+
+
+def test_zero_days():
+    r = compute_deadline("2024-06-03", 0, calendar=empty_calendar())
+    assert r.deadline == date(2024, 6, 3)
+
+
+def test_negative_days_rejected():
+    import pytest
+
+    with pytest.raises(ValueError):
+        compute_deadline("2024-06-03", -1)