getscript 0.12.0__py3-none-any.whl

getscript/config.py

@@ -0,0 +1,64 @@
+"""Configuration loading with XDG base directory compliance."""
+
+import json
+import os
+
+
+def get_config_dir() -> str:
+    return os.path.join(
+        os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")),
+        "getscript",
+    )
+
+
+def get_cache_dir() -> str:
+    return os.path.join(
+        os.environ.get("XDG_CACHE_HOME", os.path.expanduser("~/.cache")),
+        "getscript",
+    )
+
+
+def load_config() -> dict:
+    """Load config from XDG config file. Returns empty dict if not found."""
+    import sys
+
+    config_path = os.path.join(get_config_dir(), "config.json")
+    if os.path.exists(config_path):
+        try:
+            with open(config_path) as f:
+                return json.load(f)
+        except json.JSONDecodeError as e:
+            print(f"Warning: invalid config at {config_path}: {e}", file=sys.stderr)
+    return {}
+
+
+def merge_config(file_config: dict, cli_args: dict) -> dict:
+    """Merge config sources: file < env vars < CLI flags.
+
+    CLI flags override env vars override file config.
+    Only non-None CLI values override.
+    """
+    merged = dict(file_config)
+
+    # Env var overrides
+    if os.environ.get("NO_COLOR"):
+        merged["no_color"] = True
+    if os.environ.get("GETSCRIPT_YOUTUBE_API_KEY"):
+        merged["youtube_api_key"] = os.environ["GETSCRIPT_YOUTUBE_API_KEY"]
+    if os.environ.get("GETSCRIPT_PROXY"):
+        merged["proxy"] = os.environ["GETSCRIPT_PROXY"]
+    if os.environ.get("GETSCRIPT_COOKIE_FILE"):
+        merged["cookie_file"] = os.environ["GETSCRIPT_COOKIE_FILE"]
+    if os.environ.get("GETSCRIPT_UPLOAD", "").lower() in ("0", "false", "no"):
+        merged["no_upload"] = True
+    if os.environ.get("GETSCRIPT_SUPABASE_URL"):
+        merged["supabase_url"] = os.environ["GETSCRIPT_SUPABASE_URL"]
+    if os.environ.get("GETSCRIPT_SUPABASE_ANON_KEY"):
+        merged["supabase_anon_key"] = os.environ["GETSCRIPT_SUPABASE_ANON_KEY"]
+
+    # CLI flag overrides (only if explicitly set)
+    for key, value in cli_args.items():
+        if value is not None:
+            merged[key] = value
+
+    return merged

getscript/detect.py

@@ -0,0 +1,56 @@
+"""Auto-detect transcript source from URL or ID."""
+
+import re
+from urllib.parse import urlparse, parse_qs
+
+
+def detect_source(input_str: str) -> tuple[str, str]:
+    """Detect source and extract ID from a URL or bare ID.
+
+    Returns:
+        ("youtube", video_id) or ("apple", episode_id)
+
+    Raises:
+        ValueError with a helpful message if input can't be identified.
+    """
+    input_str = input_str.strip()
+
+    # YouTube patterns
+    yt_patterns = [
+        r"v=([A-Za-z0-9_-]{11})",
+        r"youtu\.be/([A-Za-z0-9_-]{11})",
+        r"shorts/([A-Za-z0-9_-]{11})",
+    ]
+    for pattern in yt_patterns:
+        m = re.search(pattern, input_str)
+        if m:
+            return ("youtube", m.group(1))
+
+    # Bare YouTube video ID (exactly 11 chars, alphanumeric + _ -)
+    if re.fullmatch(r"[A-Za-z0-9_-]{11}", input_str):
+        return ("youtube", input_str)
+
+    # Pure numeric string → Apple Podcasts episode ID
+    if input_str.isdigit():
+        return ("apple", input_str)
+
+    # Apple Podcasts URL
+    if "podcasts.apple.com" in input_str:
+        parsed = urlparse(input_str)
+        qs = parse_qs(parsed.query)
+        if "i" in qs:
+            return ("apple", qs["i"][0])
+        # Try extracting from path: /podcast/.../id<show_id>?i=<ep_id>
+        raise ValueError(
+            f"Apple Podcasts URL missing episode ID (?i=...). "
+            f"Open the episode in Apple Podcasts and copy the share link."
+        )
+
+    raise ValueError(
+        f"Could not detect source from: {input_str}\n"
+        f"Supported inputs:\n"
+        f"  YouTube:  https://youtube.com/watch?v=VIDEO_ID\n"
+        f"  YouTube:  https://youtu.be/VIDEO_ID\n"
+        f"  Apple:    https://podcasts.apple.com/...?i=EPISODE_ID\n"
+        f"  Apple:    EPISODE_ID (numeric)"
+    )

