scitex 2.10.3__py3-none-any.whl → 2.13.0__py3-none-any.whl

scitex/cli/capture.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""
+SciTeX CLI - Capture Commands (Screenshot/Monitoring)
+
+Provides screen capture, monitoring, and GIF creation.
+"""
+
+import sys
+
+import click
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+def capture():
+    """
+    Screen capture and monitoring utilities
+
+    \b
+    Commands:
+      snap          Take a single screenshot
+      start         Start continuous monitoring
+      stop          Stop monitoring
+      gif           Create GIF from session
+      info          Display info (monitors, windows)
+      window        Capture specific window by handle
+
+    \b
+    Examples:
+      scitex capture snap                      # Take screenshot
+      scitex capture snap --message "debug"   # With message in filename
+      scitex capture start --interval 2       # Monitor every 2 seconds
+      scitex capture stop                     # Stop monitoring
+      scitex capture gif                      # Create GIF from latest session
+      scitex capture info                     # List monitors and windows
+    """
+    pass
+
+
+@capture.command()
+@click.option("--message", "-m", default="", help="Message to include in filename")
+@click.option("--output", "-o", type=click.Path(), help="Output directory")
+@click.option(
+    "--quality", "-q", type=int, default=85, help="JPEG quality 1-100 (default: 85)"
+)
+@click.option(
+    "--monitor", type=int, default=0, help="Monitor number (0-based, default: 0)"
+)
+@click.option("--all-monitors", is_flag=True, help="Capture all monitors combined")
+def snap(message, output, quality, monitor, all_monitors):
+    """
+    Take a single screenshot
+
+    \b
+    Examples:
+      scitex capture snap
+      scitex capture snap --message "before-change"
+      scitex capture snap --all-monitors
+      scitex capture snap --monitor 1 --quality 95
+    """
+    try:
+        from scitex.capture import snap as take_snap
+
+        click.echo("Taking screenshot...")
+
+        # Build kwargs
+        kwargs = {"message": message}
+        if output:
+            kwargs["output_dir"] = output
+        if quality != 85:
+            kwargs["quality"] = quality
+        if all_monitors:
+            kwargs["capture_all"] = True
+        else:
+            kwargs["monitor_id"] = monitor
+
+        result = take_snap(**kwargs)
+
+        if result:
+            click.secho(f"Screenshot saved: {result}", fg="green")
+        else:
+            click.secho("Screenshot taken", fg="green")
+
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+
+@capture.command()
+@click.option(
+    "--interval",
+    "-i",
+    type=float,
+    default=1.0,
+    help="Seconds between captures (default: 1.0)",
+)
+@click.option("--output", "-o", type=click.Path(), help="Output directory")
+@click.option(
+    "--quality", "-q", type=int, default=60, help="JPEG quality 1-100 (default: 60)"
+)
+@click.option(
+    "--monitor", type=int, default=0, help="Monitor number (0-based, default: 0)"
+)
+@click.option("--all-monitors", is_flag=True, help="Capture all monitors combined")
+def start(interval, output, quality, monitor, all_monitors):
+    """
+    Start continuous screenshot monitoring
+
+    \b
+    Examples:
+      scitex capture start                    # Default 1 second interval
+      scitex capture start --interval 0.5    # Every 0.5 seconds
+      scitex capture start --all-monitors
+    """
+    try:
+        from scitex.capture import start as start_monitor
+
+        click.echo(f"Starting monitoring (interval: {interval}s)...")
+        click.echo("Press Ctrl+C or run 'scitex capture stop' to stop")
+
+        kwargs = {"interval": interval}
+        if output:
+            kwargs["output_dir"] = output
+        if quality != 60:
+            kwargs["quality"] = quality
+        if all_monitors:
+            kwargs["capture_all"] = True
+        else:
+            kwargs["monitor_id"] = monitor
+
+        start_monitor(**kwargs)
+        click.secho("Monitoring started", fg="green")
+
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+
+@capture.command()
+def stop():
+    """
+    Stop continuous monitoring
+
+    \b
+    Example:
+      scitex capture stop
+    """
+    try:
+        from scitex.capture import stop as stop_monitor
+
+        stop_monitor()
+        click.secho("Monitoring stopped", fg="green")
+
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+
+@capture.command()
+@click.option(
+    "--session",
+    "-s",
+    help="Session ID (e.g., '20250823_104523'). Use 'latest' for most recent.",
+)
+@click.option("--output", "-o", type=click.Path(), help="Output GIF path")
+@click.option(
+    "--duration",
+    "-d",
+    type=float,
+    default=0.5,
+    help="Duration per frame in seconds (default: 0.5)",
+)
+@click.option("--max-frames", type=int, help="Maximum number of frames to include")
+@click.option(
+    "--pattern", "-p", help="Glob pattern for images (alternative to session)"
+)
+def gif(session, output, duration, max_frames, pattern):
+    """
+    Create animated GIF from screenshots
+
+    \b
+    Examples:
+      scitex capture gif                         # From latest session
+      scitex capture gif --session 20250823_104523
+      scitex capture gif --duration 0.3 --max-frames 50
+      scitex capture gif --pattern "./screenshots/*.jpg"
+    """
+    try:
+        if pattern:
+            from scitex.capture import create_gif_from_pattern
+
+            click.echo(f"Creating GIF from pattern: {pattern}")
+            result = create_gif_from_pattern(
+                pattern=pattern,
+                output_path=output,
+                duration=duration,
+                max_frames=max_frames,
+            )
+        elif session:
+            from scitex.capture import create_gif_from_session
+
+            click.echo(f"Creating GIF from session: {session}")
+            result = create_gif_from_session(
+                session_id=session,
+                output_path=output,
+                duration=duration,
+                max_frames=max_frames,
+            )
+        else:
+            from scitex.capture import create_gif_from_latest_session
+
+            click.echo("Creating GIF from latest session...")
+            result = create_gif_from_latest_session(
+                output_path=output,
+                duration=duration,
+                max_frames=max_frames,
+            )
+
+        if result:
+            click.secho(f"GIF created: {result}", fg="green")
+        else:
+            click.secho("No screenshots found to create GIF", fg="yellow")
+
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+
+@capture.command()
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def info(as_json):
+    """
+    Display system info (monitors, windows, virtual desktops)
+
+    \b
+    Examples:
+      scitex capture info
+      scitex capture info --json
+    """
+    try:
+        from scitex.capture import get_info
+
+        info_data = get_info()
+
+        if as_json:
+            import json
+
+            click.echo(json.dumps(info_data, indent=2, default=str))
+        else:
+            click.secho("Display Information", fg="cyan", bold=True)
+            click.echo("=" * 50)
+
+            # Monitors
+            monitors = info_data.get("Monitors", {})
+            click.secho(f"\nMonitors ({monitors.get('Count', 0)}):", fg="yellow")
+            for i, mon in enumerate(monitors.get("Details", [])):
+                primary = " (Primary)" if mon.get("Primary") else ""
+                click.echo(f"  [{i}] {mon.get('Width')}x{mon.get('Height')}{primary}")
+
+            # Windows
+            windows = info_data.get("Windows", {})
+            click.secho(f"\nWindows ({windows.get('Count', 0)}):", fg="yellow")
+            for win in windows.get("Details", [])[:10]:  # Show first 10
+                title = win.get("Title", "")[:40]
+                handle = win.get("Handle", "")
+                click.echo(f"  [{handle}] {title}")
+            if windows.get("Count", 0) > 10:
+                click.echo(f"  ... and {windows.get('Count') - 10} more")
+
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+
+@capture.command()
+@click.argument("handle", type=int)
+@click.option("--output", "-o", type=click.Path(), help="Output file path")
+@click.option("--quality", "-q", type=int, default=85, help="JPEG quality 1-100")
+def window(handle, output, quality):
+    """
+    Capture a specific window by its handle
+
+    \b
+    Get window handles with: scitex capture info
+
+    \b
+    Examples:
+      scitex capture window 12345
+      scitex capture window 12345 --output ./window.jpg
+    """
+    try:
+        from scitex.capture import capture_window
+
+        click.echo(f"Capturing window {handle}...")
+        result = capture_window(handle, output)
+
+        if result:
+            click.secho(f"Window captured: {result}", fg="green")
+        else:
+            click.secho("Window captured", fg="green")
+
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    capture()

scitex/cli/convert.py

@@ -227,17 +227,19 @@ def validate_bundles(paths: tuple, verbose: bool):
       scitex convert validate output.stx
       scitex convert validate ./figures/*.stx --verbose
     """
