luckiest-co 1.0.32 → 1.0.34

package/skills/luckiest-video-watcher/scripts/gemini.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Gemini engine: Google watches the video (agentic processing) and answers.
+
+Standard library only. The key travels in the x-goog-api-key header and is
+scrubbed from every diagnostic.
+"""
+from __future__ import annotations
+
+import json
+import math
+import mimetypes
+import re
+import time
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+from runtime import diagnostic
+
+API = 'https://generativelanguage.googleapis.com'
+INTERACTIONS = f'{API}/v1beta/interactions'
+_YOUTUBE = re.compile(
+    r'^https?://(?:(?:www\.|m\.|music\.)?youtube\.com/(?:watch\?\S*\bv=|shorts/|live/)|youtu\.be/)\S+$', re.I)
+_HINTS = {
+    'auth': 'check GEMINI_API_KEY (create one at https://aistudio.google.com/apikey)',
+    'quota': 'the key is rate-limited or out of quota; wait or check its plan',
+    'rejected': 'Gemini refused this request; the video may be private, unsupported, or too long',
+    'service': 'Gemini had a server error; retry shortly',
+    'network': 'could not reach generativelanguage.googleapis.com; check network, proxy, or egress rules',
+    'response': 'Gemini returned something this version cannot read',
+    'upload': 'the video could not be uploaded to or processed by the Gemini Files API',
+}
+DEFAULT_QUESTION = ('Give a thorough summary of this video: what is shown, any on-screen text or code, '
+                    'and what is said, in chronological order.')
+PROMPT_SUFFIX = ('\n\nCite an MM:SS (or H:MM:SS) timestamp for every claim about a specific moment. '
+                 'Separate what is seen from what is heard when it matters. If the video does not '
+                 'show or say something needed to answer, say so plainly instead of guessing.')
+
+
+def is_youtube(source: str) -> bool:
+    return bool(_YOUTUBE.match(source or ''))
+
+
+def build_prompt(question: str | None) -> str:
+    return ((question or '').strip() or DEFAULT_QUESTION) + PROMPT_SUFFIX
+
+
+def _fail(category: str, detail: str, key: str) -> SystemExit:
+    detail = diagnostic(detail, 600).replace(key, '[redacted]') if key else diagnostic(detail, 600)
+    return SystemExit(f'Gemini {category}: {_HINTS[category]}. Detail: {detail or "none"}. '
+                      'No local fallback was attempted; rerun with --engine local to use frames + transcript.')
+
+
+def _error_message(body: bytes) -> str:
+    text = body.decode('utf-8', errors='replace')
+    try:
+        data = json.loads(text)
+        if isinstance(data, list) and data:  # Auth errors arrive wrapped in a one-element array.
+            data = data[0]
+        return str(data['error']['message'])
+    except (ValueError, KeyError, TypeError):
+        return text
+
+
+def _call(method: str, url: str, key: str, *, data=None, headers=None, timeout: float = 60.0):
+    request = Request(url, data=data, method=method, headers={'x-goog-api-key': key, **(headers or {})})
+    try:
+        with urlopen(request, timeout=timeout) as response:
+            return response.status, dict(response.headers), response.read()
+    except HTTPError as exc:
+        message = _error_message(exc.read())
+        # The Files API answers a malformed key with 400 "API key not valid", not 401.
+        category = ('auth' if exc.code in (401, 403) or 'api key' in message.lower() else 'quota' if exc.code == 429
+                    else 'service' if exc.code >= 500 else 'rejected')
+        raise _fail(category, f'HTTP {exc.code}: {message}', key) from None
+    except (URLError, TimeoutError, OSError) as exc:
+        raise _fail('network', f'{type(exc).__name__}: {getattr(exc, "reason", exc)}', key) from None
+
+
+def _clock(seconds: int) -> str:
+    hours, rest = divmod(seconds, 3600)
+    minutes, secs = divmod(rest, 60)
+    return f'{hours}:{minutes:02d}:{secs:02d}' if hours else f'{minutes:02d}:{secs:02d}'
+
+
+def _processing(clip):
+    if not clip or (clip[0] is None and clip[1] is None):
+        return 'agentic', 'agentic'
+    start, end = clip
+    config = {'type': 'static'}  # Offsets are only accepted in static mode, as duration strings.
+    if start is not None:
+        config['start_offset'] = f'{int(math.floor(start))}s'
+    if end is not None:
+        config['end_offset'] = f'{int(math.ceil(end))}s'
+    label = (f'static clip {_clock(int(math.floor(start or 0)))}–'
+             f'{_clock(int(math.ceil(end))) if end is not None else "end"}')
+    return config, label
+
+
+def ask(video: dict, question: str | None, *, model: str, key: str, clip=None, timeout: float = 600.0) -> dict:
+    processing, label = _processing(clip)
+    payload = {'model': model, 'input': [{'type': 'video', **video, 'processing': processing},
+                                         {'type': 'text', 'text': build_prompt(question)}]}
+    _, _, body = _call('POST', INTERACTIONS, key, data=json.dumps(payload).encode('utf-8'),
+                       headers={'Content-Type': 'application/json'}, timeout=timeout)
+    try:
+        data = json.loads(body)
+        parts = [part['text'] for step in data['steps'] if step.get('type') == 'model_output'
+                 for part in step.get('content', []) if part.get('type') == 'text' and part.get('text')]
+        tokens = (data.get('usage') or {}).get('total_tokens')
+    except (ValueError, KeyError, TypeError, AttributeError):
+        raise _fail('response', body[:300].decode('utf-8', errors='replace'), key) from None
+    if not parts:
+        raise _fail('response', f'no answer text (status {data.get("status")})', key)
+    return {'text': '\n'.join(parts).strip(), 'model': model, 'processing': label,
+            'total_tokens': tokens if isinstance(tokens, int) else None}
+
+
+def upload_file(path: Path, key: str, *, poll_seconds: float = 2.0, max_wait: float = 900.0, sleep=time.sleep) -> dict:
+    path = Path(path)
+    size = path.stat().st_size
+    if size == 0:
+        raise _fail('upload', f'{path.name} is empty', key)
+    guessed = mimetypes.guess_type(path.name)[0] or ''
+    mime = guessed if guessed.startswith('video/') else 'video/mp4'
+    _, headers, _ = _call('POST', f'{API}/upload/v1beta/files', key,
+                          data=json.dumps({'file': {'display_name': 'watch-upload'}}).encode('utf-8'),
+                          headers={'X-Goog-Upload-Protocol': 'resumable', 'X-Goog-Upload-Command': 'start',
+                                   'X-Goog-Upload-Header-Content-Length': str(size),
+                                   'X-Goog-Upload-Header-Content-Type': mime, 'Content-Type': 'application/json'})
+    session = {name.lower(): value for name, value in headers.items()}.get('x-goog-upload-url')
+    if not session:
+        raise _fail('upload', 'the Files API did not return an upload session URL', key)
+    with path.open('rb') as stream:  # Streamed in blocks; never held in memory.
+        _, _, body = _call('POST', session, key, data=stream,
+                           headers={'Content-Length': str(size), 'X-Goog-Upload-Offset': '0',
+                                    'X-Goog-Upload-Command': 'upload, finalize'}, timeout=3600.0)
+    try:
+        info = json.loads(body)['file']
+        waited = 0.0
+        while info.get('state') == 'PROCESSING':
+            if waited >= max_wait:
+                delete_file(info['name'], key)
+                raise _fail('upload', f'still processing after {int(max_wait)}s', key)
+            sleep(poll_seconds)
+            waited += poll_seconds
+            info = json.loads(_call('GET', f"{API}/v1beta/{info['name']}", key)[2])
+        if info.get('state') != 'ACTIVE':
+            delete_file(info['name'], key)
+            raise _fail('upload', f"file state {info.get('state')}", key)
+        return {'name': info['name'], 'uri': info['uri'], 'mime_type': info.get('mimeType') or mime}
+    except (ValueError, KeyError, TypeError):
+        raise _fail('upload', 'unreadable Files API response', key) from None
+
+
+def delete_file(name: str, key: str) -> str | None:
+    try:
+        _call('DELETE', f'{API}/v1beta/{name}', key)
+        return None
+    except (SystemExit, Exception) as exc:  # Cleanup must never mask the real result or error.
+        return (f'Could not delete uploaded {name} from Google ({str(exc).split(". Detail:")[0]}); '
+                'it expires on its own within 48 hours.')

package/skills/luckiest-video-watcher/scripts/local_whisperx.py

@@ -0,0 +1,147 @@
+"""Subprocess-only WhisperX 3.8.6 adapter. Never imports Torch into watch."""
+from __future__ import annotations
+
+import json
+import os
+import queue
+import re
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+from config import ConfigError, get_config, positive_number
+from runtime import diagnostic
+from transcribe import normalize_segments
+
+MODELS = {'tiny', 'base', 'small', 'medium', 'large', 'large-v1', 'large-v2', 'large-v3',
+          'large-v3-turbo', 'turbo', 'tiny.en', 'base.en', 'small.en', 'medium.en'}
+
+
+def settings(cfg=None) -> dict:
+    cfg = dict(get_config(backend_override='whisperx') if cfg is None else cfg)
+    if cfg['whisperx_model'] not in MODELS:
+        raise ConfigError('WATCH_WHISPERX_MODEL must be a supported Whisper model name (default small).')
+    if cfg['whisperx_device'] not in ('cpu', 'cuda'):
+        raise ConfigError('WATCH_WHISPERX_DEVICE must be cpu or cuda (CUDA is untested).')
+    if cfg['whisperx_compute_type'] not in ('default', 'int8', 'float16', 'float32'):
+        raise ConfigError('WATCH_WHISPERX_COMPUTE_TYPE must be default, int8, float16, or float32.')
+    batch = positive_number(cfg['whisperx_batch_size'], 'WATCH_WHISPERX_BATCH_SIZE')
+    if batch != int(batch):
+        raise ConfigError('WATCH_WHISPERX_BATCH_SIZE must be a positive integer.')
+    cfg['whisperx_batch_size'] = int(batch)
+    cfg['whisperx_timeout'] = positive_number(cfg['whisperx_timeout'], 'WATCH_WHISPERX_TIMEOUT') if cfg['whisperx_timeout'] else None
+    if cfg['whisperx_language'] and not re.fullmatch('[a-z]{2}', cfg['whisperx_language']):
+        raise ConfigError('WATCH_WHISPERX_LANGUAGE must be a two-letter lowercase code.')
+    return cfg
+
+
+def sentinel_for(executable: Path) -> Path:
+    return executable.parent.parent / '.deps-ok'
+
+
+def executable_path(cfg: dict, *, require_ready=True) -> Path:
+    value = cfg['whisperx_bin']
+    if not value or not Path(value).is_absolute() or not Path(value).is_file():
+        raise SystemExit('WhisperX executable missing. Run setup.py --install-whisperx.')
+    executable = Path(value)
+    if require_ready and not sentinel_for(executable).is_file():
+        raise SystemExit('WhisperX venv is incomplete (no .deps-ok). Run setup.py --install-whisperx to rebuild it.')
+    return executable
+
+
+def command(executable: Path, audio: Path, output: Path, cfg: dict) -> list[str]:
+    cmd = [str(executable), str(audio.resolve()), '--model', cfg['whisperx_model'],
+           '--device', cfg['whisperx_device'], '--compute_type', cfg['whisperx_compute_type'],
+           '--batch_size', str(cfg['whisperx_batch_size']), '--output_dir', str(output.resolve()),
+           '--output_format', 'json', '--task', 'transcribe', '--no_align', '--vad_method', 'silero', '--verbose', 'False']
+    if cfg['whisperx_language']:
+        cmd += ['--language', cfg['whisperx_language']]
+    return cmd
+
+
+def child_env() -> dict[str, str]:
+    env = dict(os.environ)
+    env.update(PYTHONIOENCODING='utf-8', PYTHONWARNINGS='ignore', PYANNOTE_METRICS_ENABLED='0')
+    return env
+
+
+def run_inference(cmd: list[str], timeout: float | None = None) -> None:
+    """Stream bounded byte diagnostics while enforcing an optional wall-clock timeout."""
+    try:
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=child_env())
+    except OSError as exc:
+        raise SystemExit(f'WhisperX executable is not runnable ({type(exc).__name__}); rerun setup.py --install-whisperx.') from None
+    messages = queue.Queue(maxsize=64)
+    def read():
+        try:
+            while chunk := process.stdout.read1(4096):
+                messages.put(chunk)
+        finally:
+            messages.put(None)
+    reader = threading.Thread(target=read, daemon=True)
+    reader.start()
+    deadline = time.monotonic() + timeout if timeout is not None else None
+    tail = b''
+    try:
+        while True:
+            if deadline is not None and time.monotonic() >= deadline:
+                raise TimeoutError()
+            try:
+                chunk = messages.get(timeout=0.1)
+            except queue.Empty:
+                continue
+            if chunk is None:
+                break
+            tail = (tail + chunk)[-16000:]
+            text = diagnostic(chunk, 4096)
+            if text:
+                print(f'[whisperx] {text}', file=sys.stderr, flush=True)
+        process.wait(timeout=max(0.01, deadline - time.monotonic()) if deadline is not None else None)
+    except (TimeoutError, subprocess.TimeoutExpired):
+        process.kill()
+        process.wait()
+        raise SystemExit('WhisperX timed out and was stopped. Increase WATCH_WHISPERX_TIMEOUT or leave it unset.') from None
+    except KeyboardInterrupt:
+        process.kill()
+        process.wait()
+        raise SystemExit('WhisperX cancelled and stopped; no cloud fallback was attempted.') from None
+    finally:
+        # Drain queued diagnostics so the reader cannot remain blocked after cancellation.
+        while reader.is_alive():
+            try:
+                messages.get(timeout=0.1)
+            except queue.Empty:
+                pass
+        reader.join()
+        process.stdout.close()
+    if process.returncode != 0:
+        detail = diagnostic(tail)
+        lower = tail.decode('utf-8', errors='replace').lower()
+        if any(token in lower for token in ('out of memory', 'bad_alloc', 'cuda', 'cudnn', 'cublas')) or process.returncode in (-9, 137):
+            hint = 'Memory or device failure; use cpu/int8, a smaller model, or lower batch size. Small needs at least 8 GB system RAM.'
+        elif any(token in lower for token in ('huggingface', 'connection', 'offline', 'download', 'localentrynotfound')):
+            hint = 'Model download/cache failure; reconnect and rerun setup.py --install-whisperx to warm the caches.'
+        else:
+            hint = 'Check the error below and rerun setup.py --install-whisperx if dependencies are broken.'
+        raise SystemExit(f'WhisperX failed (exit {process.returncode}). {hint}\n{detail}')
+
+
+def transcribe_audio(audio: Path, cfg=None, *, require_ready=True):
+    cfg = settings(cfg)
+    executable = executable_path(cfg, require_ready=require_ready)
+    print(f"[watch] local WhisperX {cfg['whisperx_model']} transcription; CPU runs may take several minutes.", file=sys.stderr, flush=True)
+    with tempfile.TemporaryDirectory(prefix='watch-whisperx-', dir=audio.parent) as temporary:
+        output = Path(temporary)
+        run_inference(command(executable, audio, output, cfg), cfg['whisperx_timeout'])
+        try:
+            data = json.loads((output / f'{audio.stem}.json').read_text(encoding='utf-8'))
+            segments = normalize_segments(data)
+        except (OSError, ValueError, TypeError) as exc:
+            raise SystemExit(f'WhisperX output missing or malformed ({type(exc).__name__}).') from None
+    # 3.8.6 overwrites JSON language with alignment language even with --no_align.
+    if segments.no_speech:
+        print('[watch] WhisperX detected no speech.', file=sys.stderr)
+    return segments

package/skills/luckiest-video-watcher/scripts/runtime.py

@@ -0,0 +1,35 @@
+"""Small cross-platform process and stream helpers; no optional dependencies."""
+from __future__ import annotations
+
+import subprocess
+import sys
+
+
+def configure_stdio() -> None:
+    """Call at script entry only, leaving imported modules' streams untouched."""
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, 'reconfigure', None)
+        if reconfigure is not None:
+            try:
+                reconfigure(encoding='utf-8', errors='backslashreplace')
+            except (OSError, ValueError):
+                pass
+
+
+def diagnostic(value, limit: int = 3000) -> str:
+    if isinstance(value, bytes):
+        value = value.decode('utf-8', errors='replace')
+    return str(value or '').strip()[-limit:]
+
+
+def run_text(cmd: list[str], **kwargs) -> subprocess.CompletedProcess:
+    """Capture diagnostics predictably, including Windows pipes and launch failures."""
+    try:
+        return subprocess.run(cmd, capture_output=True, encoding='utf-8', errors='replace', **kwargs)
+    except subprocess.TimeoutExpired as exc:
+        raise SystemExit(f'{cmd[0]} timed out: {diagnostic(exc.stderr)}') from None
+    except OSError as exc:
+        raise SystemExit(
+            f'Cannot run {cmd[0]} ({type(exc).__name__}). Check that the executable is installed '
+            'and permitted by your operating system, then retry.'
+        ) from None