griptape-nodes 0.59.2__py3-none-any.whl → 0.60.0__py3-none-any.whl

griptape_nodes/exe_types/param_components/huggingface/huggingface_utils.py

@@ -0,0 +1,136 @@
+import logging
+from pathlib import Path
+from typing import Any
+
+from huggingface_hub import scan_cache_dir
+from huggingface_hub.constants import HF_HUB_CACHE
+
+logger = logging.getLogger("griptape_nodes")
+
+
+def list_all_repo_revisions_in_cache() -> list[tuple[str, str]]:
+    """Returns a list of (repo_id, revision) tuples for all repos in the huggingface cache."""
+    # Use quick scan for diffuser repos, fallback to scan_cache_dir only on errors
+    try:
+        repos = quick_scan_diffuser_repos(HF_HUB_CACHE)
+        results = [(repo["name"], repo["hash"]) for repo in repos]
+    except Exception:
+        logger.exception("Failed to quick scan diffuser repos, falling back to scan_cache_dir.")
+    else:
+        return results
+
+    # Fallback to original implementation
+    cache_info = scan_cache_dir()
+    results = []
+    for repo in cache_info.repos:
+        for revision in repo.revisions:
+            results.append((repo.repo_id, revision.commit_hash))
+    return results
+
+
+def list_repo_revisions_in_cache(repo_id: str) -> list[tuple[str, str]]:
+    """Returns a list of (repo_id, revision) tuples matching repo_id in the huggingface cache."""
+    # Use quick scan for diffuser repos, fallback to scan_cache_dir only on errors
+    try:
+        repos = quick_scan_diffuser_repos(HF_HUB_CACHE)
+        results = [(repo["name"], repo["hash"]) for repo in repos if repo["name"] == repo_id]
+    except Exception:
+        logger.exception("Failed to quick scan diffuser repos, falling back to scan_cache_dir.")
+    else:
+        return results
+
+    # Fallback to original implementation
+    cache_info = scan_cache_dir()
+    results = []
+    for repo in cache_info.repos:
+        if repo.repo_id == repo_id:
+            for revision in repo.revisions:
+                results.append((repo.repo_id, revision.commit_hash))
+    return results
+
+
+def list_repo_revisions_with_file_in_cache(repo_id: str, file: str) -> list[tuple[str, str]]:
+    """Returns a list of (repo_id, revision) tuples matching repo_id in the huggingface cache if it contains file."""
+    # Use quick scan for diffuser repos, check if file exists
+    try:
+        repos = quick_scan_diffuser_repos(HF_HUB_CACHE)
+        results = [
+            (repo["name"], repo["hash"])
+            for repo in repos
+            if repo["name"] == repo_id and (Path(repo["path"]) / file).exists()
+        ]
+    except Exception:
+        logger.exception("Failed to quick scan diffuser repos, falling back to scan_cache_dir.")
+    else:
+        return results
+
+    # Fallback to original implementation
+    cache_info = scan_cache_dir()
+    results = []
+    for repo in cache_info.repos:
+        if repo.repo_id == repo_id:
+            for revision in repo.revisions:
+                if any(f.file_name == file for f in revision.files):
+                    results.append((repo.repo_id, revision.commit_hash))
+    return results
+
+
+def quick_scan_diffuser_repos(cache_dir: str) -> list[dict[str, Any]]:
+    """Quick scan of diffuser repositories in huggingface cache directory.
+
+    Adapted from https://github.com/huggingface/huggingface_hub/issues/1564#issuecomment-1710764361
+
+    Args:
+        cache_dir: Path to huggingface cache directory
+
+    Returns:
+        List of dictionaries containing repo info with keys:
+        - name: Repository name
+        - filename: Repository name (alias for name)
+        - path: Path to the snapshot folder
+        - hash: Commit hash
+        - mtime: Modification time
+        - model_info: Path to model_info.json file
+    """
+    diffuser_repos = []
+    cache_path = Path(cache_dir)
+
+    if not cache_path.exists():
+        return diffuser_repos
+
+    for folder_path in cache_path.iterdir():
+        folder = folder_path.name
+        if not folder_path.is_dir() or "--" not in folder:
+            continue
+        _, name = folder.split("--", maxsplit=1)
+        name = name.replace("--", "/")
+
+        snapshots_dir = folder_path / "snapshots"
+        if not snapshots_dir.exists():
+            continue
+
+        snapshots = [p.name for p in snapshots_dir.iterdir() if p.is_dir()]
+        if len(snapshots) == 0:
+            continue
+
+        commit = snapshots[-1]
+        snapshot_path = snapshots_dir / commit
+
+        if (snapshot_path / "hidden").exists():
+            continue
+
+        mtime = snapshot_path.stat().st_mtime
+        info = snapshot_path / "model_info.json"
+
+        diffuser_repos.append(
+            {
+                "name": name,
+                "filename": name,
+                "path": str(snapshot_path),
+                "hash": commit,
+                "mtime": mtime,
+                "model_info": str(info),
+            }
+        )
+
+    return diffuser_repos

