diffusers-workflow 0.4.0a3__py3-none-any.whl

dw/run.py

@@ -0,0 +1,92 @@
+import argparse
+import os
+from . import startup
+from .workflow import workflow_from_file
+from .security import (
+    validate_workflow_path,
+    validate_output_path,
+    validate_variable_name,
+    validate_string_input,
+    SecurityError,
+    MAX_VARIABLE_VALUE_LENGTH,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run a workflow from a file.")
+    parser.add_argument(
+        "file_name", type=str, help="The filespec to of the workflow to run"
+    )
+    parser.add_argument(
+        "-o",
+        "--output_dir",
+        type=str,
+        default="./outputs",
+        help="The folder to write the outputs to",
+    )
+    parser.add_argument(
+        "variables",
+        nargs="*",  # Accept 0 or more parameters
+        help="Optional parameters in name=value format",
+    )
+    parser.add_argument(
+        "-l",
+        "--log_level",
+        type=str,
+        default="INFO",
+        help="Set the logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+    )
+    args = parser.parse_args()
+
+    # Parse key-value pairs with validation
+    variables = {}
+    for variable in args.variables:
+        try:
+            name, value = variable.split("=", 1)
+            # Validate variable name and value
+            validated_name = validate_variable_name(name.strip())
+            validated_value = validate_string_input(
+                value.strip(), max_length=MAX_VARIABLE_VALUE_LENGTH, allow_empty=True
+            )
+            variables[validated_name] = validated_value
+        except ValueError:
+            print(f"Error: Variable '{variable}' is not in name=value format")
+            exit(1)
+        except SecurityError as e:
+            print(f"Error: Invalid variable input: {e}")
+            exit(1)
+
+    # Validate and secure file paths
+    try:
+        validated_output_dir = validate_output_path(args.output_dir, None)
+        if not os.path.exists(validated_output_dir):
+            # Create output directory if it doesn't exist
+            os.makedirs(validated_output_dir, exist_ok=True)
+            print(f"Created output directory: {validated_output_dir}")
+
+        validated_file_path = validate_workflow_path(args.file_name)
+        if not os.path.exists(validated_file_path):
+            raise FileNotFoundError(f"File {validated_file_path} does not exist")
+
+    except SecurityError as e:
+        print(f"Error: Security validation failed: {e}")
+        exit(1)
+
+    startup(args.log_level)
+
+    workflow = workflow_from_file(validated_file_path, validated_output_dir)
+    try:
+        workflow.validate()
+    except Exception as e:
+        print(f"Error validating workflow '{args.file_name}': {e}")
+        exit(1)
+
+    try:
+        workflow.run(variables)
+    except Exception as e:
+        print(f"Error running workflow '{args.file_name}': {e}")
+        exit(1)
+
+
+if __name__ == "__main__":
+    main()

dw/schema.py

@@ -0,0 +1,24 @@
+import json
+import os
+from jsonschema import validate, ValidationError
+
+
+def validate_data(data, schema):
+    try:
+        validate(instance=data, schema=schema)
+        return True, "Validation successful"
+
+    except ValidationError as ve:
+        return False, f"Validation error: {ve.message}"
+    except json.JSONDecodeError as je:
+        return False, f"JSON parsing error: {str(je)}"
+    except Exception as e:
+        return False, f"Unexpected error: {str(e)}"
+
+
+def load_schema(schema_name):
+    file_spec = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), f"{schema_name}_schema.json"
+    )
+    with open(file_spec, "r") as file:
+        return json.load(file)

dw/security.py

