kessler-toolkit 0.1.0__tar.gz

kessler_toolkit-0.1.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: kessler-toolkit
+Version: 0.1.0
+Summary: Open conjunction assessment: CCSDS CDM parsing, collision probability (Foster/Chan/Max-Pc), SGP4 screening, and risk triage — pure Python.
+Author-email: Ashutosh <siddhvasudev1402@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/siddhashutosh/kessler
+Project-URL: Documentation, https://github.com/siddhashutosh/kessler/tree/main/documents
+Project-URL: Issues, https://github.com/siddhashutosh/kessler/issues
+Keywords: astrodynamics,conjunction-assessment,collision-probability,space-debris,CDM,CCSDS,SGP4,space-traffic-management,SSA
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: sgp4>=2.23
+Requires-Dist: python-dateutil>=2.9
+
+# kessler-toolkit
+
+Open conjunction assessment for Python: parse CCSDS Conjunction Data Messages,
+compute collision probability three honest ways, screen a satellite against a
+catalogue, and triage the results — no MATLAB license required.
+
+Extracted from [KESSLER](https://github.com/siddhashutosh/kessler), where the same
+code powers a live dashboard over the public Space-Track feed.
+
+```bash
+pip install kessler-toolkit
+```
+
+## What's inside
+
+| Module | Purpose |
+|---|---|
+| `cdm_parser` | CCSDS 508.0-B-1 KVN CDMs (incl. RTN covariance) and Space-Track `cdm_public` JSON → typed `Cdm` |
+| `collision_probability` | Foster 2-D numerical Pc, Chan analytic series (cross-check), covariance-free Max-Pc bound |
+| `propagation` | SGP4 wrapper (TEME), close-approach refinement to sub-second TCA, ground tracks |
+| `screening` | Catalogue screening: altitude sieve → coarse scan → refined TCA + RTN miss components |
+| `risk_engine` | Operator-community risk classes (1e-4 / 1e-5 / 1e-7), urgency scoring, recommended actions |
+
+## Quick start
+
+```python
+from kessler_toolkit import parse_cdm_kvn, compute_pc
+
+cdm = parse_cdm_kvn(open("conjunction.cdm").read())
+
+result = compute_pc(
+    miss_m=cdm.miss_distance_m,
+    hbr_m=20.0,
+    r_rel_m=cdm.rel_position_rtn_m,
+    v_rel_ms=cdm.rel_velocity_rtn_ms,
+    cov1_m2=cdm.sat1.cov_rtn_m2,
+    cov2_m2=cdm.sat2.cov_rtn_m2,
+    pc_reported=cdm.pc_reported,
+)
+print(result.value, result.method, result.pc_type)
+# e.g. 2.19e-04 foster-2d computed  — with Chan cross-check in result.cross_check
+```
+
+Every result carries `pc_type` — `"computed"` (full covariance), `"reported"`
+(source value), or `"max"` (conservative upper bound) — so downstream code can
+never mistake a triage bound for a measurement.
+
+Validated against the closed-form isotropic solution (<0.1% error) and
+Foster/Chan cross-agreement; screening results are triage-grade (SGP4/GP
+accuracy limits apply) — not a substitute for operator ephemerides.
+
+Apache-2.0. Orbital data used with KESSLER courtesy of Space-Track.org and CelesTrak.

kessler_toolkit-0.1.0/README.md

@@ -0,0 +1,52 @@
+# kessler-toolkit
+
+Open conjunction assessment for Python: parse CCSDS Conjunction Data Messages,
+compute collision probability three honest ways, screen a satellite against a
+catalogue, and triage the results — no MATLAB license required.
+
+Extracted from [KESSLER](https://github.com/siddhashutosh/kessler), where the same
+code powers a live dashboard over the public Space-Track feed.
+
+```bash
+pip install kessler-toolkit
+```
+
+## What's inside
+
+| Module | Purpose |
+|---|---|
+| `cdm_parser` | CCSDS 508.0-B-1 KVN CDMs (incl. RTN covariance) and Space-Track `cdm_public` JSON → typed `Cdm` |
+| `collision_probability` | Foster 2-D numerical Pc, Chan analytic series (cross-check), covariance-free Max-Pc bound |
+| `propagation` | SGP4 wrapper (TEME), close-approach refinement to sub-second TCA, ground tracks |
+| `screening` | Catalogue screening: altitude sieve → coarse scan → refined TCA + RTN miss components |
+| `risk_engine` | Operator-community risk classes (1e-4 / 1e-5 / 1e-7), urgency scoring, recommended actions |
+
+## Quick start
+
+```python
+from kessler_toolkit import parse_cdm_kvn, compute_pc
+
+cdm = parse_cdm_kvn(open("conjunction.cdm").read())
+
+result = compute_pc(
+    miss_m=cdm.miss_distance_m,
+    hbr_m=20.0,
+    r_rel_m=cdm.rel_position_rtn_m,
+    v_rel_ms=cdm.rel_velocity_rtn_ms,
+    cov1_m2=cdm.sat1.cov_rtn_m2,
+    cov2_m2=cdm.sat2.cov_rtn_m2,
+    pc_reported=cdm.pc_reported,
+)
+print(result.value, result.method, result.pc_type)
+# e.g. 2.19e-04 foster-2d computed  — with Chan cross-check in result.cross_check
+```
+
+Every result carries `pc_type` — `"computed"` (full covariance), `"reported"`
+(source value), or `"max"` (conservative upper bound) — so downstream code can
+never mistake a triage bound for a measurement.
+
+Validated against the closed-form isotropic solution (<0.1% error) and
+Foster/Chan cross-agreement; screening results are triage-grade (SGP4/GP
+accuracy limits apply) — not a substitute for operator ephemerides.
+
+Apache-2.0. Orbital data used with KESSLER courtesy of Space-Track.org and CelesTrak.

kessler_toolkit-0.1.0/kessler_toolkit/__init__.py

@@ -0,0 +1,41 @@
+"""kessler-toolkit — open conjunction assessment primitives.
+
+Generated modules are synced from the KESSLER backend logic layer
+(backend/app/logic), which is the source of truth.
+"""
+from kessler_toolkit.cdm_parser import Cdm, CdmObject, parse_cdm_kvn, parse_cdm_public_row
+from kessler_toolkit.collision_probability import (
+    PcResult,
+    compute_pc,
+    encounter_plane_projection,
+    pc_chan,
+    pc_foster,
+    pc_max,
+)
+from kessler_toolkit.exceptions import (
+    CdmParseError,
+    KesslerError,
+    PropagationError,
+)
+from kessler_toolkit.propagation import (
+    ground_track,
+    load_satrec,
+    refine_tca,
+    rtn_components,
+    state_teme,
+)
+from kessler_toolkit.risk_engine import classify, recommend, urgency
+from kessler_toolkit.screening import CloseApproachHit, altitude_band, screen
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Cdm", "CdmObject", "parse_cdm_kvn", "parse_cdm_public_row",
+    "PcResult", "compute_pc", "encounter_plane_projection",
+    "pc_chan", "pc_foster", "pc_max",
+    "KesslerError", "CdmParseError", "PropagationError",
+    "load_satrec", "state_teme", "refine_tca", "rtn_components", "ground_track",
+    "classify", "urgency", "recommend",
+    "screen", "altitude_band", "CloseApproachHit",
+    "__version__",
+]

kessler_toolkit-0.1.0/kessler_toolkit/cdm_parser.py

@@ -0,0 +1,234 @@
+# GENERATED from backend/app/logic — edit there, then run packages/sync.py
+"""CCSDS Conjunction Data Message parsing (KVN + Space-Track cdm_public JSON).
+
+Pure logic: no I/O, no framework imports. Raises CdmParseError with the full
+list of violations (FR-CDM-3).
+"""
+from __future__ import annotations
+
+import logging
+import math
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+import numpy as np
+from dateutil import parser as dtparser
+
+from kessler_toolkit.exceptions import CdmParseError
+
+logger = logging.getLogger(__name__)
+
+# CCSDS 508.0-B-1 RTN covariance keys (position block, m**2)
+_COV_KEYS = ["CR_R", "CT_R", "CT_T", "CN_R", "CN_T", "CN_N"]
+
+
+@dataclass
+class CdmObject:
+    designator: str
+    name: str = "UNKNOWN"
+    object_type: str = "UNKNOWN"
+    r_rtn_m: np.ndarray | None = None  # position in RTN relative frame [m]
+    v_rtn_ms: np.ndarray | None = None
+    cov_rtn_m2: np.ndarray | None = None  # 3x3 position covariance [m^2]
+
+
+@dataclass
+class Cdm:
+    cdm_id: str
+    tca: datetime
+    miss_distance_m: float
+    sat1: CdmObject
+    sat2: CdmObject
+    created: datetime | None = None
+    relative_speed_ms: float | None = None
+    rel_position_rtn_m: np.ndarray | None = None
+    rel_velocity_rtn_ms: np.ndarray | None = None
+    pc_reported: float | None = None
+    emergency_reportable: bool = False
+    source: str = "unknown"
+    raw: dict = field(default_factory=dict)
+
+    @property
+    def covariance_available(self) -> bool:
+        return self.sat1.cov_rtn_m2 is not None and self.sat2.cov_rtn_m2 is not None
+
+
+def _parse_dt(value: str, errors: list[str], label: str) -> datetime | None:
+    try:
+        dt = dtparser.parse(value)
+        return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
+    except (ValueError, TypeError, OverflowError):
+        errors.append(f"{label}: unparseable datetime {value!r}")
+        return None
+
+
+def _finite(value, errors: list[str], label: str) -> float | None:
+    if value is None or value == "":
+        return None
+    try:
+        f = float(value)
+    except (TypeError, ValueError):
+        errors.append(f"{label}: not numeric ({value!r})")
+        return None
+    if not math.isfinite(f):
+        errors.append(f"{label}: non-finite value")
+        return None
+    return f
+
+
+def _validate_covariance(cov: np.ndarray, label: str) -> np.ndarray | None:
+    """Symmetrise and check positive semi-definiteness; None if unusable."""
+    cov = 0.5 * (cov + cov.T)
+    try:
+        eigvals = np.linalg.eigvalsh(cov)
+    except np.linalg.LinAlgError:
+        logger.warning("%s: covariance eigendecomposition failed; dropping", label)
+        return None
+    if np.any(eigvals < -1e-6 * max(1.0, float(np.max(np.abs(eigvals))))):
+        logger.warning("%s: covariance not PSD (eig min %.3e); dropping", label, eigvals.min())
+        return None
+    return cov
+
+
+# ---------------------------------------------------------------- KVN format
+def parse_cdm_kvn(text: str) -> Cdm:
+    """Parse a CCSDS 508.0-B-1 KVN Conjunction Data Message."""
+    errors: list[str] = []
+    header: dict[str, str] = {}
+    objects: dict[str, dict[str, str]] = {"OBJECT1": {}, "OBJECT2": {}}
+    current = None
+
+    for lineno, raw_line in enumerate(text.splitlines(), 1):
+        line = raw_line.split("COMMENT")[0].strip() if raw_line.strip().startswith("COMMENT") else raw_line.strip()
+        if not line or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key, value = key.strip().upper(), value.strip()
+        # strip trailing units like "[km]"
+        if value.endswith("]") and "[" in value:
+            value = value[: value.rindex("[")].strip()
+        if key == "OBJECT":
+            current = value.upper()
+            if current not in objects:
+                errors.append(f"line {lineno}: unknown OBJECT block {value!r}")
+                current = None
+            continue
+        if current:
+            objects[current][key] = value
+        else:
+            header[key] = value
+
+    tca = _parse_dt(header.get("TCA", ""), errors, "TCA")
+    miss = _finite(header.get("MISS_DISTANCE"), errors, "MISS_DISTANCE")
+    if miss is None:
+        errors.append("MISS_DISTANCE: missing")
+
+    def build_object(block_key: str) -> CdmObject:
+        block = objects[block_key]
+        designator = block.get("OBJECT_DESIGNATOR", "")
+        if not designator:
+            errors.append(f"{block_key}: OBJECT_DESIGNATOR missing")
+        obj = CdmObject(
+            designator=designator or "?",
+            name=block.get("OBJECT_NAME", "UNKNOWN"),
+            object_type=block.get("OBJECT_TYPE", "UNKNOWN"),
+        )
+        if all(k in block for k in _COV_KEYS):
+            vals = [_finite(block[k], errors, f"{block_key}.{k}") for k in _COV_KEYS]
+            if all(v is not None for v in vals):
+                cr_r, ct_r, ct_t, cn_r, cn_t, cn_n = vals  # type: ignore[misc]
+                cov = np.array(
+                    [[cr_r, ct_r, cn_r], [ct_r, ct_t, cn_t], [cn_r, cn_t, cn_n]],
+                    dtype=float,
+                )
+                obj.cov_rtn_m2 = _validate_covariance(cov, block_key)
+        return obj
+
+    sat1, sat2 = build_object("OBJECT1"), build_object("OBJECT2")
+
+    rel_r = rel_v = None
+    rel_keys_r = ["RELATIVE_POSITION_R", "RELATIVE_POSITION_T", "RELATIVE_POSITION_N"]
+    rel_keys_v = ["RELATIVE_VELOCITY_R", "RELATIVE_VELOCITY_T", "RELATIVE_VELOCITY_N"]
+    if all(k in header for k in rel_keys_r):
+        comps = [_finite(header[k], errors, k) for k in rel_keys_r]
+        if all(c is not None for c in comps):
+            rel_r = np.array(comps, dtype=float)
+    if all(k in header for k in rel_keys_v):
+        comps = [_finite(header[k], errors, k) for k in rel_keys_v]
+        if all(c is not None for c in comps):
+            rel_v = np.array(comps, dtype=float)
+
+    if errors:
+        raise CdmParseError("CDM KVN validation failed", detail=errors)
+    assert tca is not None and miss is not None  # guaranteed by errors check
+
+    rel_speed = _finite(header.get("RELATIVE_SPEED"), [], "RELATIVE_SPEED")
+    if rel_speed is None and rel_v is not None:
+        rel_speed = float(np.linalg.norm(rel_v))
+
+    return Cdm(
+        cdm_id=header.get("MESSAGE_ID", f"KVN-{tca.isoformat()}"),
+        tca=tca,
+        miss_distance_m=miss,
+        sat1=sat1,
+        sat2=sat2,
+        created=_parse_dt(header.get("CREATION_DATE", ""), [], "CREATION_DATE"),
+        relative_speed_ms=rel_speed,
+        rel_position_rtn_m=rel_r,
+        rel_velocity_rtn_ms=rel_v,
+        source="kvn",
+        raw={"header": header},
+    )
+
+
+# ------------------------------------------------- Space-Track cdm_public row
+def parse_cdm_public_row(row: dict) -> Cdm:
+    """Parse one Space-Track `cdm_public` JSON row.
+
+    Public rows carry no covariance/state vectors — only summary fields
+    (CDM_ID, CREATED, TCA, MIN_RNG [km], PC, SAT_1_ID, SAT_1_NAME,
+    SAT1_OBJECT_TYPE, SAT_2_*, EMERGENCY_REPORTABLE). Pc falls back to the
+    max-Pc path downstream (FR-PC-3).
+    """
+    errors: list[str] = []
+    tca = _parse_dt(str(row.get("TCA", "")), errors, "TCA")
+
+    min_rng_km = _finite(row.get("MIN_RNG"), errors, "MIN_RNG")
+    if min_rng_km is None:
+        errors.append("MIN_RNG: missing")
+
+    sat1_id = str(row.get("SAT_1_ID") or "").strip()
+    sat2_id = str(row.get("SAT_2_ID") or "").strip()
+    if not sat1_id:
+        errors.append("SAT_1_ID: missing")
+    if not sat2_id:
+        errors.append("SAT_2_ID: missing")
+
+    if errors:
+        raise CdmParseError("cdm_public row validation failed", detail=errors)
+    assert tca is not None and min_rng_km is not None
+
+    pc = _finite(row.get("PC"), [], "PC")
+    rel_speed_kms = _finite(row.get("REL_SPEED") or row.get("RELATIVE_SPEED"), [], "REL_SPEED")
+
+    return Cdm(
+        cdm_id=str(row.get("CDM_ID") or f"ST-{sat1_id}-{sat2_id}-{tca.isoformat()}"),
+        tca=tca,
+        miss_distance_m=min_rng_km * 1000.0,
+        sat1=CdmObject(
+            designator=sat1_id,
+            name=str(row.get("SAT_1_NAME") or "UNKNOWN"),
+            object_type=str(row.get("SAT1_OBJECT_TYPE") or "UNKNOWN"),
+        ),
+        sat2=CdmObject(
+            designator=sat2_id,
+            name=str(row.get("SAT_2_NAME") or "UNKNOWN"),
+            object_type=str(row.get("SAT2_OBJECT_TYPE") or "UNKNOWN"),
+        ),
+        created=_parse_dt(str(row.get("CREATED", "")), [], "CREATED"),
+        relative_speed_ms=rel_speed_kms * 1000.0 if rel_speed_kms is not None else None,
+        pc_reported=pc,
+        emergency_reportable=str(row.get("EMERGENCY_REPORTABLE", "N")).upper() in ("Y", "YES", "TRUE", "1"),
+        source="spacetrack:cdm_public",
+        raw=dict(row),
+    )

kessler_toolkit-0.1.0/kessler_toolkit/collision_probability.py

@@ -0,0 +1,201 @@
+# GENERATED from backend/app/logic — edit there, then run packages/sync.py
+"""Collision probability (Pc) computation — the mathematical core (FR-PC).
+
+Methods:
+  * pc_foster : 2D numerical integration of the bivariate Gaussian over the
+                hard-body disc in the encounter plane (Foster & Estes 1992).
+  * pc_chan   : Chan (2008) equivalent-area analytic series — independent
+                cross-check for pc_foster.
+  * pc_max    : covariance-free conservative upper bound (triage grade).
+
+All functions are pure (no I/O) and unit-tested against closed-form cases.
+"""
+from __future__ import annotations
+
+import logging
+import math
+from dataclasses import dataclass
+
+import numpy as np
+
+from kessler_toolkit.exceptions import PropagationError
+
+logger = logging.getLogger(__name__)
+
+_DIVERGENCE_TOLERANCE = 0.05  # FR-PC-2: methods must agree within 5%
+
+
+@dataclass
+class PcResult:
+    value: float
+    method: str
+    pc_type: str  # "computed" | "max" | "reported"
+    cross_check: float | None = None
+    divergence_flag: bool = False
+
+
+def encounter_plane_projection(
+    r_rel_m: np.ndarray,
+    v_rel_ms: np.ndarray,
+    cov1_m2: np.ndarray,
+    cov2_m2: np.ndarray,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Project the miss vector and combined covariance onto the encounter plane.
+
+    The encounter plane is perpendicular to the relative velocity at TCA;
+    for hypervelocity conjunctions the along-track dimension integrates out,
+    reducing Pc to a 2D problem (standard short-encounter assumption).
+
+    Returns (mu_2d [m], C_2d [m^2]).
+    """
+    v_norm = float(np.linalg.norm(v_rel_ms))
+    if v_norm < 1e-9:
+        raise PropagationError(
+            "Relative velocity ~0; short-encounter assumption invalid",
+            detail={"v_rel_ms": v_rel_ms.tolist()},
+        )
+
+    ez = v_rel_ms / v_norm
+    # ex: component of miss vector orthogonal to ez
+    r_orth = r_rel_m - np.dot(r_rel_m, ez) * ez
+    r_orth_norm = float(np.linalg.norm(r_orth))
+    if r_orth_norm < 1e-12:
+        # miss vector parallel to velocity — any orthogonal basis works
+        candidate = np.array([1.0, 0.0, 0.0])
+        if abs(np.dot(candidate, ez)) > 0.9:
+            candidate = np.array([0.0, 1.0, 0.0])
+        ex = candidate - np.dot(candidate, ez) * ez
+        ex /= np.linalg.norm(ex)
+    else:
+        ex = r_orth / r_orth_norm
+    ey = np.cross(ez, ex)
+
+    basis = np.vstack([ex, ey])  # 2x3
+    combined = cov1_m2 + cov2_m2  # independent OD errors
+    mu = basis @ r_rel_m
+    c2d = basis @ combined @ basis.T
+    # numerical symmetrisation
+    c2d = 0.5 * (c2d + c2d.T)
+    return mu, c2d
+
+
+def pc_foster(
+    mu_m: np.ndarray,
+    cov_m2: np.ndarray,
+    hbr_m: float,
+    n_r: int = 60,
+    n_theta: int = 90,
+) -> float:
+    """Foster 2D Pc: midpoint-rule polar integration of N(x; mu, C) over the HBR disc."""
+    det = float(np.linalg.det(cov_m2))
+    if det <= 0 or hbr_m <= 0:
+        raise PropagationError(
+            "Degenerate 2D covariance or non-positive HBR in Foster integration",
+            detail={"det": det, "hbr_m": hbr_m},
+        )
+    inv = np.linalg.inv(cov_m2)
+    norm_const = 1.0 / (2.0 * math.pi * math.sqrt(det))
+
+    radii = (np.arange(n_r) + 0.5) * (hbr_m / n_r)
+    thetas = (np.arange(n_theta) + 0.5) * (2.0 * math.pi / n_theta)
+    r_grid, t_grid = np.meshgrid(radii, thetas, indexing="ij")
+    x = r_grid * np.cos(t_grid) - mu_m[0]
+    y = r_grid * np.sin(t_grid) - mu_m[1]
+    quad = inv[0, 0] * x * x + 2.0 * inv[0, 1] * x * y + inv[1, 1] * y * y
+    density = norm_const * np.exp(-0.5 * quad)
+    d_area = (hbr_m / n_r) * (2.0 * math.pi / n_theta) * r_grid
+    return float(np.clip(np.sum(density * d_area), 0.0, 1.0))
+
+
+def pc_chan(mu_m: np.ndarray, cov_m2: np.ndarray, hbr_m: float, terms: int = 24) -> float:
+    """Chan (2008) analytic series via equivalent-area isotropic transformation.
+
+    Diagonalise C -> (sx^2, sy^2); u = hbr^2 / (sx*sy); v = scaled miss distance.
+    Pc = e^(-v/2) * sum_{m=0}^{M} [ (v/2)^m / m! * (1 - e^(-u/2) sum_{k=0}^{m} (u/2)^k / k!) ]
+    """
+    eigvals, eigvecs = np.linalg.eigh(cov_m2)
+    if np.any(eigvals <= 0) or hbr_m <= 0:
+        raise PropagationError(
+            "Degenerate 2D covariance or non-positive HBR in Chan series",
+            detail={"eigvals": eigvals.tolist(), "hbr_m": hbr_m},
+        )
+    sx2, sy2 = float(eigvals[0]), float(eigvals[1])
+    mu_rot = eigvecs.T @ mu_m
+    u = hbr_m * hbr_m / math.sqrt(sx2 * sy2)
+    v = mu_rot[0] ** 2 / sx2 + mu_rot[1] ** 2 / sy2
+
+    # series with running factorial terms (numerically safe for small u, v)
+    inner_sum = 0.0
+    inner_term = 1.0
+    exp_u = math.exp(-0.5 * u)
+    outer_total = 0.0
+    outer_term = 1.0  # (v/2)^m / m!
+    for m in range(terms):
+        if m > 0:
+            outer_term *= (0.5 * v) / m
+            inner_term *= (0.5 * u) / m
+        inner_sum += inner_term  # sum_{k<=m} (u/2)^k/k!
+        outer_total += outer_term * (1.0 - exp_u * inner_sum)
+    return float(np.clip(math.exp(-0.5 * v) * outer_total, 0.0, 1.0))
+
+
+def pc_max(miss_m: float, hbr_m: float) -> float:
+    """Conservative covariance-free upper bound.
+
+    For an isotropic 2D Gaussian, Pc(sigma) is maximised at sigma* = miss/sqrt(2),
+    giving Pc_max = (hbr^2 / miss^2) * e^-1 (small-HBR limit), clipped to 1.
+    Labelled triage-grade; documented in LLD §3.3.
+    """
+    if hbr_m <= 0:
+        return 0.0
+    if miss_m <= hbr_m:
+        return 1.0
+    return float(min(1.0, (hbr_m * hbr_m) / (miss_m * miss_m) * math.exp(-1.0)))
+
+
+def compute_pc(
+    *,
+    miss_m: float,
+    hbr_m: float,
+    r_rel_m: np.ndarray | None = None,
+    v_rel_ms: np.ndarray | None = None,
+    cov1_m2: np.ndarray | None = None,
+    cov2_m2: np.ndarray | None = None,
+    pc_reported: float | None = None,
+) -> PcResult:
+    """Dispatch Pc computation per FR-PC.
+
+    Full state + covariance -> Foster with Chan cross-check.
+    Otherwise -> reported Pc if the source supplied one, else max-Pc bound.
+    """
+    has_full_state = (
+        r_rel_m is not None
+        and v_rel_ms is not None
+        and cov1_m2 is not None
+        and cov2_m2 is not None
+    )
+    if has_full_state:
+        try:
+            mu, c2d = encounter_plane_projection(r_rel_m, v_rel_ms, cov1_m2, cov2_m2)
+            foster = pc_foster(mu, c2d, hbr_m)
+            chan = pc_chan(mu, c2d, hbr_m)
+            reference = max(foster, chan, 1e-300)
+            divergence = abs(foster - chan) / reference > _DIVERGENCE_TOLERANCE
+            if divergence:
+                logger.warning(
+                    "Pc method divergence: foster=%.3e chan=%.3e", foster, chan
+                )
+            return PcResult(
+                value=foster,
+                method="foster-2d",
+                pc_type="computed",
+                cross_check=chan,
+                divergence_flag=divergence,
+            )
+        except PropagationError as exc:
+            logger.warning("Full-state Pc failed (%s); falling back to max-Pc", exc.message)
+
+    if pc_reported is not None and math.isfinite(pc_reported):
+        return PcResult(value=float(pc_reported), method="source-reported", pc_type="reported")
+
+    return PcResult(value=pc_max(miss_m, hbr_m), method="alfano-max", pc_type="max")

kessler_toolkit-0.1.0/kessler_toolkit/exceptions.py

@@ -0,0 +1,64 @@
+# GENERATED from backend/app/logic — edit there, then run packages/sync.py
+"""Typed exception hierarchy — the only errors allowed to cross layer boundaries.
+
+Boundary rule (HLD §4): logic raises, service contextualises/falls back,
+API converts to the JSON error envelope. Nothing else escapes.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+class KesslerError(Exception):
+    code = "KESSLER_ERROR"
+    http_status = 500
+
+    def __init__(self, message: str, detail: Any = None):
+        super().__init__(message)
+        self.message = message
+        self.detail = detail
+
+    def envelope(self, request_id: str = "-") -> dict:
+        return {
+            "error": {
+                "code": self.code,
+                "message": self.message,
+                "detail": self.detail,
+                "request_id": request_id,
+            }
+        }
+
+
+class ConfigError(KesslerError):
+    code = "CONFIG_ERROR"
+    http_status = 500
+
+
+class DataSourceError(KesslerError):
+    code = "DATA_SOURCE_ERROR"
+    http_status = 502
+
+
+class RateLimitError(KesslerError):
+    code = "RATE_LIMITED"
+    http_status = 503
+
+
+class CdmParseError(KesslerError):
+    code = "CDM_PARSE_ERROR"
+    http_status = 422
+
+
+class PropagationError(KesslerError):
+    code = "PROPAGATION_ERROR"
+    http_status = 500
+
+
+class NotFoundError(KesslerError):
+    code = "NOT_FOUND"
+    http_status = 404
+
+
+class ValidationFailure(KesslerError):
+    code = "VALIDATION_ERROR"
+    http_status = 422

kessler_toolkit-0.1.0/kessler_toolkit/propagation.py

@@ -0,0 +1,189 @@
+# GENERATED from backend/app/logic — edit there, then run packages/sync.py
+"""SGP4 propagation utilities (TEME frame) + TCA refinement (FR-SCR-3).
+
+Pure logic: numpy + sgp4 only.
+"""
+from __future__ import annotations
+
+import logging
+import math
+from datetime import datetime, timedelta, timezone
+
+import numpy as np
+from sgp4.api import WGS72, Satrec, jday
+
+from kessler_toolkit.exceptions import PropagationError
+
+logger = logging.getLogger(__name__)
+
+_EARTH_RADIUS_KM = 6378.137
+_DEG = math.pi / 180.0
+# SGP4 mean-motion conversion: rev/day -> rad/min
+_XPDOTP = 1440.0 / (2.0 * math.pi)
+
+
+def load_satrec(omm: dict) -> Satrec:
+    """Build an sgp4 Satrec from an OMM dict (CelesTrak gp.php JSON fields)."""
+    try:
+        epoch = datetime.fromisoformat(str(omm["EPOCH"]).replace("Z", "+00:00"))
+        if epoch.tzinfo is None:
+            epoch = epoch.replace(tzinfo=timezone.utc)
+        # sgp4 epoch: days since 1949 December 31 00:00 UT
+        base = datetime(1949, 12, 31, tzinfo=timezone.utc)
+        epoch_days = (epoch - base).total_seconds() / 86400.0
+
+        sat = Satrec()
+        sat.sgp4init(
+            WGS72,
+            "i",
+            int(omm["NORAD_CAT_ID"]),
+            epoch_days,
+            float(omm.get("BSTAR", 0.0)),
+            float(omm.get("MEAN_MOTION_DOT", 0.0)) * 2.0 * math.pi / (1440.0**2),
+            float(omm.get("MEAN_MOTION_DDOT", 0.0)) * 2.0 * math.pi / (1440.0**3),
+            float(omm["ECCENTRICITY"]),
+            float(omm["ARG_OF_PERICENTER"]) * _DEG,
+            float(omm["INCLINATION"]) * _DEG,
+            float(omm["MEAN_ANOMALY"]) * _DEG,
+            float(omm["MEAN_MOTION"]) / _XPDOTP,  # rad/min
+            float(omm["RA_OF_ASC_NODE"]) * _DEG,
+        )
+        return sat
+    except (KeyError, ValueError, TypeError) as exc:
+        raise PropagationError(
+            f"Invalid OMM element set: {exc}", detail={"norad": omm.get("NORAD_CAT_ID")}
+        ) from exc
+
+
+def state_teme(sat: Satrec, t: datetime) -> tuple[np.ndarray, np.ndarray]:
+    """Position [km] and velocity [km/s] in TEME at time t (UTC)."""
+    if t.tzinfo is None:
+        t = t.replace(tzinfo=timezone.utc)
+    jd, fr = jday(t.year, t.month, t.day, t.hour, t.minute, t.second + t.microsecond / 1e6)
+    code, r, v = sat.sgp4(jd, fr)
+    if code != 0:
+        raise PropagationError(
+            f"SGP4 error code {code} at {t.isoformat()}",
+            detail={"satnum": sat.satnum, "code": code},
+        )
+    return np.array(r), np.array(v)
+
+
+def sample_states(
+    sat: Satrec, t0: datetime, duration_s: float, step_s: float
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Vectorised state sampling. Returns (offsets_s, r[N,3] km, v[N,3] km/s)."""
+    if t0.tzinfo is None:
+        t0 = t0.replace(tzinfo=timezone.utc)
+    n = max(2, int(duration_s / step_s) + 1)
+    offsets = np.arange(n) * step_s
+    jd0, fr0 = jday(t0.year, t0.month, t0.day, t0.hour, t0.minute,
+                    t0.second + t0.microsecond / 1e6)
+    jd = np.full(n, jd0)
+    fr = fr0 + offsets / 86400.0
+    codes, r, v = sat.sgp4_array(jd, fr)
+    if np.all(codes != 0):
+        raise PropagationError(
+            f"SGP4 failed across entire window for sat {sat.satnum}",
+            detail={"first_code": int(codes[0])},
+        )
+    bad = codes != 0
+    if np.any(bad):
+        # mask decayed/err samples with NaN so range math ignores them
+        r = r.copy()
+        r[bad] = np.nan
+    return offsets, r, v
+
+
+def _range_at(sat_a: Satrec, sat_b: Satrec, t: datetime) -> float:
+    ra, _ = state_teme(sat_a, t)
+    rb, _ = state_teme(sat_b, t)
+    return float(np.linalg.norm(ra - rb))
+
+
+def refine_tca(
+    sat_a: Satrec,
+    sat_b: Satrec,
+    t_guess: datetime,
+    half_window_s: float = 90.0,
+    tol_s: float = 0.25,
+) -> tuple[datetime, float, float]:
+    """Golden-section minimisation of inter-satellite range around t_guess.
+
+    Returns (tca, miss_distance_m, relative_speed_ms); TCA accuracy <= tol_s.
+    """
+    phi = (math.sqrt(5.0) - 1.0) / 2.0
+    a, b = -half_window_s, half_window_s
+
+    def f(offset: float) -> float:
+        return _range_at(sat_a, sat_b, t_guess + timedelta(seconds=offset))
+
+    c = b - phi * (b - a)
+    d = a + phi * (b - a)
+    fc, fd = f(c), f(d)
+    while (b - a) > tol_s:
+        if fc < fd:
+            b, d, fd = d, c, fc
+            c = b - phi * (b - a)
+            fc = f(c)
+        else:
+            a, c, fc = c, d, fd
+            d = a + phi * (b - a)
+            fd = f(d)
+    t_offset = 0.5 * (a + b)
+    tca = t_guess + timedelta(seconds=t_offset)
+
+    ra, va = state_teme(sat_a, tca)
+    rb, vb = state_teme(sat_b, tca)
+    miss_m = float(np.linalg.norm(ra - rb)) * 1000.0
+    rel_speed_ms = float(np.linalg.norm(va - vb)) * 1000.0
+    return tca, miss_m, rel_speed_ms
+
+
+def rtn_components(r_primary_km: np.ndarray, v_primary_kms: np.ndarray,
+                   rel_vector_km: np.ndarray) -> np.ndarray:
+    """Express a relative vector in the primary's RTN frame [same units as input]."""
+    r_hat = r_primary_km / np.linalg.norm(r_primary_km)
+    n_vec = np.cross(r_primary_km, v_primary_kms)
+    n_hat = n_vec / np.linalg.norm(n_vec)
+    t_hat = np.cross(n_hat, r_hat)
+    return np.array([
+        float(np.dot(rel_vector_km, r_hat)),
+        float(np.dot(rel_vector_km, t_hat)),
+        float(np.dot(rel_vector_km, n_hat)),
+    ])
+
+
+def ground_track(sat: Satrec, t0: datetime, minutes: int, step_s: int) -> list[dict]:
+    """Sub-satellite points (lat/lon/alt) using spherical Earth + GMST rotation.
+
+    Triage-grade accuracy (no polar motion/nutation) — sufficient for viz.
+    """
+    points: list[dict] = []
+    if t0.tzinfo is None:
+        t0 = t0.replace(tzinfo=timezone.utc)
+    for k in range(0, minutes * 60 + 1, step_s):
+        t = t0 + timedelta(seconds=k)
+        try:
+            r, _ = state_teme(sat, t)
+        except PropagationError:
+            continue  # skip decayed samples, keep the rest of the track
+        # GMST (IAU 1982 approximation)
+        jd, fr = jday(t.year, t.month, t.day, t.hour, t.minute,
+                      t.second + t.microsecond / 1e6)
+        tut1 = (jd + fr - 2451545.0) / 36525.0
+        gmst_s = 67310.54841 + (876600.0 * 3600.0 + 8640184.812866) * tut1 \
+            + 0.093104 * tut1**2 - 6.2e-6 * tut1**3
+        gmst = math.fmod(gmst_s * (math.pi / 43200.0) / 240.0 * 240.0, 2.0 * math.pi)
+        norm = float(np.linalg.norm(r))
+        lat = math.asin(r[2] / norm)
+        lon = math.atan2(r[1], r[0]) - gmst
+        lon = math.atan2(math.sin(lon), math.cos(lon))  # wrap to [-pi, pi]
+        points.append({
+            "t": t,
+            "lat": math.degrees(lat),
+            "lon": math.degrees(lon),
+            "alt_km": norm - _EARTH_RADIUS_KM,
+            "r_eci_km": [float(r[0]), float(r[1]), float(r[2])],
+        })
+    return points

kessler_toolkit-0.1.0/kessler_toolkit/risk_engine.py

@@ -0,0 +1,77 @@
+# GENERATED from backend/app/logic — edit there, then run packages/sync.py
+"""Risk classification, urgency scoring, recommended actions (FR-RSK)."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+# Operator-community Pc thresholds (NASA CARA heritage), FR-RSK-1
+_CRITICAL = 1e-4
+_WARNING = 1e-5
+_MONITOR = 1e-7
+
+_ESCALATION_MISS_M = 1000.0  # <1 km miss without covariance escalates one class
+
+_ORDER = ["NEGLIGIBLE", "MONITOR", "WARNING", "CRITICAL"]
+
+
+def classify(pc: float, pc_type: str, miss_m: float, covariance_available: bool) -> str:
+    if pc >= _CRITICAL:
+        risk = "CRITICAL"
+    elif pc >= _WARNING:
+        risk = "WARNING"
+    elif pc >= _MONITOR:
+        risk = "MONITOR"
+    else:
+        risk = "NEGLIGIBLE"
+
+    if not covariance_available and miss_m < _ESCALATION_MISS_M:
+        idx = _ORDER.index(risk)
+        risk = _ORDER[min(idx + 1, len(_ORDER) - 1)]
+    return risk
+
+
+def urgency(risk: str, tca: datetime, created: datetime | None,
+            now: datetime | None = None) -> float:
+    """0-100 score: base by class + up to 20 for imminent TCA + up to 10 for stale data."""
+    now = now or datetime.now(timezone.utc)
+    base = {"CRITICAL": 70.0, "WARNING": 45.0, "MONITOR": 20.0, "NEGLIGIBLE": 5.0}[risk]
+
+    hours_to_tca = (tca - now).total_seconds() / 3600.0
+    if hours_to_tca <= 0:
+        time_score = 0.0  # event passed
+    elif hours_to_tca >= 24.0:
+        time_score = 2.0
+    else:
+        time_score = 20.0 * (1.0 - hours_to_tca / 24.0)
+
+    stale_score = 0.0
+    if created is not None:
+        age_h = (now - created).total_seconds() / 3600.0
+        stale_score = min(10.0, max(0.0, (age_h - 8.0) / 4.0))
+
+    return round(min(100.0, base + time_score + stale_score), 1)
+
+
+def recommend(risk: str, tca: datetime, covariance_available: bool,
+              now: datetime | None = None, pc_type: str = "computed") -> str:
+    now = now or datetime.now(timezone.utc)
+    hours = max(0.0, (tca - now).total_seconds() / 3600.0)
+    horizon = f"T-{hours:.0f} h" if hours >= 1 else "imminent TCA"
+
+    if risk == "CRITICAL":
+        base = ("Treat as actionable: contact secondary operator, request refreshed "
+                "operator CDM with covariance, evaluate manoeuvre options")
+    elif risk == "WARNING":
+        base = "Elevated: request CDM refresh and re-screen every update cycle"
+    elif risk == "MONITOR":
+        base = "Track: re-screen at next catalogue update"
+    else:
+        base = "No action required; routine monitoring"
+
+    if pc_type == "max":
+        cov_note = " (Pc is a covariance-free upper bound — obtain operator CDM for full-fidelity Pc)"
+    elif not covariance_available:
+        cov_note = " (source-reported Pc; obtain operator CDM with covariance for full-fidelity assessment)"
+    else:
+        cov_note = ""
+    return f"{base} ({horizon}){cov_note}."

kessler_toolkit-0.1.0/kessler_toolkit/screening.py

@@ -0,0 +1,140 @@
+# GENERATED from backend/app/logic — edit there, then run packages/sync.py
+"""Catalogue screening: altitude sieve -> coarse scan -> TCA refinement (FR-SCR)."""
+from __future__ import annotations
+
+import logging
+import math
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+
+import numpy as np
+
+from kessler_toolkit.exceptions import PropagationError
+from kessler_toolkit import propagation
+from kessler_toolkit.collision_probability import pc_max
+
+logger = logging.getLogger(__name__)
+
+_MU_EARTH = 398600.4418  # km^3/s^2
+_EARTH_RADIUS_KM = 6378.137
+
+
+@dataclass
+class CloseApproachHit:
+    norad_id: str
+    name: str
+    object_type: str
+    tca: datetime
+    miss_distance_m: float
+    relative_speed_ms: float
+    miss_rtn_m: list[float]
+    pc_max: float
+
+
+def altitude_band(omm: dict) -> tuple[float, float]:
+    """(perigee_km, apogee_km) altitude band from mean elements."""
+    n_rad_s = float(omm["MEAN_MOTION"]) * 2.0 * math.pi / 86400.0
+    a_km = (_MU_EARTH / (n_rad_s**2)) ** (1.0 / 3.0)
+    ecc = float(omm["ECCENTRICITY"])
+    perigee = a_km * (1.0 - ecc) - _EARTH_RADIUS_KM
+    apogee = a_km * (1.0 + ecc) - _EARTH_RADIUS_KM
+    return perigee, apogee
+
+
+def bands_overlap(band_a: tuple[float, float], band_b: tuple[float, float],
+                  pad_km: float) -> bool:
+    return band_a[0] - pad_km <= band_b[1] and band_b[0] - pad_km <= band_a[1]
+
+
+def screen(
+    asset_omm: dict,
+    catalog: list[dict],
+    start: datetime,
+    window_hours: int,
+    threshold_km: float = 10.0,
+    hbr_m: float = 20.0,
+    coarse_step_s: float = 60.0,
+) -> tuple[int, list[CloseApproachHit]]:
+    """Screen an asset against the catalogue. Returns (objects_screened, hits)."""
+    if start.tzinfo is None:
+        start = start.replace(tzinfo=timezone.utc)
+    duration_s = window_hours * 3600.0
+
+    asset_sat = propagation.load_satrec(asset_omm)
+    asset_band = altitude_band(asset_omm)
+    asset_id = str(asset_omm["NORAD_CAT_ID"])
+
+    _, asset_r, asset_v = propagation.sample_states(asset_sat, start, duration_s, coarse_step_s)
+
+    screened = 0
+    hits: list[CloseApproachHit] = []
+    coarse_gate_km = max(threshold_km * 5.0, 50.0)
+
+    for omm in catalog:
+        norad = str(omm.get("NORAD_CAT_ID", ""))
+        if norad == asset_id:
+            continue
+        try:
+            band = altitude_band(omm)
+        except (KeyError, ValueError, ZeroDivisionError):
+            logger.warning("Skipping catalogue object with bad elements: %s", norad)
+            continue
+        if not bands_overlap(asset_band, band, pad_km=threshold_km + 5.0):
+            continue  # FR-SCR-2 sieve
+
+        screened += 1
+        try:
+            _, obj_r, _ = propagation.sample_states(
+                propagation.load_satrec(omm), start, duration_s, coarse_step_s
+            )
+        except PropagationError as exc:
+            logger.warning("Propagation failed for %s: %s", norad, exc.message)
+            continue
+
+        n = min(len(asset_r), len(obj_r))
+        ranges = np.linalg.norm(asset_r[:n] - obj_r[:n], axis=1)
+        if np.all(np.isnan(ranges)):
+            continue
+
+        # local minima below the coarse gate (NaN-safe)
+        with np.errstate(invalid="ignore"):
+            candidates = [
+                i for i in range(1, n - 1)
+                if ranges[i] == ranges[i] and ranges[i] < coarse_gate_km
+                and ranges[i] <= ranges[i - 1] and ranges[i] <= ranges[i + 1]
+            ]
+
+        obj_sat = propagation.load_satrec(omm)
+        seen_tca: list[datetime] = []
+        for idx in candidates:
+            t_guess = start + timedelta(seconds=idx * coarse_step_s)
+            try:
+                tca, miss_m, rel_speed = propagation.refine_tca(
+                    asset_sat, obj_sat, t_guess, half_window_s=coarse_step_s * 1.5
+                )
+            except PropagationError as exc:
+                logger.warning("TCA refinement failed for %s: %s", norad, exc.message)
+                continue
+            if miss_m > threshold_km * 1000.0:
+                continue
+            if any(abs((tca - prev).total_seconds()) < 30.0 for prev in seen_tca):
+                continue  # duplicate minimum from adjacent samples
+            seen_tca.append(tca)
+
+            r_a, v_a = propagation.state_teme(asset_sat, tca)
+            r_b, _ = propagation.state_teme(obj_sat, tca)
+            rtn_km = propagation.rtn_components(r_a, v_a, r_b - r_a)
+
+            hits.append(CloseApproachHit(
+                norad_id=norad,
+                name=str(omm.get("OBJECT_NAME", "UNKNOWN")),
+                object_type=str(omm.get("OBJECT_TYPE", "UNKNOWN")),
+                tca=tca,
+                miss_distance_m=miss_m,
+                relative_speed_ms=rel_speed,
+                miss_rtn_m=[c * 1000.0 for c in rtn_km],
+                pc_max=pc_max(miss_m, hbr_m),
+            ))
+
+    hits.sort(key=lambda h: h.miss_distance_m)
+    return screened, hits

kessler_toolkit-0.1.0/kessler_toolkit.egg-info/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: kessler-toolkit
+Version: 0.1.0
+Summary: Open conjunction assessment: CCSDS CDM parsing, collision probability (Foster/Chan/Max-Pc), SGP4 screening, and risk triage — pure Python.
+Author-email: Ashutosh <siddhvasudev1402@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/siddhashutosh/kessler
+Project-URL: Documentation, https://github.com/siddhashutosh/kessler/tree/main/documents
+Project-URL: Issues, https://github.com/siddhashutosh/kessler/issues
+Keywords: astrodynamics,conjunction-assessment,collision-probability,space-debris,CDM,CCSDS,SGP4,space-traffic-management,SSA
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: sgp4>=2.23
+Requires-Dist: python-dateutil>=2.9
+
+# kessler-toolkit
+
+Open conjunction assessment for Python: parse CCSDS Conjunction Data Messages,
+compute collision probability three honest ways, screen a satellite against a
+catalogue, and triage the results — no MATLAB license required.
+
+Extracted from [KESSLER](https://github.com/siddhashutosh/kessler), where the same
+code powers a live dashboard over the public Space-Track feed.
+
+```bash
+pip install kessler-toolkit
+```
+
+## What's inside
+
+| Module | Purpose |
+|---|---|
+| `cdm_parser` | CCSDS 508.0-B-1 KVN CDMs (incl. RTN covariance) and Space-Track `cdm_public` JSON → typed `Cdm` |
+| `collision_probability` | Foster 2-D numerical Pc, Chan analytic series (cross-check), covariance-free Max-Pc bound |
+| `propagation` | SGP4 wrapper (TEME), close-approach refinement to sub-second TCA, ground tracks |
+| `screening` | Catalogue screening: altitude sieve → coarse scan → refined TCA + RTN miss components |
+| `risk_engine` | Operator-community risk classes (1e-4 / 1e-5 / 1e-7), urgency scoring, recommended actions |
+
+## Quick start
+
+```python
+from kessler_toolkit import parse_cdm_kvn, compute_pc
+
+cdm = parse_cdm_kvn(open("conjunction.cdm").read())
+
+result = compute_pc(
+    miss_m=cdm.miss_distance_m,
+    hbr_m=20.0,
+    r_rel_m=cdm.rel_position_rtn_m,
+    v_rel_ms=cdm.rel_velocity_rtn_ms,
+    cov1_m2=cdm.sat1.cov_rtn_m2,
+    cov2_m2=cdm.sat2.cov_rtn_m2,
+    pc_reported=cdm.pc_reported,
+)
+print(result.value, result.method, result.pc_type)
+# e.g. 2.19e-04 foster-2d computed  — with Chan cross-check in result.cross_check
+```
+
+Every result carries `pc_type` — `"computed"` (full covariance), `"reported"`
+(source value), or `"max"` (conservative upper bound) — so downstream code can
+never mistake a triage bound for a measurement.
+
+Validated against the closed-form isotropic solution (<0.1% error) and
+Foster/Chan cross-agreement; screening results are triage-grade (SGP4/GP
+accuracy limits apply) — not a substitute for operator ephemerides.
+
+Apache-2.0. Orbital data used with KESSLER courtesy of Space-Track.org and CelesTrak.

kessler_toolkit-0.1.0/kessler_toolkit.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+kessler_toolkit/__init__.py
+kessler_toolkit/cdm_parser.py
+kessler_toolkit/collision_probability.py
+kessler_toolkit/exceptions.py
+kessler_toolkit/propagation.py
+kessler_toolkit/risk_engine.py
+kessler_toolkit/screening.py
+kessler_toolkit.egg-info/PKG-INFO
+kessler_toolkit.egg-info/SOURCES.txt
+kessler_toolkit.egg-info/dependency_links.txt
+kessler_toolkit.egg-info/requires.txt
+kessler_toolkit.egg-info/top_level.txt

kessler_toolkit-0.1.0/kessler_toolkit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kessler_toolkit-0.1.0/kessler_toolkit.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.24
+sgp4>=2.23
+python-dateutil>=2.9

kessler_toolkit-0.1.0/kessler_toolkit.egg-info/top_level.txt

@@ -0,0 +1 @@
+kessler_toolkit

kessler_toolkit-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kessler-toolkit"
+version = "0.1.0"
+description = "Open conjunction assessment: CCSDS CDM parsing, collision probability (Foster/Chan/Max-Pc), SGP4 screening, and risk triage — pure Python."
+readme = "README.md"
+license = { text = "Apache-2.0" }
+requires-python = ">=3.9"
+authors = [{ name = "Ashutosh", email = "siddhvasudev1402@gmail.com" }]
+keywords = [
+  "astrodynamics", "conjunction-assessment", "collision-probability",
+  "space-debris", "CDM", "CCSDS", "SGP4", "space-traffic-management", "SSA",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering :: Astronomy",
+  "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+  "numpy>=1.24",
+  "sgp4>=2.23",
+  "python-dateutil>=2.9",
+]
+
+[project.urls]
+Homepage = "https://github.com/siddhashutosh/kessler"
+Documentation = "https://github.com/siddhashutosh/kessler/tree/main/documents"
+Issues = "https://github.com/siddhashutosh/kessler/issues"
+
+[tool.setuptools]
+packages = ["kessler_toolkit"]

kessler_toolkit-0.1.0/setup.cfg

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