textrun 0.1.0__py3-none-any.whl

textrun/__init__.py

@@ -0,0 +1,3 @@
+"""textrun - Generalized Wayland-compatible text reader with OCR and TTS."""
+
+__version__ = "0.1.0"

textrun/__main__.py

@@ -0,0 +1,194 @@
+"""CLI entry point for textrun."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from textrun import __version__
+from textrun.config import detect_profile, load_config
+from textrun.pipeline import Pipeline
+
+
+def setup_logging(verbose: bool = False) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%H:%M:%S",
+    )
+    # Third-party libs probe multiple backends internally and log every
+    # failed probe (with tracebacks) at DEBUG. That is noise for us.
+    for name in ("pyscreenshot", "easyprocess", "PIL", "pyautogui", "pyscreeze"):
+        logging.getLogger(name).setLevel(logging.WARNING)
+
+
+def parse_region(value: str) -> tuple[int, int, int, int]:
+    """Parse 'x,y,w,h' into a tuple of ints."""
+    parts = value.split(",")
+    if len(parts) != 4:
+        raise argparse.ArgumentTypeError(f"Region must be x,y,w,h (got {value!r})")
+    try:
+        return int(parts[0]), int(parts[1]), int(parts[2]), int(parts[3])
+    except ValueError:
+        raise argparse.ArgumentTypeError(
+            f"Region values must be integers (got {value!r})"
+        )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="textrun",
+        description="Generalized text reader with OCR and TTS",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=Path,
+        default=None,
+        help="Path to config file (default: ~/.config/textrun/config.toml)",
+    )
+    parser.add_argument(
+        "-p",
+        "--profile",
+        default=None,
+        help="Profile to use (default: auto-detect session type)",
+    )
+    parser.add_argument(
+        "--list-profiles",
+        action="store_true",
+        help="List available profiles and exit",
+    )
+    parser.add_argument(
+        "--gui",
+        action="store_true",
+        help="Launch the configuration GUI",
+    )
+    parser.add_argument(
+        "--shortcuts",
+        action="store_true",
+        help=("Daemon-like: register the global shortcuts and wait, no window shown"),
+    )
+    parser.add_argument(
+        "--install-desktop",
+        action="store_true",
+        help=(
+            "Install .desktop entry and icon so global shortcuts register "
+            "under 'textrun' instead of the launching terminal"
+        ),
+    )
+    parser.add_argument(
+        "--region",
+        type=parse_region,
+        default=None,
+        metavar="X,Y,W,H",
+        help=(
+            "Screen region to capture in real screen pixels "
+            "(e.g. 100,200,800,600). Note: the GUI saves logical coords plus "
+            "screen sizes and scales automatically; CLI coords are used as-is."
+        ),
+    )
+    parser.add_argument(
+        "--no-tts",
+        action="store_true",
+        help="Disable text-to-speech output",
+    )
+    parser.add_argument(
+        "--scroll-amount",
+        type=int,
+        default=None,
+        help="Override scroll amount (wheel clicks)",
+    )
+    parser.add_argument(
+        "--max-scrolls",
+        type=int,
+        default=None,
+        help="Override max scroll attempts",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        default=None,
+        help="Save extracted text to file instead of stdout",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    setup_logging(args.verbose)
+    profile = args.profile or detect_profile()
+
+    if args.gui or args.shortcuts:
+        try:
+            from textrun.gui.main_window import run_gui, run_shortcuts_daemon
+        except ImportError as exc:  # pragma: no cover - broken install only
+            print(f"GUI unavailable (broken install?): {exc}", file=sys.stderr)
+            sys.exit(1)
+        config = load_config(args.config, profile=profile)
+        if args.shortcuts:
+            run_shortcuts_daemon(config)
+        else:
+            run_gui(config)
+        sys.exit(0)
+
+    if args.list_profiles:
+        cfg = load_config(args.config, profile="global")
+        for p in cfg.list_profiles():
+            print(p)
+        sys.exit(0)
+
+    if args.install_desktop:
+        from textrun.desktop import install_desktop_files
+
+        for p in install_desktop_files():
+            print(f"Installed: {p}")
+        print(
+            "Launch textrun from your app menu so global shortcuts "
+            "register under 'textrun' instead of your terminal."
+        )
+        sys.exit(0)
+
+    overrides: dict = {}
+    if args.no_tts:
+        overrides["tts_enabled"] = False
+    if args.scroll_amount is not None:
+        overrides["scroll_amount"] = args.scroll_amount
+    if args.max_scrolls is not None:
+        overrides["max_scroll_attempts"] = args.max_scrolls
+    if args.region is not None:
+        x, y, w, h = args.region
+        overrides["region"] = {"x": x, "y": y, "width": w, "height": h}
+
+    config = load_config(args.config, profile=profile)
+    if overrides:
+        config._profile_data.update(overrides)
+
+    logger = logging.getLogger("textrun")
+    logger.info("Using profile: %s", config.profile)
+
+    pipeline = Pipeline(config)
+    text = pipeline.run()
+
+    if args.output:
+        args.output.write_text(text, encoding="utf-8")
+        logger.info("Text saved to %s", args.output)
+    else:
+        print(text)
+
+
+if __name__ == "__main__":
+    main()

textrun/adapters.py

@@ -0,0 +1,176 @@
+"""Adapter functions for stateful libraries that need initialization.
+
+These are referenced from config as type="adapter" backends.
+Each adapter is a simple function that takes a context dict
+and returns a result string (or raises on failure).
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Cached library instances, keyed by thread (COM objects on Windows are
+# apartment-threaded and must not be shared across threads). Reusing the
+# instance avoids per-chunk init cost during live chunked playback.
+_speechd_clients: dict[int, Any] = {}
+_pyttsx3_engines: dict[int, Any] = {}
+
+
+def _drop_cached(cache: dict, key: int) -> None:
+    cache.pop(key, None)
+
+
+def speechd_say(context: dict[str, Any]) -> str:
+    """Speak text using speech-dispatcher."""
+    text = context.get("text", "")
+    if not text:
+        return ""
+
+    import speechd
+
+    key = threading.get_ident()
+    client = _speechd_clients.get(key)
+    if client is None:
+        client = speechd.Client()
+        _speechd_clients[key] = client
+
+    try:
+        client.set_output_module(context.get("speechd_module", "pico"))
+        client.set_language(context.get("language", "eng"))
+        client.speak(text)
+    except Exception as exc:
+        _drop_cached(_speechd_clients, key)
+        try:
+            client.close()
+        except Exception:
+            pass
+        raise RuntimeError(f"speech-dispatcher failed: {exc}") from exc
+
+    return text
+
+
+def pyttsx3_say(context: dict[str, Any]) -> str:
+    """Speak text using pyttsx3 (wraps system TTS engine)."""
+    text = context.get("text", "")
+    if not text:
+        return ""
+
+    import pyttsx3
+
+    key = threading.get_ident()
+    engine = _pyttsx3_engines.get(key)
+    if engine is None:
+        engine = pyttsx3.init()
+        _pyttsx3_engines[key] = engine
+        rate = context.get("pyttsx3_rate")
+        if rate is not None:
+            engine.setProperty("rate", rate)
+        volume = context.get("pyttsx3_volume")
+        if volume is not None:
+            engine.setProperty("volume", volume)
+
+    try:
+        engine.say(text)
+        engine.runAndWait()
+    except Exception as exc:
+        _drop_cached(_pyttsx3_engines, key)
+        raise RuntimeError(f"pyttsx3 failed: {exc}") from exc
+
+    return text
+
+
+def playsound3_play(context: dict[str, Any]) -> str:
+    """Play an audio file using playsound3."""
+    path = context.get("audio_path", "")
+    if not path:
+        raise RuntimeError("No audio_path provided")
+
+    from playsound3 import playsound
+
+    playsound(path)
+    return path
+
+
+def crop_to_region(
+    path: str,
+    region: dict[str, Any],
+    screen_size: dict[str, Any] | None = None,
+    config_monitors: list | None = None,
+) -> str:
+    """Crop the image at *path* to *region* in place.
+
+    Region coords are logical and global (GUI). Monitor layout comes from
+    live providers (wlpdisplays/screeninfo/xrandr), then config-saved
+    monitors, then the legacy single-scale screen_size dict; with no info
+    at all coords are taken as-is. Skips cropping when the image already
+    matches the target size (backend cropped natively).
+    """
+    from PIL import Image
+
+    from textrun.monitors import get_monitors, region_crop_rect, single_from_screen_size
+
+    img = Image.open(path)
+    mons = get_monitors(config_monitors=config_monitors)
+    if mons is None and screen_size:
+        # Legacy aggregate info: missing real dims come from the capture
+        info = dict(screen_size)
+        if not info.get("real_width"):
+            info["real_width"] = img.width
+        if not info.get("real_height"):
+            info["real_height"] = img.height
+        mons = single_from_screen_size(info)
+
+    if mons:
+        x, y, w, h = region_crop_rect(region, mons)
+    else:
+        x = int(region["x"])
+        y = int(region["y"])
+        w = int(region["width"])
+        h = int(region["height"])
+
+    if abs(img.width - w) <= 2 and abs(img.height - h) <= 2:
+        return path  # already region-sized
+
+    img.crop((x, y, x + w, y + h)).save(path)
+    return path
+
+
+def pyscreenshot_capture(context: dict[str, Any]) -> str:
+    """Capture a screenshot using pyscreenshot. Supports region if set in context."""
+    output_path = context.get("output_path", "/tmp/textrun/screenshot.png")
+    region = context.get("region")
+
+    import pyscreenshot as ImageGrab
+
+    # Grab the full screen, then crop with PIL. Using bbox directly can be
+    # unreliable on Wayland (positioning ignored, cutout centered).
+    img = ImageGrab.grab()
+    img.save(output_path)
+    if region:
+        crop_to_region(output_path, region, context.get("screen_size"))
+    return output_path
+
+
+def pyautogui_scroll(context: dict[str, Any]) -> str:
+    """Scroll using pyautogui."""
+    amount = int(context.get("scroll_amount", 3))
+
+    import pyautogui
+
+    pyautogui.scroll(amount)
+    return f"scrolled {amount}"
+
+
+def pyautogui_screenshot(context: dict[str, Any]) -> str:
+    """Take a screenshot using pyautogui."""
+    output_path = context.get("output_path", "/tmp/textrun/screenshot.png")
+
+    import pyautogui
+
+    img = pyautogui.screenshot()
+    img.save(output_path)
+    return output_path

textrun/backends/__init__.py

@@ -0,0 +1 @@
+"""Backend orchestrators for textrun."""

textrun/backends/audio.py

@@ -0,0 +1,34 @@
+"""Audio playback backend orchestrator."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from textrun.runner import BackendResult, run_chain
+
+logger = logging.getLogger(__name__)
+
+
+def play(
+    config: dict[str, Any],
+    context: dict[str, Any],
+    skip: set[str] | None = None,
+) -> BackendResult:
+    """Play an audio file using the configured backend chain.
+
+    Args:
+        config: The 'audio' section from the profile config.
+        context: Runtime context with audio_path, etc.
+        skip: Optional set of backend names to skip (failed earlier in this run).
+
+    Returns:
+        BackendResult indicating success/failure.
+    """
+    chain = config.get("chain", [])
+    backends = config.get("backends", {})
+
+    if not chain:
+        return BackendResult(success=False, error="No audio backends configured")
+
+    return run_chain(chain, backends, context, skip)

textrun/backends/ocr.py

@@ -0,0 +1,34 @@
+"""OCR backend orchestrator."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from textrun.runner import BackendResult, run_chain
+
+logger = logging.getLogger(__name__)
+
+
+def extract_text(
+    config: dict[str, Any],
+    context: dict[str, Any],
+    skip: set[str] | None = None,
+) -> BackendResult:
+    """Extract text from an image using the configured backend chain.
+
+    Args:
+        config: The 'ocr' section from the profile config.
+        context: Runtime context with image_path, language, etc.
+        skip: Optional set of backend names to skip (failed earlier in this run).
+
+    Returns:
+        BackendResult with output containing extracted text.
+    """
+    chain = config.get("chain", [])
+    backends = config.get("backends", {})
+
+    if not chain:
+        return BackendResult(success=False, error="No OCR backends configured")
+
+    return run_chain(chain, backends, context, skip)

textrun/backends/screenshot.py

@@ -0,0 +1,44 @@
+"""Screenshot backend orchestrator."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from textrun.runner import BackendResult, run_chain
+
+logger = logging.getLogger(__name__)
+
+
+def capture(
+    config: dict[str, Any],
+    context: dict[str, Any],
+    skip: set[str] | None = None,
+) -> BackendResult:
+    """Capture a screenshot using the configured backend chain.
+
+    Args:
+        config: The 'screenshot' section from the profile config.
+        context: Runtime context with output_path, etc.
+        skip: Optional set of backend names to skip (failed earlier in this run).
+
+    Returns:
+        BackendResult with output containing the screenshot path.
+    """
+    chain = config.get("chain", [])
+    backends = config.get("backends", {})
+
+    if not chain:
+        return BackendResult(success=False, error="No screenshot backends configured")
+
+    output_path = context.get("output_path", "/tmp/textrun/screenshot.png")
+    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+
+    ctx = {**context, "output_path": output_path}
+    result = run_chain(chain, backends, ctx, skip)
+
+    if result.success and not result.output:
+        result.output = output_path
+
+    return result

textrun/backends/scroll.py

@@ -0,0 +1,34 @@
+"""Scroll backend orchestrator."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from textrun.runner import BackendResult, run_chain
+
+logger = logging.getLogger(__name__)
+
+
+def scroll(
+    config: dict[str, Any],
+    context: dict[str, Any],
+    skip: set[str] | None = None,
+) -> BackendResult:
+    """Scroll down using the configured backend chain.
+
+    Args:
+        config: The 'scroll' section from the profile config.
+        context: Runtime context with scroll_amount, etc.
+        skip: Optional set of backend names to skip (failed earlier in this run).
+
+    Returns:
+        BackendResult indicating success/failure.
+    """
+    chain = config.get("chain", [])
+    backends = config.get("backends", {})
+
+    if not chain:
+        return BackendResult(success=False, error="No scroll backends configured")
+
+    return run_chain(chain, backends, context, skip)

textrun/backends/tts.py

@@ -0,0 +1,48 @@
+"""TTS backend orchestrator."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from textrun.runner import BackendResult, run_chain
+
+logger = logging.getLogger(__name__)
+
+
+def synthesize(
+    config: dict[str, Any],
+    context: dict[str, Any],
+    skip: set[str] | None = None,
+) -> BackendResult:
+    """Convert text to speech using the configured backend chain.
+
+    Args:
+        config: The 'tts' section from the profile config.
+        context: Runtime context with text, output_path, etc.
+        skip: Optional set of backend names to skip (failed earlier in this run).
+
+    Returns:
+        BackendResult with output containing the audio file path.
+    """
+    chain = config.get("chain", [])
+    backends = config.get("backends", {})
+
+    if not chain:
+        return BackendResult(success=False, error="No TTS backends configured")
+
+    output_path = context.get("tts_output_path", "/tmp/textrun/tts_output.wav")
+    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+
+    ctx = {
+        **context,
+        "output_path": output_path,
+        "stdin_text": context.get("text", ""),
+    }
+    result = run_chain(chain, backends, ctx, skip)
+
+    if result.success and not result.output:
+        result.output = output_path
+
+    return result