-    # Use FTS instead of deprecated io.bundle
+    # Use Bundle for validation
     try:
-        from scitex.fts import FTS as ZipBundle
+        from scitex.io.bundle import Bundle as ZipBundle
+
         def validate_stx_bundle(path):
             try:
                 bundle = ZipBundle(path)
                 return bundle.validate(level="strict")
             except Exception as e:
                 return {"valid": False, "errors": [str(e)]}
+
     except ImportError:
-        click.echo("Error: scitex.fts not available", err=True)
+        click.echo("Error: scitex.io.bundle not available", err=True)
         return
 
     valid = 0
@@ -303,9 +305,9 @@ def bundle_info(path: str):
       scitex convert info figure.stx
     """
     try:
-        from scitex.fts import FTS as ZipBundle
+        from scitex.io.bundle import Bundle as ZipBundle
     except ImportError:
-        click.echo("Error: scitex.fts not available", err=True)
+        click.echo("Error: scitex.io.bundle not available", err=True)
         return
 
     bundle_path = Path(path)
@@ -368,12 +370,14 @@ def _convert_bundle(input_path: Path, output_path: Path) -> None:
     """
     import json
     import tempfile
-    import zipfile
 
     # Generate bundle ID and normalize spec - inline functions since io.bundle is deprecated
     import uuid