getscript/output.py

@@ -0,0 +1,97 @@
+"""Output formatting: plain text, JSON, TTML, Markdown."""
+
+import json
+import sys
+from datetime import date
+
+
+def is_tty() -> bool:
+    return sys.stdout.isatty()
+
+
+def format_timestamp(seconds: float) -> str:
+    """Format seconds as HH:MM:SS or MM:SS."""
+    h = int(seconds // 3600)
+    m = int((seconds % 3600) // 60)
+    s = int(seconds % 60)
+    if h > 0:
+        return f"{h:02d}:{m:02d}:{s:02d}"
+    return f"{m:02d}:{s:02d}"
+
+
+def format_text(segments: list[dict], timestamps: bool = False) -> str:
+    """Format segments as plain text."""
+    if timestamps:
+        lines = []
+        for seg in segments:
+            ts = format_timestamp(seg.get("start", 0))
+            lines.append(f"[{ts}] {seg['text']}")
+        return "\n".join(lines)
+    return " ".join(seg["text"] for seg in segments)
+
+
+def format_json(
+    segments: list[dict],
+    source: str,
+    source_id: str,
+    timestamps: bool = False,
+) -> str:
+    """Format as structured JSON."""
+    output = {
+        "source": source,
+        "id": source_id,
+        "text": " ".join(seg["text"] for seg in segments),
+    }
+    if timestamps:
+        output["segments"] = segments
+    else:
+        output["segments"] = [{"text": seg["text"]} for seg in segments]
+    return json.dumps(output, indent=2, ensure_ascii=False)
+
+
+def format_markdown(
+    segments: list[dict],
+    source: str,
+    source_id: str,
+    timestamps: bool = False,
+) -> str:
+    """Format as Markdown with YAML frontmatter."""
+    lines = [
+        "---",
+        f"source: {source}",
+        f"id: \"{source_id}\"",
+        f"date: \"{date.today().isoformat()}\"",
+        "---",
+        "",
+        "# Transcript",
+        "",
+    ]
+    if timestamps:
+        for seg in segments:
+            ts = format_timestamp(seg.get("start", 0))
+            lines.append(f"**[{ts}]** {seg['text']}")
+            lines.append("")
+    else:
+        lines.append(" ".join(seg["text"] for seg in segments))
+        lines.append("")
+    return "\n".join(lines)
+
+
+def format_output(
+    segments: list[dict],
+    fmt: str = "text",
+    source: str = "",
+    source_id: str = "",
+    timestamps: bool = False,
+    ttml_raw: str | None = None,
+) -> str:
+    """Route to the appropriate formatter."""
+    if fmt == "ttml":
+        if ttml_raw is None:
+            raise ValueError("--ttml is only supported for Apple Podcasts transcripts")
+        return ttml_raw
+    if fmt == "json":
+        return format_json(segments, source, source_id, timestamps)
+    if fmt == "markdown":
+        return format_markdown(segments, source, source_id, timestamps)
+    return format_text(segments, timestamps)

getscript/picker.py

@@ -0,0 +1,69 @@
+"""Interactive selection via fzf."""
+
+import shutil
+import subprocess
+import sys
+
+
+def pick_result(results: list[dict]) -> dict | None:
+    """Format results and pipe to fzf for interactive selection.
+
+    Returns the selected result dict, or None if user cancelled.
+    Raises RuntimeError if fzf is not installed.
+    """
+    if not shutil.which("fzf"):
+        raise RuntimeError(
+            "fzf required for --search. "
+            "Install: https://github.com/junegunn/fzf#installation"
+        )
+
+    # Build aligned columns
+    lines = []
+    for r in results:
+        parts = [r["id"], r["title"], r["channel"]]
+        if r.get("duration"):
+            parts.append(r["duration"])
+        lines.append("\t".join(parts))
+
+    fzf_input = "\n".join(lines)
+
+    try:
+        proc = subprocess.run(
+            ["fzf", "--delimiter=\t", "--with-nth=2..", "--header=Select a result:"],
+            input=fzf_input,
+            capture_output=True,
+            text=True,
+        )
+    except KeyboardInterrupt:
+        return None
+
+    if proc.returncode == 130:
+        # User pressed Esc or Ctrl-C in fzf
+        return None
+    if proc.returncode != 0:
+        return None
+
+    selected_line = proc.stdout.strip()
+    if not selected_line:
+        return None
+
+    # Parse the ID from the first column
+    selected_id = selected_line.split("\t")[0]
+
+    # Find the matching result
+    for r in results:
+        if r["id"] == selected_id:
+            return r
+
+    return None
+
+
+def format_list(results: list[dict]) -> str:
+    """Format results as a printable list for --list mode."""
+    lines = []
+    for i, r in enumerate(results, 1):
+        parts = [r["id"], r["title"], r["channel"]]
+        if r.get("duration"):
+            parts.append(r["duration"])
+        lines.append(f"{i:3d}. " + "\t".join(parts))
+    return "\n".join(lines)

getscript/progress.py

@@ -0,0 +1,34 @@
+"""Lightweight stderr progress spinner (TTY-aware)."""
+
+import sys
+import time
+
+SPINNER_CHARS = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+
+class Progress:
+    """Simple stderr status indicator. Auto-disabled when stderr is not a TTY."""
+
+    def __init__(self, quiet: bool = False):
+        self._enabled = sys.stderr.isatty() and not quiet
+        self._idx = 0
+        self._last_msg = ""
+
+    def update(self, message: str) -> None:
+        if not self._enabled:
+            return
+        char = SPINNER_CHARS[self._idx % len(SPINNER_CHARS)]
+        self._idx += 1
+        # Clear line and write status
+        sys.stderr.write(f"\r\033[K{char} {message}")
+        sys.stderr.flush()
+        self._last_msg = message
+
+    def done(self, message: str | None = None) -> None:
+        if not self._enabled:
+            return
+        if message:
+            sys.stderr.write(f"\r\033[K{message}\n")
+        else:
+            sys.stderr.write("\r\033[K")
+        sys.stderr.flush()

getscript/search.py

@@ -0,0 +1,83 @@
+"""Search backends for YouTube and Apple Podcasts."""
+
+import json
+import urllib.request
+import urllib.parse
+
+
+def search_youtube(query: str, api_key: str, limit: int = 10) -> list[dict]:
+    """Search YouTube via Data API v3.
+
+    Returns list of {"id", "title", "channel", "duration"} dicts.
+    Duration is not available from search endpoint, so set to "".
+    """
+    params = urllib.parse.urlencode({
+        "q": query,
+        "type": "video",
+        "part": "snippet",
+        "maxResults": min(limit, 50),
+        "key": api_key,
+    })
+    url = f"https://www.googleapis.com/youtube/v3/search?{params}"
+
+    req = urllib.request.Request(url)
+    req.add_header("Accept", "application/json")
+
+    with urllib.request.urlopen(req, timeout=15) as resp:
+        data = json.loads(resp.read())
+
+    results = []
+    for item in data.get("items", []):
+        video_id = item.get("id", {}).get("videoId")
+        if not video_id:
+            continue
+        snippet = item.get("snippet", {})
+        results.append({
+            "id": video_id,
+            "title": snippet.get("title", ""),
+            "channel": snippet.get("channelTitle", ""),
+            "duration": "",
+        })
+
+    return results
+
+
+def search_apple(query: str, limit: int = 10) -> list[dict]:
+    """Search Apple Podcasts via iTunes Search API (free, no auth).
+
+    Returns list of {"id", "title", "channel", "duration"} dicts.
+    """
+    params = urllib.parse.urlencode({
+        "term": query,
+        "media": "podcast",
+        "entity": "podcastEpisode",
+        "limit": min(limit, 200),
+    })
+    url = f"https://itunes.apple.com/search?{params}"
+
+    req = urllib.request.Request(url)
+    with urllib.request.urlopen(req, timeout=15) as resp:
+        data = json.loads(resp.read())
+
+    results = []
+    for item in data.get("results", []):
+        track_id = item.get("trackId")
+        if not track_id:
+            continue
+        # Duration from API is in milliseconds
+        duration_ms = item.get("trackTimeMillis", 0)
+        if duration_ms:
+            total_secs = duration_ms // 1000
+            mins, secs = divmod(total_secs, 60)
+            hours, mins = divmod(mins, 60)
+            duration = f"{hours}:{mins:02d}:{secs:02d}" if hours else f"{mins}:{secs:02d}"
+        else:
+            duration = ""
+        results.append({
+            "id": str(track_id),
+            "title": item.get("trackName", ""),
+            "channel": item.get("collectionName", ""),
+            "duration": duration,
+        })
+
+    return results

getscript/upload.py

@@ -0,0 +1,131 @@
+"""Upload transcripts to the shared Voxly transcript pool."""
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+import uuid
+
+from getscript import __version__
+from getscript.config import get_config_dir
+
+SUPABASE_URL = "https://ohxuifdseybxckmprcry.supabase.co"
+SUPABASE_ANON_KEY = (
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9."
+    "eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im9oeHVpZmRzZXlieGNrbXByY3J5Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzA2NDE5NDgsImV4cCI6MjA4NjIxNzk0OH0."
+    "_4NFs2SY98gIL6Z0tgiTxIVSX7FBJ8b_46oF7Vi7p6M"
+)
+
+SOURCE_TYPE_MAP = {
+    "youtube": "youtube_transcript",
+    "apple": "podcast",
+}
+
+
+def get_device_id() -> str:
+    """Get or create a persistent anonymous device ID."""
+    config_dir = get_config_dir()
+    device_path = os.path.join(config_dir, "device.json")
+    if os.path.exists(device_path):
+        try:
+            with open(device_path) as f:
+                data = json.load(f)
+                return data["device_id"]
+        except (json.JSONDecodeError, KeyError):
+            pass
+    device_id = str(uuid.uuid4())
+    os.makedirs(config_dir, exist_ok=True)
+    with open(device_path, "w") as f:
+        json.dump({"device_id": device_id}, f)
+    os.chmod(device_path, 0o600)
+    return device_id
+
+
+def fetch_title(source: str, source_id: str) -> str | None:
+    """Fetch video/episode title via oembed. Returns None on failure."""
+    if source == "youtube":
+        url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={source_id}&format=json"
+    else:
+        return None
+    try:
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+            return data.get("title")
+    except Exception:
+        return None
+
+
+def _build_source_url(source: str, source_id: str) -> str:
+    if source == "youtube":
+        return f"https://www.youtube.com/watch?v={source_id}"
+    elif source == "apple":
+        return f"https://podcasts.apple.com/podcast/ep?i={source_id}"
+    return source_id
+
+
+def upload_transcript(
+    source: str,
+    source_id: str,
+    segments: list[dict],
+    title: str | None,
+    config: dict,
+) -> dict | None:
+    """Upload a transcript to the shared pool. Returns response dict or None on failure.
+
+    Never raises — all errors are printed to stderr.
+    """
+    try:
+        base_url = config.get("supabase_url", SUPABASE_URL).rstrip("/")
+        anon_key = config.get("supabase_anon_key", SUPABASE_ANON_KEY)
+
+        source_url = _build_source_url(source, source_id)
+        source_type = SOURCE_TYPE_MAP.get(source, source)
+        full_text = " ".join(seg.get("text", "") for seg in segments)
+        word_count = len(full_text.split())
+
+        device_id = get_device_id()
+
+        payload = {
+            "device_id": device_id,
+            "source_type": source_type,
+            "source_id": source_id,
+            "source_url": source_url,
+            "title": title,
+            "segments": segments,
+            "full_text": full_text,
+            "word_count": word_count,
+            "cli_version": __version__,
+        }
+
+        data = json.dumps(payload).encode("utf-8")
+        url = f"{base_url}/functions/v1/ingest-transcript"
+
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {anon_key}",
+            },
+            method="POST",
+        )
+
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+
+    except urllib.error.HTTPError as e:
+        body = ""
+        try:
+            body = e.read().decode("utf-8", errors="replace")
+        except Exception:
+            pass
+        print(f"Warning: upload failed (HTTP {e.code}): {body}", file=sys.stderr)
+        return None
+    except urllib.error.URLError as e:
+        print(f"Warning: upload failed (network): {e.reason}", file=sys.stderr)
+        return None
+    except Exception as e:
+        print(f"Warning: upload failed: {e}", file=sys.stderr)
+        return None