griptape_nodes/exe_types/param_components/log_parameter.py

@@ -0,0 +1,136 @@
+import contextlib
+import logging
+import sys
+import time
+from collections.abc import Callable, Iterator
+from types import TracebackType
+
+from griptape_nodes.exe_types.core_types import Parameter, ParameterMode
+from griptape_nodes.exe_types.node_types import BaseNode
+
+
+class LogParameter:
+    def __init__(self, node: BaseNode):
+        self._node = node
+
+    def add_output_parameters(self) -> None:
+        self._node.add_parameter(
+            Parameter(
+                name="logs",
+                output_type="str",
+                allowed_modes={ParameterMode.OUTPUT},
+                tooltip="logs",
+                ui_options={"multiline": True},
+            )
+        )
+
+    @contextlib.contextmanager
+    def append_stdout_to_logs(self) -> Iterator[None]:
+        def callback(data: str) -> None:
+            self.append_to_logs(data)
+
+        with StdoutCapture(callback):
+            yield
+
+    @contextlib.contextmanager
+    def append_logs_to_logs(self, logger: logging.Logger) -> Iterator[None]:
+        def callback(data: str) -> None:
+            self.append_to_logs(data)
+
+        with LoggerCapture(logger, callback):
+            yield
+
+    @contextlib.contextmanager
+    def append_profile_to_logs(self, label: str) -> Iterator[None]:
+        start = time.perf_counter()
+        yield
+        seconds = time.perf_counter() - start
+        human_readable_duration = seconds_to_human_readable(seconds)
+        self.append_to_logs(f"{label} took {human_readable_duration}\n")
+
+    def append_to_logs(self, text: str) -> None:
+        self._node.append_value_to_parameter("logs", text)
+
+    def clear_logs(self) -> None:
+        self._node.publish_update_to_parameter("logs", "")
+
+
+class StdoutCapture:
+    def __init__(self, callback: Callable[[str], None]) -> None:
+        self.callback: Callable[[str], None] = callback
+        self._original_stdout = sys.stdout
+
+    def write(self, data: str) -> None:
+        self._original_stdout.write(data)
+        self._original_stdout.flush()
+        self.callback(data)
+
+    def flush(self) -> None:
+        self._original_stdout.flush()
+
+    def __enter__(self) -> "StdoutCapture":
+        sys.stdout = self
+        return self
+
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
+    ) -> None:
+        sys.stdout = self._original_stdout
+
+
+class CallbackHandler(logging.Handler):
+    def __init__(self, callback: Callable[[str], None]) -> None:
+        super().__init__(level=logging.INFO)
+        self.callback = callback
+        self.setFormatter(logging.Formatter("%(message)s\n"))
+
+    def emit(self, record: logging.LogRecord) -> None:
+        message = self.format(record)
+        self.callback(message)
+
+
+class LoggerCapture:
+    def __init__(
+        self, logger: logging.Logger, callback: Callable[[str], None], level: int | str = logging.INFO
+    ) -> None:
+        self.logger = logger
+        self.target_level = level
+        self._handler = CallbackHandler(callback)
+
+    def __enter__(self) -> "LoggerCapture":
+        self.original_level = self.logger.level
+        self.logger.setLevel(self.target_level)
+        self.logger.addHandler(self._handler)
+        return self
+
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
+    ) -> None:
+        self.logger.removeHandler(self._handler)
+        self.logger.setLevel(self.original_level)
+
+
+def seconds_to_human_readable(seconds: float) -> str:
+    """Convert seconds to a human-readable format.
+
+    Args:
+        seconds (float): The number of seconds to convert.
+
+    Returns:
+        str: A human-readable string representing the time duration.
+    """
+    intervals = (
+        ("year", 31536000),
+        ("month", 2592000),
+        ("day", 86400),
+        ("hour", 3600),
+        ("minute", 60),
+        ("second", 1),
+        ("millisecond", 0.001),
+    )
+
+    for name, count in intervals:
+        if seconds >= count:
+            value = seconds / count
+            return f"{value:.2f} {name}{'s' if value != 1 else ''}"
+    return "0.00 milliseconds"

griptape_nodes/exe_types/param_components/seed_parameter.py

