@they-juanreina/compost-cli 0.1.0 → 0.1.2

package/transcriber/app/prosody.py

@@ -0,0 +1,123 @@
+"""Prosody hint extractor (#13).
+
+Deterministic per-utterance hints derived from word timings, optional VAD
+energy, and speech rate. No ML model — cheap, reproducible context.
+
+Output shape (matches transcript.schema.json #/$defs/prosody):
+    {"volume": "low|normal|high", "pace": "slow|normal|fast", "hesitations": int}
+
+Thresholds are module constants, documented here for reproducibility:
+
+  pace (words per second over the utterance span):
+    < 2.0  → slow
+    > 3.3  → fast
+    else   → normal
+
+  volume (mean VAD RMS energy, normalized 0..1; requires the energy signal
+  from Silero VAD, issue #9). When energy is unavailable we report "normal"
+  rather than guess:
+    < 0.33 → low
+    > 0.66 → high
+    else   → normal
+
+  hesitations = filler tokens + immediate word repetitions + long
+  intra-utterance gaps (> 400 ms between consecutive words).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+PACE_SLOW_WPS = 2.0
+PACE_FAST_WPS = 3.3
+VOLUME_LOW = 0.33
+VOLUME_HIGH = 0.66
+HESITATION_GAP_MS = 400
+
+# Multilingual (es-CO + en) filler set.
+_FILLERS = {
+    "uh",
+    "um",
+    "eh",
+    "em",
+    "este",
+    "esto",
+    "mmm",
+    "hmm",
+    "like",
+    "pues",
+}
+_FILLER_PHRASES = ("o sea", "you know", "es decir")
+
+_WORD_RE = re.compile(r"[^\W\d_]+", re.UNICODE)
+
+
+def _pace(text: str, start_ms: int, end_ms: int) -> str:
+    duration_s = max((end_ms - start_ms) / 1000.0, 1e-6)
+    n_words = len(_WORD_RE.findall(text))
+    wps = n_words / duration_s
+    if wps < PACE_SLOW_WPS:
+        return "slow"
+    if wps > PACE_FAST_WPS:
+        return "fast"
+    return "normal"
+
+
+def _volume(energy: float | None) -> str:
+    if energy is None:
+        return "normal"
+    if energy < VOLUME_LOW:
+        return "low"
+    if energy > VOLUME_HIGH:
+        return "high"
+    return "normal"
+
+
+def _count_hesitations(text: str, words: list[dict[str, Any]] | None) -> int:
+    count = 0
+    tokens = [t.lower() for t in _WORD_RE.findall(text)]
+
+    # filler single tokens
+    count += sum(1 for t in tokens if t in _FILLERS)
+
+    # filler phrases
+    lowered = text.lower()
+    for phrase in _FILLER_PHRASES:
+        count += lowered.count(phrase)
+
+    # immediate repetitions ("yo yo", "the the")
+    for a, b in zip(tokens, tokens[1:], strict=False):
+        if a == b and len(a) > 1:
+            count += 1
+
+    # long gaps between consecutive words
+    if words:
+        for prev, nxt in zip(words, words[1:], strict=False):
+            if nxt.get("s", 0) - prev.get("e", 0) > HESITATION_GAP_MS:
+                count += 1
+
+    return count
+
+
+def extract_prosody(utterance: dict[str, Any], energy: float | None = None) -> dict[str, Any]:
+    """Compute {volume, pace, hesitations} for a single utterance dict."""
+    text = utterance.get("text", "")
+    return {
+        "volume": _volume(energy),
+        "pace": _pace(text, utterance["start_ms"], utterance["end_ms"]),
+        "hesitations": _count_hesitations(text, utterance.get("words")),
+    }
+
+
+def annotate_prosody(
+    transcript: dict[str, Any],
+    energies: dict[str, float] | None = None,
+) -> dict[str, Any]:
+    """Attach `prosody` to every utterance. `energies` maps utterance id → mean
+    VAD RMS energy (0..1) when available. Mutates and returns the transcript.
+    """
+    energies = energies or {}
+    for utt in transcript.get("utterances", []):
+        utt["prosody"] = extract_prosody(utt, energies.get(utt.get("id")))
+    return transcript

package/transcriber/app/routes/__init__.py

@@ -0,0 +1 @@
+"""HTTP route modules. Each subsystem (#9-#15) mounts its own router."""

package/transcriber/app/routes/legacy.py

@@ -0,0 +1,117 @@
+"""POST /legacy-ingest — normalize a legacy document into a transcript.json.
+
+The Node-side legacy-worker (cli/src/loops/legacy_worker.ts) pulls
+`legacy-ingest` jobs from the queue and POSTs each here. The route dispatches
+by file extension to the pure ingestors in `app/legacy.py`, then writes the
+normalized JSON to `<seed>/legacy/<basename>.json`.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, status
+from pydantic import BaseModel, Field
+
+from ..legacy import ingest as ingest_legacy
+
+router = APIRouter()
+
+
+class LegacyIngestRequest(BaseModel):
+    seed_path: str = Field(..., description="Absolute path to the seed root.")
+    source_path: str = Field(..., description="Absolute path to the asset to ingest.")
+    # CSV/XLSX column mapping — if text_col is None, the ingestor auto-detects
+    # from the header (text → transcript → content → utterance → quote →
+    # message → body, then first-column fallback). Node-side workers may also
+    # consult a `<source_path>.compost.json` sidecar that takes precedence.
+    text_col: str | None = Field(
+        None,
+        description="Column holding the utterance text (CSV/XLSX). Auto-detected if None.",
+    )
+    speaker_col: str | None = Field(None, description="Optional column for speaker label.")
+    sheet: str | None = Field(None, description="Optional XLSX sheet name (defaults to active).")
+
+
+class LegacyIngestResponse(BaseModel):
+    source_path: str
+    normalized_path: str
+    utterance_count: int
+    status: str  # ok | empty | failed
+    text_col_resolved: str | None = None  # which column was actually used (CSV/XLSX)
+    warnings: list[str] = []  # surfaced UX hints (e.g. xlsx un-evaluated formulas)
+
+
+@router.post(
+    "/legacy-ingest",
+    response_model=LegacyIngestResponse,
+    status_code=status.HTTP_200_OK,
+    summary="Normalize a PDF/DOCX/PPTX/CSV/XLSX/TXT/MD into a transcript-shaped JSON.",
+)
+def post_legacy_ingest(req: LegacyIngestRequest) -> LegacyIngestResponse:
+    src = Path(req.source_path)
+    seed = Path(req.seed_path)
+    if not src.exists():
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"source not found: {req.source_path}",
+        )
+    if not seed.exists():
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"seed not found: {req.seed_path}",
+        )
+
+    kwargs: dict[str, Any] = {}
+    if req.text_col is not None:
+        kwargs["text_col"] = req.text_col
+    if req.speaker_col is not None:
+        kwargs["speaker_col"] = req.speaker_col
+    if req.sheet is not None:
+        kwargs["sheet"] = req.sheet
+
+    try:
+        doc = ingest_legacy(src, **kwargs)
+    except ValueError as e:
+        # Unsupported ext or missing column — surface as 422 so the worker
+        # can mark the job failed and the CLI can show the researcher what's wrong.
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"invalid_input: {e}",
+        ) from e
+    except RuntimeError as e:
+        # Missing optional dep (python-docx, openpyxl, etc.) — 503 so the
+        # CLI can route to `compost setup --fix`.
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail=f"dep_missing: {e}",
+        ) from e
+
+    # Write normalized JSON under <seed>/legacy/<basename>.json
+    legacy_dir = seed / "legacy"
+    legacy_dir.mkdir(parents=True, exist_ok=True)
+    out_path = legacy_dir / f"{src.stem}.json"
+    out_path.write_text(json.dumps(doc, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+    utt_count = len(doc.get("utterances", []))
+    prov = doc.get("provenance", {})
+    warnings: list[str] = []
+    skipped = prov.get("xlsx_rows_skipped_empty_text", 0)
+    if skipped > 0:
+        warnings.append(
+            f"{skipped} XLSX row(s) had data in other columns but an empty text cell — "
+            "likely an un-evaluated formula. Open the file in Excel once, or export to CSV."
+        )
+    return LegacyIngestResponse(
+        source_path=req.source_path,
+        normalized_path=str(out_path),
+        utterance_count=utt_count,
+        status="ok" if utt_count > 0 else "empty",
+        text_col_resolved=prov.get("text_col_resolved"),
+        warnings=warnings,
+    )
+
+
+__all__ = ["router", "LegacyIngestRequest", "LegacyIngestResponse"]

package/transcriber/app/routes/transcribe.py

@@ -0,0 +1,133 @@
+"""POST /transcribe — orchestrate the full descriptive pipeline (v0.1-01).
+
+Body shape mirrors the CLI's `TranscriberClient.transcribe()` contract: the
+client passes the seed root, the session id, and the absolute source path
+(already moved into `sessions/<sid>/source.<ext>` by the inbox watcher).
+
+The route returns the transcript path and a status code the worker uses to
+either commit the job, requeue for retry, or surface needs_speaker_labels to
+the researcher.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel, Field
+
+from ..asr import ASRConfig
+from ..pipeline import (
+    PipelineBackends,
+    PipelineConfig,
+    run_pipeline,
+    write_transcript,
+)
+
+router = APIRouter()
+
+
+class TranscribeRequest(BaseModel):
+    """JSON body for POST /transcribe."""
+
+    seed_path: str = Field(..., description="Absolute path to the seed root (Seeds/<name>/).")
+    session_id: str = Field(..., pattern=r"^[A-Za-z0-9_-]+$")
+    source_path: str = Field(..., description="Absolute path to the audio/video file.")
+    language: str | None = Field(None, description="Optional language hint (e.g. 'es-CO').")
+    model_name: str = Field("large-v3-turbo", description="Whisper model id.")
+    device: str = Field("auto", description="Device: auto | cpu | cuda | mps.")
+    compute_type: str = Field("int8", description="Compute precision (int8|float16|float32).")
+
+
+class TranscribeResponse(BaseModel):
+    """Response shape mirroring `TranscriberClient.TranscribeResponse`."""
+
+    session_id: str
+    transcript_path: str
+    status: str  # ok | needs_speaker_labels | failed_transcription
+
+
+def _build_backends() -> PipelineBackends:
+    """Resolve real backends from the environment.
+
+    Each backend is lazy-loaded by its own module; this function just decides
+    *which* backend to inject. In production all three are None → each module
+    falls back to its real implementation (WhisperX / pyannote / Silero). In
+    tests we override via FastAPI's `app.dependency_overrides`.
+    """
+    return PipelineBackends(vad=None, asr=None, diarization=None)
+
+
+def _build_pipeline_config(req: TranscribeRequest) -> PipelineConfig:
+    asr = ASRConfig(
+        model_name=req.model_name,
+        device=req.device,
+        compute_type=req.compute_type,
+        language=req.language,
+        event_tags=True,
+    )
+    return PipelineConfig(asr=asr)
+
+
+@router.post(
+    "/transcribe",
+    response_model=TranscribeResponse,
+    status_code=status.HTTP_200_OK,
+    summary="Run the descriptive transcription pipeline on a session's source media.",
+)
+def post_transcribe(
+    req: TranscribeRequest,
+    backends: Annotated[PipelineBackends, Depends(_build_backends)],
+) -> TranscribeResponse:
+    if not Path(req.source_path).exists():
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"source not found: {req.source_path}",
+        )
+    if not Path(req.seed_path).exists():
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"seed not found: {req.seed_path}",
+        )
+
+    config = _build_pipeline_config(req)
+
+    try:
+        transcript = run_pipeline(
+            seed_path=req.seed_path,
+            session_id=req.session_id,
+            source_path=req.source_path,
+            config=config,
+            backends=backends,
+        )
+    except RuntimeError as e:
+        # Backend missing weights → distinguishable from generic failure so the
+        # CLI can suggest `compost setup --fix`.
+        if "asr extra" in str(e).lower() or "HUGGINGFACE_TOKEN" in str(e):
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail=f"model_missing: {e}",
+            ) from e
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"failed_transcription: {e}",
+        ) from e
+
+    transcript_path = write_transcript(req.seed_path, req.session_id, transcript)
+
+    return TranscribeResponse(
+        session_id=req.session_id,
+        transcript_path=transcript_path,
+        status=transcript.get("status", "ok"),
+    )
+
+
+def hf_token_present() -> bool:
+    """Helper exposed for the /compost-setup doctor: whether a HuggingFace
+    token is on the environment (does NOT validate it works against pyannote)."""
+    return bool(os.environ.get("HUGGINGFACE_TOKEN") or os.environ.get("HF_TOKEN"))
+
+
+__all__ = ["router", "TranscribeRequest", "TranscribeResponse", "hf_token_present"]

