scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/capture/cli.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-18 09:55:58 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/capture/cli.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/capture/cli.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+CLI for scitex.capture - AI's Camera
+"""
+
+import argparse
+import sys
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="scitex.capture - AI's Camera: Capture screenshots from anywhere",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python -m scitex.capture                        # Capture current screen
+  python -m scitex.capture --all                  # Capture all monitors
+  python -m scitex.capture --app chrome           # Capture Chrome window
+  python -m scitex.capture --url 127.0.0.1:8000   # Capture URL
+  python -m scitex.capture --monitor 1            # Capture monitor 1
+  python -m scitex.capture --list                 # List available windows
+
+  python -m scitex.capture --start                # Start monitoring
+  python -m scitex.capture --stop                 # Stop monitoring
+  python -m scitex.capture --gif                  # Create GIF from session
+  python -m scitex.capture --mcp                  # Start MCP server
+        """,
+    )
+
+    # Capture options
+    parser.add_argument(
+        "message", nargs="?", help="Optional message for filename"
+    )
+    parser.add_argument(
+        "--all", action="store_true", help="Capture all monitors"
+    )
+    parser.add_argument(
+        "--app", type=str, help="App name to capture (e.g., chrome)"
+    )
+    parser.add_argument(
+        "--url", type=str, help="URL to capture (e.g., 127.0.0.1:8000)"
+    )
+    parser.add_argument(
+        "--monitor", type=int, default=0, help="Monitor ID (0-based)"
+    )
+    parser.add_argument(
+        "--quality", type=int, default=85, help="JPEG quality (1-100)"
+    )
+    parser.add_argument("-o", "--output", type=str, help="Output path")
+
+    # Actions
+    parser.add_argument(
+        "--list", action="store_true", help="List available windows"
+    )
+    parser.add_argument(
+        "--info", action="store_true", help="Show display info"
+    )
+    parser.add_argument(
+        "--start", action="store_true", help="Start monitoring"
+    )
+    parser.add_argument("--stop", action="store_true", help="Stop monitoring")
+    parser.add_argument(
+        "--gif", action="store_true", help="Create GIF from latest session"
+    )
+    parser.add_argument("--mcp", action="store_true", help="Start MCP server")
+
+    # Options
+    parser.add_argument(
+        "--interval",
+        type=float,
+        default=1.0,
+        help="Monitoring interval in seconds",
+    )
+    parser.add_argument(
+        "-q", "--quiet", action="store_true", help="Quiet mode"
+    )
+
+    args = parser.parse_args()
+
+    # Import scitex.capture after parsing to avoid import overhead for --help
+    from scitex import capture
+
+    verbose = not args.quiet
+
+    try:
+        # Handle actions
+        if args.list:
+            info = capture.get_info()
+            windows = info.get("Windows", {}).get("Details", [])
+            print(f"\n📱 Visible Windows ({len(windows)}):")
+            print("=" * 60)
+            for i, win in enumerate(windows, 1):
+                print(f"{i}. [{win['ProcessName']}] {win['Title']}")
+                print(f"   Handle: {win['Handle']} | PID: {win['ProcessId']}")
+            return 0
+
+        elif args.info:
+            info = capture.get_info()
+            monitors = info.get("Monitors", {})
+            windows = info.get("Windows", {})
+            vd = info.get("VirtualDesktops", {})
+
+            print("\n🖥️  Display Information")
+            print("=" * 60)
+            print(f"\n📺 Monitors: {monitors.get('Count')}")
+            print(f"   Primary: {monitors.get('PrimaryMonitor')}")
+
+            for i, mon in enumerate(monitors.get("Details", [])):
+                bounds = mon.get("Bounds", {})
+                print(f"\n   Monitor {i}:")
+                print(f"     Device: {mon.get('DeviceName')}")
+                print(
+                    f"     Resolution: {bounds.get('Width')}x{bounds.get('Height')}"
+                )
+                print(f"     Primary: {mon.get('IsPrimary')}")
+
+            print(f"\n🪟 Windows: {windows.get('VisibleCount')}")
+            print(
+                f"   On current virtual desktop: {len(windows.get('Details', []))}"
+            )
+
+            print(f"\n🖥️  Virtual Desktops:")
+            print(f"   Supported: {vd.get('Supported')}")
+            print(f"   Note: {vd.get('Note')}")
+
+            return 0
+
+        elif args.start:
+            print(f"📸 Starting monitoring (interval: {args.interval}s)...")
+            capture.start(
+                interval=args.interval,
+                verbose=verbose,
+                monitor_id=args.monitor,
+                all=args.all,
+            )
+            print(
+                "✅ Monitoring started. Press Ctrl+C to stop, or run: python -m scitex.capture --stop"
+            )
+            print(f"📁 Saving to: ~/.scitex/capture/")
+
+            # Keep running
+            try:
+                import time
+
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                capture.stop()
+                print("\n✅ Monitoring stopped")
+
+            return 0
+
+        elif args.stop:
+            capture.stop()
+            print("✅ Monitoring stopped")
+            return 0
+
+        elif args.gif:
+            print("📹 Creating GIF from latest session...")
+            path = capture.gif()
+            if path:
+                print(f"✅ GIF created: {path}")
+                return 0
+            else:
+                print("❌ No session found")
+                return 1
+
+        elif args.mcp:
+            print("🤖 Starting scitex.capture MCP server...")
+            print("Add to Claude Code settings:")
+            print("{")
+            print('  "mcpServers": {')
+            print('    "scitex-capture": {')
+            print('      "command": "python",')
+            print('      "args": ["-m", "scitex.capture", "--mcp"]')
+            print("    }")
+            print("  }")
+            print("}")
+            print()
+
+            # Start MCP server
+            import asyncio
+            from .mcp_server import main as mcp_main
+
+            asyncio.run(mcp_main())
+            return 0
+
+        # Default: capture screenshot
+        else:
+            path = capture.snap(
+                message=args.message,
+                path=args.output,
+                quality=args.quality,
+                monitor_id=args.monitor,
+                all=args.all,
+                app=args.app,
+                url=args.url,
+                verbose=verbose,
+            )
+
+            if path:
+                if not args.quiet:
+                    print(f"✅ {path}")
+                return 0
+            else:
+                print("❌ Screenshot failed")
+                return 1
+
+    except KeyboardInterrupt:
+        print("\n⚠️  Interrupted")
+        return 130
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+# EOF

