pyworkflow-engine 0.1.7__py3-none-any.whl

pyworkflow/cli/utils/interactive.py

@@ -0,0 +1,364 @@
+"""
+Interactive prompt utilities using InquirerPy.
+
+This module provides reusable prompt functions for interactive CLI workflows,
+all styled with PyWorkflow branding.
+"""
+
+from collections.abc import Callable
+from pathlib import Path
+
+import click
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+
+from pyworkflow.cli.output.styles import PYWORKFLOW_STYLE
+
+
+def confirm(message: str, default: bool = True) -> bool:
+    """
+    Display a yes/no confirmation prompt.
+
+    Args:
+        message: Question to ask the user
+        default: Default answer if user just presses Enter
+
+    Returns:
+        True if user confirms, False otherwise
+
+    Raises:
+        click.Abort: If user presses Ctrl+C
+
+    Example:
+        >>> if confirm("Continue with setup?"):
+        ...     print("Continuing...")
+    """
+    try:
+        return inquirer.confirm(
+            message=message,
+            default=default,
+            style=PYWORKFLOW_STYLE,
+        ).execute()
+    except KeyboardInterrupt:
+        raise click.Abort()
+
+
+def select(
+    message: str,
+    choices: list[str] | list[dict[str, str]],
+    default: str | None = None,
+) -> str:
+    """
+    Display a single-selection list.
+
+    Args:
+        message: Question to ask the user
+        choices: List of options. Can be:
+            - List of strings: ["option1", "option2"]
+            - List of dicts: [{"name": "Display Text", "value": "value1"}]
+        default: Default selected value
+
+    Returns:
+        Selected value
+
+    Raises:
+        click.Abort: If user presses Ctrl+C
+
+    Example:
+        >>> storage = select(
+        ...     "Choose storage:",
+        ...     choices=[
+        ...         {"name": "SQLite (recommended)", "value": "sqlite"},
+        ...         {"name": "File storage", "value": "file"}
+        ...     ]
+        ... )
+    """
+    try:
+        # Convert string list to Choice objects
+        choice_objects: list[Choice] = []
+        if choices and isinstance(choices[0], str):
+            for c in choices:
+                if isinstance(c, str):
+                    choice_objects.append(Choice(value=c, name=c))
+        else:
+            # Dict format: {"name": "...", "value": "..."}
+            for c in choices:
+                if isinstance(c, dict):
+                    choice_objects.append(Choice(value=c.get("value", c["name"]), name=c["name"]))
+
+        return inquirer.select(
+            message=message,
+            choices=choice_objects,
+            default=default,
+            style=PYWORKFLOW_STYLE,
+        ).execute()
+    except KeyboardInterrupt:
+        raise click.Abort()
+
+
+def input_text(
+    message: str,
+    default: str = "",
+    validate: Callable[[str], bool | str] | None = None,
+) -> str:
+    """
+    Display a text input prompt.
+
+    Args:
+        message: Question or prompt text
+        default: Default value if user just presses Enter
+        validate: Optional validation function. Should return:
+            - True if valid
+            - False or error message string if invalid
+
+    Returns:
+        User's input text
+
+    Raises:
+        click.Abort: If user presses Ctrl+C
+
+    Example:
+        >>> def validate_module(value: str) -> bool | str:
+        ...     if not value:
+        ...         return True  # Empty is OK
+        ...     if "." not in value:
+        ...         return "Module path should contain dots (e.g., myapp.workflows)"
+        ...     return True
+        >>>
+        >>> module = input_text(
+        ...     "Workflow module path:",
+        ...     default="myapp.workflows",
+        ...     validate=validate_module
+        ... )
+    """
+    try:
+        return inquirer.text(
+            message=message,
+            default=default,
+            validate=validate,  # type: ignore[arg-type]
+            style=PYWORKFLOW_STYLE,
+        ).execute()
+    except KeyboardInterrupt:
+        raise click.Abort()
+
+
+def filepath(
+    message: str,
+    default: str = "",
+    only_directories: bool = False,
+) -> str:
+    """
+    Display a filepath input prompt with tab completion.
+
+    Args:
+        message: Question or prompt text
+        default: Default path value
+        only_directories: If True, only allow directory paths
+
+    Returns:
+        Selected or entered file path
+
+    Raises:
+        click.Abort: If user presses Ctrl+C
+
+    Example:
+        >>> db_path = filepath(
+        ...     "SQLite database path:",
+        ...     default="./pyworkflow_data/pyworkflow.db"
+        ... )
+        >>>
+        >>> data_dir = filepath(
+        ...     "Data directory:",
+        ...     default="./pyworkflow_data",
+        ...     only_directories=True
+        ... )
+    """
+    try:
+        result = inquirer.filepath(
+            message=message,
+            default=default,
+            only_directories=only_directories,
+            style=PYWORKFLOW_STYLE,
+        ).execute()
+
+        # Convert to absolute path and resolve
+        return str(Path(result).expanduser())
+    except KeyboardInterrupt:
+        raise click.Abort()
+
+
+def multiselect(
+    message: str,
+    choices: list[str] | list[dict[str, str]],
+    default: list[str] | None = None,
+) -> list[str]:
+    """
+    Display a multi-selection checkbox list.
+
+    Args:
+        message: Question to ask the user
+        choices: List of options. Can be:
+            - List of strings: ["option1", "option2"]
+            - List of dicts: [{"name": "Display Text", "value": "value1"}]
+        default: List of default selected values
+
+    Returns:
+        List of selected values
+
+    Raises:
+        click.Abort: If user presses Ctrl+C
+
+    Example:
+        >>> features = multiselect(
+        ...     "Select features to enable:",
+        ...     choices=[
+        ...         {"name": "Dashboard", "value": "dashboard"},
+        ...         {"name": "Monitoring", "value": "monitoring"},
+        ...         {"name": "Metrics", "value": "metrics"}
+        ...     ],
+        ...     default=["dashboard"]
+        ... )
+    """
+    try:
+        # Convert string list to Choice objects
+        choice_objects: list[Choice] = []
+        if choices and isinstance(choices[0], str):
+            for c in choices:
+                if isinstance(c, str):
+                    choice_objects.append(Choice(value=c, name=c, enabled=(c in (default or []))))
+        else:
+            # Dict format: {"name": "...", "value": "..."}
+            for c in choices:
+                if isinstance(c, dict):
+                    value = c.get("value", c["name"])
+                    choice_objects.append(
+                        Choice(
+                            value=value,
+                            name=c["name"],
+                            enabled=(value in (default or [])),
+                        )
+                    )
+
+        return inquirer.checkbox(
+            message=message,
+            choices=choice_objects,
+            style=PYWORKFLOW_STYLE,
+        ).execute()
+    except KeyboardInterrupt:
+        raise click.Abort()
+
+
+def password(message: str, validate: Callable[[str], bool | str] | None = None) -> str:
+    """
+    Display a password input prompt (hidden text).
+
+    Args:
+        message: Question or prompt text
+        validate: Optional validation function
+
+    Returns:
+        Entered password
+
+    Raises:
+        click.Abort: If user presses Ctrl+C
+
+    Example:
+        >>> def validate_password(value: str) -> bool | str:
+        ...     if len(value) < 8:
+        ...         return "Password must be at least 8 characters"
+        ...     return True
+        >>>
+        >>> pwd = password("Enter password:", validate=validate_password)
+    """
+    try:
+        return inquirer.secret(
+            message=message,
+            validate=validate,  # type: ignore[arg-type]
+            style=PYWORKFLOW_STYLE,
+        ).execute()
+    except KeyboardInterrupt:
+        raise click.Abort()
+
+
+# Validation helper functions
+
+
+def validate_module_path(value: str) -> bool | str:
+    """
+    Validate Python module path.
+
+    Args:
+        value: Module path string (e.g., "myapp.workflows")
+
+    Returns:
+        True if valid, error message string if invalid
+
+    Example:
+        >>> validate_module_path("myapp.workflows")
+        True
+        >>> validate_module_path("invalid module")
+        'Module path cannot contain spaces'
+    """
+    if not value:
+        return True  # Empty is allowed
+
+    if " " in value:
+        return "Module path cannot contain spaces"
+
+    if not all(part.isidentifier() for part in value.split(".")):
+        return "Module path must be valid Python identifiers separated by dots"
+
+    return True
+
+
+def validate_nonempty(value: str) -> bool | str:
+    """
+    Validate that input is not empty.
+
+    Args:
+        value: Input string
+
+    Returns:
+        True if not empty, error message if empty
+    """
+    if not value or not value.strip():
+        return "This field cannot be empty"
+    return True
+
+
+def validate_port(value: str) -> bool | str:
+    """
+    Validate port number.
+
+    Args:
+        value: Port number as string
+
+    Returns:
+        True if valid port (1-65535), error message otherwise
+    """
+    try:
+        port = int(value)
+        if 1 <= port <= 65535:
+            return True
+        return "Port must be between 1 and 65535"
+    except ValueError:
+        return "Port must be a number"
+
+
+def validate_url(value: str) -> bool | str:
+    """
+    Validate URL format.
+
+    Args:
+        value: URL string
+
+    Returns:
+        True if valid URL format, error message otherwise
+    """
+    if not value:
+        return "URL cannot be empty"
+
+    if not (value.startswith("http://") or value.startswith("https://")):
+        return "URL must start with http:// or https://"
+
+    return True

