reactor-runtime 0.0.0__py3-none-any.whl

reactor_cli/commands/__init__.py

@@ -0,0 +1,14 @@
+"""Reactor CLI Commands
+
+This module contains all command implementations for the reactor CLI.
+Each command is implemented as a class following the HuggingFace pattern.
+"""
+
+from .run import RunCommand
+from .init import InitCommand
+from .download import DownloadCommand
+from .upload import UploadCommand
+from .setup import SetupCommand
+from .capabilities import CapabilitiesCommand
+
+__all__ = ['RunCommand', 'InitCommand', 'DownloadCommand', 'UploadCommand', 'SetupCommand', 'CapabilitiesCommand']

reactor_cli/commands/capabilities.py

@@ -0,0 +1,118 @@
+"""Run command implementation."""
+
+import importlib
+import json
+from reactor_runtime.model_api import VideoModel, command
+import ast
+from pathlib import Path
+
+def load_class_without_init(file_path: str, class_name: str):
+	"""
+	Load only the subclass definition from a Python file (without executing imports or __init__),
+	recreate it with CommandBase as its parent, and call its inherited commands() method.
+	All imports from the source file are detected via AST and replicated in the namespace.
+	"""
+	source = Path(file_path).read_text(encoding="utf-8")
+	tree = ast.parse(source, filename=file_path)
+
+	def extract_imports(tree):
+		"""Return a dict of {imported_name: module_object or attribute} from the AST."""
+		imports = {}
+
+		for node in tree.body:
+			if isinstance(node, ast.Import):
+				for alias in node.names:
+					mod_name = alias.name
+					as_name = alias.asname or mod_name.split(".")[0]
+					try:
+						imports[as_name] = importlib.import_module(mod_name)
+					except ImportError:
+						pass  # Skip missing modules safely
+
+			elif isinstance(node, ast.ImportFrom):
+				if node.module is None:
+					continue
+				try:
+					mod = importlib.import_module(node.module)
+				except ImportError:
+					continue
+				for alias in node.names:
+					as_name = alias.asname or alias.name
+					if alias.name == "*":
+						# Handle "from X import *" by copying all public symbols
+						for name in dir(mod):
+							if not name.startswith("_"):
+								imports[name] = getattr(mod, name)
+					else:
+						try:
+							imports[as_name] = getattr(mod, alias.name)
+						except AttributeError:
+							pass
+
+		return imports
+
+	# Detect and import all modules referenced in the source
+	imported_symbols = extract_imports(tree)
+
+	for node in tree.body:
+		if isinstance(node, ast.ClassDef) and node.name == class_name:
+			# Replace base classes with CommandBase
+			node.bases = [ast.Name(id='CommandBase', ctx=ast.Load())]
+			ast.fix_missing_locations(node)
+
+			# Compile a module containing only that class
+			class_module = ast.Module(body=[node], type_ignores=[])
+			ast.fix_missing_locations(class_module)
+			code = compile(class_module, filename=file_path, mode="exec")
+
+			# Build isolated namespace
+			ns = {
+				"CommandBase": VideoModel,
+				"command": command,
+				**imported_symbols
+			}
+
+			exec(code, ns)
+			subcls = ns[class_name]
+			obj = subcls.__new__(subcls)
+			return obj
+
+	raise ValueError(f"Class '{class_name}' not found in {file_path}")
+
+
+class CapabilitiesCommand:
+    @staticmethod
+    def register_subcommand(subparsers):
+        """Register capabilities command"""
+        run_parser = subparsers.add_parser("capabilities", help="Print the capabilities of a reactor VideoModel.")
+        run_parser.set_defaults(func=CapabilitiesCommand)
+
+    def __init__(self, args):
+        """Initialize with parsed arguments"""
+        self.args = args
+
+    def run(self):
+        """Print the capabilities of a reactor VideoModel."""
+        from ..main import verify_reactor_workspace
+
+        # Verify workspace and get manifest data
+        manifest_data = verify_reactor_workspace()
+        if manifest_data is None:
+            return
+
+        # Extract model information from manifest
+        model_class_name: str = manifest_data["class"]
+        model_file, model_class = model_class_name.split(":")
+        model_class: VideoModel = load_class_without_init(model_file+".py", model_class)
+
+        if "model_name" not in manifest_data.keys():
+            print("Error: manifest.json is missing required 'model_name' field.")
+            print("Please add a 'model_name' field specifying the model name.")
+            return
+        if "model_version" not in manifest_data.keys():
+            print("Error: manifest.json is missing required 'model_version' field.")
+            print("Please add a 'model_version' field specifying the model version.")
+            return
+
+
+        print(json.dumps(model_class.commands(), indent=4))