@@ -0,0 +1,379 @@
+"""
+Security utilities for input validation and safe file operations.
+"""
+
+import os
+import re
+import logging
+from pathlib import Path
+from urllib.parse import urlparse
+from typing import Union, List, Optional
+
+logger = logging.getLogger("dw")
+
+# Security constants
+MAX_PATH_LENGTH = 4096
+MAX_FILENAME_LENGTH = 255
+MAX_JSON_SIZE = 50 * 1024 * 1024  # 50MB
+MAX_VARIABLE_NAME_LENGTH = 100
+MAX_VARIABLE_VALUE_LENGTH = 10000
+MAX_CONSTANT_NAME_LENGTH = 200
+DEFAULT_MAX_STRING_LENGTH = 1000
+MAX_FILE_PATH_LENGTH = 1000
+ALLOWED_JSON_EXTENSIONS = {".json"}
+ALLOWED_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"}
+ALLOWED_VIDEO_EXTENSIONS = {".mp4", ".avi", ".mkv", ".mov", ".webm"}
+ALLOWED_AUDIO_EXTENSIONS = {".wav", ".mp3", ".flac", ".ogg"}
+
+# Dangerous path patterns (handle both Unix and Windows paths)
+DANGEROUS_PATTERNS = [
+    r"\.\.",  # Parent directory traversal (.. anywhere)
+    r"~[\\/]",  # Home directory expansion
+    r"^/dev/",  # Device files (Unix)
+    r"^/proc/",  # Process files (Unix)
+    r"^/sys/",  # System files (Unix)
+]
+
+
+class SecurityError(Exception):
+    """Base exception for security-related errors."""
+
+    pass
+
+
+class PathTraversalError(SecurityError):
+    """Raised when path traversal attempt is detected."""
+
+    pass
+
+
+class InvalidInputError(SecurityError):
+    """Raised when input validation fails."""
+
+    pass
+
+
+def validate_path(
+    path: Union[str, Path], base_dir: Optional[str] = None, allow_create: bool = True
+) -> str:
+    """
+    Validate and sanitize file paths to prevent path traversal attacks.
+
+    Args:
+        path: The path to validate
+        base_dir: Optional base directory to restrict access to
+        allow_create: Whether to allow creation of non-existent paths
+
+    Returns:
+        Absolute, sanitized path
+
+    Raises:
+        PathTraversalError: If path contains dangerous patterns
+        InvalidInputError: If path is invalid or too long
+    """
+    if not path:
+        raise InvalidInputError("Path cannot be empty")
+
+    path_str = str(path)
+
+    # Check path length
+    if len(path_str) > MAX_PATH_LENGTH:
+        raise InvalidInputError(f"Path too long: {len(path_str)} > {MAX_PATH_LENGTH}")
+
+    # Check for null bytes
+    if "\x00" in path_str:
+        raise InvalidInputError("Path contains null bytes")
+
+    # Normalize path separators for consistent checking across platforms
+    normalized_path = path_str.replace("\\", "/")
+
+    # Check for dangerous patterns
+    for pattern in DANGEROUS_PATTERNS:
+        if re.search(pattern, normalized_path, re.IGNORECASE):
+            raise PathTraversalError(
+                f"Path contains dangerous pattern matching {pattern}"
+            )
+
+    # Convert to absolute path and resolve
+    try:
+        abs_path = os.path.abspath(os.path.expanduser(path_str))
+        resolved_path = os.path.realpath(abs_path)
+    except (OSError, ValueError) as e:
+        raise InvalidInputError(f"Invalid path: {e}")
+
+    # Check if path is within base directory if specified
+    if base_dir:
+        try:
+            base_abs = os.path.abspath(os.path.expanduser(base_dir))
+            base_real = os.path.realpath(base_abs)
+
+            # Use os.path.commonpath to properly check if path is within base_dir
+            # This handles edge cases like different drives on Windows
+            try:
+                common = os.path.commonpath([base_real, resolved_path])
+                # The common path should be the base directory (or parent of it)
+                # Fixed: Check if resolved_path starts with base_real for proper containment
+                if not (
+                    common == base_real
+                    or resolved_path.startswith(base_real + os.sep)
+                    or resolved_path == base_real
+                ):
+                    raise PathTraversalError(
+                        f"Path outside allowed directory: {resolved_path}"
+                    )
+            except ValueError:
+                # Raised when paths are on different drives (Windows)
+                raise PathTraversalError(
+                    f"Path on different drive than allowed directory: {resolved_path}"
+                )
+        except (OSError, ValueError) as e:
+            raise InvalidInputError(f"Invalid base directory: {e}")
+
+    # Check filename length
+    filename = os.path.basename(resolved_path)
+    if len(filename) > MAX_FILENAME_LENGTH:
+        raise InvalidInputError(
+            f"Filename too long: {len(filename)} > {MAX_FILENAME_LENGTH}"
+        )
+
+    # Check if path exists or creation is allowed
+    if not os.path.exists(resolved_path) and not allow_create:
+        raise InvalidInputError(f"Path does not exist: {resolved_path}")
+
+    logger.debug(f"Validated path: {path_str} -> {resolved_path}")
+    return resolved_path
+
+
+def validate_file_extension(path: str, allowed_extensions: set) -> str:
+    """
+    Validate file extension against allowed list.
+
+    Args:
+        path: File path to validate
+        allowed_extensions: Set of allowed extensions (with dots)
+
+    Returns:
+        The validated path
+
+    Raises:
+        InvalidInputError: If extension is not allowed
+    """
+    ext = os.path.splitext(path)[1].lower()
+    if ext not in allowed_extensions:
+        raise InvalidInputError(f"File extension not allowed: {ext}")
+    return path
+
+
+def validate_workflow_path(path: str, workflow_dir: str = None) -> str:
+    """Validate workflow file paths."""
+    validated = validate_path(path, workflow_dir, allow_create=False)
+    return validate_file_extension(validated, ALLOWED_JSON_EXTENSIONS)
+
+
+def validate_output_path(path: str, output_dir: str) -> str:
+    """Validate output file paths."""
+    return validate_path(path, output_dir, allow_create=True)
+
+
+def validate_url(url: str) -> str:
+    """
+    Validate URL format and scheme.
+
+    Args:
+        url: URL to validate
+
+    Returns:
+        The validated URL
+
+    Raises:
+        InvalidInputError: If URL is invalid or uses dangerous scheme
+    """
+    if not url:
+        raise InvalidInputError("URL cannot be empty")
+
+    try:
+        parsed = urlparse(url)
+        if parsed.scheme not in {"http", "https"}:
+            raise InvalidInputError(f"URL scheme not allowed: {parsed.scheme}")
+        if not parsed.netloc:
+            raise InvalidInputError("URL must have a valid domain")
+        return url
+    except Exception as e:
+        raise InvalidInputError(f"Invalid URL: {e}")
+
+
+def sanitize_command_args(args: List[str]) -> List[str]:
+    """
+    Sanitize command arguments for subprocess execution with shell=False.
+
+    When using subprocess with a list of arguments and shell=False, Python
+    handles argument separation safely without shell interpretation. This
+    function validates that arguments don't contain shell metacharacters
+    that could be dangerous if shell=True were accidentally used.
+
+    Args:
+        args: List of command arguments
+
+    Returns:
+        List of validated arguments (no modification needed for shell=False)
+
+    Raises:
+        InvalidInputError: If arguments contain dangerous content
+    """
+    sanitized = []
+
+    for arg in args:
+        if not isinstance(arg, str):
+            arg = str(arg)
+
+        # Check for dangerous characters that would be problematic with shell=True
+        # Even though we use shell=False, this prevents accidental security issues
+        if any(char in arg for char in ["`", "$", "|", "&", ";", ">", "<", "\n", "\r"]):
+            raise InvalidInputError(f"Argument contains dangerous characters: {arg}")
+
+        # With shell=False, we don't need shlex.quote() - Python handles it safely
+        # Just validate and pass through
+        sanitized.append(arg)
+
+    return sanitized
+
+
+def validate_variable_name(name: str) -> str:
+    """
+    Validate variable names to prevent injection attacks.
+
+    Args:
+        name: Variable name to validate
+
+    Returns:
+        The validated variable name
+
+    Raises:
+        InvalidInputError: If name is invalid
+    """
+    if not name:
+        raise InvalidInputError("Variable name cannot be empty")
+
+    # Allow only alphanumeric characters, underscores, and hyphens
+    if not re.match(r"^[a-zA-Z_][a-zA-Z0-9_-]*$", name):
+        raise InvalidInputError(f"Invalid variable name: {name}")
+
+    if len(name) > MAX_VARIABLE_NAME_LENGTH:
+        raise InvalidInputError(
+            f"Variable name too long: {len(name)} > {MAX_VARIABLE_NAME_LENGTH}"
+        )
+
+    return name
+
+
+# A dotted python name: identifiers separated by dots, and nothing else
+CONSTANT_NAME_PATTERN = r"^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$"
+
+
+def validate_constant_name(name: str) -> str:
+    """
+    Validate the dotted name of a python constant a workflow references.
+
+    Resolving a name imports the module it lives in, which runs that module's
+    code, so the name is checked before anything is imported - identifiers and
+    dots only, no relative paths and nothing to evaluate.
+
+    Args:
+        name: Dotted name to validate
+
+    Returns:
+        The validated name
+
+    Raises:
+        InvalidInputError: If name is invalid
+    """
+    if not name:
+        raise InvalidInputError("Constant name cannot be empty")
+
+    if not re.match(CONSTANT_NAME_PATTERN, name):
+        raise InvalidInputError(
+            f"Invalid constant name: {name} - a constant is named by its module "
+            f"and the attribute to read from it, like "
+            f"'diffusers.pipelines.ltx2.utils.DISTILLED_SIGMA_VALUES'"
+        )
+
+    if len(name) > MAX_CONSTANT_NAME_LENGTH:
+        raise InvalidInputError(
+            f"Constant name too long: {len(name)} > {MAX_CONSTANT_NAME_LENGTH}"
+        )
+
+    return name
+
+
+def validate_json_size(file_path: str) -> None:
+    """
+    Validate JSON file size before loading.
+
+    Args:
+        file_path: Path to JSON file
+
+    Raises:
+        InvalidInputError: If file is too large
+    """
+    try:
+        size = os.path.getsize(file_path)
+        if size > MAX_JSON_SIZE:
+            raise InvalidInputError(f"JSON file too large: {size} > {MAX_JSON_SIZE}")
+    except OSError as e:
+        raise InvalidInputError(f"Cannot check file size: {e}")
+
+
+def validate_string_input(
+    value: str, max_length: int = DEFAULT_MAX_STRING_LENGTH, allow_empty: bool = False
+) -> str:
+    """
+    Validate string input for basic safety.
+
+    Args:
+        value: String to validate
+        max_length: Maximum allowed length
+        allow_empty: Whether empty strings are allowed
+
+    Returns:
+        The validated string
+
+    Raises:
+        InvalidInputError: If string is invalid
+    """
+    if not allow_empty and not value:
+        raise InvalidInputError("String cannot be empty")
+
+    if len(value) > max_length:
+        raise InvalidInputError(f"String too long: {len(value)} > {max_length}")
+
+    # Check for null bytes and control characters
+    if "\x00" in value or any(ord(c) < 32 for c in value if c not in "\t\n\r"):
+        raise InvalidInputError("String contains invalid characters")
+
+    return value
+
+
+def safe_join_path(*parts: str) -> str:
+    """
+    Safely join path components with validation.
+
+    Args:
+        *parts: Path components to join
+
+    Returns:
+        Safely joined path
+
+    Raises:
+        InvalidInputError: If any component is invalid
+    """
+    # Validate each component
+    for part in parts:
+        if not part:
+            continue
+        validate_string_input(part, MAX_FILENAME_LENGTH)
+        if ".." in part or "/" in part or "\\" in part:
+            raise InvalidInputError(
+                f"Path component contains invalid characters: {part}"
+            )
+
+    return os.path.join(*parts)