pyworkflow/cli/utils/storage.py

@@ -0,0 +1,115 @@
+"""Storage backend factory utilities."""
+
+from typing import Any
+
+from loguru import logger
+
+from pyworkflow import StorageBackend
+from pyworkflow.storage.config import config_to_storage
+
+
+def create_storage(
+    backend_type: str | None = None,
+    path: str | None = None,
+    config: dict[str, Any] | None = None,
+) -> StorageBackend:
+    """
+    Create storage backend from configuration.
+
+    Configuration priority:
+    1. CLI flags (backend_type, path arguments)
+    2. Environment variables (handled by Click)
+    3. Config file (config dict)
+    4. Default (file backend with ./workflow_data)
+
+    Args:
+        backend_type: Storage backend type ("file", "memory", "redis", "sqlite", "dynamodb")
+        path: Storage path (for file/sqlite backends)
+        config: Configuration dict from pyworkflow.toml
+
+    Returns:
+        Configured StorageBackend instance
+
+    Raises:
+        ValueError: If backend type is unsupported
+
+    Examples:
+        # File storage with explicit path
+        storage = create_storage(backend_type="file", path="./data")
+
+        # From config
+        config = {"storage": {"type": "file", "base_path": "./workflow_data"}}
+        storage = create_storage(config=config)
+
+        # Default (file storage)
+        storage = create_storage()
+    """
+    # Resolve backend type with priority: CLI flag > config file > default
+    backend = backend_type
+
+    if not backend and config:
+        backend = config.get("storage", {}).get("type")
+
+    if not backend:
+        backend = "file"  # Default
+
+    logger.debug(f"Creating storage backend: {backend}")
+
+    # Resolve storage path with priority: CLI flag > config file > default
+    storage_path = path
+    if not storage_path and config:
+        storage_path = config.get("storage", {}).get("base_path")
+
+    # Build unified config dict
+    storage_config: dict[str, Any] = {"type": backend}
+    if storage_path:
+        storage_config["base_path"] = storage_path
+
+    # Extract redis config if present
+    if backend == "redis" and config:
+        storage_section = config.get("storage", {})
+        if "host" in storage_section:
+            storage_config["host"] = storage_section["host"]
+        if "port" in storage_section:
+            storage_config["port"] = storage_section["port"]
+        if "db" in storage_section:
+            storage_config["db"] = storage_section["db"]
+
+    # Extract postgres config if present
+    if backend == "postgres" and config:
+        storage_section = config.get("storage", {})
+        if "dsn" in storage_section:
+            storage_config["dsn"] = storage_section["dsn"]
+        else:
+            if "host" in storage_section:
+                storage_config["host"] = storage_section["host"]
+            if "port" in storage_section:
+                storage_config["port"] = storage_section["port"]
+            if "user" in storage_section:
+                storage_config["user"] = storage_section["user"]
+            if "password" in storage_section:
+                storage_config["password"] = storage_section["password"]
+            if "database" in storage_section:
+                storage_config["database"] = storage_section["database"]
+
+    # Extract dynamodb config if present
+    if backend == "dynamodb" and config:
+        storage_section = config.get("storage", {})
+        if "table_name" in storage_section:
+            storage_config["table_name"] = storage_section["table_name"]
+        if "region" in storage_section:
+            storage_config["region"] = storage_section["region"]
+        if "endpoint_url" in storage_section:
+            storage_config["endpoint_url"] = storage_section["endpoint_url"]
+
+    # Use unified config_to_storage
+    storage = config_to_storage(storage_config)
+
+    # Log which backend was created
+    backend_name = storage.__class__.__name__
+    if hasattr(storage, "base_path"):
+        logger.info(f"Using {backend_name} with path: {storage.base_path}")
+    else:
+        logger.info(f"Using {backend_name}")
+
+    return storage