griptape-nodes 0.55.1__py3-none-any.whl → 0.56.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/resource_components/resource_instance.py

@@ -0,0 +1,236 @@
+import logging
+from abc import ABC, abstractmethod
+from copy import deepcopy
+from typing import TYPE_CHECKING, Any
+from uuid import uuid4
+
+from griptape_nodes.retained_mode.managers.resource_components.comparator import Comparator
+
+if TYPE_CHECKING:
+    from griptape_nodes.retained_mode.managers.resource_components.resource_type import ResourceType
+
+logger = logging.getLogger("griptape_nodes")
+
+# Type aliases for resource requirements
+RequirementValue = (
+    Any  # Simple values: "present", 8, True
+    | tuple[Any, str]  # Tuple format: (8, ">"), ("cuda", "present")
+    | tuple[Any, Comparator]  # Enum format: (8, Comparator.GREATER_THAN)
+)
+Requirements = dict[str, RequirementValue]
+
+
+class ResourceInstance(ABC):
+    """Base class for resource instances that can be locked and managed."""
+
+    def __init__(self, resource_type: "ResourceType", instance_id_prefix: str, capabilities: dict[str, Any]):
+        self._resource_type = resource_type
+        self._capabilities = deepcopy(capabilities)
+        self._instance_id = f"{instance_id_prefix}_{uuid4()}"
+        self._locked_by = None
+
+    def get_resource_type(self) -> "ResourceType":
+        """Get the resource type of this instance."""
+        return self._resource_type
+
+    def get_capabilities(self) -> list[str]:
+        """Get the capability keys available for this resource."""
+        return list(self._capabilities.keys())
+
+    def has_capability(self, key: str) -> bool:
+        """Check if resource has a specific capability key."""
+        return key in self._capabilities
+
+    def get_capability_value(self, key: str) -> Any:
+        """Get a specific capability value.
+
+        This method can be overridden by subclasses to support volatile resources
+        that require real-time queries (e.g., current memory usage, GPU temperature)
+        or resources that need external API calls to retrieve current values.
+
+        The default implementation returns the static value from the capabilities dict.
+        """
+        return self._capabilities[key]
+
+    def get_instance_id(self) -> str:
+        """Unique handle/ID for this instance."""
+        return self._instance_id
+
+    def acquire_lock(self, owner_id: str) -> None:
+        """Acquire exclusive lock.
+
+        Args:
+            owner_id: The ID of the entity requesting the lock
+
+        Raises:
+            ValueError: If the resource is already locked by another owner
+        """
+        if self._locked_by is not None:
+            if self._locked_by == owner_id:
+                # Already locked by the same owner - this is fine
+                return
+            msg = f"Resource {self._instance_id} is already locked by {self._locked_by}, cannot lock for {owner_id}"
+            raise ValueError(msg)
+
+        self._locked_by = owner_id
+        logger.debug("Resource %s locked by %s", self._instance_id, owner_id)
+
+    def release_lock(self, owner_id: str) -> None:
+        """Release lock.
+
+        Args:
+            owner_id: The ID of the entity releasing the lock
+
+        Raises:
+            ValueError: If the resource is not locked by the specified owner
+        """
+        if self._locked_by != owner_id:
+            if self._locked_by is None:
+                msg = f"Resource {self._instance_id} is not locked, cannot release for {owner_id}"
+            else:
+                msg = f"Resource {self._instance_id} is locked by {self._locked_by}, cannot release for {owner_id}"
+            raise ValueError(msg)
+
+        self._locked_by = None
+        logger.debug("Resource %s unlocked by %s", self._instance_id, owner_id)
+
+    def is_locked(self) -> bool:
+        """Check if resource is currently locked."""
+        return self._locked_by is not None
+
+    def is_locked_by(self, owner_id: str) -> bool:
+        """Check if resource is locked by specific owner."""
+        return self._locked_by == owner_id
+
+    def get_lock_owner(self) -> str | None:
+        """Get the current lock owner, if any."""
+        return self._locked_by
+
+    def force_unlock(self) -> None:
+        """Force unlock this resource instance (for administrative operations)."""
+        self._locked_by = None
+
+    def get_all_capabilities_and_current_values(self) -> dict[str, Any]:
+        """Get the complete capabilities dictionary with current values.
+
+        This method returns all capability keys and their current values, which may
+        include real-time queries for volatile resources that override get_capability_value().
+        Returns a deep copy to prevent external modification of nested mutable objects.
+        """
+        # First get current values (may trigger real-time queries for volatile resources)
+        result = {key: self.get_capability_value(key) for key in self._capabilities}
+        # Then deep copy to protect against modification of nested mutable objects
+        return deepcopy(result)
+
+    def is_compatible_with(self, requirements: Requirements | None) -> bool:
+        """Check if this instance can satisfy the requirements."""
+        if requirements is None:
+            return True
+
+        for key, req_spec in requirements.items():
+            # Handle both tuple and non-tuple formats
+            if isinstance(req_spec, tuple):
+                required_value, comparator_str = req_spec
+            else:
+                required_value, comparator_str = req_spec, Comparator.EQUALS
+
+            # Convert string to StrEnum
+            comparator = Comparator(comparator_str)
+
+            if not self._compare_values(key, required_value, comparator):
+                return False
+        return True
+
+    def _compare_values(self, key: str, required: Any, comparator: Comparator) -> bool:
+        """Compare actual capability value against required value using comparator."""
+        match comparator:
+            case Comparator.NOT_PRESENT:
+                return key not in self._capabilities
+            case _:
+                # For all other comparators, key must exist
+                if key not in self._capabilities:
+                    return False
+                actual = self._capabilities[key]
+                return self._apply_comparator(actual, required, comparator, key)
+
+    def _apply_comparator(self, actual: Any, required: Any, comparator: Comparator, key: str) -> bool:
+        """Apply the comparator operation."""
+        match comparator:
+            case Comparator.EQUALS:
+                return actual == required
+            case Comparator.NOT_EQUALS:
+                return actual != required
+            case (
+                Comparator.GREATER_THAN_OR_EQUAL
+                | Comparator.GREATER_THAN
+                | Comparator.LESS_THAN_OR_EQUAL
+                | Comparator.LESS_THAN
+            ):
+                return self._apply_numeric_comparator(actual, required, comparator)
+            case Comparator.STARTS_WITH | Comparator.INCLUDES:
+                return self._apply_string_comparator(actual, required, comparator)
+            case Comparator.HAS_ANY | Comparator.HAS_ALL:
+                return self._apply_container_comparator(actual, required, comparator, key)
+            case Comparator.CUSTOM:
+                return self._resource_type.handle_custom_requirement(
+                    _instance=self,
+                    _key=key,
+                    _requirement_value=required,
+                    _actual_value=actual,
+                    _capabilities=self._capabilities,
+                )
+            case _:
+                msg = f"Unknown comparator: {comparator}"
+                raise ValueError(msg)
+
+    def _apply_numeric_comparator(self, actual: Any, required: Any, comparator: Comparator) -> bool:
+        """Apply numeric comparison operators."""
+        match comparator:
+            case Comparator.GREATER_THAN_OR_EQUAL:
+                return actual >= required
+            case Comparator.GREATER_THAN:
+                return actual > required
+            case Comparator.LESS_THAN_OR_EQUAL:
+                return actual <= required
+            case Comparator.LESS_THAN:
+                return actual < required
+            case _:
+                msg = f"Invalid numeric comparator: {comparator}"
+                raise ValueError(msg)
+
+    def _apply_string_comparator(self, actual: Any, required: Any, comparator: Comparator) -> bool:
+        """Apply string comparison operators."""
+        match comparator:
+            case Comparator.STARTS_WITH:
+                return str(actual).startswith(str(required))
+            case Comparator.INCLUDES:
+                return str(required) in str(actual)
+            case _:
+                msg = f"Invalid string comparator: {comparator}"
+                raise ValueError(msg)
+
+    def _apply_container_comparator(self, actual: Any, required: Any, comparator: Comparator, key: str) -> bool:
+        """Apply container comparison operators."""
+        if not hasattr(actual, "__iter__") or isinstance(actual, str):
+            msg = f"{comparator} comparator requires capability '{key}' to be a container, got {type(actual)}"
+            raise ValueError(msg)
+        if not hasattr(required, "__iter__") or isinstance(required, str):
+            msg = f"{comparator} comparator requires requirement value to be a container, got {type(required)}"
+            raise ValueError(msg)
+
+        match comparator:
+            case Comparator.HAS_ANY:
+                return any(item in actual for item in required)
+            case Comparator.HAS_ALL:
+                return all(item in actual for item in required)
+            case _:
+                msg = f"Invalid container comparator: {comparator}"
+                raise ValueError(msg)
+
+    @abstractmethod
+    def can_be_freed(self) -> bool:
+        """Check if this resource can be safely freed."""
+
+    @abstractmethod
+    def free(self) -> None:
+        """Free this resource instance."""