package/transcriber/app/shot_change.py

@@ -0,0 +1,74 @@
+"""Perceptual-hash shot-change detector (#15).
+
+Samples the video at a fixed cadence, computes a perceptual hash per sampled
+frame, and reports the timestamps where the hash distance to the previous
+sample crosses a threshold — i.e. a scene cut, slide change, or camera move.
+
+Output is a list of at_ms values consumed by the frame extractor (#14) as
+`shot_change` triggers. No classification beyond "something changed".
+"""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+from pathlib import Path
+
+import imagehash
+from PIL import Image
+
+# Default Hamming-distance threshold between consecutive perceptual hashes.
+# Tunable via config ([frames].shot_change_phash_distance).
+DEFAULT_PHASH_DISTANCE = 12
+DEFAULT_SAMPLE_INTERVAL_MS = 1000
+
+
+def _sample_frame(video_path: Path, at_ms: int, out_path: Path) -> bool:
+    ts = at_ms / 1000.0
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-ss",
+        f"{ts:.3f}",
+        "-i",
+        str(video_path),
+        "-frames:v",
+        "1",
+        "-vf",
+        "scale=160:90",
+        str(out_path),
+    ]
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    return proc.returncode == 0 and out_path.exists()
+
+
+def detect_shot_changes(
+    video_path: str | Path,
+    duration_ms: int,
+    threshold: int = DEFAULT_PHASH_DISTANCE,
+    sample_interval_ms: int = DEFAULT_SAMPLE_INTERVAL_MS,
+) -> list[int]:
+    """Return at_ms timestamps where a shot change is detected.
+
+    The first sampled frame is never a "change" (no predecessor). Distances at
+    or above `threshold` mark a change.
+    """
+    video_path = Path(video_path)
+    changes: list[int] = []
+    prev_hash: imagehash.ImageHash | None = None
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_dir = Path(tmp)
+        at = 0
+        idx = 0
+        while at < duration_ms:
+            frame_path = tmp_dir / f"s{idx}.png"
+            if _sample_frame(video_path, at, frame_path):
+                with Image.open(frame_path) as img:
+                    h = imagehash.phash(img)
+                if prev_hash is not None and (h - prev_hash) >= threshold:
+                    changes.append(at)
+                prev_hash = h
+            at += sample_interval_ms
+            idx += 1
+    return changes