@@ -0,0 +1,59 @@
+import random
+from typing import Any
+
+from griptape_nodes.exe_types.core_types import Parameter, ParameterMode
+from griptape_nodes.exe_types.node_types import BaseNode
+
+
+class SeedParameter:
+    def __init__(self, node: BaseNode):
+        self._node = node
+
+    def add_input_parameters(self) -> None:
+        self._node.add_parameter(
+            Parameter(
+                name="randomize_seed",
+                type="bool",
+                output_type="bool",
+                tooltip="randomize the seed on each run",
+                default_value=False,
+            )
+        )
+        self._node.add_parameter(
+            Parameter(
+                name="seed",
+                type="int",
+                tooltip="seed",
+                default_value=42,
+            )
+        )
+
+    def remove_input_parameters(self) -> None:
+        self._node.remove_parameter_element_by_name("randomize_seed")
+        self._node.remove_parameter_element_by_name("seed")
+
+    def after_value_set(self, parameter: Parameter, value: Any) -> None:
+        if parameter.name != "randomize_seed":
+            return
+
+        seed_parameter = self._node.get_parameter_by_name("seed")
+        if not seed_parameter:
+            msg = "Seed parameter not found"
+            raise RuntimeError(msg)
+
+        if value:
+            # Disable editing the seed if randomize_seed is True
+            seed_parameter.allowed_modes = {ParameterMode.OUTPUT}
+        else:
+            # Enable editing the seed if randomize_seed is False
+            seed_parameter.allowed_modes = {ParameterMode.PROPERTY, ParameterMode.INPUT, ParameterMode.OUTPUT}
+
+    def preprocess(self) -> None:
+        if self._node.get_parameter_value("randomize_seed"):
+            # Not using for cryptographic purposes
+            seed = random.randint(0, 2**32 - 1)  # noqa: S311
+            self._node.set_parameter_value("seed", seed)
+            self._node.publish_update_to_parameter("seed", seed)
+
+    def get_seed(self) -> int:
+        return int(self._node.get_parameter_value("seed"))

griptape_nodes/exe_types/param_types/__init__.py

@@ -0,0 +1 @@
+"""Parameter types for simple parameter creation."""

griptape_nodes/exe_types/param_types/parameter_bool.py