griptape_nodes/retained_mode/managers/resource_components/resource_type.py

@@ -0,0 +1,79 @@
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from griptape_nodes.retained_mode.managers.resource_components.capability_field import CapabilityField
+    from griptape_nodes.retained_mode.managers.resource_components.resource_instance import (
+        Requirements,
+        ResourceInstance,
+    )
+
+
+class ResourceType(ABC):
+    """Base class for resource type handlers."""
+
+    @abstractmethod
+    def get_capability_schema(self) -> list["CapabilityField"]:
+        """Get the capability schema for this resource type."""
+
+    @abstractmethod
+    def create_instance(self, capabilities: dict[str, Any]) -> "ResourceInstance":
+        """Create a resource instance with the specified capabilities."""
+
+    def select_best_compatible_instance(
+        self, compatible_instances: list["ResourceInstance"], _requirements: "Requirements | None" = None
+    ) -> "ResourceInstance | None":
+        """Select the best instance from pre-filtered compatible instances.
+
+        Args:
+            compatible_instances: List of instances that are already known to be compatible
+            _requirements: The original requirements dict for context
+
+        Returns:
+            The best instance to use, or None if none are suitable
+
+        Note:
+            All instances in compatible_instances are guaranteed to satisfy the requirements.
+            This method allows ResourceType implementations to apply their own selection
+            logic (e.g., prefer instances with more resources, least used, etc.).
+        """
+        # Default behavior: return the first compatible instance if available
+        # Implementors can override this method to provide more optimized instance selection
+        return compatible_instances[0] if compatible_instances else None
+
+    def handle_custom_requirement(
+        self,
+        *,
+        _instance: "ResourceInstance",
+        _key: str,
+        _requirement_value: Any,
+        _actual_value: Any,
+        _capabilities: dict[str, Any],
+    ) -> bool:
+        """Handle custom requirement logic with full context.
+
+        This method is called when a requirement uses the Comparator.CUSTOM comparator,
+        allowing ResourceType implementations to define complex comparison logic that
+        goes beyond the standard built-in comparators.
+
+        Use cases for custom comparators:
+        - Complex mathematical relationships (e.g., GPU memory + system memory > threshold)
+        - Version compatibility checks (e.g., CUDA version compatibility matrices)
+        - Hardware compatibility logic (e.g., CPU instruction set compatibility)
+        - Multi-field validation (e.g., ensuring RAM and CPU are balanced)
+
+        Args:
+            _instance: The resource instance being evaluated
+            _key: The requirement key being evaluated
+            _requirement_value: The value from the requirements dict
+            _actual_value: The actual capability value
+            _capabilities: Full capabilities dict for context
+
+        Returns:
+            True if the custom requirement is satisfied, False otherwise
+
+        Raises:
+            NotImplementedError: If the ResourceType doesn't implement custom logic
+        """
+        msg = f"Custom requirement handling not implemented for {type(self).__name__}"
+        raise NotImplementedError(msg)