package/transcriber/app/silence_typer.py

@@ -0,0 +1,144 @@
+"""Silence typer — heuristic post-processor that assigns a semantic type to each
+first-class silence (> threshold) from the surrounding utterance context.
+
+Types (ROADMAP § Descriptive transcription A):
+  - after_question : the silence follows a moderator question
+  - mid_utterance  : the silence sits inside one speaker's turn
+  - thinking       : a pre-response pause that isn't clearly after a question
+  - interruption   : the silence coincides with an overlap/turn-steal
+
+Rules are versioned. Researchers can override any assignment downstream; an
+override is recorded as a `researcher`-authored event in the provenance log
+(see issue #12 / provenance writer #27).
+
+CHANGELOG
+  v1 (2026-06-03): initial rule set.
+    - after_question: previous utterance is a moderator AND ends with '?'
+      (or a leading inverted '¿' question), and abuts the silence start.
+    - interruption: an overlap/interruption cue overlaps the silence window,
+      OR previous and next utterances are different speakers and the previous
+      did not end on sentence-final punctuation (cut off).
+    - mid_utterance: previous and next utterances are the same speaker.
+    - thinking: default.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+RULES_VERSION = "1"
+
+_SILENCE_TYPES = ("after_question", "mid_utterance", "thinking", "interruption")
+
+# How close (ms) the previous utterance's end must be to the silence start for
+# the silence to be considered "abutting" that utterance.
+_ABUT_TOLERANCE_MS = 250
+
+_SENTENCE_FINAL = (".", "!", "?", "…")
+
+
+def _ends_question(text: str) -> bool:
+    stripped = text.rstrip()
+    if stripped.endswith("?"):
+        return True
+    # Spanish inverted question mark opening with no closing yet still reads as a question.
+    return "¿" in stripped and "?" in stripped
+
+
+def _ends_sentence_final(text: str) -> bool:
+    stripped = text.rstrip()
+    return stripped.endswith(_SENTENCE_FINAL)
+
+
+def _speaker_type(speakers: list[dict[str, Any]], speaker_id: str | None) -> str | None:
+    if speaker_id is None:
+        return None
+    for s in speakers:
+        if s.get("id") == speaker_id:
+            return s.get("type")
+    return None
+
+
+def _cue_overlaps(silence: dict[str, Any], cues: list[dict[str, Any]]) -> bool:
+    s_start = silence["start_ms"]
+    s_end = silence["end_ms"]
+    for cue in cues:
+        if cue.get("kind") not in ("overlap", "interruption"):
+            continue
+        # any temporal overlap between the cue and the silence window
+        if cue["start_ms"] <= s_end and cue["end_ms"] >= s_start:
+            return True
+    return False
+
+
+def type_silence(
+    silence: dict[str, Any],
+    prev_utt: dict[str, Any] | None,
+    next_utt: dict[str, Any] | None,
+    speakers: list[dict[str, Any]],
+    cues: list[dict[str, Any]] | None = None,
+) -> str:
+    """Return one of the four silence types for a single silence."""
+    cues = cues or []
+
+    if _cue_overlaps(silence, cues):
+        return "interruption"
+
+    if prev_utt is not None:
+        abuts = abs(silence["start_ms"] - prev_utt["end_ms"]) <= _ABUT_TOLERANCE_MS
+        prev_type = _speaker_type(speakers, prev_utt.get("speaker_id"))
+        if abuts and prev_type == "moderator" and _ends_question(prev_utt.get("text", "")):
+            return "after_question"
+
+    if (
+        prev_utt is not None
+        and next_utt is not None
+        and prev_utt.get("speaker_id") == next_utt.get("speaker_id")
+    ):
+        return "mid_utterance"
+
+    # Different speakers (or unknown) and the previous turn was cut off → interruption.
+    if (
+        prev_utt is not None
+        and next_utt is not None
+        and prev_utt.get("speaker_id") != next_utt.get("speaker_id")
+        and not _ends_sentence_final(prev_utt.get("text", ""))
+    ):
+        return "interruption"
+
+    return "thinking"
+
+
+def _utterance_before(utterances: list[dict[str, Any]], at_ms: int) -> dict[str, Any] | None:
+    candidate = None
+    for u in utterances:
+        if u["end_ms"] <= at_ms + _ABUT_TOLERANCE_MS and (
+            candidate is None or u["end_ms"] > candidate["end_ms"]
+        ):
+            candidate = u
+    return candidate
+
+
+def _utterance_after(utterances: list[dict[str, Any]], at_ms: int) -> dict[str, Any] | None:
+    candidate = None
+    for u in utterances:
+        if u["start_ms"] >= at_ms - _ABUT_TOLERANCE_MS and (
+            candidate is None or u["start_ms"] < candidate["start_ms"]
+        ):
+            candidate = u
+    return candidate
+
+
+def type_all_silences(transcript: dict[str, Any]) -> dict[str, Any]:
+    """Annotate every silence in a transcript dict with a `context` type.
+
+    Mutates and returns the transcript. Idempotent. Fast: O(silences × utterances).
+    """
+    utterances = transcript.get("utterances", [])
+    cues = transcript.get("cues", [])
+    speakers = transcript.get("speakers", [])
+    for silence in transcript.get("silences", []):
+        prev_utt = _utterance_before(utterances, silence["start_ms"])
+        next_utt = _utterance_after(utterances, silence["end_ms"])
+        silence["context"] = type_silence(silence, prev_utt, next_utt, speakers, cues)
+    return transcript

package/transcriber/app/transcribe_cli.py

@@ -0,0 +1,82 @@
+"""Native (host) transcription entrypoint (#176).
+
+Runs the full pipeline ON THE HOST (no Docker) so Apple-Silicon ASR backends
+(`parakeet-mlx` / Metal) and pyannote use the GPU/CPU directly — the Docker
+container is CPU-only on macOS, which is the bottleneck this path removes. The
+Node CLI shells out to this when `transcriber.runtime = native`; the Docker
+`/transcribe` route stays the cross-platform fallback and shares the exact same
+`run_pipeline` orchestration.
+
+    python -m app.transcribe_cli \
+        --seed-path <seed> --session-id S001 \
+        --source-path <seed>/sessions/S001/source.mp3 \
+        --engine parakeet --language en
+
+Prints one JSON line mirroring the /transcribe response shape so the Node
+caller parses both paths identically.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from .asr import ASRConfig
+from .pipeline import PipelineBackends, PipelineConfig, run_pipeline, write_transcript
+
+_DEFAULT_MODEL = {
+    "parakeet": "mlx-community/parakeet-tdt-0.6b-v3",
+    "whisper": "large-v3-turbo",
+}
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="compost-transcribe-native")
+    p.add_argument("--seed-path", required=True)
+    p.add_argument("--session-id", required=True)
+    p.add_argument("--source-path", required=True)
+    p.add_argument("--engine", default="parakeet", choices=["parakeet", "whisper"])
+    p.add_argument("--model", default=None, help="ASR model id (engine default if omitted)")
+    p.add_argument("--language", default=None)
+    p.add_argument("--device", default="auto")
+    p.add_argument("--compute-type", default="int8")
+    args = p.parse_args(argv)
+
+    asr = ASRConfig(
+        model_name=args.model or _DEFAULT_MODEL[args.engine],
+        device=args.device,
+        compute_type=args.compute_type,
+        language=args.language,
+        engine=args.engine,
+    )
+    config = PipelineConfig(asr=asr, asr_model_tag=f"{asr.model_name} ({args.engine})")
+
+    try:
+        transcript = run_pipeline(
+            seed_path=args.seed_path,
+            session_id=args.session_id,
+            source_path=args.source_path,
+            config=config,
+            backends=PipelineBackends(),  # all None → real lazy backends (Silero / engine ASR / pyannote)
+        )
+    except Exception as e:  # surface as JSON so the Node caller can report it
+        print(json.dumps({"status": "failed", "error": str(e)}))
+        return 1
+
+    path = write_transcript(args.seed_path, args.session_id, transcript)
+    print(
+        json.dumps(
+            {
+                "session_id": args.session_id,
+                "transcript_path": path,
+                "status": transcript.get("status", "ok"),
+                "engine": args.engine,
+                "model": asr.model_name,
+            }
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())