@@ -0,0 +1,221 @@
+"""ParameterBool component for boolean inputs with enhanced UI options."""
+
+from collections.abc import Callable
+from typing import Any
+
+from griptape_nodes.exe_types.core_types import Parameter, ParameterMode, Trait
+
+
+class ParameterBool(Parameter):
+    """A specialized Parameter class for boolean inputs with enhanced UI options.
+
+    This class provides a convenient way to create boolean parameters with common
+    UI customizations like custom on/off labels. It exposes these UI options as
+    direct properties for easy runtime modification.
+
+    Example:
+        param = ParameterBool(
+            name="enabled",
+            tooltip="Enable this feature",
+            on_label="Yes",
+            off_label="No",
+            default_value=True
+        )
+        param.on_label = "Enable"  # Change labels at runtime
+    """
+
+    def __init__(  # noqa: PLR0913
+        self,
+        name: str,
+        tooltip: str | None = None,
+        *,
+        type: str = "bool",  # noqa: A002, ARG002
+        default_value: Any = None,
+        tooltip_as_input: str | None = None,
+        tooltip_as_property: str | None = None,
+        tooltip_as_output: str | None = None,
+        allowed_modes: set[ParameterMode] | None = None,
+        traits: set[type[Trait] | Trait] | None = None,
+        converters: list[Callable[[Any], Any]] | None = None,
+        validators: list[Callable[[Parameter, Any], None]] | None = None,
+        ui_options: dict | None = None,
+        on_label: str | None = None,
+        off_label: str | None = None,
+        accept_any: bool = True,
+        hide: bool = False,
+        hide_label: bool = False,
+        hide_property: bool = False,
+        allow_input: bool = True,
+        allow_property: bool = True,
+        allow_output: bool = True,
+        settable: bool = True,
+        serializable: bool = True,
+        user_defined: bool = False,
+        element_id: str | None = None,
+        element_type: str | None = None,
+        parent_container_name: str | None = None,
+    ) -> None:
+        """Initialize a boolean parameter with enhanced UI options.
+
+        Args:
+            name: Parameter name
+            tooltip: Parameter tooltip
+            type: Parameter type (ignored, always "bool" for ParameterBool)
+            default_value: Default parameter value
+            tooltip_as_input: Tooltip for input mode
+            tooltip_as_property: Tooltip for property mode
+            tooltip_as_output: Tooltip for output mode
+            allowed_modes: Allowed parameter modes
+            traits: Parameter traits
+            converters: Parameter converters
+            validators: Parameter validators
+            ui_options: Dictionary of UI options
+            on_label: Label for the "on" state
+            off_label: Label for the "off" state
+            accept_any: Whether to accept any input type and convert to boolean (default: True)
+            hide: Whether to hide the entire parameter
+            hide_label: Whether to hide the parameter label
+            hide_property: Whether to hide the parameter in property mode
+            allow_input: Whether to allow input mode
+            allow_property: Whether to allow property mode
+            allow_output: Whether to allow output mode
+            settable: Whether the parameter is settable
+            serializable: Whether the parameter is serializable
+            user_defined: Whether the parameter is user-defined
+            element_id: Element ID
+            element_type: Element type
+            parent_container_name: Name of parent container
+        """
+        # Build ui_options dictionary from the provided UI-specific parameters
+        if ui_options is None:
+            ui_options = {}
+        else:
+            ui_options = ui_options.copy()
+
+        # Add boolean-specific UI options if they have values
+        if on_label is not None:
+            ui_options["on_label"] = on_label
+        if off_label is not None:
+            ui_options["off_label"] = off_label
+
+        # Set up boolean conversion based on accept_any setting
+        if converters is None:
+            existing_converters = []
+        else:
+            existing_converters = converters
+
+        if accept_any:
+            final_input_types = ["any"]
+            final_converters = [self._convert_to_bool, *existing_converters]
+        else:
+            final_input_types = ["bool"]
+            final_converters = existing_converters
+
+        # Call parent with explicit parameters, following ControlParameter pattern
+        super().__init__(
+            name=name,
+            tooltip=tooltip,
+            type="bool",  # Always a boolean type for ParameterBool
+            input_types=final_input_types,
+            output_type="bool",  # Always output as boolean
+            default_value=default_value,
+            tooltip_as_input=tooltip_as_input,
+            tooltip_as_property=tooltip_as_property,
+            tooltip_as_output=tooltip_as_output,
+            allowed_modes=allowed_modes,
+            traits=traits,
+            converters=final_converters,
+            validators=validators,
+            ui_options=ui_options,
+            hide=hide,
+            hide_label=hide_label,
+            hide_property=hide_property,
+            allow_input=allow_input,
+            allow_property=allow_property,
+            allow_output=allow_output,
+            settable=settable,
+            serializable=serializable,
+            user_defined=user_defined,
+            element_id=element_id,
+            element_type=element_type,
+            parent_container_name=parent_container_name,
+        )
+
+    def _convert_to_bool(self, value: Any) -> bool:
+        """Safely convert any input value to a boolean.
+
+        Handles various input types including strings, numbers, and other objects.
+        Uses Python's built-in bool() conversion with proper handling of common
+        string representations.
+
+        Args:
+            value: The value to convert to boolean
+
+        Returns:
+            Boolean representation of the value
+        """
+        if value is None:
+            return False
+
+        # Handle boolean inputs
+        if isinstance(value, bool):
+            return value
+
+        # Handle string inputs with common boolean representations
+        if isinstance(value, str):
+            value_lower = value.lower().strip()
+            if value_lower in ("true", "yes", "on", "1", "enable", "enabled"):
+                return True
+            if value_lower in ("false", "no", "off", "0", "disable", "disabled"):
+                return False
+            # For other strings, use truthiness
+            return bool(value)
+
+        # For all other types (including numeric), use Python's built-in bool conversion
+        return bool(value)
+
+    @property
+    def on_label(self) -> str | None:
+        """Get the label for the "on" state.
+
+        Returns:
+            The on label if set, None otherwise
+        """
+        return self.ui_options.get("on_label")
+
+    @on_label.setter
+    def on_label(self, value: str | None) -> None:
+        """Set the label for the "on" state.
+
+        Args:
+            value: The on label to use, or None to remove it
+        """
+        if value is None:
+            ui_options = self.ui_options.copy()
+            ui_options.pop("on_label", None)
+            self.ui_options = ui_options
+        else:
+            self.update_ui_options_key("on_label", value)
+
+    @property
+    def off_label(self) -> str | None:
+        """Get the label for the "off" state.
+
+        Returns:
+            The off label if set, None otherwise
+        """
+        return self.ui_options.get("off_label")
+
+    @off_label.setter
+    def off_label(self, value: str | None) -> None:
+        """Set the label for the "off" state.
+
+        Args:
+            value: The off label to use, or None to remove it
+        """
+        if value is None:
+            ui_options = self.ui_options.copy()
+            ui_options.pop("off_label", None)
+            self.ui_options = ui_options
+        else:
+            self.update_ui_options_key("off_label", value)