+    import zipfile
+
     def generate_bundle_id():
         return str(uuid.uuid4())[:8]
+
     def normalize_spec(spec):
         return spec  # FTS handles normalization internally
 

scitex/cli/main.py

@@ -8,7 +8,22 @@ import sys
 
 import click
 
-from . import cloud, config, convert, scholar, security, web, writer
+from . import (
+    audio,
+    capture,
+    cloud,
+    config,
+    convert,
+    repro,
+    resource,
+    scholar,
+    security,
+    stats,
+    template,
+    tex,
+    web,
+    writer,
+)
 
 
 @click.group(context_settings={"help_option_names": ["-h", "--help"]})
@@ -28,6 +43,10 @@ def cli():
       scitex security check --save
       scitex web get-urls https://example.com
       scitex web download-images https://example.com --output ./downloads
+      scitex audio speak "Hello world"
+      scitex capture snap --output screenshot.jpg
+      scitex resource usage
+      scitex stats recommend --data data.csv
 
     \b
     Enable tab-completion:
@@ -38,11 +57,18 @@ def cli():
 
 
 # Add command groups
+cli.add_command(audio.audio)
+cli.add_command(capture.capture)
 cli.add_command(cloud.cloud)
 cli.add_command(config.config)
 cli.add_command(convert.convert)
+cli.add_command(repro.repro)
+cli.add_command(resource.resource)
 cli.add_command(scholar.scholar)
 cli.add_command(security.security)
+cli.add_command(stats.stats)
+cli.add_command(template.template)
+cli.add_command(tex.tex)
 cli.add_command(web.web)
 cli.add_command(writer.writer)
 
@@ -111,15 +137,12 @@ def completion(shell, show):
 
     # Generate completion script
     if shell == "bash":
-        completion_script = f"_SCITEX_COMPLETE=bash_source {scitex_full}"
         rc_file = os.path.expanduser("~/.bashrc")
         eval_line = f'eval "$(_SCITEX_COMPLETE=bash_source {scitex_full})"'
     elif shell == "zsh":
-        completion_script = f"_SCITEX_COMPLETE=zsh_source {scitex_full}"
         rc_file = os.path.expanduser("~/.zshrc")
         eval_line = f'eval "$(_SCITEX_COMPLETE=zsh_source {scitex_full})"'
     elif shell == "fish":
-        completion_script = f"_SCITEX_COMPLETE=fish_source {scitex_full}"
         rc_file = os.path.expanduser("~/.config/fish/config.fish")
         eval_line = f"eval (env _SCITEX_COMPLETE=fish_source {scitex_full})"
 

