cronphase 0.2.1__py3-none-any.whl

cronphase/__init__.py

@@ -0,0 +1,21 @@
+"""
+cronphase — Fleet-wide cron thundering-herd detector & deterministic phase-shift solver.
+"""
+
+from .parser import CronExpression, ScheduledJob, parse_manifest
+from .engine import SimulationResult, simulate_day
+from .solver import SolverConfig, optimize_fleet
+from .diff import generate_unified_diff, apply_rewrites
+
+__version__ = "0.2.1"
+__all__ = [
+    "CronExpression",
+    "ScheduledJob",
+    "parse_manifest",
+    "SimulationResult",
+    "simulate_day",
+    "SolverConfig",
+    "optimize_fleet",
+    "generate_unified_diff",
+    "apply_rewrites",
+]

cronphase/__main__.py

@@ -0,0 +1,5 @@
+import sys
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

cronphase/cli.py

@@ -0,0 +1,136 @@
+"""
+Command-Line Interface for `cronphase`.
+Usage:
+  python3 -m cronphase examples/prod.crontab --optimize --diff
+"""
+
+from __future__ import annotations
+import argparse
+import json
+import sys
+from typing import List, Optional
+from .parser import parse_manifest
+from .engine import format_hhmm, simulate_day
+from .solver import SolverConfig, optimize_fleet
+from .diff import apply_rewrites, generate_unified_diff
+
+
+def _ascii_sparkline(values: List[float], width: int = 48) -> str:
+    blocks = " ▂▃▄▅▆▇█"
+    if not values:
+        return ""
+    step = max(1, len(values) // width)
+    bucketed = [max(values[i : i + step]) for i in range(0, len(values), step)][:width]
+    hi = max(bucketed) if bucketed else 1.0
+    if hi <= 0:
+        return blocks[0] * len(bucketed)
+    return "".join(blocks[min(len(blocks) - 1, int((v / hi) * (len(blocks) - 1)))] for v in bucketed)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="cronphase",
+        description="Fleet-wide cron thundering-herd analyzer & deterministic phase-shift compiler.",
+    )
+    parser.add_argument("manifest", help="Path to crontab, Kubernetes CronJob YAML, or GitHub Actions YAML ('-' for stdin)")
+    parser.add_argument("--optimize", "-o", action="store_true", help="Run constrained phase-shift solver")
+    parser.add_argument(
+        "--strategy",
+        choices=["anneal", "prime-splay", "fnv-hash"],
+        default="anneal",
+        help="Phase-shift solver algorithm (default: anneal)",
+    )
+    parser.add_argument("--diff", "-d", action="store_true", help="Output unified git diff patch")
+    parser.add_argument("--json", action="store_true", help="Output machine-readable JSON report")
+    parser.add_argument(
+        "--max-crest-factor",
+        type=float,
+        default=None,
+        help="Exit with code 2 if Crest Factor (Peak/Mean load) exceeds threshold (for CI linting)",
+    )
+
+    args = parser.parse_args(argv)
+    if args.manifest == "-":
+        raw = sys.stdin.read()
+        fname = "stdin.crontab"
+    else:
+        with open(args.manifest, "r", encoding="utf-8") as f:
+            raw = f.read()
+        fname = args.manifest.rsplit("/", 1)[-1]
+
+    jobs = parse_manifest(raw)
+    if not jobs:
+        print("cronphase: no valid cron schedules found in input.", file=sys.stderr)
+        return 1
+
+    cfg = SolverConfig(strategy=args.strategy)
+    if args.optimize or args.diff:
+        opt_jobs, rewrites, before_sim, after_sim = optimize_fleet(jobs, cfg)
+    else:
+        before_sim = simulate_day(jobs)
+        opt_jobs, rewrites, after_sim = jobs, [], before_sim
+
+    if args.json:
+        payload = {
+            "job_count": len(jobs),
+            "before": {
+                "peak_concurrency": before_sim.peak_concurrency,
+                "peak_load": before_sim.peak_load,
+                "peak_time": format_hhmm(before_sim.peak_minute),
+                "mean_load": before_sim.mean_load,
+                "crest_factor": before_sim.crest_factor,
+                "collision_minutes": before_sim.collision_minutes_count,
+                "harmonics": before_sim.harmonic_buckets,
+            },
+            "after": {
+                "peak_concurrency": after_sim.peak_concurrency,
+                "peak_load": after_sim.peak_load,
+                "peak_time": format_hhmm(after_sim.peak_minute),
+                "mean_load": after_sim.mean_load,
+                "crest_factor": after_sim.crest_factor,
+                "collision_minutes": after_sim.collision_minutes_count,
+                "harmonics": after_sim.harmonic_buckets,
+            },
+            "rewrites": [
+                {
+                    "job_id": r.job_id,
+                    "job_name": r.job_name,
+                    "old_expr": r.old_expr,
+                    "new_expr": r.new_expr,
+                    "phase_shift_minutes": r.phase_shift_minutes,
+                }
+                for r in rewrites
+            ],
+        }
+        print(json.dumps(payload, indent=2))
+    else:
+        print(f"CRONPHASE // FLEET HARMONIC & COLLISION REPORT ({len(jobs)} jobs parsed)")
+        print("=" * 74)
+        b_loads = [s.load for s in before_sim.timeline]
+        print(
+            f"BASELINE   | Peak Load: {before_sim.peak_load:5.1f} ({before_sim.peak_concurrency} jobs @ {format_hhmm(before_sim.peak_minute)}) "
+            f"| Crest: {before_sim.crest_factor:4.2f}x | Collisions: {before_sim.collision_minutes_count}m"
+        )
+        print(f"WAVEFORM   | [{_ascii_sparkline(b_loads, 48)}] (00:00..23:59)")
+        if args.optimize or args.diff:
+            a_loads = [s.load for s in after_sim.timeline]
+            drop_pct = ((before_sim.peak_load - after_sim.peak_load) / before_sim.peak_load * 100.0) if before_sim.peak_load else 0.0
+            print(
+                f"OPTIMIZED  | Peak Load: {after_sim.peak_load:5.1f} ({after_sim.peak_concurrency} jobs @ {format_hhmm(after_sim.peak_minute)}) "
+                f"| Crest: {after_sim.crest_factor:4.2f}x | Peak Drop: -{drop_pct:.1f}%"
+            )
+            print(f"DE-PHASED  | [{_ascii_sparkline(a_loads, 48)}] ({len(rewrites)} schedules shifted)")
+
+        if args.diff and rewrites:
+            print("\n" + "-" * 74)
+            rewritten_text = apply_rewrites(raw, jobs, rewrites)
+            print(generate_unified_diff(raw, rewritten_text, filename=fname).rstrip())
+
+    active_sim = after_sim if (args.optimize or args.diff) else before_sim
+    if args.max_crest_factor is not None and active_sim.crest_factor > args.max_crest_factor:
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