reactor_cli/commands/download.py

@@ -0,0 +1,217 @@
+"""Download command implementation."""
+
+import os
+import json
+import logging
+from typing import List, Optional
+from pathlib import Path
+from supabase import create_client
+from ..utils import get_weights_parallel, get_latest_version
+from ..main import verify_reactor_workspace
+
+# Set up logger
+logger = logging.getLogger(__name__)
+
+
+def parse_manifest(manifest_str: str) -> dict:
+    """Parse a manifest string into a dictionary.
+    
+    Args:
+        manifest_str: JSON string containing the manifest
+        
+    Returns:
+        Parsed manifest dictionary
+    """
+    try:
+        return json.loads(manifest_str)
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to parse manifest JSON: {e}")
+        raise ValueError(f"Invalid manifest JSON: {e}")
+
+
+def get_weights_from_manifest(manifest: dict) -> List[str]:
+    """Extract the weights list from a manifest dictionary.
+    
+    Args:
+        manifest: Dictionary containing manifest data
+        
+    Returns:
+        List of weight folder names
+    """
+    if "weights" not in manifest:
+        logger.warning("Manifest does not contain a 'weights' field")
+        return []
+    
+    weights = manifest["weights"]
+    if not isinstance(weights, list):
+        logger.error(f"'weights' field must be a list, got {type(weights)}")
+        raise ValueError("'weights' field in manifest must be a list")
+    
+    return weights
+
+
+def get_weights_from_local_manifest() -> List[str]:
+    """Read weights from local manifest.json file.
+    
+    Returns:
+        List of weight folder names from local manifest
+    """
+    manifest = verify_reactor_workspace()
+    if not manifest:
+        raise RuntimeError("Failed to verify reactor workspace or read manifest.json")
+    
+    return get_weights_from_manifest(manifest)
+
+
+def get_weights_from_model_id(model_id: str) -> List[str]:
+    """Fetch model manifest from Supabase and extract weights.
+    
+    Args:
+        model_id: Model identifier with optional version (e.g., "matrix-2" or "matrix-2@v1.0")
+                  If no version is specified, defaults to "latest"
+        
+    Returns:
+        List of weight folder names from the model's manifest
+    """
+    # Parse model_id and version from format: model@version or just model
+    if '@' in model_id:
+        model_name, version = model_id.split('@', 1)
+    else:
+        model_name = model_id
+        version = "latest"
+    
+    supabase = create_client(
+        os.getenv('SUPABASE_URL'),
+        os.getenv('SUPABASE_SERVICE_KEY')
+    )
+    
+    # If version is "latest", we need to find the actual latest version
+    if version == "latest":
+        logger.info(f"Resolving latest version for model '{model_name}'...")
+        
+        # Get the latest version using our utility function
+        try:
+            version = get_latest_version(model_name)
+            logger.info(f"Resolved latest version for '{model_name}': {version}")
+        except (ValueError, RuntimeError) as e:
+            raise ValueError(f"Failed to determine latest version for model '{model_name}': {e}")
+    
+    logger.info(f"Fetching manifest for model '{model_name}' version '{version}'...")
+    
+    result = supabase.table('models').select('manifest').eq(
+        'model_id', model_name
+    ).eq('version', version).execute()
+    
+    if not result.data:
+        raise ValueError(f"Model '{model_name}' version '{version}' not found in database")
+    
+    manifest = result.data[0]['manifest']
+
+    if not manifest:
+        raise ValueError(f"Model '{model_name}' version '{version}' doesn't have a manifest in database.")
+    
+    return get_weights_from_manifest(manifest)
+
+
+def get_weights_from_model_ids(model_ids: List[str]) -> List[str]:
+    """Fetch manifests for multiple models and extract unique weights.
+    
+    Args:
+        model_ids: List of model identifiers with optional versions 
+                   (e.g., ["matrix-2", "longlive@v1.0", "mk64"])
+        
+    Returns:
+        Deduplicated list of weight folder names from all models
+    """
+    all_weights = set()
+    
+    for model_id in model_ids:
+        try:
+            weights = get_weights_from_model_id(model_id)
+            all_weights.update(weights)
+            logger.info(f"Model '{model_id}' requires weights: {weights}")
+        except Exception as e:
+            logger.error(f"Failed to fetch weights for model '{model_id}': {e}")
+            raise
+    
+    unique_weights = list(all_weights)
+    logger.info(f"Total unique weights across all models: {unique_weights}")
+    return unique_weights
+
+
+class DownloadCommand:
+    @staticmethod
+    def register_subcommand(subparsers):
+        """Register download command"""
+        download_parser = subparsers.add_parser(
+            "download",
+            help="Download model weights"
+        )
+        download_parser.add_argument(
+            "--weights",
+            nargs='+',
+            help="List of weight folder names to download"
+        )
+        download_parser.add_argument(
+            "--models",
+            nargs='+',
+            help="List of model identifiers to fetch weights from (e.g., matrix-2 longlive@v1.0). Use model@version format to specify version, defaults to 'latest'"
+        )
+        download_parser.add_argument(
+            "--no-cache",
+            action="store_true",
+            help="Force re-download even if weights exist locally"
+        )
+        download_parser.set_defaults(func=DownloadCommand)
+
+    def __init__(self, args):
+        """Initialize command with parsed arguments"""
+        self.args = args
+
+    def run(self):
+        """Download model weights from registry"""
+        try:
+            # Determine which route to take based on arguments
+            weights_list: Optional[List[str]] = None
+            
+            if self.args.weights:
+                # Route 1: Explicit weights list provided
+                weights_list = self.args.weights
+                logger.info(f"Downloading specified weights: {weights_list}")
+                
+            elif self.args.models:
+                # Route 2: Fetch from model IDs in Supabase and deduplicate
+                print(f"Fetching manifests for {len(self.args.models)} model(s)...")
+                weights_list = get_weights_from_model_ids(self.args.models)
+                print(f"Found {len(weights_list)} unique weight(s) across all models")
+                logger.info(f"Downloaded manifests for models {self.args.models}, unique weights: {weights_list}")
+                
+            else:
+                # Route 3: Default - read from local manifest.json
+                logger.info("No arguments specified, reading from local manifest.json...")
+                weights_list = get_weights_from_local_manifest()
+                logger.info(f"Found weights in local manifest: {weights_list}")
+            
+            if not weights_list:
+                print("No weights to download.")
+                return
+            
+            # Download weights in parallel
+            if self.args.no_cache:
+                print(f"Force downloading {len(weights_list)} weight folder(s) (no-cache mode)...")
+            else:
+                print(f"Downloading {len(weights_list)} weight folder(s)...")
+            weight_paths = get_weights_parallel(weights_list, no_cache=self.args.no_cache)
+            
+            # Print results
+            print("\nDownload complete! Weight paths:")
+            for i, (weight_name, weight_path) in enumerate(zip(weights_list, weight_paths), 1):
+                if weight_path:
+                    print(f"  {i}. {weight_name}: {weight_path}")
+                else:
+                    print(f"  {i}. {weight_name}: FAILED")
+            
+        except Exception as e:
+            logger.error(f"Download command failed: {e}")
+            print(f"Error: {e}")
+            return

