tactus 0.34.1__py3-none-any.whl → 0.35.1__py3-none-any.whl

tactus/core/dependencies/registry.py

@@ -5,9 +5,9 @@ This module provides the infrastructure for declaring, creating, and managing
 external dependencies (HTTP clients, databases, caches) that procedures need.
 """
 
-from enum import Enum
-from typing import Dict, Any
 import logging
+from enum import Enum
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -29,13 +29,13 @@ class ResourceFactory:
     """
 
     @staticmethod
-    async def create(resource_type: str, config: Dict[str, Any]) -> Any:
+    async def create(resource_type: str, resource_config: dict[str, Any]) -> Any:
         """
         Create a real resource from configuration.
 
         Args:
             resource_type: Type of resource (http_client, postgres, redis)
-            config: Configuration dictionary from procedure DSL
+            resource_config: Configuration dictionary from procedure DSL
 
         Returns:
             Configured resource instance
@@ -45,16 +45,15 @@ class ResourceFactory:
             ImportError: If required library is not installed
         """
         if resource_type == ResourceType.HTTP_CLIENT.value:
-            return await ResourceFactory._create_http_client(config)
-        elif resource_type == ResourceType.POSTGRES.value:
-            return await ResourceFactory._create_postgres(config)
-        elif resource_type == ResourceType.REDIS.value:
-            return await ResourceFactory._create_redis(config)
-        else:
-            raise ValueError(f"Unknown resource type: {resource_type}")
+            return await ResourceFactory._create_http_client(resource_config)
+        if resource_type == ResourceType.POSTGRES.value:
+            return await ResourceFactory._create_postgres(resource_config)
+        if resource_type == ResourceType.REDIS.value:
+            return await ResourceFactory._create_redis(resource_config)
+        raise ValueError(f"Unknown resource type: {resource_type}")
 
     @staticmethod
-    async def _create_http_client(config: Dict[str, Any]) -> Any:
+    async def _create_http_client(resource_config: dict[str, Any]) -> Any:
         """Create HTTP client (httpx.AsyncClient)."""
         try:
             import httpx
@@ -63,16 +62,20 @@ class ResourceFactory:
                 "httpx is required for HTTP client dependencies. Install it with: pip install httpx"
             )
 
-        base_url = config.get("base_url")
-        headers = config.get("headers", {})
-        timeout = config.get("timeout", 30.0)
+        base_url = resource_config.get("base_url")
+        headers = resource_config.get("headers", {})
+        timeout_seconds = resource_config.get("timeout", 30.0)
 
-        logger.info(f"Creating HTTP client for base_url={base_url}")
+        logger.info("Creating HTTP client for base_url=%s", base_url)
 
-        return httpx.AsyncClient(base_url=base_url, headers=headers, timeout=timeout)
+        return httpx.AsyncClient(
+            base_url=base_url,
+            headers=headers,
+            timeout=timeout_seconds,
+        )
 
     @staticmethod
-    async def _create_postgres(config: Dict[str, Any]) -> Any:
+    async def _create_postgres(resource_config: dict[str, Any]) -> Any:
         """Create PostgreSQL connection pool (asyncpg.Pool)."""
         try:
             import asyncpg
@@ -82,18 +85,18 @@ class ResourceFactory:
                 "Install it with: pip install asyncpg"
             )
 
-        connection_string = config["connection_string"]
-        pool_size = config.get("pool_size", 10)
-        max_pool_size = config.get("max_pool_size", 20)
+        connection_string = resource_config["connection_string"]
+        pool_size = resource_config.get("pool_size", 10)
+        max_pool_size = resource_config.get("max_pool_size", 20)
 
-        logger.info(f"Creating PostgreSQL pool with size={pool_size}")
+        logger.info("Creating PostgreSQL pool with size=%s", pool_size)
 
         return await asyncpg.create_pool(
             connection_string, min_size=pool_size, max_size=max_pool_size
         )
 
     @staticmethod
-    async def _create_redis(config: Dict[str, Any]) -> Any:
+    async def _create_redis(resource_config: dict[str, Any]) -> Any:
         """Create Redis client (redis.asyncio.Redis)."""
         try:
             import redis.asyncio as redis