cronphase/diff.py

@@ -0,0 +1,51 @@
+"""
+Unified Diff & Rewritten Manifest Generator for Crontab, Kubernetes YAML, and GitHub Actions.
+"""
+
+from __future__ import annotations
+import difflib
+from typing import Dict, List
+from .parser import ScheduledJob
+from .solver import JobRewrite
+
+
+def apply_rewrites(original_text: str, jobs: List[ScheduledJob], rewrites: List[JobRewrite]) -> str:
+    """Applies phase-shifted cron expressions back to the original manifest line-by-line."""
+    rewrite_by_id: Dict[str, JobRewrite] = {r.job_id: r for r in rewrites}
+    line_to_rewrite: Dict[int, JobRewrite] = {}
+    for j in jobs:
+        if j.id in rewrite_by_id and j.source_line > 0:
+            line_to_rewrite[j.source_line] = rewrite_by_id[j.id]
+
+    out_lines: List[str] = []
+    for idx, line in enumerate(original_text.splitlines(keepends=True), start=1):
+        rw = line_to_rewrite.get(idx)
+        if rw is not None:
+            # Replace only inside the schedule portion before any trailing comment
+            comment_idx = line.find(" #")
+            if comment_idx != -1:
+                head = line[:comment_idx].replace(rw.old_expr, rw.new_expr, 1)
+                replaced = head + line[comment_idx:]
+            else:
+                replaced = line.replace(rw.old_expr, rw.new_expr, 1)
+            out_lines.append(replaced)
+        else:
+            out_lines.append(line)
+    return "".join(out_lines)
+
+
+def generate_unified_diff(
+    original_text: str,
+    rewritten_text: str,
+    filename: str = "crontab",
+) -> str:
+    orig_lines = [ln if ln.endswith("\n") else ln + "\n" for ln in original_text.splitlines()]
+    new_lines = [ln if ln.endswith("\n") else ln + "\n" for ln in rewritten_text.splitlines()]
+    diff = difflib.unified_diff(
+        orig_lines,
+        new_lines,
+        fromfile=f"a/{filename}",
+        tofile=f"b/{filename}",
+        lineterm="\n",
+    )
+    return "".join(diff)

cronphase/engine.py

@@ -0,0 +1,167 @@
+"""
+1,440-Minute Diurnal Concurrency, Resource Load & Harmonic Spectrum Simulator.
+Accurately models multi-minute job durations, midnight wrap-around spillover,
+crest factor (Peak / Mean), and pairwise job collision matrices.
+"""
+
+from __future__ import annotations
+import dataclasses
+import math
+from typing import Dict, List, Tuple
+from .parser import ScheduledJob
+
+
+@dataclasses.dataclass
+class MinuteSlice:
+    minute: int  # 0..1439
+    concurrency: int
+    load: float
+    active_job_ids: List[str]
+    resource_loads: Dict[str, float]
+
+
+@dataclasses.dataclass
+class CollisionSpike:
+    minute: int
+    time_label: str
+    concurrency: int
+    total_load: float
+    dominant_resource: str
+    job_names: List[str]
+
+
+@dataclasses.dataclass
+class SimulationResult:
+    timeline: List[MinuteSlice]
+    peak_concurrency: int
+    peak_load: float
+    peak_minute: int
+    mean_load: float
+    p95_load: float
+    l2_energy: float
+    crest_factor: float
+    collision_minutes_count: int
+    harmonic_buckets: Dict[str, int]
+    top_spikes: List[CollisionSpike]
+    pairwise_overlaps: Dict[Tuple[str, str], int]
+
+
+def format_hhmm(minute: int) -> str:
+    m = minute % 1440
+    return f"{m // 60:02d}:{m % 60:02d}"
+
+
+def simulate_day(jobs: List[ScheduledJob], collision_threshold: int = 3) -> SimulationResult:
+    timeline: List[MinuteSlice] = [
+        MinuteSlice(minute=m, concurrency=0, load=0.0, active_job_ids=[], resource_loads={})
+        for m in range(1440)
+    ]
+
+    harmonic_buckets: Dict[str, int] = {
+        ":00": 0,
+        ":15": 0,
+        ":30": 0,
+        ":45": 0,
+        "5m-grid": 0,
+        "prime/off-grid": 0,
+    }
+
+    for job in jobs:
+        starts = job.cron.firing_minutes_in_day()
+        dur = max(1, job.duration_min)
+        for start_min in starts:
+            mod_m = start_min % 60
+            if mod_m == 0:
+                harmonic_buckets[":00"] += 1
+            elif mod_m == 15:
+                harmonic_buckets[":15"] += 1
+            elif mod_m == 30:
+                harmonic_buckets[":30"] += 1
+            elif mod_m == 45:
+                harmonic_buckets[":45"] += 1
+            elif mod_m % 5 == 0:
+                harmonic_buckets["5m-grid"] += 1
+            else:
+                harmonic_buckets["prime/off-grid"] += 1
+
+            for offset in range(dur):
+                m_idx = (start_min + offset) % 1440
+                sl = timeline[m_idx]
+                if job.id not in sl.active_job_ids:
+                    sl.active_job_ids.append(job.id)
+                    sl.concurrency += 1
+                    sl.load = round(sl.load + job.weight, 4)
+                    sl.resource_loads[job.resource] = round(
+                        sl.resource_loads.get(job.resource, 0.0) + job.weight, 4
+                    )
+
+    job_map = {j.id: j for j in jobs}
+    loads = [sl.load for sl in timeline]
+    concurrencies = [sl.concurrency for sl in timeline]
+
+    peak_load = max(loads) if loads else 0.0
+    peak_concurrency = max(concurrencies) if concurrencies else 0
+    peak_minute = 0
+    for sl in timeline:
+        if sl.load == peak_load:
+            peak_minute = sl.minute
+            break
+
+    mean_load = sum(loads) / 1440.0 if loads else 0.0
+    sorted_loads = sorted(loads)
+    p95_load = sorted_loads[int(1440 * 0.95)] if sorted_loads else 0.0
+    l2_energy = math.sqrt(sum(x * x for x in loads) / 1440.0) if loads else 0.0
+    crest_factor = (peak_load / mean_load) if mean_load > 1e-6 else 1.0
+    collision_minutes_count = sum(1 for sl in timeline if sl.concurrency >= collision_threshold)
+
+    pairwise: Dict[Tuple[str, str], int] = {}
+    for sl in timeline:
+        active = sl.active_job_ids
+        n = len(active)
+        if n > 1:
+            for i in range(n):
+                for k in range(i + 1, n):
+                    pair = (active[i], active[k]) if active[i] < active[k] else (active[k], active[i])
+                    pairwise[pair] = pairwise.get(pair, 0) + 1
+
+    candidate_slices = sorted(
+        [sl for sl in timeline if sl.concurrency >= 2],
+        key=lambda s: (s.load, s.concurrency, -s.minute),
+        reverse=True,
+    )
+    top_spikes: List[CollisionSpike] = []
+    used_minutes: List[int] = []
+    for sl in candidate_slices:
+        if any(min((sl.minute - u) % 1440, (u - sl.minute) % 1440) < 5 for u in used_minutes):
+            continue
+        used_minutes.append(sl.minute)
+        dom_res = "none"
+        if sl.resource_loads:
+            dom_res = max(sl.resource_loads.items(), key=lambda kv: kv[1])[0]
+        top_spikes.append(
+            CollisionSpike(
+                minute=sl.minute,
+                time_label=format_hhmm(sl.minute),
+                concurrency=sl.concurrency,
+                total_load=round(sl.load, 2),
+                dominant_resource=dom_res,
+                job_names=[job_map[jid].name for jid in sl.active_job_ids],
+            )
+        )
+        if len(top_spikes) >= 8:
+            break
+
+    return SimulationResult(
+        timeline=timeline,
+        peak_concurrency=peak_concurrency,
+        peak_load=round(peak_load, 2),
+        peak_minute=peak_minute,
+        mean_load=round(mean_load, 2),
+        p95_load=round(p95_load, 2),
+        l2_energy=round(l2_energy, 2),
+        crest_factor=round(crest_factor, 2),
+        collision_minutes_count=collision_minutes_count,
+        harmonic_buckets=harmonic_buckets,
+        top_spikes=top_spikes,
+        pairwise_overlaps=pairwise,
+    )