reactor_cli/commands/init.py

@@ -0,0 +1,86 @@
+"""Init command implementation."""
+
+import pathlib
+import importlib.resources
+
+
+class InitCommand:
+    @staticmethod
+    def register_subcommand(subparsers):
+        """Register init command"""
+        init_parser = subparsers.add_parser("init", help="Initialize a new reactor model workspace")
+        init_parser.add_argument("name", help="Name of the model (will create directory with this name)")
+        init_parser.set_defaults(func=InitCommand)
+
+    def __init__(self, args):
+        """Initialize with parsed arguments"""
+        self.args = args
+
+    def run(self):
+        """Initialize a new reactor model workspace in a directory with the given name."""
+        model_name = self.args.name
+        current_dir = pathlib.Path.cwd()
+        target_dir = current_dir / model_name
+
+        # Check if directory already exists
+        if target_dir.exists():
+            print(f"Error: Directory '{model_name}' already exists")
+            print(f"Please choose a different name or remove the existing directory")
+            return
+
+        # Create the model directory
+        try:
+            target_dir.mkdir()
+            print(f"Created directory: {model_name}")
+        except Exception as e:
+            print(f"Error creating directory '{model_name}': {e}")
+            return
+
+        print(f"Initializing reactor workspace in {target_dir}")
+
+        # Copy template files from the installed package
+        try:
+            import template as template_package
+            template_files = [
+                "model_template.py",
+                "manifest.json",
+                "requirements.txt",
+                "Dockerfile",
+                "README.md"
+            ]
+
+            for filename in template_files:
+                dest_path = target_dir / filename
+                if dest_path.exists():
+                    print(f"Warning: {filename} already exists, skipping...")
+                    continue
+
+                # Read template file from package resources
+                try:
+                    with importlib.resources.open_text(template_package, filename) as f:
+                        content = f.read()
+
+                    # Write to destination
+                    with open(dest_path, 'w') as f:
+                        f.write(content)
+
+                    print(f"Created: {filename}")
+                except FileNotFoundError:
+                    print(f"Warning: Template file {filename} not found in package")
+                    continue
+
+            print(f"\nReactor workspace '{model_name}' initialized successfully!")
+            print(f"\nNext steps:")
+            print(f"1. cd {model_name}")
+            print("2. Edit model_template.py to implement your video model")
+            print("3. Update manifest.json with your model class, parameters, and reactor-runtime version")
+            print("4. Add any additional dependencies to requirements.txt")
+            print("5. Run 'reactor run' to start your model")
+            print(f"6. Build Docker image: docker build --build-arg GITHUB_TOKEN=<github_token> -t {model_name} .")
+
+        except ImportError:
+            print("Error: reactor_runtime package not found. Make sure it's properly installed.")
+            return
+        except Exception as e:
+            print(f"Error initializing workspace: {e}")
+            return

