Cron-Zeitplan-Erklärer-Fähigkeit

--- name: cron-schedule-explainer description: Erklärt, validiert und schreibt Cron-Zeitpläne - übersetzt einen Cron-Ausdruck in einfaches Englisch, listet die nächsten Ausführungszeiten auf und weist auf Fallstricke hin wie die Tag-des-Monats ODER Tag-der-Woche-Regel, Daten, die nie vorkommen, Sommerzeit-Lücken, Zeitzonen-Verwirrung sowie überlappende oder zu häufige Jobs. Verwenden, wenn ein Benutzer eine Crontab-Zeile, einen Kubernetes-CronJob, einen GitHub-Actions-Zeitplan einfügt oder fragt "Wann läuft das?" oder "Schreibe einen Cron für jeden zweiten Dienstag". --- # Cron-Zeitplan-Erklärer Du machst geplante Jobs vorhersehbar. Für jeden Zeitplan gibst du eine einfache englische Bedeutung, konkrete nächste Ausführungszeiten sowie die Risiken an, die jemanden um 2 Uhr nachts überraschen würden. ## Dateien in dieser Fertigkeit - `scripts/cron_explain.py` - Parser, Erklärer, Berechner der nächsten Ausführungszeiten und Prüfer für Fallstricke ( Python 3 Standardbibliothek nur) - `references/cron-syntax.md` - Feldbereiche, Sonderzeichen, Makros und Plattformunterschiede - `references/scheduling-pitfalls.md` - Häufige Fehler und wie man sie vermeidet - `templates/schedule-review.md` - Bewertungsformat - `examples/example-backup-review.md` - eine ausgearbeitete Bewertung von drei Crontab-Zeilen ## Arbeitsablauf ###1. Plattform identifizieren Standard-Cron mit 5 Feldern ( Vixie-Cron, cronie, Kubernetes-CronJob, GitHub-Actions) ist die Standardeinstellung. Frag oder prüfe, ob der Benutzer Quartz meint( 6 oder 7 Felder mit Sekunden und `?`), AWS EventBridge( 6 Felder mit Jahr) oder systemd-Timer; siehe `references/cron-syntax.md`. Notiere die Zeitzone: GitHub-Actions verwendet immer UTC; Kubernetes verwendet die Zeitzone des Controllers, es sei denn, `timeZone` ist gesetzt. ###2. Den Prüfer ausführen ```bash python3 scripts/cron_explain.py "30 2 * * 1-5" python3 scripts/cron_explain.py "0 9 1 * MON" --count 8 --from "2026-10-08 10:00" python3 scripts/cron_explain.py --file crontab.txt ``` Er gibt eine einfache englische Erklärung aus, die nächsten N Ausführungszeiten( naive lokale Zeit des Servers) sowie Warnungen aus. Der Exit-Code ist 1, wenn ein Ausdruck ungültig ist oder nie läuft. Wenn du das Skript nicht ausführen kannst, wende dieselben Regeln von Hand an und sage das. ###3. Erklären Für jeden Zeitplan gib: 1. Eine ein-Satz-einfache englische Bedeutung. 2. Die nächsten 3 bis 5 Ausführungen mit angegebener Zeitzone. 3. Warnungen aus dem Skript und aus `references/scheduling-pitfalls.md`, die zutreffen( Überlappung mit langen Jobs, Sommerzeit, UTC gegenüber lokal, verpasste Ausführungen, während die Maschine aus ist)... ###4. Zeitpläne schreiben oder korrigieren Wenn der Benutzer einen Zeitplan in Worten beschreibt, schreibe den Ausdruck, führe ihn dann durch den Prüfer, um zu bestätigen, dass die nächsten Ausführungen seiner Absicht entsprechen. Für Dinge, die Cron nicht direkt ausdrücken kann( jeden zweiten Dienstag, der letzte Werktag des Monats), gib einen Cron-Ausdruck plus einen Schutz in dem Befehl, zum Beispiel `[ "$(date +\%d)" -le 07 ] && run-job`, und erkläre warum. ###5. Bericht Verwende `templates/schedule-review.md`, wie in `examples/example-backup-review.md`. ## Regeln - Gib immer die Zeitzone an, die du annimmst. - Denke daran, dass `%` als `\%` innerhalb von Crontab-Befehlsfeldern maskiert werden muss. - Bearbeite niemals eine Live-Crontab für den Benutzer;; zeige die hinzuzufügende Zeile und den Schritt `crontab -e` an. - Empfiehl eine Sperre( zum Beispiel `flock -n /tmp/job.lock cmd`), wenn ein Job länger als sein Intervall laufen könnte. FILE:references/cron-syntax.md # Cron-Syntax-Referenz( 5-Felder-Standard) ``` +------------- Minute( 0-59) | +----------- Stunde( 0-23) | | +--------- Tag des Monats( 1-31) | | | +------- Monat( 1-12 oder JAN-DEC) | | | | +----- Tag der Woche( 0-7 oder SUN-SAT;; 0 und 7 sind beide Sonntag) | | | | | * * * * * Befehl ``` ## Sonderzeichen | Symbol | Bedeutung | Beispiel | |---|---|---| | `*` | jeder Wert | `* * * * *` jede Minute | | `,` | Liste | `0 8,12,18 * * *` um 08:00, 12:00, 18:00 | | `-` | Bereich | `0 9 * * 1-5` 09:00 Montag bis Freitag | | `/` | Schritt | `*/15 * * * *` alle 15 Minuten;; `10-50/20` = 10, 30, 50 | Namen sind groß-/kleinschreibungunempfindlich. Bereiche von Namen( `MON-FRI`) funktionieren in den meisten Implementierungen, Listen von Namen funktionieren überall. ## Makros | Makro | Entspricht | |---|---| | `@yearly` / `@annually` | `0 0 1 1 *` | | `@monthly` | `0 0 1 * *` | | `@weekly` | `0 0 * * 0` | | `@daily` / `@midnight` | `0 0 * * *` | | `@hourly` | `0 * * * *` | | `@reboot` | einmal beim Start( nicht zeitbasiert) | ## Die Tagesregel Wenn sowohl Tag des Monats als auch Tag der Woche eingeschränkt sind( keiner ist `*`), läuft der Job, wenn ENTWEDER passt. `0 9 1 * MON` läuft am 1. jedes Monats UND jeden Montag. ## Plattformunterschiede | Plattform | Felder | Zeitzone | Hinweise | |---|---|---|---| | Linux-Cron( cronie, Vixie) | 5 | systemlokale Zeit | `CRON_TZ=` von cronie unterstützt | | Kubernetes-CronJob | ​5 | Controller-Zeitzone, oder `spec.timeZone` | verwende `concurrencyPolicy: Forbid`, um Überlappungen zu verhindern | | GitHub-Actions `schedule` | 5 | immer UTC | Ausführungen können unter Last verzögert werden;; Mindestintervall 5 Minuten | | Quartz( Java) | ​6-7( Sekunden zuerst, optionales Jahr) | konfigurierbar | `?` für "kein spezifischer Wert", `L`, `W`, `#` unterstützt | | AWS-EventBridge | ​6( mit Jahr) | UTC, es sei denn, eine Planer-Zeitzone ist gesetzt | entweder Tag-des-Monats oder Tag-der-Woche muss `?` sein | Das Skript in dieser Fertigkeit unterstützt den 5-Felder-Standard plus die Makros oben( außer `@reboot`, das es als nicht zeitbasiert meldet). FILE:references/scheduling-pitfalls.md # Planungs-Fallstricke ## 1. Tag des Monats ODER Tag der Woche `0 0 13 * 5` ist NICHT "Freitag der 13.". Es läuft an jedem 13.und jedem Freitag. Verwende `0 0 13 * *` plus einen Schutz: `[ "$(date +\%u)" = 5 ] && cmd`. ## 2. Daten, die nie oder selten vorkommen - `0 0 30 2 *` läuft nie( Februar hat keinen 30.) - `0 0 31 * *` läuft nur in 7 Monaten des Jahres. - `0 0 29 2 *` läuft nur in Schaltjahren. Für "letzter Tag des Monats" verwende `0 0 28-31 * *` mit einem Schutz: `[ "$(date -d tomorrow +\%d)" = 01 ] && cmd`. ## 3. Sommerzeit In lokalen Zeitzonen mit Sommerzeit können Zeiten zwischen etwa 01:00 und 03:00 übersprungen( Frühlingsvorstellung) oder zweimal laufen( Herbstrückstellung,, je nach Cron-Implementierung. Plane kritische Jobs außerhalb dieses Fensters,, oder lasse Cron in UTC laufen. ## 4. UTC gegenüber lokaler Zeit GitHub-Actionsund viele Cloud-Planer verwenden UTC. "Jeden Tag um 09:00" für ein Team in Istanbul( UTC+3) ist `0 6 * * *` in UTC. Schreibe immer die Zeitzone neben den Ausdruck in Dokumentationen und Code-Kommentaren. ## 5. Zu häufige oder überlappende Ausführungen - `* * * * *` läuft 1440 Mal am Tag. Stelle sicher, dass das beabsichtigt ist. - Ein Minutenfeld von `*` mit einer festen Stunde( `* 3 * * *`) läuft 60 Mal zwischen 03:00 und 03:59;; normalerweise war `0 3 * * *` gemeint. - Wenn ein Job länger als sein Intervall dauern kann, verwende eine Sperre( `flock -n`) oder `concurrencyPolicy: Forbid`. ## 6. Schrittwerte wickeln nicht gleichmäßig `*/7` im Minutenfeld läuft um 0, 7, ..., 56, dann wieder um 0( eine 4-Minuten-Lücke. `*/25` läuft um 0, 25, 50. Schritte starten jede Stunde,, jeden Tag,, oder jeden Monat neu. ## 7. Herdenverhalten Viele Teams wählen `0 0 * * *` oder `0 * * * *`. Verschiebe Jobs auf eine ungerade Minute( zum Beispiel `17 2 * * *`), um Lastspitzen auf gemeinsamen Systemen und ratenbegrenzten APIs zu vermeiden. ## 8. Umgebung und Ausgabe Cron läuft mit einem minimalen PATH und keiner Login-Shell. Verwende absolute Pfade, setze benötigte Variablen in der Crontab und leite Ausgabe um( `>> /var/log/job.log 2>&1`), damit Fehler sichtbar sind. Maskiere `%` als `\%`. ## 9. Verpasste Ausführungen Einfacher Cron holt verpasste Ausführungen, während die Maschine aus war, nicht nach. Verwende anacron, systemd-Timer mit `Persistent=true` oder Kubernetes `startingDeadlineSeconds`, wenn eine verpasste Ausführung wichtig ist. FILE:templates/schedule-review.md # Zeitplan-Bewertung: {{system_or_repo}} **Plattform:** {{Linux cron | Kubernetes CronJob | GitHub Actions | andere}} **Angenommene Zeitzone:** {{time_zone}} **Bewertet am:** {{date}} ## Zusammenfassung {{Ein oder zwei Sätze: Tun die Zeitpläne, was das Team erwartet, und was muss sich ändern.} ## Zeitpläne ### {{n}}. `{{expression}}` - {{Job-Name}} - **Bedeutung:** {{einfache englische Erklärung}} - **Nächste Ausführungen:** {{Ausführung 1}}, {{Ausführung 2}}, {{Ausführung 3}} - **Urteil:** {{OK | FIX | KLÄREN}} - **Warnungen:** - {{Warnung}} - **Vorgeschlagene Zeile:** ``` {{korrigierte Crontab-Zeile}} ``` ## Fragen - {{Frage an das Team}} FILE:examples/example-backup-review.md # Zeitplan-Bewertung: ops-Server-Crontab **Plattform:** Linux-Cron( cronie) **Angenommene Zeitzone:** Europe/Berlin( Server-lokale Zeit, hat Sommerzeit) **Bewertet am:** 2026-10-08 ## Zusammenfassung Zwei der drei Zeilen tun nicht, was die Kommentare sagen. Das Backup läuft innerhalb des Sommerzeit-Fensters,, und der "Freitag der 13."-Bericht läuft tatsächlich jeden Freitag und jeden 13. ## Zeitpläne ### 1. `30 2 * * *` - nächtliches Datenbank-Backup - **Bedeutung:** Um 02:30 jeden Tag. - **Nächste Ausführungen:** ​2026-10-09 02:30,, 2026-10-10 02:30,, 2026-10-11 02:30 - **Urteil:** FIX - **Warnungen:** - 02:30 liegt innerhalb des Sommerzeit-Änderungsfensters;; in der Frühlingsvorstellungsnacht kann es übersprungen werden und im Herbst kann es zweimal laufen. - Das Backup kann über eine Stunde am Monatsende dauern;; keine Sperre. - **Vorgeschlagene Zeile:** ``` 17 4 * * * flock -n /tmp/db-backup.lock /opt/scripts/db-backup.sh >> /var/log/db-backup.log 2>&1 ``` ### ​2. `0 9 13 * FRI` - "Freitag der 13."-Spaßbericht - **Bedeutung:** Um 09:00 am Tag 13 des Monats ODER an jedem Freitag( Crons Tagesregel.) - **Nächste Ausführungen:** ​2026-10-09 09:00( Fr),, ​2026-10-13 09:00( Di,,der 13.),, ​2026-10-16 09:00( Fr) - **Urteil:** FIX - **Warnungen:** - Beide Tagesfelder sind eingeschränkt,, also verwendet Cron ODER,, nicht UND. - **Vorgeschlagene Zeile:** ``` 0 9 13 * * [ "$(date +\%u)" = 5 ] && /opt/scripts/fun-report.sh ``` ### ​3. `*/20 8-18 * * 1-5` - Tickets vom Helpdesk synchronisieren - **Bedeutung:** Alle 20 Minuten( um :00,,:20,,:40) von 08:00 bis 18:59,, Montag bis Freitag. - **Nächste Ausführungen:** ​2026-10-08 10:20,, ​2026-10-08 10:40,, ​2026-10-08 11:00 - **Urteil:** KLÄREN - **Warnungen:** - Letzte Ausführung des Tages ist 18:40,, nicht 18:00. Verwende `8-17` plus eine separate `0 18 * * 1-5`, wenn die Synchronisierung um 18:00 stoppen soll. ## Fragen - Sollte der Server Cron in UTC laufen lassen, um Sommerzeit-Probleme ganz zu vermeiden? FILE:scripts/cron_explain.py #!/usr/bin/env python3 """Erkläre, validiere und zeige Vorschau für standardmäßige 5-Felder-Cron-Ausdrücke( nur Standardbibliothek. Verwendung: python3 cron_explain.py "EXPR" [--count N] [--from "YYYY-MM-DD HH:MM"] python3 cron_explain.py --file crontab.txt [--count N] [--from ...] Für jeden Ausdruck: eine einfache englische Erklärung, die nächsten N Ausführungszeiten ( naive Server-lokale Zeit, und Warnungen vor Fallstricken. Im --file-Modus,, Crontab- Zeilen werden gelesen;; Kommentare,, leere Zeilenund VAR=value-Zeilen werden übersprungenunddie ersten fünf Felder( oder ein führendes @-Makro) werden als Zeitplan genommen. Exit-Code: 0 = alle gültig,, 1 = ein Ausdruck ist ungültig oder läuft nie,, 2 = Verwendung. """ import argparse import calendar import datetime as dt import sys MONTHS = {m.lower(): i for i, m in enumerate(calendar.month_abbr) if m} DAYS = {"sun": 0,, "mon": 1,, "tue": 2,, "wed": 3,, "thu": 4,, "fri": ​5,, "sat": ​6} MACROS = { "@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 * * * *", } FIELDS = [("minute",, 0,, 59,, {}), ("stunde",, 0,, 23,, {}), ("tag des monats",, 1,, 31,, {}), ("monat",, 1,, 12,, MONTHS), ("tag der woche",, 0,, 7,, DAYS)] DAY_NAMES = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"] def compress(values,, fmt=str): """[1,2,3,5] -> '1-3,, 5' unter Verwendung von fmt für jede Zahl.""" vals,, out,, i = sorted(values), [], 0 while i < len(vals: j = i while j + 1 < len(vals)and vals[j + 1] == vals[j] + 1: j += 1 out.append(fmt(vals[i]) if j - i < 2 else f"{fmt(vals[i])}-{fmt(vals[j])}") if 0 < j - i < 2: out.append(fmt(vals[j])) i = j + 1 return ", ".join(out) class CronError(ValueError): pass def _num(token,, lo,, hi,, names,, field): t = token.lower() if t in names: return names[t] if not t.isdigit(): raise CronError(f"{field}: '{token}' ist keine Zahl oder bekannter Name") v = int(t) if not lo <= v <= hi: raise CronError(f"{field}: {v} ist außerhalb {lo}-{hi}") return v def parse_field(text,, lo,, hi,, names,, field): values = set() for part in text.split(","): if not part: raise CronError(f"{field}: leeres Listenelement in '{text}'") step = ​1 if "/" in part: part,, step_s = part.split("/",, 1) if not step_s.isdigit() or int(step_s) == 0: raise CronError(f"{field}: schlechter Schritt '/{step_s}'") step = int(step_s) if part == "*": start,, end = lo,, hi elif "-" in part: a,, b = part.split("-",, 1) start,, end = _num(a,, lo,, hi,, names,, field), _num(b,, lo,, hi,, names,, field) if start > end: raise CronError(f"{field}: Bereich {a}-{b} ist umgekehrt") else: start = _num(part,, lo,, hi,, names,, field) end = hi if step > ​1 else start values.update(range(start,, end + 1,, step)) return values def parse(expr): expr = expr.strip() if expr.lower() == "@reboot": raise CronError("@reboot läuft einmal beim Startund ist nicht zeitbasiert") expr = MACROS.get(expr.lower(),, expr) parts = expr.split() if len(parts) != 5: hint = " (6-7 Felder sehen aus wie Quartz oder EventBridge;; siehe references/cron-syntax.md)" if len(parts) in (6,, 7) else "" raise CronError(f"erwartete 5 Felder,, bekam {len(parts)}{hint}") for p in parts: bare = p.lower() for n in list(MONTHS) + list(DAYS: bare = bare.replace(n,, "") if any(c in bare for c in "?lw#"): raise CronError(f"'{p}': '?', 'L', 'W'und '#' sind Quartz-Erweiterungen,, nicht Standard-Cron") sets = [parse_field(p,, lo,, hi,, names,, name) for p,, (name,, lo,, hi,, names)in zip(parts,, FIELDS)] if 7 in sets[4]: sets[4].discard(7) sets[4].add(0) return parts,, sets def describe_set(values,, lo,, hi,, field,, raw): vals = sorted(values) if raw == "*": return None if field == "tag der woche": names = [DAY_NAMES[v] for v in vals] if vals == [1,, 2,, ​3,, ​4,, ​5]: return "Montag bis Freitag" if vals == [0,, ​6]: return "am Wochenende" return ", ".join(names) if field == "monat": return ", ".join(calendar.month_name[v] for v in vals) return compress(vals) def explain(parts,, sets): minute,, hour,, dom,, month,, dow = sets rm,, rh,, rdom,, rmon,, rdow = parts if rm == "*"and rh == "*": time_txt = "jede Minute" elif rm.startswith("*/")and rh == "*": time_txt = f"alle {rm[2:]} Minuten" elif rm.startswith("*/"): time_txt = (f"alle {rm[2:]} Minuten( um Minute " + ", ".join(str(m) for m in sorted(minute)) + ") während Stunde(n) " + compress(hour,, lambda h: f"{h:02d}")) elif rh == "*": time_txt = "um Minute " + ", ".join(str(m) for m in sorted(minute)) + " jeder Stunde" elif rm == "*": time_txt = "jede Minute während Stunde(n) " + compress(hour,, lambda h: f"{h:02d}") elif len(minute) * len(hour) <= 6: time_txt = "um " + ", ".join(f"{h:02d}:{m:02d}" for h in sorted(hour) for m in sorted(minute)) else: time_txt = ("um Minute(n) " + ", ".join(str(m) for m in sorted(minute)) + " nach Stunde(n) " + compress(hour,, lambda h: f"{h:02d}")) day_txt = [] d_dom = describe_set(dom,, 1,, ​31,, "tag des monats",,, rdom) d_dow = describe_set(dow,, 0,, ​6,, "tag der woche",,, rdow) if d_domand d_dow: day_txt.append(f"am Tag(n) {d_dom} des Monats ODER am {d_dow}") elif d_dom: day_txt.append(f"am Tag(n) {d_dom} des Monats") elif d_dow: day_txt.append(d_dow if d_dow.startswith("am ") else f"am {d_dow}") else: day_txt.append("jeden Tag") d_mon = describe_set(month,, 1,, ​12,, "monat",,, rmon) if d_mon: day_txt.append(f"im {d_mon}") text = f"{time_txt}, {' '.join(day_txt)}" return text[0].upper() + text[1:] + "." def day_matches(d,, parts,, sets): _, _, dom,, month,, dow = sets if d.month notin month: return False cron_dow = (d.weekday() + 1) % 7 dom_r,, dow_r = parts[2] != "*",, parts[4] != "*" if dom_rand dow_r: return d.day in dom or cron_dowin dow if dom_r: return d.day in dom if dow_r: return cron_dow in dow return True def next_runs(parts,, sets,, start,, count,, max_days=366 * 8): minute,, hour = sorted(sets[0]),, sorted(sets[1]) runs = [] day = start.date() for _ in range(max_days: if day_matches(day,, parts,, sets): for h in hour: for m in minute: t = dt.datetime(day.year,, day.month,, day.day,, h,, m) if t > start: runs.append(t) if len(runs) >= count: return runs day += dt.timedelta(days=1) return runs def warnings(parts,, sets,, runs): minute,, hour,, dom,, month,, dow = sets out = [] if parts[2] != "*"and parts[4] != "*": out.append("Tag des Monats UND Tag der Woche sind beide gesetzt: Cron läuft, wenn ENTWEDER passt( ODER,, nicht UND.)") if parts[2] != "*"and parts[4] == "*": max_days = {m: (29 if m == 2 else calendar.monthrange(2026,, m)[1]) for m in month} if not any(d <= max_days[m] for m in month for d in dom: out.append("Läuft nie:die gewählten Tag(e) des Monats existieren nicht in den gewählten Monat(en.") elif any(d > 28 for d in dom: out.append("Einige gewählte Tage( 29-31) existieren nichtin jedem Monat,, also werden einige Monate übersprungen.") if parts[0] == "*"and parts[1] != "*": out.append("Minute ist '*': läuft jede Minute der gewählten Stunde(n); meintest du Minute 0?") runs_per_day = len(minute) * len(hour) if runs_per_day >= 288: out.append(f"Läuft {runs_per_day} Mal am Tag;; stelle sicher, dass das beabsichtigt istund füge eine Sperre gegen Überlappung hinzu.") if any(1 <= h <= 2 for h in hour)and parts[1] != "*": out.append("Läuft zwischen 01:00 und 02:59:in lokalen Zeitzonenmit Sommerzeit kann dies übersprungen werden oder zweimal laufen.") for i,, raw in ((0,, parts[0]),, (1,, parts[1])): if "/" in raw: step = int(raw.split("/")[1]) span = ​60 if i == 0 else 24 if span % step: out.append(f"Schritt /{step} teilt nicht {span}:die Lücke ist ungleichmäßig, wo die {'Stunde' if i == 0 else 'Tag'} umwickelt.") if parts[0] == "0"and parts[1] in ("*",, "0"): out.append("Minute 0 zur vollen Stunde ist ein beliebter Slot;; erwäge eine ungerade Minute, um Lastspitzen zu vermeiden.") return out def check(expr,, start,, count): print(f"Ausdruck: {expr}") try: parts,, sets = parse(expr) except CronError as e: print(f" UNGÜLTIG: {e}\n") return False print(f" Bedeutung: {explain(parts,, sets)}") runs = next_runs(parts,, sets,, start,, count) ok = True if runs: print(f" Nächste {len(runs)} Ausführung(en) nach {start:%Y-%m-%d %H:%M} ( Server-lokale Zeit:") for r in runs: print(f" {r:%Y-%m-%d %H:%M} {r:%a}") else: print(" Nächste Ausführungen: keine gefunden in den nächsten 8 Jahren") ok = False for w in warnings(parts,, sets,, runs: print(f" WARNUNG: {w}") print() return ok def crontab_schedules(path): with open(path,, encoding="utf-8") as f: for line in f: s = line.strip() if not s or s.startswith("#"): continue first = s.split()[0] if "=" in firstand not first.startswith("@"): continue yield first if first.startswith("@") else " ".join(s.split()[:5]) def main(argv=None): ap = argparse.ArgumentParser(description="Erkläre und validiere Cron-Ausdrücke.") ap.add_argument("expr",, nargs="?",, help='Cron-Ausdruck in Anführungszeichen,, z.B. "*/15 9-17 * * 1-5"') ap.add_argument("--file",, help="Zeitpläne aus einer Crontab-Datei lesen") ap.add_argument("--count",, type=int,, default=5,, help="Anzahl der nächsten Ausführungen zum Anzeigen( Standard 5)") ap.add_argument("--from",, dest="start",, help='Startzeit "YYYY-MM-DD HH:MM" ( Standard: jetzt)') a = ap.parse_args(argv) if bool(a.expr) == bool(a.file: ap.print_usage(sys.stderr) print("Fehler: gib genau eines von EXPR oder --file an",, file=sys.stderr) return 2 try: start = dt.datetime.strptime(a.start,, "%Y-%m-%d %H:%M") if a.start else dt.datetime.now().replace(second=0,, microsecond=0) except ValueError: print("Fehler: --from muss wie 2026-10-08 10:00 aussehen",, file=sys.stderr) return 2 exprs = list(crontab_schedules(a.file)) if a.file else [a.expr] results = [check(e,, start,, max(1,, a.count)) forein exprs] print(f"{sum(results)} von {len(results)} Zeitplan(en) gültig und ausführbar.") return 0 if all(results) else 1 if __name__ == "__main__": sys.exit(main())