scitex/capture/gif.py

@@ -0,0 +1,344 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-18 09:55:56 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/capture/gif.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/capture/gif.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+GIF creation functionality for CAM.
+Create animated GIFs from screenshot sequences for visual summaries.
+"""
+
+import glob
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+
+class GifCreator:
+    """
+    Creates animated GIFs from screenshot sequences.
+    Useful for creating visual summaries of monitoring sessions or workflows.
+    """
+
+    def __init__(self):
+        """Initialize GIF creator."""
+        pass
+
+    def create_gif_from_session(
+        self,
+        session_id: str,
+        output_path: Optional[str] = None,
+        screenshot_dir: str = "~/.scitex/capture",
+        duration: float = 0.5,
+        optimize: bool = True,
+        max_frames: Optional[int] = None,
+    ) -> Optional[str]:
+        """
+        Create a GIF from a monitoring session's screenshots.
+
+        Args:
+            session_id: Session ID from monitoring (e.g., "20250823_104523")
+            output_path: Output GIF path (auto-generated if None)
+            screenshot_dir: Directory containing screenshots
+            duration: Duration per frame in seconds (default: 0.5)
+            optimize: Optimize GIF for smaller file size (default: True)
+            max_frames: Maximum number of frames to include (None = all)
+
+        Returns:
+            Path to created GIF file, or None if failed
+        """
+        try:
+            screenshot_dir = Path(screenshot_dir).expanduser()
+
+            # Find all screenshots for this session
+            pattern = f"{session_id}_*.jpg"
+            jpg_files = list(screenshot_dir.glob(pattern))
+
+            # Also try PNG if no JPG files found
+            if not jpg_files:
+                pattern = f"{session_id}_*.png"
+                jpg_files = list(screenshot_dir.glob(pattern))
+
+            if not jpg_files:
+                print(f"No screenshots found for session {session_id}")
+                return None
+
+            # Sort by filename (which includes timestamp)
+            jpg_files.sort()
+
+            # Limit frames if specified
+            if max_frames and len(jpg_files) > max_frames:
+                # Take evenly spaced frames
+                step = len(jpg_files) // max_frames
+                jpg_files = jpg_files[::step][:max_frames]
+
+            if output_path is None:
+                output_path = screenshot_dir / f"{session_id}_summary.gif"
+            else:
+                output_path = Path(output_path)
+
+            return self.create_gif_from_files(
+                image_paths=[str(f) for f in jpg_files],
+                output_path=str(output_path),
+                duration=duration,
+                optimize=optimize,
+            )
+
+        except Exception as e:
+            print(f"Error creating GIF from session: {e}")
+            return None
+
+    def create_gif_from_files(
+        self,
+        image_paths: List[str],
+        output_path: str,
+        duration: float = 0.5,
+        optimize: bool = True,
+        loop: int = 0,
+    ) -> Optional[str]:
+        """
+        Create a GIF from a list of image files.
+
+        Args:
+            image_paths: List of image file paths
+            output_path: Output GIF path
+            duration: Duration per frame in seconds (default: 0.5)
+            optimize: Optimize GIF for smaller file size (default: True)
+            loop: Number of loops (0 = infinite, default: 0)
+
+        Returns:
+            Path to created GIF file, or None if failed
+        """
+        try:
+            from PIL import Image
+
+            if not image_paths:
+                print("No image paths provided")
+                return None
+
+            # Load all images
+            images = []
+            for path in image_paths:
+                if not os.path.exists(path):
+                    print(f"Image not found: {path}")
+                    continue
+
+                try:
+                    img = Image.open(path)
+                    # Convert to RGB if necessary (for consistency)
+                    if img.mode != "RGB":
+                        img = img.convert("RGB")
+                    images.append(img)
+                except Exception as e:
+                    print(f"Error loading image {path}: {e}")
+                    continue
+
+            if not images:
+                print("No valid images found")
+                return None
+
+            # Ensure all images have the same size (resize to first image size)
+            target_size = images[0].size
+            for i in range(1, len(images)):
+                if images[i].size != target_size:
+                    images[i] = images[i].resize(
+                        target_size, Image.Resampling.LANCZOS
+                    )
+
+            # Create output directory if it doesn't exist
+            output_path = Path(output_path)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Save as GIF
+            duration_ms = int(duration * 1000)  # Convert to milliseconds
+
+            images[0].save(
+                str(output_path),
+                format="GIF",
+                save_all=True,
+                append_images=images[1:],
+                duration=duration_ms,
+                loop=loop,
+                optimize=optimize,
+            )
+
+            if output_path.exists():
+                file_size = output_path.stat().st_size / 1024  # KB
+                print(
+                    f"📹 GIF created: {output_path} ({len(images)} frames, {file_size:.1f}KB)"
+                )
+                return str(output_path)
+            else:
+                return None
+
+        except ImportError:
+            print(
+                "PIL (Pillow) is required for GIF creation. Install with: pip install Pillow"
+            )
+            return None
+        except Exception as e:
+            print(f"Error creating GIF: {e}")
+            return None
+
+    def create_gif_from_pattern(
+        self,
+        pattern: str,
+        output_path: Optional[str] = None,
+        duration: float = 0.5,
+        optimize: bool = True,
+        max_frames: Optional[int] = None,
+    ) -> Optional[str]:
+        """
+        Create a GIF from files matching a glob pattern.
+
+        Args:
+            pattern: Glob pattern for image files (e.g., "/path/screenshots/*.jpg")
+            output_path: Output GIF path (auto-generated if None)
+            duration: Duration per frame in seconds (default: 0.5)
+            optimize: Optimize GIF for smaller file size (default: True)
+            max_frames: Maximum number of frames to include (None = all)
+
+        Returns:
+            Path to created GIF file, or None if failed
+        """
+        try:
+            # Find matching files
+            files = glob.glob(pattern)
+            files.sort()  # Sort alphabetically
+
+            if not files:
+                print(f"No files found matching pattern: {pattern}")
+                return None
+
+            # Limit frames if specified
+            if max_frames and len(files) > max_frames:
+                step = len(files) // max_frames
+                files = files[::step][:max_frames]
+
+            if output_path is None:
+                # Generate output path based on pattern
+                pattern_dir = Path(pattern).parent
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                output_path = pattern_dir / f"gif_summary_{timestamp}.gif"
+
+            return self.create_gif_from_files(
+                image_paths=files,
+                output_path=str(output_path),
+                duration=duration,
+                optimize=optimize,
+            )
+
+        except Exception as e:
+            print(f"Error creating GIF from pattern: {e}")
+            return None
+
+    def get_recent_sessions(
+        self, screenshot_dir: str = "~/.scitex/capture"
+    ) -> List[str]:
+        """
+        Get list of recent monitoring session IDs.
+
+        Args:
+            screenshot_dir: Directory containing screenshots
+
+        Returns:
+            List of session IDs sorted by recency (newest first)
+        """
+        try:
+            screenshot_dir = Path(screenshot_dir).expanduser()
+
+            if not screenshot_dir.exists():
+                return []
+
+            # Find all monitoring session files (format: SESSIONID_NNNN_timestamp.ext)
+            session_pattern = re.compile(
+                r"^(\d{8}_\d{6})_\d{4}_.*\.(jpg|png)$"
+            )
+
+            sessions = set()
+            for file in screenshot_dir.iterdir():
+                if file.is_file():
+                    match = session_pattern.match(file.name)
+                    if match:
+                        sessions.add(match.group(1))
+
+            # Sort by session ID (which includes timestamp)
+            return sorted(sessions, reverse=True)
+
+        except Exception as e:
+            print(f"Error getting recent sessions: {e}")
+            return []
+
+    def create_gif_from_recent_session(
+        self,
+        screenshot_dir: str = "~/.scitex/capture",
+        duration: float = 0.5,
+        optimize: bool = True,
+        max_frames: Optional[int] = None,
+    ) -> Optional[str]:
+        """
+        Create a GIF from the most recent monitoring session.
+
+        Args:
+            screenshot_dir: Directory containing screenshots
+            duration: Duration per frame in seconds (default: 0.5)
+            optimize: Optimize GIF for smaller file size (default: True)
+            max_frames: Maximum number of frames to include (None = all)
+
+        Returns:
+            Path to created GIF file, or None if failed
+        """
+        sessions = self.get_recent_sessions(screenshot_dir)
+
+        if not sessions:
+            print("No monitoring sessions found")
+            return None
+
+        latest_session = sessions[0]
+        print(f"Creating GIF from latest session: {latest_session}")
+
+        return self.create_gif_from_session(
+            session_id=latest_session,
+            screenshot_dir=screenshot_dir,
+            duration=duration,
+            optimize=optimize,
+            max_frames=max_frames,
+        )
+
+
+# Convenience functions for easy usage
+def create_gif_from_session(session_id: str, **kwargs) -> Optional[str]:
+    """Create GIF from monitoring session screenshots."""
+    creator = GifCreator()
+    return creator.create_gif_from_session(session_id, **kwargs)
+
+
+def create_gif_from_files(
+    image_paths: List[str], output_path: str, **kwargs
+) -> Optional[str]:
+    """Create GIF from list of image files."""
+    creator = GifCreator()
+    return creator.create_gif_from_files(image_paths, output_path, **kwargs)
+
+
+def create_gif_from_pattern(pattern: str, **kwargs) -> Optional[str]:
+    """Create GIF from files matching glob pattern."""
+    creator = GifCreator()
+    return creator.create_gif_from_pattern(pattern, **kwargs)
+
+
+def create_gif_from_latest_session(**kwargs) -> Optional[str]:
+    """Create GIF from the most recent monitoring session."""
+    creator = GifCreator()
+    return creator.create_gif_from_recent_session(**kwargs)
+
+# EOF