flock-core 0.5.0b28__py3-none-any.whl → 0.5.56b0__py3-none-any.whl

flock/core/registry/type_registry.py

@@ -1,86 +0,0 @@
-# src/flock/core/registry/type_registry.py
-"""Type registration and lookup functionality."""
-
-import threading
-from typing import Any, Literal, Mapping, Optional, Sequence, TypeVar, Union
-
-from flock.core.logging.logging import get_logger
-
-logger = get_logger("registry.types")
-
-
-class TypeRegistry:
-    """Manages type registration and lookup with thread safety."""
-
-    def __init__(self, lock: threading.RLock):
-        self._lock = lock
-        self._types: dict[str, type] = {}
-        self._register_core_types()
-
-    def register_type(self, type_obj: type, name: str | None = None) -> str | None:
-        """Register a class/type (Pydantic, Dataclass, etc.) used in signatures."""
-        type_name = name or type_obj.__name__
-        if not type_name:
-            logger.error(f"Could not determine name for type: {type_obj}")
-            return None
-
-        with self._lock:
-            if type_name in self._types and self._types[type_name] != type_obj:
-                logger.warning(f"Type '{type_name}' already registered. Overwriting.")
-            
-            self._types[type_name] = type_obj
-            logger.debug(f"Registered type: {type_name}")
-            return type_name
-
-    def get_type(self, type_name: str) -> type:
-        """Retrieve a registered type by its name."""
-        with self._lock:
-            if type_name in self._types:
-                return self._types[type_name]
-            
-            # Consider adding dynamic import attempts for types if needed,
-            # but explicit registration is generally safer for types.
-            logger.warning(f"Type '{type_name}' not found in registry. Will attempt to build it from builtins.")
-            raise KeyError(f"Type '{type_name}' not found. Ensure it is registered.")
-
-    def get_all_types(self) -> dict[str, type]:
-        """Get all registered types."""
-        with self._lock:
-            return self._types.copy()
-
-    def clear(self) -> None:
-        """Clear all registered types (except core types)."""
-        with self._lock:
-            # Save core types
-            core_types = {
-                name: type_obj for name, type_obj in self._types.items()
-                if type_obj in [str, int, float, bool, list, dict, tuple, set, Any, Mapping, Sequence, TypeVar, Literal, Optional, Union]
-            }
-            self._types.clear()
-            self._types.update(core_types)
-            logger.debug("Cleared all registered types (keeping core types)")
-
-    def _register_core_types(self):
-        """Register common built-in and typing types."""
-        core_types = [
-            str,
-            int, 
-            float,
-            bool,
-            list,
-            dict,
-            tuple,
-            set,
-            Any,
-            Mapping,
-            Sequence,
-            TypeVar,
-            Literal,
-            Optional,
-            Union,  # Common typing generics
-        ]
-        for t in core_types:
-            try:
-                self.register_type(t)
-            except Exception as e:
-                logger.error(f"Failed to auto-register core type {t}: {e}")

flock/core/serialization/__init__.py

@@ -1,13 +0,0 @@
-"""Serialization utilities for Flock objects."""
-
-from flock.core.serialization.callable_registry import CallableRegistry
-from flock.core.serialization.json_encoder import FlockJSONEncoder
-from flock.core.serialization.secure_serializer import SecureSerializer
-from flock.core.serialization.serializable import Serializable
-
-__all__ = [
-    "CallableRegistry",
-    "FlockJSONEncoder",
-    "SecureSerializer",
-    "Serializable",
-]

flock/core/serialization/callable_registry.py

@@ -1,52 +0,0 @@
-"""Registry system for callable objects to support serialization."""
-
-from collections.abc import Callable
-
-
-class CallableRegistry:
-    """Registry for callable objects.
-
-    This class serves as a central registry for callable objects (functions, methods)
-    that can be referenced by name in serialized formats.
-
-    This is a placeholder implementation that will be fully implemented in task US007-T004.
-    """
-
-    _registry: dict[str, Callable] = {}
-
-    @classmethod
-    def register(cls, name: str, callable_obj: Callable) -> None:
-        """Register a callable object with the given name.
-
-        Args:
-            name: Unique name for the callable
-            callable_obj: Function or method to register
-        """
-        cls._registry[name] = callable_obj
-
-    @classmethod
-    def get(cls, name: str) -> Callable:
-        """Get a callable object by name.
-
-        Args:
-            name: Name of the callable to retrieve
-
-        Returns:
-            The registered callable
-
-        Raises:
-            KeyError: If no callable with the given name is registered
-        """
-        return cls._registry[name]
-
-    @classmethod
-    def contains(cls, name: str) -> bool:
-        """Check if a callable with the given name is registered.
-
-        Args:
-            name: Name to check
-
-        Returns:
-            True if registered, False otherwise
-        """
-        return name in cls._registry