getscript/youtube.py

@@ -0,0 +1,58 @@
+"""YouTube transcript fetching."""
+
+import http.cookiejar
+import os
+
+from requests import Session
+from youtube_transcript_api import YouTubeTranscriptApi
+from youtube_transcript_api.proxies import GenericProxyConfig
+
+
+def _load_cookies(cookie_path: str) -> http.cookiejar.MozillaCookieJar:
+    """Load Netscape/Mozilla format cookies from file."""
+    jar = http.cookiejar.MozillaCookieJar(cookie_path)
+    jar.load(ignore_discard=True, ignore_expires=True)
+    return jar
+
+
+def _build_api(config: dict) -> YouTubeTranscriptApi:
+    """Build YouTubeTranscriptApi with optional proxy and cookie config."""
+    proxy_config = None
+    http_client = None
+
+    proxy_url = config.get("proxy")
+    cookie_file = config.get("cookie_file")
+
+    if proxy_url:
+        proxy_config = GenericProxyConfig(https_url=proxy_url)
+
+    if cookie_file:
+        cookie_path = os.path.expanduser(cookie_file)
+        if not os.path.exists(cookie_path):
+            raise FileNotFoundError(f"Cookie file not found: {cookie_path}")
+        http_client = Session()
+        http_client.cookies = _load_cookies(cookie_path)
+
+    return YouTubeTranscriptApi(proxy_config=proxy_config, http_client=http_client)
+
+
+def fetch_transcript(video_id: str, config: dict | None = None) -> list[dict]:
+    """Fetch transcript segments for a YouTube video.
+
+    Args:
+        video_id: YouTube video ID.
+        config: Optional config dict with proxy/cookie_file keys.
+
+    Returns:
+        List of {"text": str, "start": float, "duration": float}
+    """
+    api = _build_api(config or {})
+    transcript = api.fetch(video_id)
+    return [
+        {
+            "text": segment.text,
+            "start": segment.start,
+            "duration": segment.duration,
+        }
+        for segment in transcript
+    ]