reactor_cli/commands/run.py

@@ -0,0 +1,118 @@
+"""Run command implementation."""
+
+import json
+import os
+from reactor_runtime.utils.launch import run_reactor_runtime_sync
+import logging
+
+logger = logging.getLogger(__name__)
+
+class RunCommand:
+    @staticmethod
+    def register_subcommand(subparsers):
+        """Register run command"""
+        run_parser = subparsers.add_parser("run", help="Run reactor runtime with model from manifest.json")
+        run_parser.add_argument(
+            "--deploy",
+            action="store_true",
+            help="Run the model in a proper deployment mode."
+        )
+        run_parser.add_argument(
+            "--debug","--headless",
+            action="store_true",
+            help="Run the model in a headless, debug mode."
+        )
+        run_parser.add_argument(
+            "--host",
+            type=str,
+            default="0.0.0.0",
+            help="Host to bind the FastAPI Server. Default: 0.0.0.0"
+        )
+        run_parser.add_argument(
+            "--port",
+            type=int,
+            default=8081,
+            help="FastAPI Server port. Default: 8081"
+        )
+        run_parser.add_argument(
+            "--log-level",
+            type=str,
+            default="INFO",
+            choices=["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"],
+            help="Logging level. Default: INFO"
+        )
+        run_parser.set_defaults(func=RunCommand)
+
+    def __init__(self, args):
+        """Initialize with parsed arguments"""
+        self.args = args
+
+    def run(self):
+        """Run the reactor runtime with the model specified in manifest.json."""
+        from ..main import verify_reactor_workspace
+
+        # Verify workspace and get manifest data
+        manifest_data = verify_reactor_workspace()
+        if manifest_data is None:
+            return
+
+        # Extract model information from manifest
+        model_class = manifest_data["class"]
+        model_args = manifest_data.get("args", {})
+
+        if "model_name" not in manifest_data.keys():
+            print("Error: manifest.json is missing required 'model_name' field.")
+            print("Please add a 'model_name' field specifying the model name.")
+            return
+        if "model_version" not in manifest_data.keys():
+            print("Error: manifest.json is missing required 'model_version' field.")
+            print("Please add a 'model_version' field specifying the model version.")
+            return
+
+        print(f"Starting reactor runtime...")
+        print(f"Model: {model_class}")
+        if model_args:
+            print(f"Model args: {model_args}")
+
+        runtime_serve_fn = None
+        if self.args.deploy:
+            try:
+                from reactor_runtime.context._cloud.cloud_runtime import serve
+                if os.getenv("REDIS_URL", None) is None:
+                    raise KeyError("REDIS_URL environment variable is not set. Please set it to the Redis URL.")
+                runtime_serve_fn = serve
+            except KeyError as e:
+                logger.error(f"Error starting reactor runtime: {e}")
+                return
+            except ModuleNotFoundError as e:
+                logger.error("Deploy mode is not supported locally. Please use the command without --deploy.")
+                return
+        else:
+            if self.args.debug:
+                try:
+                    from reactor_runtime.context.debug.debug_runtime import serve
+                    runtime_serve_fn = serve
+                except ModuleNotFoundError:
+                    logger.error("Debug mode is not available. Please use the command without --debug/--headless.")
+                    return
+            else:
+                from reactor_runtime.context.local.local_runtime import serve
+                runtime_serve_fn = serve
+        
+        try:
+            run_reactor_runtime_sync(
+                runtime_serve_fn=runtime_serve_fn,
+                model=model_class,
+                model_args=json.dumps(model_args) if model_args else None,
+                host=self.args.host,
+                port=self.args.port,
+                log_level=self.args.log_level,
+                model_name=manifest_data["model_name"],
+                model_version=manifest_data["model_version"],
+            )
+
+        except KeyboardInterrupt:
+            print("\nReactor runtime stopped by user.")
+        except Exception as e:
+            print(f"Error running reactor runtime: {e}")
+            raise