dw/serve.py

@@ -0,0 +1,70 @@
+"""Run the workflow engine as a local HTTP server.
+
+    python -m dw.serve
+    python -m dw.serve --port 8765 --workflow-dir ./examples
+
+Binds to localhost by default - this serves your GPU to your own tools,
+not to the network. Interactive API docs at http://127.0.0.1:8765/docs
+"""
+
+import argparse
+import multiprocessing
+
+# Spawn start method before anything touches multiprocessing (CUDA/MPS)
+if multiprocessing.get_start_method(allow_none=True) != "spawn":
+    try:
+        multiprocessing.set_start_method("spawn", force=True)
+    except RuntimeError:
+        pass
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Serve diffusers workflows over HTTP.")
+    parser.add_argument(
+        "--host", default="127.0.0.1", help="Bind address (default: 127.0.0.1)"
+    )
+    parser.add_argument("--port", type=int, default=8765, help="Port (default: 8765)")
+    parser.add_argument(
+        "--workflow-dir", default="./examples", help="Directory of workflow JSON files"
+    )
+    parser.add_argument(
+        "--output-dir", default="./outputs", help="Directory results are written to"
+    )
+    parser.add_argument(
+        "-l",
+        "--log_level",
+        default="INFO",
+        help="DEBUG, INFO, WARNING, ERROR, CRITICAL",
+    )
+    args = parser.parse_args()
+
+    try:
+        import uvicorn
+    except ImportError:
+        print(
+            "The server needs fastapi and uvicorn: pip install fastapi 'uvicorn[standard]'"
+        )
+        raise SystemExit(1)
+
+    from . import startup
+
+    startup(args.log_level)
+
+    from .server.app import create_app
+
+    from .server.app import default_ui_dir
+
+    app = create_app(
+        workflow_dir=args.workflow_dir,
+        output_dir=args.output_dir,
+        log_level=args.log_level,
+    )
+    ui = " - UI at /" if default_ui_dir() else ""
+    print(
+        f"diffusers-workflow server on http://{args.host}:{args.port}  (docs at /docs{ui})"
+    )
+    uvicorn.run(app, host=args.host, port=args.port, log_level=args.log_level.lower())
+
+
+if __name__ == "__main__":
+    main()

dw/server/__init__.py

@@ -0,0 +1,2 @@
+"""HTTP server exposing the workflow engine: submit jobs, stream progress,
+cancel, browse workflows and outputs. See dw/serve.py for the entry point."""