griptape_nodes/retained_mode/managers/resource_manager.py

@@ -0,0 +1,306 @@
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from griptape_nodes.retained_mode.events.base_events import ResultPayload
+from griptape_nodes.retained_mode.events.resource_events import (
+    AcquireResourceInstanceLockRequest,
+    AcquireResourceInstanceLockResultFailure,
+    AcquireResourceInstanceLockResultSuccess,
+    CreateResourceInstanceRequest,
+    CreateResourceInstanceResultFailure,
+    CreateResourceInstanceResultSuccess,
+    FreeResourceInstanceRequest,
+    FreeResourceInstanceResultFailure,
+    FreeResourceInstanceResultSuccess,
+    GetResourceInstanceStatusRequest,
+    GetResourceInstanceStatusResultFailure,
+    GetResourceInstanceStatusResultSuccess,
+    ListCompatibleResourceInstancesRequest,
+    ListCompatibleResourceInstancesResultFailure,
+    ListCompatibleResourceInstancesResultSuccess,
+    ListRegisteredResourceTypesRequest,
+    ListRegisteredResourceTypesResultSuccess,
+    ListResourceInstancesByTypeRequest,
+    ListResourceInstancesByTypeResultFailure,
+    ListResourceInstancesByTypeResultSuccess,
+    RegisterResourceTypeRequest,
+    RegisterResourceTypeResultSuccess,
+    ReleaseResourceInstanceLockRequest,
+    ReleaseResourceInstanceLockResultFailure,
+    ReleaseResourceInstanceLockResultSuccess,
+)
+from griptape_nodes.retained_mode.managers.event_manager import EventManager
+from griptape_nodes.retained_mode.managers.resource_components.resource_type import ResourceType
+
+if TYPE_CHECKING:
+    from griptape_nodes.retained_mode.managers.resource_components.resource_instance import ResourceInstance
+
+logger = logging.getLogger("griptape_nodes")
+
+
+@dataclass
+class ResourceStatus:
+    resource_type: ResourceType
+    instance_id: str
+    owner_of_lock: str | None
+    capabilities: dict[str, Any]
+
+    def is_locked(self) -> bool:
+        """Check if this resource is currently locked."""
+        return self.owner_of_lock is not None
+
+
+class ResourceManager:
+    """Manager for resource allocation, locking, and lifecycle management."""
+
+    def __init__(self, event_manager: EventManager) -> None:
+        self._resource_types: set[ResourceType] = set()
+        # Maps instance_id to ResourceInstance objects
+        self._instances: dict[str, ResourceInstance] = {}
+
+        # Register event handlers
+        event_manager.assign_manager_to_request_type(
+            request_type=ListRegisteredResourceTypesRequest, callback=self.on_list_registered_resource_types_request
+        )
+        event_manager.assign_manager_to_request_type(
+            request_type=RegisterResourceTypeRequest, callback=self.on_register_resource_type_request
+        )
+        event_manager.assign_manager_to_request_type(
+            request_type=CreateResourceInstanceRequest, callback=self.on_create_resource_instance_request
+        )
+        event_manager.assign_manager_to_request_type(
+            request_type=FreeResourceInstanceRequest, callback=self.on_free_resource_instance_request
+        )
+        event_manager.assign_manager_to_request_type(
+            request_type=AcquireResourceInstanceLockRequest, callback=self.on_acquire_resource_instance_lock_request
+        )
+        event_manager.assign_manager_to_request_type(
+            request_type=ReleaseResourceInstanceLockRequest, callback=self.on_release_resource_instance_lock_request
+        )
+        event_manager.assign_manager_to_request_type(
+            request_type=ListCompatibleResourceInstancesRequest,
+            callback=self.on_list_compatible_resource_instances_request,
+        )
+        event_manager.assign_manager_to_request_type(
+            request_type=GetResourceInstanceStatusRequest, callback=self.on_get_resource_instance_status_request
+        )
+        event_manager.assign_manager_to_request_type(
+            request_type=ListResourceInstancesByTypeRequest, callback=self.on_list_resource_instances_by_type_request
+        )
+
+    # Public Event Handlers
+    def on_list_registered_resource_types_request(self, _request: ListRegisteredResourceTypesRequest) -> ResultPayload:
+        """Handle request to list all registered resource types."""
+        type_names = []
+        for rt in self._resource_types:
+            type_names.append(type(rt).__name__)  # noqa: PERF401
+
+        return ListRegisteredResourceTypesResultSuccess(
+            resource_type_names=type_names, result_details="Successfully listed registered resource types"
+        )
+
+    def on_register_resource_type_request(self, request: RegisterResourceTypeRequest) -> ResultPayload:
+        """Handle request to register a new resource type."""
+        self._resource_types.add(request.resource_type)
+
+        return RegisterResourceTypeResultSuccess(
+            result_details=f"Successfully registered resource type {type(request.resource_type).__name__}"
+        )
+
+    def on_create_resource_instance_request(self, request: CreateResourceInstanceRequest) -> ResultPayload:
+        """Handle request to create a new resource instance."""
+        resource_type = self._get_resource_type_by_name(request.resource_type_name)
+        if not resource_type:
+            return CreateResourceInstanceResultFailure(
+                result_details=f"Attempted to create resource instance with resource type {request.resource_type_name} and capabilities {request.capabilities}. Failed due to resource type not found."
+            )
+
+        try:
+            new_instance = resource_type.create_instance(request.capabilities)
+        except Exception as e:
+            return CreateResourceInstanceResultFailure(
+                result_details=f"Attempted to create resource instance with resource type {request.resource_type_name} and capabilities {request.capabilities}. Failed due to resource type creation failed: {e}."
+            )
+
+        instance_id = new_instance.get_instance_id()
+        self._instances[instance_id] = new_instance
+
+        return CreateResourceInstanceResultSuccess(
+            instance_id=instance_id, result_details=f"Successfully created resource instance {instance_id}"
+        )
+
+    def on_free_resource_instance_request(self, request: FreeResourceInstanceRequest) -> ResultPayload:
+        """Handle request to free a resource instance."""
+        instance = self._instances.get(request.instance_id)
+        if instance is None:
+            return FreeResourceInstanceResultFailure(
+                result_details=f"Attempted to free resource instance {request.instance_id} with force_unlock={request.force_unlock}. Failed due to resource instance does not exist."
+            )
+
+        # Check if resource can be safely freed before touching locks
+        if not instance.can_be_freed():
+            return FreeResourceInstanceResultFailure(
+                result_details=f"Resource instance {request.instance_id} cannot be freed and therefore cannot be deleted."
+            )
+
+        if instance.is_locked():
+            if not request.force_unlock:
+                owner = instance.get_lock_owner()
+                return FreeResourceInstanceResultFailure(
+                    result_details=f"Attempted to free resource instance {request.instance_id} with force_unlock={request.force_unlock}. Failed due to resource instance is locked by {owner}."
+                )
+
+            owner = instance.get_lock_owner()
+            instance.force_unlock()
+
+        try:
+            instance.free()
+        except Exception as e:
+            return FreeResourceInstanceResultFailure(
+                result_details=f"Attempted to free resource instance {request.instance_id} with force_unlock={request.force_unlock}. Failed to free: {e}."
+            )
+
+        del self._instances[request.instance_id]
+
+        return FreeResourceInstanceResultSuccess(
+            result_details=f"Successfully freed resource instance {request.instance_id}"
+        )
+
+    def on_acquire_resource_instance_lock_request(self, request: AcquireResourceInstanceLockRequest) -> ResultPayload:
+        """Handle request to acquire a resource instance lock."""
+        resource_type = self._get_resource_type_by_name(request.resource_type_name)
+        if not resource_type:
+            return AcquireResourceInstanceLockResultFailure(
+                result_details=f"Attempted to acquire resource instance lock for owner {request.owner_id} with resource type {request.resource_type_name} and requirements {request.requirements}. Failed due to resource type not found."
+            )
+
+        # Get compatible unlocked instances
+        compatible_instances = []
+        for instance in self._instances.values():
+            if instance.is_locked():
+                continue
+            if instance.get_resource_type() != resource_type:
+                continue
+            if request.requirements is None:
+                compatible_instances.append(instance)
+                continue
+            if instance.is_compatible_with(request.requirements):
+                compatible_instances.append(instance)
+
+        best_instance = resource_type.select_best_compatible_instance(compatible_instances, request.requirements)
+        if not best_instance:
+            return AcquireResourceInstanceLockResultFailure(
+                result_details=f"Attempted to acquire resource instance lock for owner {request.owner_id} with resource type {request.resource_type_name} and requirements {request.requirements}. Failed due to no compatible resource instances available."
+            )
+
+        try:
+            best_instance.acquire_lock(request.owner_id)
+        except Exception as e:
+            return AcquireResourceInstanceLockResultFailure(
+                result_details=f"Attempted to acquire resource instance lock for owner {request.owner_id} with resource type {request.resource_type_name} and requirements {request.requirements}. Failed due to lock acquisition failed: {e}."
+            )
+
+        instance_id = best_instance.get_instance_id()
+
+        return AcquireResourceInstanceLockResultSuccess(
+            instance_id=instance_id,
+            result_details=f"Successfully acquired lock on resource instance {instance_id} for {request.owner_id}",
+        )
+
+    def on_release_resource_instance_lock_request(self, request: ReleaseResourceInstanceLockRequest) -> ResultPayload:
+        """Handle request to release a resource instance lock."""
+        instance = self._instances.get(request.instance_id)
+        if instance is None:
+            return ReleaseResourceInstanceLockResultFailure(
+                result_details=f"Attempted to release resource instance lock on {request.instance_id} for owner {request.owner_id}. Failed due to resource instance does not exist."
+            )
+
+        try:
+            instance.release_lock(request.owner_id)
+        except Exception as e:
+            return ReleaseResourceInstanceLockResultFailure(
+                result_details=f"Attempted to release resource instance lock on {request.instance_id} for owner {request.owner_id}. Failed due to lock release failed: {e}."
+            )
+
+        return ReleaseResourceInstanceLockResultSuccess(
+            result_details=f"Successfully released lock on resource instance {request.instance_id} from {request.owner_id}"
+        )
+
+    def on_list_compatible_resource_instances_request(
+        self, request: ListCompatibleResourceInstancesRequest
+    ) -> ResultPayload:
+        """Handle request to list compatible resource instances."""
+        resource_type = self._get_resource_type_by_name(request.resource_type_name)
+        if not resource_type:
+            return ListCompatibleResourceInstancesResultFailure(
+                result_details=f"Attempted to list compatible resource instances with resource type {request.resource_type_name}, requirements {request.requirements}, and include_locked={request.include_locked}. Failed due to resource type not found."
+            )
+
+        # Get compatible instances (with optional locked instances)
+        instance_ids = []
+        for instance in self._instances.values():
+            if instance.is_locked() and not request.include_locked:
+                continue
+            if instance.get_resource_type() != resource_type:
+                continue
+            if request.requirements is None:
+                instance_ids.append(instance.get_instance_id())
+                continue
+            if instance.is_compatible_with(request.requirements):
+                instance_ids.append(instance.get_instance_id())
+
+        return ListCompatibleResourceInstancesResultSuccess(
+            instance_ids=instance_ids,
+            result_details=f"Successfully found {len(instance_ids)} compatible resource instances",
+        )
+
+    def on_get_resource_instance_status_request(self, request: GetResourceInstanceStatusRequest) -> ResultPayload:
+        """Handle request to get resource instance status."""
+        instance = self._instances.get(request.instance_id)
+        if instance is None:
+            return GetResourceInstanceStatusResultFailure(
+                result_details=f"Attempted to get resource instance status for {request.instance_id}. Failed due to resource instance not found."
+            )
+
+        status = ResourceStatus(
+            resource_type=instance.get_resource_type(),
+            instance_id=request.instance_id,
+            owner_of_lock=instance.get_lock_owner(),
+            capabilities=instance.get_all_capabilities_and_current_values(),
+        )
+
+        return GetResourceInstanceStatusResultSuccess(
+            status=status,
+            result_details=f"Successfully retrieved status for resource instance {request.instance_id}",
+        )
+
+    def on_list_resource_instances_by_type_request(self, request: ListResourceInstancesByTypeRequest) -> ResultPayload:
+        """Handle request to list resource instances by type."""
+        resource_type = self._get_resource_type_by_name(request.resource_type_name)
+        if not resource_type:
+            return ListResourceInstancesByTypeResultFailure(
+                result_details=f"Attempted to list resource instances by type {request.resource_type_name} with include_locked={request.include_locked}. Failed due to resource type not found."
+            )
+
+        matching_instances = []
+        for instance in self._instances.values():
+            if instance.get_resource_type() != resource_type:
+                continue
+            if not request.include_locked and instance.is_locked():
+                continue
+            matching_instances.append(instance.get_instance_id())
+
+        return ListResourceInstancesByTypeResultSuccess(
+            instance_ids=matching_instances,
+            result_details=f"Successfully found {len(matching_instances)} resource instances of specified type",
+        )
+
+    # Private Implementation Methods
+
+    def _get_resource_type_by_name(self, name: str) -> ResourceType | None:
+        """Get a registered resource type by its class name."""
+        for resource_type in self._resource_types:
+            if type(resource_type).__name__ == name:
+                return resource_type
+        return None

griptape_nodes/retained_mode/managers/resource_types/__init__.py

@@ -0,0 +1 @@
+"""Resource types package containing concrete resource type implementations."""