reactor_cli/commands/setup.py

@@ -0,0 +1,103 @@
+"""Setup command implementation.
+
+Interactive setup for configuring Reactor weights management credentials.
+This is for manual setup only - helps users configure their environment
+variables for Supabase and AWS S3 access.
+"""
+
+import os
+
+class SetupCommand:
+    @staticmethod
+    def register_subcommand(subparsers):
+        """Register setup command"""
+        setup_parser = subparsers.add_parser("setup", help="Check reactor weights configuration")
+        setup_parser.set_defaults(func=SetupCommand)
+
+    def __init__(self, args):
+        """Initialize command with parsed arguments"""
+        self.args = args
+
+    def run(self):
+        """Interactive setup for reactor weights"""
+        print("Reactor weights setup")
+        print("This will help you configure Supabase and AWS credentials")
+
+        # Check current status
+        supabase_vars = {
+            "SUPABASE_URL": os.getenv("SUPABASE_URL"),
+            "SUPABASE_SERVICE_KEY": os.getenv("SUPABASE_SERVICE_KEY"),
+        }
+
+        aws_vars = {
+            "AWS_ACCESS_KEY_ID": os.getenv("AWS_ACCESS_KEY_ID"),
+            "AWS_SECRET_ACCESS_KEY": os.getenv("AWS_SECRET_ACCESS_KEY"),
+        }
+
+        # Setup Supabase
+        print("\nSupabase setup:")
+        print("Go to https://supabase.com/dashboard > Settings > API")
+
+        supabase_url = input(f"Supabase URL (current: {supabase_vars['SUPABASE_URL'] or 'not set'}): ").strip()
+        supabase_service_key = input(f"Supabase service key (current: {'***' if supabase_vars['SUPABASE_SERVICE_KEY'] else 'not set'}): ").strip()
+
+        # Setup AWS
+        print("\nAWS setup:")
+        print("Go to AWS Console > IAM > Users (create user with S3 permissions)")
+
+        aws_access_key = input(f"AWS Access Key ID (current: {'***' if aws_vars['AWS_ACCESS_KEY_ID'] else 'not set'}): ").strip()
+        aws_secret_key = input(f"AWS Secret Key (current: {'***' if aws_vars['AWS_SECRET_ACCESS_KEY'] else 'not set'}): ").strip()
+
+        # Generate export commands
+        print("\nAdd these to your shell profile (.bashrc, .zshrc, etc.):")
+
+        if supabase_url:
+            print(f"export SUPABASE_URL='{supabase_url}'")
+        if supabase_service_key:
+            print(f"export SUPABASE_SERVICE_KEY='{supabase_service_key}'")
+        if aws_access_key:
+            print(f"export AWS_ACCESS_KEY_ID='{aws_access_key}'")
+        if aws_secret_key:
+            print(f"export AWS_SECRET_ACCESS_KEY='{aws_secret_key}'")
+
+        print("\nRun 'source ~/.bashrc' (or restart terminal) to apply changes")
+
+        # Test connections if user entered values
+        if any([supabase_url, supabase_service_key, aws_access_key, aws_secret_key]):
+            print("\nTesting connections with provided credentials...")
+            self._test_connections(supabase_url, supabase_service_key, aws_access_key, aws_secret_key)
+
+    def _test_connections(self, supabase_url=None, supabase_service_key=None, aws_access_key=None, aws_secret_key=None):
+        """Test connections with provided credentials"""
+
+        # Test Supabase with provided values or environment
+        try:
+            from supabase import create_client
+            url = supabase_url or os.getenv('SUPABASE_URL')
+            key = supabase_service_key or os.getenv('SUPABASE_SERVICE_KEY')
+
+            if url and key:
+                supabase = create_client(url, key)
+                supabase.table('models').select('count').execute()
+                print("Supabase: connection successful")
+            else:
+                print("Supabase: skipped (no credentials provided)")
+        except Exception as e:
+            print(f"Supabase: connection failed - {e}")
+
+        # Test AWS with provided values or environment
+        try:
+            import boto3
+            access_key = aws_access_key or os.getenv('AWS_ACCESS_KEY_ID')
+            secret_key = aws_secret_key or os.getenv('AWS_SECRET_ACCESS_KEY')
+
+            if access_key and secret_key:
+                s3 = boto3.client('s3',
+                    aws_access_key_id=access_key,
+                    aws_secret_access_key=secret_key)
+                s3.list_buckets()
+                print("AWS S3: connection successful")
+            else:
+                print("AWS S3: skipped (no credentials provided)")
+        except Exception as e:
+            print(f"AWS S3: connection failed - {e}")