scitex/cli/repro.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+SciTeX CLI - Repro Commands (Reproducibility)
+
+Provides reproducibility utilities: ID generation, timestamps, hashing.
+"""
+
+import sys
+
+import click
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+def repro():
+    """
+    Reproducibility utilities
+
+    \b
+    Commands:
+      gen-id         Generate unique identifier
+      gen-timestamp  Generate timestamp
+      hash           Hash array/file for reproducibility
+      seed           Set random seed across all libraries
+
+    \b
+    Examples:
+      scitex repro gen-id              # Generate unique ID
+      scitex repro gen-timestamp       # Generate timestamp
+      scitex repro hash data.npy       # Hash array file
+      scitex repro seed 42             # Set random seed
+    """
+    pass
+
+
+@repro.command("gen-id")
+@click.option("--length", "-l", type=int, default=8, help="ID length (default: 8)")
+@click.option("--prefix", "-p", default="", help="Prefix to add to ID")
+@click.option("--count", "-n", type=int, default=1, help="Number of IDs to generate")
+def gen_id(length, prefix, count):
+    """
+    Generate unique identifier(s)
+
+    \b
+    Examples:
+      scitex repro gen-id
+      scitex repro gen-id --length 12
+      scitex repro gen-id --prefix exp_
+      scitex repro gen-id --count 5
+    """
+    try:
+        from scitex.repro import gen_ID
+
+        for _ in range(count):
+            id_str = gen_ID()
+            if length != 8:
+                id_str = id_str[:length]
+            if prefix:
+                id_str = f"{prefix}{id_str}"
+            click.echo(id_str)
+
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+
+@repro.command("gen-timestamp")
+@click.option(
+    "--format",
+    "-f",
+    "fmt",
+    type=click.Choice(["iso", "file", "compact", "human"]),
+    default="iso",
+    help="Timestamp format (default: iso)",
+)
+@click.option("--utc", is_flag=True, help="Use UTC timezone")
+def gen_timestamp(fmt, utc):
+    """
+    Generate timestamp
+
+    \b
+    Formats:
+      iso     - ISO 8601 format (2025-01-08T12:30:45)
+      file    - File-safe format (20250108_123045)
+      compact - Compact format (20250108123045)
+      human   - Human readable (Jan 08, 2025 12:30:45)
+
+    \b
+    Examples:
+      scitex repro gen-timestamp
+      scitex repro gen-timestamp --format file
+      scitex repro gen-timestamp --format human --utc
+    """
+    try:
+        from datetime import datetime, timezone
+
+        from scitex.repro import gen_timestamp as make_timestamp
+
+        if utc:
+            now = datetime.now(timezone.utc)
+        else:
+            now = datetime.now()
+
+        if fmt == "iso":
+            ts = now.isoformat()
+        elif fmt == "file":
+            ts = now.strftime("%Y%m%d_%H%M%S")
+        elif fmt == "compact":
+            ts = now.strftime("%Y%m%d%H%M%S")
+        elif fmt == "human":
+            ts = now.strftime("%b %d, %Y %H:%M:%S")
+        else:
+            ts = make_timestamp()
+
+        click.echo(ts)
+
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+
+@repro.command()
+@click.argument("file_path", type=click.Path(exists=True))
+@click.option(
+    "--algorithm", "-a", default="sha256", help="Hash algorithm (default: sha256)"
+)
+@click.option("--short", "-s", is_flag=True, help="Output short hash (first 8 chars)")
+def hash(file_path, algorithm, short):
+    """
+    Hash array or file for reproducibility verification
+
+    \b
+    Supported file types:
+      .npy, .npz  - NumPy arrays
+      .pt, .pth   - PyTorch tensors
+      .pkl        - Pickle files
+      *           - Any file (raw bytes hash)
+
+    \b
+    Examples:
+      scitex repro hash data.npy
+      scitex repro hash model.pt --short
+      scitex repro hash weights.npz --algorithm md5
+    """
+    try:
+        import hashlib
+        from pathlib import Path
+
+        path = Path(file_path)
+
+        # Try to load as array first
+        hash_val = None
+        try:
+            if path.suffix in (".npy", ".npz"):
+                import numpy as np
+
+                from scitex.repro import hash_array
+
+                arr = np.load(path, allow_pickle=True)
+                if isinstance(arr, np.lib.npyio.NpzFile):
+                    # For npz, hash all arrays
+                    hashes = []
+                    for key in arr.files:
+                        hashes.append(hash_array(arr[key]))
+                    hash_val = hashlib.sha256("".join(hashes).encode()).hexdigest()
+                else:
+                    hash_val = hash_array(arr)
+            elif path.suffix in (".pt", ".pth"):
+                import torch
+
+                data = torch.load(path, map_location="cpu")
+                if isinstance(data, torch.Tensor):
+                    hash_val = hashlib.sha256(data.numpy().tobytes()).hexdigest()
+                else:
+                    # State dict or other
+                    hash_val = hashlib.sha256(str(data).encode()).hexdigest()
+        except ImportError:
+            pass
+
+        # Fall back to file hash
+        if hash_val is None:
+            h = hashlib.new(algorithm)
+            with open(path, "rb") as f:
+                for chunk in iter(lambda: f.read(8192), b""):
+                    h.update(chunk)
+            hash_val = h.hexdigest()
+
+        if short:
+            hash_val = hash_val[:8]
+
+        click.echo(f"{hash_val}  {path.name}")
+
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+
+@repro.command()
+@click.argument("seed", type=int)
+@click.option("--verbose", "-v", is_flag=True, help="Show what was seeded")
+def seed(seed, verbose):
+    """
+    Set random seed across all available libraries
+
+    \b
+    Affects: os, random, numpy, torch, tensorflow, jax
+
+    \b
+    Examples:
+      scitex repro seed 42
+      scitex repro seed 12345 --verbose
+    """
+    try:
+        from scitex.repro import RandomStateManager
+
+        rsm = RandomStateManager(seed=seed, verbose=verbose)
+
+        click.secho(f"Random seed set to: {seed}", fg="green")
+        if verbose:
+            click.echo("Seeded libraries:")
+            click.echo("  - os.environ['PYTHONHASHSEED']")
+            click.echo("  - random")
+            click.echo("  - numpy (if available)")
+            click.echo("  - torch (if available)")
+            click.echo("  - tensorflow (if available)")
+            click.echo("  - jax (if available)")
+
+    except Exception as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    repro()