@@ -102,14 +105,14 @@ class ResourceFactory:
                 "redis is required for Redis dependencies. Install it with: pip install redis"
             )
 
-        url = config["url"]
+        url = resource_config["url"]
 
-        logger.info(f"Creating Redis client for url={url}")
+        logger.info("Creating Redis client for url=%s", url)
 
         return redis.from_url(url, encoding="utf-8", decode_responses=True)
 
     @staticmethod
-    async def create_all(dependencies_config: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
+    async def create_all(dependencies_config: dict[str, dict[str, Any]]) -> dict[str, Any]:
         """
         Create all dependencies from configuration.
 
@@ -119,15 +122,21 @@ class ResourceFactory:
         Returns:
             Dict mapping dependency name to created resource
         """
-        resources = {}
+        resources: dict[str, Any] = {}
 
-        for name, config in dependencies_config.items():
-            resource_type = config.get("type")
+        for dependency_name, dependency_config in dependencies_config.items():
+            resource_type = dependency_config.get("type")
             if not resource_type:
-                raise ValueError(f"Dependency '{name}' missing 'type' field")
+                raise ValueError(f"Dependency '{dependency_name}' missing 'type' field")
 
-            logger.info(f"Creating dependency '{name}' of type '{resource_type}'")
-            resources[name] = await ResourceFactory.create(resource_type, config)
+            logger.info(
+                "Creating dependency '%s' of type '%s'",
+                dependency_name,
+                resource_type,
+            )
+            resources[dependency_name] = await ResourceFactory.create(
+                resource_type, dependency_config
+            )
 
         return resources
 
@@ -141,40 +150,49 @@ class ResourceManager:
     """
 
     def __init__(self):
-        self.resources: Dict[str, Any] = {}
+        self.resources: dict[str, Any] = {}
 
     async def add_resource(self, name: str, resource: Any) -> None:
         """Add a resource to be managed."""
         self.resources[name] = resource
-        logger.debug(f"Added resource '{name}' to manager")
+        logger.debug("Added resource '%s' to manager", name)
 
     async def cleanup(self) -> None:
         """Clean up all managed resources."""
-        logger.info(f"Cleaning up {len(self.resources)} resources")
+        logger.info("Cleaning up %s resources", len(self.resources))
 
-        for name, resource in self.resources.items():
+        for resource_name, resource in self.resources.items():
             try:
-                await self._cleanup_resource(name, resource)
-            except Exception as e:
-                logger.error(f"Error cleaning up resource '{name}': {e}")
-
-    async def _cleanup_resource(self, name: str, resource: Any) -> None:
+                await self._cleanup_resource(resource_name, resource)
+            except Exception as exception:
+                logger.error(
+                    "Error cleaning up resource '%s': %s",
+                    resource_name,
+                    exception,
+                )
+
+    async def _cleanup_resource(self, resource_name: str, resource: Any) -> None:
         """Clean up a single resource based on its type."""
         # HTTP client cleanup
         if hasattr(resource, "aclose"):
-            logger.debug(f"Closing HTTP client '{name}'")
+            logger.debug("Closing HTTP client '%s'", resource_name)
             await resource.aclose()
+            return
 
         # PostgreSQL pool cleanup
-        elif hasattr(resource, "close") and hasattr(resource, "wait_closed"):
-            logger.debug(f"Closing PostgreSQL pool '{name}'")
+        if hasattr(resource, "close") and hasattr(resource, "wait_closed"):
+            logger.debug("Closing PostgreSQL pool '%s'", resource_name)
             await resource.close()
             await resource.wait_closed()
+            return
 
         # Redis client cleanup
-        elif hasattr(resource, "close") and not hasattr(resource, "wait_closed"):
-            logger.debug(f"Closing Redis client '{name}'")
+        if hasattr(resource, "close") and not hasattr(resource, "wait_closed"):
+            logger.debug("Closing Redis client '%s'", resource_name)
             await resource.close()
+            return
 
-        else:
-            logger.warning(f"Unknown resource type for '{name}', no cleanup performed")
+        logger.warning(
+            "Unknown resource type for '%s', no cleanup performed",
+            resource_name,
+        )