cronphase/parser.py

@@ -0,0 +1,413 @@
+"""
+Multi-format parser for UNIX Crontab, Kubernetes CronJob YAML, and GitHub Actions workflows.
+Supports standard 5-field cron expressions, @hourly/@daily/@weekly/@midnight macros,
+and inline or heuristic job metadata (@duration, @weight, @window, @lock, @resource).
+"""
+
+from __future__ import annotations
+import dataclasses
+import re
+from typing import Dict, List, Optional, Set, Tuple
+
+MACROS: Dict[str, str] = {
+    "@yearly": "0 0 1 1 *",
+    "@annually": "0 0 1 1 *",
+    "@monthly": "0 0 1 * *",
+    "@weekly": "0 0 * * 0",
+    "@daily": "0 0 * * *",
+    "@midnight": "0 0 * * *",
+    "@hourly": "0 * * * *",
+}
+
+MONTH_NAMES = {
+    "jan": 1, "feb": 2, "mar": 3, "apr": 4, "may": 5, "jun": 6,
+    "jul": 7, "aug": 8, "sep": 9, "oct": 10, "nov": 11, "dec": 12,
+}
+
+DOW_NAMES = {
+    "sun": 0, "mon": 1, "tue": 2, "wed": 3, "thu": 4, "fri": 5, "sat": 6,
+}
+
+
+@dataclasses.dataclass(frozen=True)
+class CronExpression:
+    raw: str
+    minute_field: str
+    hour_field: str
+    dom_field: str
+    month_field: str
+    dow_field: str
+    minutes: Tuple[int, ...]
+    hours: Tuple[int, ...]
+    doms: Tuple[int, ...]
+    months: Tuple[int, ...]
+    dows: Tuple[int, ...]
+    dom_restricted: bool
+    dow_restricted: bool
+
+    @classmethod
+    def parse(cls, expr: str) -> "CronExpression":
+        cleaned = expr.strip()
+        if cleaned.lower() in MACROS:
+            cleaned = MACROS[cleaned.lower()]
+        parts = cleaned.split()
+        if len(parts) != 5:
+            raise ValueError(f"Expected 5 cron fields, got {len(parts)} in '{expr}'")
+
+        m_str, h_str, dom_str, mon_str, dow_str = parts
+        minutes = tuple(sorted(_parse_field(m_str, 0, 59)))
+        hours = tuple(sorted(_parse_field(h_str, 0, 23)))
+        doms = tuple(sorted(_parse_field(dom_str, 1, 31)))
+        months = tuple(sorted(_parse_field(mon_str, 1, 12, MONTH_NAMES)))
+        dows_raw = _parse_field(dow_str, 0, 7, DOW_NAMES)
+        dows = tuple(sorted({0 if d == 7 else d for d in dows_raw}))
+
+        return cls(
+            raw=expr.strip(),
+            minute_field=m_str,
+            hour_field=h_str,
+            dom_field=dom_str,
+            month_field=mon_str,
+            dow_field=dow_str,
+            minutes=minutes,
+            hours=hours,
+            doms=doms,
+            months=months,
+            dows=dows,
+            dom_restricted=(dom_str != "*"),
+            dow_restricted=(dow_str != "*"),
+        )
+
+    def matches_minute_of_day(
+        self,
+        minute_of_day: int,
+        day_of_week: int = 0,
+        day_of_month: int = 1,
+        month: int = 1,
+    ) -> bool:
+        if month not in self.months:
+            return False
+        # Standard Vixie cron semantics: if both DOM and DOW are restricted (not '*'),
+        # match if EITHER matches; otherwise both must match.
+        if self.dom_restricted and self.dow_restricted:
+            day_match = (day_of_month in self.doms) or (day_of_week in self.dows)
+        else:
+            day_match = (day_of_month in self.doms) and (day_of_week in self.dows)
+        if not day_match:
+            return False
+
+        h = (minute_of_day // 60) % 24
+        m = minute_of_day % 60
+        return (h in self.hours) and (m in self.minutes)
+
+    def firing_minutes_in_day(self) -> List[int]:
+        """Returns sorted list of minutes [0..1439] in a representative active day."""
+        out: List[int] = []
+        for h in self.hours:
+            base = h * 60
+            for m in self.minutes:
+                out.append(base + m)
+        return out
+
+    def format_canonical(self) -> str:
+        return f"{self.minute_field} {self.hour_field} {self.dom_field} {self.month_field} {self.dow_field}"
+
+
+def _parse_field(
+    field: str,
+    min_val: int,
+    max_val: int,
+    names: Optional[Dict[str, int]] = None,
+) -> Set[int]:
+    text = field.strip().lower()
+    if names:
+        for k, v in names.items():
+            text = re.sub(rf"\b{k}\b", str(v), text)
+
+    result: Set[int] = set()
+    for part in text.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        step = 1
+        if "/" in part:
+            range_part, step_str = part.split("/", 1)
+            step = int(step_str)
+            if step <= 0:
+                raise ValueError(f"Step must be positive in '{field}'")
+        else:
+            range_part = part
+
+        if range_part == "*":
+            start, end = min_val, max_val
+        elif "-" in range_part:
+            s_str, e_str = range_part.split("-", 1)
+            start, end = int(s_str), int(e_str)
+        else:
+            val = int(range_part)
+            if "/" in part:
+                start, end = val, max_val
+            else:
+                start, end = val, val
+
+        if start < min_val or end > max_val or start > end:
+            raise ValueError(
+                f"Field '{field}' value out of bounds [{min_val}..{max_val}]"
+            )
+        for v in range(start, end + 1, step):
+            result.add(v)
+
+    if not result:
+        raise ValueError(f"Empty cron field '{field}'")
+    return result
+
+
+@dataclasses.dataclass
+class ScheduledJob:
+    id: str
+    name: str
+    cron: CronExpression
+    command: str
+    duration_min: int = 3
+    weight: float = 2.0
+    resource: str = "db-primary"
+    locked: bool = False
+    window_start_hour: Optional[int] = None
+    window_end_hour: Optional[int] = None
+    source_line: int = 0
+    source_format: str = "crontab"  # 'crontab' | 'k8s' | 'github'
+
+
+def infer_job_profile(name: str, command: str) -> Tuple[int, float, str]:
+    """Heuristically estimates duration (minutes), load weight (1-10), and primary resource."""
+    text = f"{name} {command}".lower()
+    if any(k in text for k in ("pg_dump", "mysqldump", "backup", "snapshot", "xtrabackup")):
+        return 12, 8.5, "db-replica"
+    if any(k in text for k in ("vacuum", "reindex", "analyze", "optimize", "migration")):
+        return 9, 9.0, "db-primary"
+    if any(k in text for k in ("dbt", "warehouse", "snowflake", "bigquery", "spark", "etl", "rollup")):
+        return 8, 7.0, "analytics-db"
+    if any(k in text for k in ("billing", "invoice", "stripe", "ledger", "payout", "reconcile")):
+        return 6, 6.5, "db-primary"
+    if any(k in text for k in ("rsync", "s3", "rclone", "export", "sitemap", "feed")):
+        return 5, 4.5, "storage-io"
+    if any(k in text for k in ("pytest", "playwright", "cypress", "e2e", "audit", "trivy", "codeql")):
+        return 7, 5.5, "ci-pool"
+    if any(k in text for k in ("cache", "redis", "flush", "warm", "prune", "gc", "cleanup")):
+        return 3, 4.0, "redis-cluster"
+    if any(k in text for k in ("health", "ping", "heartbeat", "metrics", "exporter")):
+        return 1, 1.2, "api-gateway"
+    return 3, 3.0, "db-primary"
+
+
+_CRONTAB_LINE_RE = re.compile(
+    r"^\s*(?:(@(?:yearly|annually|monthly|weekly|daily|midnight|hourly))|"
+    r"(\S+\s+\S+\s+\S+\s+\S+\s+\S+))\s+(.+?)$",
+    re.IGNORECASE,
+)
+
+
+def _extract_annotations(text: str) -> Dict[str, str]:
+    """Parses @duration=5m @weight=4 @resource=db @window=01-05 @lock tags from comments."""
+    meta: Dict[str, str] = {}
+    for m in re.finditer(r"@(duration|weight|resource|window|name|id)=([^\s#]+)", text):
+        meta[m.group(1).lower()] = m.group(2)
+    if re.search(r"@lock\b", text):
+        meta["lock"] = "true"
+    return meta
+
+
+def parse_manifest(content: str) -> List[ScheduledJob]:
+    """Auto-detects and parses UNIX crontab, Kubernetes CronJob YAML, or GitHub Actions YAML."""
+    lines = content.splitlines()
+    is_yaml = any(
+        re.match(r"^\s*(apiVersion:|kind:\s*CronJob|on:|schedule:|-\s*cron:)", ln)
+        for ln in lines
+    )
+    if is_yaml:
+        return _parse_yaml_schedules(lines)
+    return _parse_crontab(lines)
+
+
+def _parse_crontab(lines: List[str]) -> List[ScheduledJob]:
+    jobs: List[ScheduledJob] = []
+    pending_comment = ""
+    for idx, raw_line in enumerate(lines, start=1):
+        stripped = raw_line.strip()
+        if not stripped:
+            pending_comment = ""
+            continue
+        if stripped.startswith("#"):
+            pending_comment += " " + stripped[1:].strip()
+            continue
+        if re.match(r"^[A-Za-z_][A-Za-z0-9_]*\s*=", stripped):
+            continue
+
+        m = _CRONTAB_LINE_RE.match(stripped)
+        if not m:
+            continue
+        expr_str = m.group(1) or m.group(2)
+        rest = m.group(3).strip()
+
+        if " #" in rest:
+            cmd_part, inline_comment = rest.split(" #", 1)
+        else:
+            cmd_part, inline_comment = rest, ""
+
+        tokens = cmd_part.split()
+        if len(tokens) >= 2 and tokens[0] in ("root", "ubuntu", "postgres", "www-data", "app", "cron"):
+            cmd_clean = " ".join(tokens[1:])
+        else:
+            cmd_clean = cmd_part.strip()
+
+        full_comment = f"{pending_comment} {inline_comment}".strip()
+        pending_comment = ""
+
+        try:
+            cron = CronExpression.parse(expr_str)
+        except ValueError:
+            continue
+
+        meta = _extract_annotations(full_comment)
+        job_id = f"job-{len(jobs) + 1:02d}"
+        name = meta.get("name") or _derive_job_name(cmd_clean, full_comment, len(jobs) + 1)
+        dur, weight, resource = infer_job_profile(name, cmd_clean)
+
+        if "duration" in meta:
+            dur_val = re.sub(r"[^0-9]", "", meta["duration"])
+            if dur_val:
+                dur = max(1, min(180, int(dur_val)))
+        if "weight" in meta:
+            try:
+                weight = max(0.5, min(25.0, float(meta["weight"])))
+            except ValueError:
+                pass
+        if "resource" in meta:
+            resource = meta["resource"]
+
+        win_start, win_end = None, None
+        if "window" in meta:
+            wm = re.match(r"(\d{1,2})(?::\d{2})?-(\d{1,2})(?::\d{2})?", meta["window"])
+            if wm:
+                win_start, win_end = int(wm.group(1)) % 24, int(wm.group(2)) % 24
+
+        jobs.append(
+            ScheduledJob(
+                id=job_id,
+                name=name,
+                cron=cron,
+                command=cmd_clean,
+                duration_min=dur,
+                weight=weight,
+                resource=resource,
+                locked=("lock" in meta),
+                window_start_hour=win_start,
+                window_end_hour=win_end,
+                source_line=idx,
+                source_format="crontab",
+            )
+        )
+    return jobs
+
+
+_YAML_NAME_RE = re.compile(r"""^name:\s*['"]?([A-Za-z0-9_.-]+(?:\s+[A-Za-z0-9_.-]+)*)['"]?""")
+_YAML_SCHED_RE = re.compile(
+    r"""^(?:schedule|-\s*cron):\s*['"]?(@[a-zA-Z]+|[^'"#]+?)['"]?\s*(?:#(.*))?$"""
+)
+
+
+def _parse_yaml_schedules(lines: List[str]) -> List[ScheduledJob]:
+    """Parses Kubernetes CronJob manifests and GitHub Actions workflow schedules."""
+    jobs: List[ScheduledJob] = []
+    current_name: Optional[str] = None
+    current_cmd: str = ""
+    current_comment: str = ""
+
+    for idx, raw_line in enumerate(lines, start=1):
+        stripped = raw_line.strip()
+        if stripped.startswith("#"):
+            current_comment += " " + stripped[1:].strip()
+            continue
+        if stripped == "---":
+            current_name = None
+            current_cmd = ""
+            current_comment = ""
+            continue
+
+        name_m = _YAML_NAME_RE.match(stripped)
+        if name_m and not current_name:
+            current_name = name_m.group(1).strip()
+
+        sched_m = _YAML_SCHED_RE.match(stripped)
+        if sched_m:
+            expr_str = sched_m.group(1).strip()
+            inline_c = (sched_m.group(2) or "").strip()
+            fmt = "github" if stripped.startswith("-") or "cron:" in stripped else "k8s"
+            try:
+                cron = CronExpression.parse(expr_str)
+            except ValueError:
+                continue
+
+            full_meta_text = f"{current_comment} {inline_c}".strip()
+            meta = _extract_annotations(full_meta_text)
+            job_idx = len(jobs) + 1
+            j_name = meta.get("name") or current_name or f"{fmt}-job-{job_idx:02d}"
+            dur, weight, resource = infer_job_profile(j_name, current_cmd or full_meta_text)
+            if "duration" in meta:
+                d_str = re.sub(r"[^0-9]", "", meta["duration"])
+                if d_str:
+                    dur = max(1, int(d_str))
+            if "weight" in meta:
+                try:
+                    weight = float(meta["weight"])
+                except ValueError:
+                    pass
+            if "resource" in meta:
+                resource = meta["resource"]
+
+            win_start, win_end = None, None
+            if "window" in meta:
+                wm = re.match(r"(\d{1,2})(?::\d{2})?-(\d{1,2})(?::\d{2})?", meta["window"])
+                if wm:
+                    win_start, win_end = int(wm.group(1)) % 24, int(wm.group(2)) % 24
+
+            jobs.append(
+                ScheduledJob(
+                    id=f"job-{job_idx:02d}",
+                    name=j_name,
+                    cron=cron,
+                    command=current_cmd or f"[{fmt.upper()}] {j_name}",
+                    duration_min=dur,
+                    weight=weight,
+                    resource=resource,
+                    locked=("lock" in meta),
+                    window_start_hour=win_start,
+                    window_end_hour=win_end,
+                    source_line=idx,
+                    source_format=fmt,
+                )
+            )
+            if fmt == "k8s":
+                current_name = None
+            current_comment = ""
+    return jobs
+
+
+def _derive_job_name(command: str, comment: str, index: int) -> str:
+    clean_c = re.sub(r"@[a-zA-Z0-9_=-]+", "", comment).strip(" -:#")
+    if clean_c and len(clean_c) <= 36:
+        return re.sub(r"\s+", "-", clean_c.lower())
+    tokens = [
+        t for t in command.split()
+        if not t.startswith("-") and "=" not in t and t not in ("/bin/sh", "/bin/bash", "python", "python3", "node", "flock", "nice", "ionice", "cronic")
+    ]
+    if tokens:
+        base = tokens[0].rsplit("/", 1)[-1]
+        base = re.sub(r"\.(sh|py|js|rb|pl|sql)$", "", base)
+        if len(tokens) > 1 and base in ("manage", "artisan", "rake", "celery", "kubectl", "pg_dump", "mysqldump", "dbt"):
+            sub = re.sub(r"[^a-zA-Z0-9_-]", "", tokens[1])
+            if sub:
+                return f"{base}-{sub}"[:32]
+        if base:
+            return base[:32]
+    return f"cron-job-{index:02d}"

cronphase/solver.py

@@ -0,0 +1,320 @@
+"""
+Deterministic Constrained Phase-Shift Compiler for Cron Fleets.
+Shifts job minute/hour phase offsets while strictly preserving:
+  1. Exact execution cadence / period (every 5m/15m/30m, hourly, multi-hour lattice, daily)
+  2. Pinned jobs (`locked=True`)
+  3. Allowed maintenance window bounds (`window_start_hour`..`window_end_hour`)
+  4. Standard POSIX/Vixie cron syntax compatibility
+"""
+
+from __future__ import annotations
+import copy
+import dataclasses
+from typing import Dict, List, Optional, Tuple
+from .parser import CronExpression, ScheduledJob
+from .engine import SimulationResult, simulate_day
+
+
+@dataclasses.dataclass
+class SolverConfig:
+    strategy: str = "anneal"  # 'anneal' | 'prime-splay' | 'fnv-hash'
+    preserve_hours_for_daily: bool = False
+    daily_window_hours: Tuple[int, int] = (0, 4)
+
+
+@dataclasses.dataclass
+class JobRewrite:
+    job_id: str
+    job_name: str
+    old_expr: str
+    new_expr: str
+    phase_shift_minutes: int
+    reason: str
+
+
+def _detect_minute_period(minutes: Tuple[int, ...]) -> Optional[int]:
+    """If minutes form an exact periodic lattice across [0..59], return its period."""
+    n = len(minutes)
+    if n == 1:
+        return 60
+    if n in (2, 3, 4, 5, 6, 10, 12, 15, 20, 30):
+        period = 60 // n
+        base = minutes[0] % period
+        expected = tuple(sorted((base + i * period) % 60 for i in range(n)))
+        if minutes == expected:
+            return period
+    return None
+
+
+def _detect_hour_period(hours: Tuple[int, ...]) -> Optional[int]:
+    """If hours form a multi-hour periodic lattice (e.g., */2, */3, */4, */6, */8, */12), return period."""
+    n = len(hours)
+    if n in (2, 3, 4, 6, 8, 12):
+        period = 24 // n
+        base = hours[0] % period
+        expected = tuple(sorted((base + i * period) % 24 for i in range(n)))
+        if hours == expected:
+            return period
+    return None
+
+
+def _build_shifted_minute_field(period: int, phase: int) -> str:
+    phase_mod = phase % period
+    if period == 60:
+        return str(phase_mod)
+    if phase_mod == 0:
+        return f"*/{period}"
+    return f"{phase_mod}-59/{period}"
+
+
+def _build_shifted_hour_field(h_period: int, h_phase: int) -> str:
+    p = h_phase % h_period
+    if p == 0:
+        return f"*/{h_period}"
+    return f"{p}-23/{h_period}"
+
+
+def _allowed_hours_for_job(job: ScheduledJob, cfg: SolverConfig) -> List[int]:
+    if job.window_start_hour is not None and job.window_end_hour is not None:
+        s, e = job.window_start_hour, job.window_end_hour
+        if s <= e:
+            return list(range(s, e + 1))
+        return list(range(s, 24)) + list(range(0, e + 1))
+
+    if not cfg.preserve_hours_for_daily and len(job.cron.hours) == 1 and len(job.cron.minutes) == 1:
+        orig_h = job.cron.hours[0]
+        w_start, w_end = cfg.daily_window_hours
+        if w_start <= orig_h <= w_end:
+            return list(range(w_start, w_end + 1))
+    return list(job.cron.hours)
+
+
+def _fnv1a_32(text: str) -> int:
+    h = 0x811C9DC5
+    for b in text.encode("utf-8"):
+        h ^= b
+        h = (h * 0x01000193) & 0xFFFFFFFF
+    return h
+
+
+def optimize_fleet(
+    jobs: List[ScheduledJob],
+    config: Optional[SolverConfig] = None,
+) -> Tuple[List[ScheduledJob], List[JobRewrite], SimulationResult, SimulationResult]:
+    """
+    Optimizes the fleet schedule to minimize Peak Load (L_inf) and Load Variance (L_2).
+    Returns (optimized_jobs, rewrites, before_sim, after_sim).
+    """
+    cfg = config or SolverConfig()
+    before_sim = simulate_day(jobs)
+    optimized = [copy.deepcopy(j) for j in jobs]
+
+    indexed_jobs = list(enumerate(optimized))
+    indexed_jobs.sort(
+        key=lambda pair: (
+            not pair[1].locked,
+            pair[1].weight * pair[1].duration_min * len(pair[1].cron.firing_minutes_in_day()),
+        ),
+        reverse=True,
+    )
+
+    if cfg.strategy == "fnv-hash":
+        _apply_hash_splay(optimized, cfg)
+    elif cfg.strategy == "prime-splay":
+        _apply_prime_splay(optimized, cfg)
+    else:
+        _apply_minimax_solver(optimized, indexed_jobs, cfg)
+
+    rewrites: List[JobRewrite] = []
+    for orig, new_job in zip(jobs, optimized):
+        old_s = orig.cron.format_canonical()
+        new_s = new_job.cron.format_canonical()
+        if old_s != new_s:
+            old_first = orig.cron.firing_minutes_in_day()[0] if orig.cron.firing_minutes_in_day() else 0
+            new_first = new_job.cron.firing_minutes_in_day()[0] if new_job.cron.firing_minutes_in_day() else 0
+            delta = new_first - old_first
+            rewrites.append(
+                JobRewrite(
+                    job_id=orig.id,
+                    job_name=orig.name,
+                    old_expr=orig.cron.raw,
+                    new_expr=new_s,
+                    phase_shift_minutes=delta,
+                    reason=f"De-phased from {old_s} to flatten {orig.resource} peak contention",
+                )
+            )
+
+    after_sim = simulate_day(optimized)
+    return optimized, rewrites, before_sim, after_sim
+
+
+def _candidate_expressions(job: ScheduledJob, cfg: SolverConfig) -> List[CronExpression]:
+    period = _detect_minute_period(job.cron.minutes)
+    if period is None or period <= 1:
+        return [job.cron]
+
+    allowed_hours = _allowed_hours_for_job(job, cfg)
+    h_period = _detect_hour_period(job.cron.hours)
+    candidates: List[CronExpression] = []
+
+    if len(job.cron.hours) == 1 and len(allowed_hours) > 1 and period == 60:
+        for h in allowed_hours:
+            for m_phase in range(0, 60):
+                expr_str = f"{m_phase} {h} {job.cron.dom_field} {job.cron.month_field} {job.cron.dow_field}"
+                candidates.append(CronExpression.parse(expr_str))
+    elif h_period is not None and period == 60:
+        for hp in range(0, h_period):
+            h_field = _build_shifted_hour_field(h_period, hp)
+            for m_phase in range(0, 60):
+                expr_str = f"{m_phase} {h_field} {job.cron.dom_field} {job.cron.month_field} {job.cron.dow_field}"
+                candidates.append(CronExpression.parse(expr_str))
+    else:
+        for m_phase in range(0, period):
+            m_field = _build_shifted_minute_field(period, m_phase)
+            expr_str = f"{m_field} {job.cron.hour_field} {job.cron.dom_field} {job.cron.month_field} {job.cron.dow_field}"
+            candidates.append(CronExpression.parse(expr_str))
+
+    return candidates
+
+
+def _apply_hash_splay(jobs: List[ScheduledJob], cfg: SolverConfig) -> None:
+    for job in jobs:
+        if job.locked:
+            continue
+        period = _detect_minute_period(job.cron.minutes)
+        if not period or period <= 1:
+            continue
+        h_val = _fnv1a_32(f"{job.name}:{job.command}")
+        allowed_hours = _allowed_hours_for_job(job, cfg)
+        h_period = _detect_hour_period(job.cron.hours)
+        m_phase = h_val % period
+        m_field = _build_shifted_minute_field(period, m_phase)
+        h_field = job.cron.hour_field
+        if len(job.cron.hours) == 1 and len(allowed_hours) > 1 and period == 60:
+            h_field = str(allowed_hours[(h_val >> 8) % len(allowed_hours)])
+        elif h_period is not None and period == 60:
+            h_field = _build_shifted_hour_field(h_period, (h_val >> 8) % h_period)
+        job.cron = CronExpression.parse(
+            f"{m_field} {h_field} {job.cron.dom_field} {job.cron.month_field} {job.cron.dow_field}"
+        )
+
+
+def _apply_prime_splay(jobs: List[ScheduledJob], cfg: SolverConfig) -> None:
+    prime_stride = 17
+    prime_hour_stride = 3
+    for idx, job in enumerate(jobs):
+        if job.locked:
+            continue
+        period = _detect_minute_period(job.cron.minutes)
+        if not period or period <= 1:
+            continue
+        allowed_hours = _allowed_hours_for_job(job, cfg)
+        h_period = _detect_hour_period(job.cron.hours)
+        m_phase = ((idx + 1) * prime_stride) % period
+        m_field = _build_shifted_minute_field(period, m_phase)
+        h_field = job.cron.hour_field
+        if len(job.cron.hours) == 1 and len(allowed_hours) > 1 and period == 60:
+            h_field = str(allowed_hours[((idx + 1) * prime_hour_stride) % len(allowed_hours)])
+        elif h_period is not None and period == 60:
+            h_field = _build_shifted_hour_field(h_period, ((idx + 1) * prime_hour_stride) % h_period)
+        job.cron = CronExpression.parse(
+            f"{m_field} {h_field} {job.cron.dom_field} {job.cron.month_field} {job.cron.dow_field}"
+        )
+
+
+def _apply_minimax_solver(
+    jobs: List[ScheduledJob],
+    ordered_pairs: List[Tuple[int, ScheduledJob]],
+    cfg: SolverConfig,
+) -> None:
+    """
+    3-pass coordinate descent on the 1,440-minute load vector.
+    Minimizes lexicographical objective:
+      (candidate_peak_load, candidate_resource_peak, l2_sum_of_squares_delta, concurrency_l2_delta, harmonic_penalty)
+    """
+    total_load = [0.0] * 1440
+    total_conc = [0] * 1440
+    res_load: Dict[str, List[float]] = {}
+
+    def add_job_to_grid(j: ScheduledJob, sign: int) -> None:
+        r_arr = res_load.setdefault(j.resource, [0.0] * 1440)
+        dur = max(1, j.duration_min)
+        w = j.weight * sign
+        visited = set()
+        for s in j.cron.firing_minutes_in_day():
+            for off in range(dur):
+                m = (s + off) % 1440
+                if m not in visited:
+                    visited.add(m)
+                    total_load[m] += w
+                    total_conc[m] += sign
+                    r_arr[m] += w
+
+    for j in jobs:
+        add_job_to_grid(j, +1)
+
+    for _pass in range(3):
+        improved_in_pass = False
+        for idx, job in ordered_pairs:
+            if job.locked:
+                continue
+            candidates = _candidate_expressions(job, cfg)
+            if len(candidates) <= 1:
+                continue
+
+            add_job_to_grid(job, -1)
+            r_arr = res_load[job.resource]
+            dur = max(1, job.duration_min)
+            w = job.weight
+
+            best_cron = job.cron
+            best_score: Optional[Tuple[float, float, float, float, int]] = None
+
+            seed_offset = ((idx + 1) * 13) % len(candidates)
+            rotated = candidates[seed_offset:] + candidates[:seed_offset]
+
+            for cand in rotated:
+                fires = cand.firing_minutes_in_day()
+                cand_peak_load = 0.0
+                cand_res_peak = 0.0
+                delta_l2 = 0.0
+                delta_conc_l2 = 0.0
+
+                touched = {
+                    (s + off) % 1440
+                    for s in fires
+                    for off in range(dur)
+                }
+
+                for m in touched:
+                    nl = total_load[m] + w
+                    nr = r_arr[m] + w
+                    nc = total_conc[m] + 1
+                    if nl > cand_peak_load:
+                        cand_peak_load = nl
+                    if nr > cand_res_peak:
+                        cand_res_peak = nr
+                    delta_l2 += nl * nl - total_load[m] * total_load[m]
+                    delta_conc_l2 += nc * nc - total_conc[m] * total_conc[m]
+
+                first_mod = (fires[0] % 60) if fires else 0
+                harmonic_penalty = 2 if first_mod == 0 else (1 if first_mod % 15 == 0 else 0)
+
+                score = (
+                    round(cand_peak_load, 4),
+                    round(cand_res_peak, 4),
+                    round(delta_l2, 4),
+                    round(delta_conc_l2, 4),
+                    harmonic_penalty,
+                )
+                if best_score is None or score < best_score:
+                    best_score = score
+                    best_cron = cand
+
+            if best_cron.format_canonical() != job.cron.format_canonical():
+                improved_in_pass = True
+            job.cron = best_cron
+            add_job_to_grid(job, +1)
+
+        if not improved_in_pass:
+            break

cronphase-0.2.1.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: cronphase
+Version: 0.2.1
+Summary: Fleet-wide cron thundering-herd analyzer & deterministic phase-shift compiler
+Author: cronphase contributors
+License: MIT
+Keywords: cron,crontab,kubernetes,devops,sre,scheduler,thundering-herd
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# `cronphase` — Fleet-Wide Cron Thundering-Herd Oscilloscope & Phase-Shift Compiler
+
+> **Why does your database CPU spike to 100% at `00:00`, `:00`, and `:15` every day?**
+> Because humans write `0 * * * *`, `*/5 * * * *`, `*/15 * * * *`, and `0 0 * * *`. Across 20+ microservices, Kubernetes `CronJob` manifests, and GitHub Actions workflows, those schedules constructively interfere like acoustic waves—creating **The Midnight Stampede**.
+
+Existing tools (like `crontab.guru`) only translate a **single** cron line into English.
+**`cronphase`** analyzes your **entire fleet** as a 1,440-minute diurnal signal, pinpoints multi-job resource collisions (accounting for multi-minute execution durations and midnight wrap-around), and runs a **constrained minimax phase-shift solver** that rewrites cron expressions with deterministic offsets (`*/15 * * * *` → `7-59/15 * * * *`, `0 * * * *` → `23 * * * *`, `0 */4 * * *` → `19 1-23/4 * * *`) while strictly preserving every job's exact frequency, SLA window bounds, and pinned locks.
+
+## Key Capabilities
+
+1. **Multi-Format Fleet Ingestion**: Parses standard UNIX `/etc/crontab`, Kubernetes `batch/v1 CronJob` YAML manifests, and GitHub Actions `.github/workflows/*.yml` schedule blocks.
+2. **1,440-Minute Load Envelope & Crest Factor Simulator**: Models job execution duration (`@duration=8m`), resource weight (`@weight=7.5`), and target subsystem contention (`@resource=db-primary`), including jobs that start at `23:55` and spill across midnight into `00:05`.
+3. **Harmonic Resonance Spectrum**: Quantifies `:00`, `:15`, `:30`, `:45`, and `5m-grid` harmonic clustering across your fleet.
+4. **Constrained Minimax Phase-Shift Compiler**:
+   - **Coordinate Descent / Minimax (`--strategy anneal`)**: Minimizes $L_\infty$ peak resource load and $L_2$ load variance across the 1,440-minute ring.
+   - **Deterministic FNV-1a Hash Jitter (`--strategy fnv-hash`)**: Zero-coordination stateless phase assignment (compiles Jenkins `H/15 * * * *` semantics to standard POSIX/Vixie cron syntax).
+   - **Prime-Modulo Splay (`--strategy prime-splay`)**: Coprime stride distribution across periodic lattices.
+5. **Ready-to-Apply Unified Git Diff & CI Gate**: Generates a `git apply`-ready patch and supports `--max-crest-factor` for CI/CD pull request checks.
+
+## Quick Start (CLI)
+
+```bash
+# 1. Analyze a production crontab and print the 24h waveform + collision spikes
+python3 -m cronphase examples/prod.crontab
+
+# 2. Run the constrained phase-shift compiler and emit a unified git diff patch
+python3 -m cronphase examples/prod.crontab --optimize --diff
+
+# 3. Gate CI pipelines if peak-to-mean crest factor exceeds 2.5x
+python3 -m cronphase examples/k8s-cronjobs.yaml --optimize --max-crest-factor 2.5
+```

cronphase-0.2.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+cronphase/__init__.py,sha256=qsfJw3SKG0eYJIHC-mAHpAhpi7eA9OZQtgFSOeZOac4,559
+cronphase/__main__.py,sha256=R8toRIEpaunLvLRpFhTKF4x0aBUmBLoqHo0IrF4wuTw,82
+cronphase/cli.py,sha256=Cx4nkPNCtFEg2feFMqLOPcGv789vBNz0utK9M0OpxIs,5652
+cronphase/diff.py,sha256=jGuAmw3G3eduM2ojHh0am7grtdB7_V_9OdDcmbZ7MWg,1881
+cronphase/engine.py,sha256=6FWP7B7MGzIeJmH3lbQE6oUSdC5ShY_856WPKGSEub8,5447
+cronphase/parser.py,sha256=siczRf_ACPt0ga281qBrlFhMonS8NpKbGlI0sdE14jw,14429
+cronphase/solver.py,sha256=avxBf2E5ApzRYMIrVHaodAybAmYudZ8q2_290UNQIN8,11842
+cronphase-0.2.1.dist-info/licenses/LICENSE,sha256=OPnhVzkF-cltTDNu7Xwr83wTPrQs3pADR62XsHDoDD4,1079
+cronphase-0.2.1.dist-info/METADATA,sha256=EfCjTP3cC9ByDV1Q2Tsafy2kJ94Z-9FG6cxCCEW-vsQ,3468
+cronphase-0.2.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+cronphase-0.2.1.dist-info/entry_points.txt,sha256=sUcmhBc3Psb0-G1EJAVKsEZ8__y5u_NqRNKZZxitX64,49
+cronphase-0.2.1.dist-info/top_level.txt,sha256=a4cvIu_YPOitzYvgQ4Jml8TEw1ibwH3YRX9nlbrswjk,10
+cronphase-0.2.1.dist-info/RECORD,,

cronphase-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cronphase-0.2.1.dist-info/entry_points.txt

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

cronphase-0.2.1.dist-info/licenses/LICENSE

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

cronphase-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+cronphase