hexcore 2.5.0__tar.gz → 3.0.0__tar.gz

{hexcore-2.5.0/hexcore.egg-info → hexcore-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexcore
-Version: 2.5.0
+Version: 3.0.0
 Summary: Núcleo reutilizable para proyectos Python con arquitectura hexagonal y event handling. Provee abstracciones, utilidades y contratos para DDD, eventos y desacoplamiento de infraestructura.
 Author-email: "David Latosefki (Indroic)" <indroic@outlook.com>
 License-Expression: MIT
@@ -297,7 +297,7 @@ HexCore v2 integra de forma nativa soporte para el patrón **CQRS (Command Query
 
 El sistema se basa en 3 buses principales, configurables e independientes:
 
-1. **`AbstractCommandBus`**: Despacha inteniones de mutación (`Command`) a un único `AbstractCommandHandler`. Los commands modifican el estado del sistema y se ejecutan (por defecto) dentro de una transacción de base de datos (Unit of Work).
+1. **`AbstractCommandBus`**: Despacha inteniones de mutación (`Command`) a un único `AbstractCommandHandler`. Los commands modifican el estado del sistema. La transacción la gestiona el handler (el patrón que enseñan los ejemplos de use case); si preferís que la gestione el bus, añadí `TransactionMiddleware` explícitamente con su `uow_factory`.
 2. **`AbstractQueryBus`**: Despacha intenciones de lectura (`Query`) a un único `AbstractQueryHandler`. Retornan un resultado sin mutar el estado.
 3. **`EventBus`**: Distribuye eventos de dominio (`DomainEvent`) a múltiples suscriptores asíncronamente (vía `subscribe`/`publish`).
 
@@ -310,8 +310,9 @@ from hexcore.application.cqrs.config import CQRSConfig, BusConfig
 config = ServerConfig(
     cqrs=CQRSConfig(
         command_bus=BusConfig(
-            # Por defecto incluye TransactionMiddleware
-            middlewares=["hexcore.infrastructure.cqrs.middlewares.TransactionMiddleware"]
+            # Sin middlewares por defecto. Los que no necesitan configuración se
+            # pueden declarar por dotted path:
+            middlewares=["hexcore.infrastructure.cqrs.middlewares.LoggingMiddleware"]
         ),
         # Puedes sustituir el backend en memoria por uno distribuido (Ej: Celery, Procrastinate)
         # backend="mi_app.infrastructure.ProcrastinateCommandBus" 
@@ -319,6 +320,15 @@ config = ServerConfig(
 )
 ```
 
+> **`TransactionMiddleware` no es el default.** Comitea después del handler, así que
+> con un handler que ya gestiona su propia transacción comitearías dos veces. Y
+> necesita un `uow_factory` construido con *tu* engine, cosa que no se puede expresar
+> como dotted path: instancialo a mano y pasá el pipeline al bus.
+>
+> ```python
+> TransactionMiddleware(uow_factory=lambda: SqlAlchemyUnitOfWork(session=session_factory()))
+> ```
+
 ---
 
 ### Guía de Migración: De Casos de Uso Clásicos a CQRS

{hexcore-2.5.0 → hexcore-3.0.0}/README.md

@@ -252,7 +252,7 @@ HexCore v2 integra de forma nativa soporte para el patrón **CQRS (Command Query
 
 El sistema se basa en 3 buses principales, configurables e independientes:
 
-1. **`AbstractCommandBus`**: Despacha inteniones de mutación (`Command`) a un único `AbstractCommandHandler`. Los commands modifican el estado del sistema y se ejecutan (por defecto) dentro de una transacción de base de datos (Unit of Work).
+1. **`AbstractCommandBus`**: Despacha inteniones de mutación (`Command`) a un único `AbstractCommandHandler`. Los commands modifican el estado del sistema. La transacción la gestiona el handler (el patrón que enseñan los ejemplos de use case); si preferís que la gestione el bus, añadí `TransactionMiddleware` explícitamente con su `uow_factory`.
 2. **`AbstractQueryBus`**: Despacha intenciones de lectura (`Query`) a un único `AbstractQueryHandler`. Retornan un resultado sin mutar el estado.
 3. **`EventBus`**: Distribuye eventos de dominio (`DomainEvent`) a múltiples suscriptores asíncronamente (vía `subscribe`/`publish`).
 
@@ -265,8 +265,9 @@ from hexcore.application.cqrs.config import CQRSConfig, BusConfig
 config = ServerConfig(
     cqrs=CQRSConfig(
         command_bus=BusConfig(
-            # Por defecto incluye TransactionMiddleware
-            middlewares=["hexcore.infrastructure.cqrs.middlewares.TransactionMiddleware"]
+            # Sin middlewares por defecto. Los que no necesitan configuración se
+            # pueden declarar por dotted path:
+            middlewares=["hexcore.infrastructure.cqrs.middlewares.LoggingMiddleware"]
         ),
         # Puedes sustituir el backend en memoria por uno distribuido (Ej: Celery, Procrastinate)
         # backend="mi_app.infrastructure.ProcrastinateCommandBus" 
@@ -274,6 +275,15 @@ config = ServerConfig(
 )
 ```
 
+> **`TransactionMiddleware` no es el default.** Comitea después del handler, así que
+> con un handler que ya gestiona su propia transacción comitearías dos veces. Y
+> necesita un `uow_factory` construido con *tu* engine, cosa que no se puede expresar
+> como dotted path: instancialo a mano y pasá el pipeline al bus.
+>
+> ```python
+> TransactionMiddleware(uow_factory=lambda: SqlAlchemyUnitOfWork(session=session_factory()))
+> ```
+
 ---
 
 ### Guía de Migración: De Casos de Uso Clásicos a CQRS

{hexcore-2.5.0 → hexcore-3.0.0}/hexcore/application/cqrs/config.py

@@ -55,13 +55,12 @@ class CQRSConfig(BaseModel):
     """
 
     enabled: bool = True
-    command_bus: BusConfig = Field(
-        default_factory=lambda: BusConfig(
-            middlewares=[
-                "hexcore.infrastructure.cqrs.middlewares.TransactionMiddleware"
-            ]
-        )
-    )
+    # Sin middlewares por defecto (P0-6). `TransactionMiddleware` *era* el default,
+    # pero adivinaba la sesión con el session factory interno de HexCore en vez del
+    # engine de la aplicación, y comiteaba por segunda vez sobre los handlers que ya
+    # gestionan su transacción. Si lo querés, declaralo explícitamente con su
+    # `uow_factory`.
+    command_bus: BusConfig = Field(default_factory=BusConfig)
     query_bus: BusConfig = Field(default_factory=BusConfig)
     event_bus: BusConfig = Field(default_factory=BusConfig)
     serializer: t.Optional[str] = None  # None = PydanticSerializer por defecto

hexcore-3.0.0/hexcore/application/cqrs/factory.py

@@ -0,0 +1,215 @@
+"""
+Factory para construir buses CQRS a partir de la configuración.
+Resuelve backends, serializers y middlewares por dotted path.
+"""
+from __future__ import annotations
+
+import importlib
+import typing as t
+
+from hexcore.domain.cqrs.buses import ICommandBus, IQueryBus, IEventBus
+from hexcore.domain.cqrs.middleware import IMiddleware
+from hexcore.domain.cqrs.serializer import ISerializer
+from hexcore.domain.cqrs.task_queues import ITaskEnqueuer
+
+from .config import CQRSConfig, BusConfig
+from .registry import HandlerRegistry
+from .pipeline import MiddlewarePipeline
+from .in_memory_buses import InMemoryCommandBus, InMemoryQueryBus, InMemoryEventBus
+
+
+def _import_class(dotted_path: str) -> type:
+    """Importa una clase a partir de su dotted path."""
+    module_path, class_name = dotted_path.rsplit(".", 1)
+    module = importlib.import_module(module_path)
+    return getattr(module, class_name)
+
+
+def _build_middlewares(dotted_paths: list[str]) -> list[IMiddleware]:
+    """
+    Instancia middlewares a partir de sus dotted paths.
+
+    Sólo sirve para middlewares construibles sin argumentos. Los que necesitan
+    configuración (p. ej. `TransactionMiddleware`, que requiere un `uow_factory`
+    atado al engine de la aplicación) hay que instanciarlos a mano y pasar el
+    `MiddlewarePipeline` al bus.
+    """
+    middlewares: list[IMiddleware] = []
+    for path in dotted_paths:
+        cls = _import_class(path)
+        try:
+            middlewares.append(cls())
+        except TypeError as exc:
+            raise TypeError(
+                f"El middleware '{path}' no se puede construir sin argumentos: {exc}. "
+                "Declararlo por dotted path sólo funciona para middlewares sin "
+                "configuración; instancialo a mano y pasá el MiddlewarePipeline al bus."
+            ) from exc
+        except ValueError as exc:
+            raise ValueError(
+                f"El middleware '{path}' rechazó su construcción por defecto: {exc} "
+                "Declararlo por dotted path sólo funciona para middlewares sin "
+                "configuración; instancialo a mano y pasá el MiddlewarePipeline al bus."
+            ) from exc
+    return middlewares
+
+
+def _build_pipeline(bus_config: BusConfig) -> MiddlewarePipeline:
+    """Construye un MiddlewarePipeline desde la configuración de un bus."""
+    middlewares = _build_middlewares(bus_config.middlewares)
+    return MiddlewarePipeline(middlewares)
+
+
+class CQRSFactory:
+    """
+    Factory que construye las instancias de buses CQRS.
+
+    Usa CQRSConfig para determinar qué implementación de bus instanciar,
+    qué middlewares configurar y qué serializer utilizar.
+
+    Uso::
+
+        config = CQRSConfig(...)
+        registry = HandlerRegistry()
+        # ...registrar handlers...
+
+        factory = CQRSFactory(config, registry, enqueuer=ProcrastinateEnqueuer(app))
+        command_bus = factory.create_command_bus()
+        query_bus = factory.create_query_bus()
+        event_bus = factory.create_event_bus()
+
+    El `enqueuer` es lo que habilita el Smart Routing: sin él, los buses in-memory
+    no pueden enrutar un `@background_command` y la factory lo dice **al construir**,
+    no en el primer dispatch.
+    """
+
+    def __init__(
+        self,
+        config: CQRSConfig,
+        registry: HandlerRegistry,
+        enqueuer: ITaskEnqueuer | None = None,
+    ) -> None:
+        self._config = config
+        self._registry = registry
+        self._enqueuer = enqueuer
+        self._serializer: ISerializer | None = None
+
+    def create_serializer(self) -> ISerializer:
+        """
+        Crea el serializer configurado (PydanticSerializer por defecto).
+
+        La instancia se cachea: los buses y el consumer tienen que compartir el
+        mismo serializer para que el round-trip por la cola sea coherente.
+        """
+        if self._serializer is not None:
+            return self._serializer
+
+        if self._config.serializer:
+            cls = _import_class(self._config.serializer)
+            self._serializer = t.cast(ISerializer, cls())
+        else:
+            from hexcore.infrastructure.cqrs.pydantic_serializer import PydanticSerializer
+
+            self._serializer = PydanticSerializer()
+        return self._serializer
+
+    def create_command_bus(self, **extra_kwargs: t.Any) -> ICommandBus:
+        """
+        Crea el CommandBus configurado.
+        Si no hay backend explícito, retorna InMemoryCommandBus con el enqueuer y el
+        serializer necesarios para el Smart Routing.
+        """
+        bus_config = self._config.command_bus
+        pipeline = _build_pipeline(bus_config)
+
+        if bus_config.backend is None:
+            self._assert_enqueuer_for_background_commands()
+            return InMemoryCommandBus(
+                registry=self._registry,
+                pipeline=pipeline,
+                enqueuer=self._enqueuer,
+                serializer=self.create_serializer(),
+                **extra_kwargs,
+            )
+
+        # Backend personalizado (ej. ProcrastinateCommandBus)
+        cls = _import_class(bus_config.backend)
+        return cls(
+            registry=self._registry,
+            serializer=self.create_serializer(),
+            pipeline=pipeline,
+            **bus_config.options,
+            **extra_kwargs,
+        )
+
+    def create_query_bus(self) -> IQueryBus:
+        """
+        Crea el QueryBus configurado.
+        Nota: Las queries siempre son síncronas en CQRS puro.
+        """
+        bus_config = self._config.query_bus
+        pipeline = _build_pipeline(bus_config)
+
+        if bus_config.backend is None:
+            return InMemoryQueryBus(
+                registry=self._registry,
+                pipeline=pipeline,
+            )
+
+        cls = _import_class(bus_config.backend)
+        return cls(
+            registry=self._registry,
+            pipeline=pipeline,
+            **bus_config.options,
+        )
+
+    def create_event_bus(self, **extra_kwargs: t.Any) -> IEventBus:
+        """
+        Crea el EventBus configurado.
+
+        Al bus in-memory se le pasan enqueuer y serializer para que los suscriptores
+        marcados con `@background_handler` se puedan enrutar.
+        """
+        bus_config = self._config.event_bus
+        pipeline = _build_pipeline(bus_config)
+
+        if bus_config.backend is None:
+            return InMemoryEventBus(
+                pipeline=pipeline,
+                enqueuer=self._enqueuer,
+                serializer=self.create_serializer(),
+                **extra_kwargs,
+            )
+
+        cls = _import_class(bus_config.backend)
+        return cls(
+            pipeline=pipeline,
+            **bus_config.options,
+            **extra_kwargs,
+        )
+
+    # ── Validación ────────────────────────────────────────────────────────────
+
+    def _assert_enqueuer_for_background_commands(self) -> None:
+        """
+        Falla al construir si hay commands de background registrados y no hay
+        enqueuer. El error en el primer dispatch llega demasiado tarde: para
+        entonces la petición del usuario ya está en vuelo.
+        """
+        if self._enqueuer is not None:
+            return
+
+        background = [
+            command_type.__name__
+            for command_type in self._registry.registered_commands
+            if getattr(command_type, "__cqrs_background__", False)
+        ]
+        if not background:
+            return
+
+        raise RuntimeError(
+            "CQRSFactory no tiene 'enqueuer', pero hay commands decorados con "
+            f"@background_command: {', '.join(sorted(background))}. "
+            "Pasá un ITaskEnqueuer al construir la factory, p. ej. "
+            "CQRSFactory(config, registry, enqueuer=ProcrastinateEnqueuer(app))."
+        )

{hexcore-2.5.0 → hexcore-3.0.0}/hexcore/application/cqrs/in_memory_buses.py

@@ -8,6 +8,7 @@ import logging
 
 from hexcore.domain.cqrs.buses import ICommandBus, IQueryBus, IEventBus
 from hexcore.domain.cqrs.commands import Command
+from hexcore.domain.cqrs.context import is_worker_execution, local_execution
 from hexcore.domain.cqrs.queries import Query
 from hexcore.domain.events import DomainEvent
 from hexcore.domain.cqrs.task_queues import ITaskEnqueuer
@@ -28,6 +29,10 @@ class InMemoryCommandBus(ICommandBus):
     Si el comando está decorado con `@background_command` y se provee un `enqueuer`,
     el comando es automáticamente encolado para su ejecución en segundo plano
     sin bloquear el proceso actual (retornando None).
+
+    Cuando el mensaje viene de un worker (``IN_WORKER`` activo, lo pone el
+    ``CQRSConsumer``), el bus lo ejecuta **localmente** en vez de reencolarlo.
+    Esto permite usar el mismo bus en el proceso web y en el worker.
     """
 
     def __init__(
@@ -44,17 +49,19 @@ class InMemoryCommandBus(ICommandBus):
 
     async def dispatch(self, command: Command) -> t.Any:
         cmd_type = type(command)
-        
+
         # 1. Smart Routing: ¿Debe irse a background?
+        # Si ya estamos dentro de un worker, el mensaje viene de la cola: hay que
+        # ejecutarlo, no volver a encolarlo.
         is_background = getattr(cmd_type, "__cqrs_background__", False)
-        
-        if is_background:
+
+        if is_background and not is_worker_execution():
             if not self._enqueuer or not self._serializer:
                 raise RuntimeError(
                     f"El comando '{cmd_type.__name__}' requiere ejecución en background, "
                     "pero el InMemoryCommandBus no tiene configurado un 'enqueuer' o 'serializer'."
                 )
-            
+
             async def background_dispatcher(cmd: Command) -> None:
                 queue_name = getattr(cmd_type, "__cqrs_queue__", "default")
                 payload = self._serializer.serialize(cmd) # type: ignore
@@ -70,7 +77,10 @@ class InMemoryCommandBus(ICommandBus):
         async def final_handler(cmd: t.Any) -> t.Any:
             return await handler.handle(cmd)
 
-        return await self._pipeline.execute(command, final_handler)
+        # `local_execution` consume el flag de worker: si el handler despacha otro
+        # `@background_command`, ese sí debe encolarse.
+        with local_execution():
+            return await self._pipeline.execute(command, final_handler)
 
 
 class InMemoryQueryBus(IQueryBus):
@@ -129,9 +139,15 @@ class InMemoryEventBus(IEventBus):
 
     async def publish(self, event: DomainEvent) -> None:
         handlers = self._handlers.get(type(event), [])
+        # Si el evento viene de un worker, sus handlers de background se ejecutan
+        # aquí; reencolarlos sería un bucle infinito.
+        in_worker = is_worker_execution()
 
         for event_handler in handlers:
-            is_background = getattr(event_handler, "__cqrs_background_handler__", False)
+            is_background = (
+                getattr(event_handler, "__cqrs_background_handler__", False)
+                and not in_worker
+            )
 
             if is_background:
                 # Enrutamiento hacia background
@@ -161,4 +177,5 @@ class InMemoryEventBus(IEventBus):
                 ) -> None:
                     await _h(evt)
 
-                await self._pipeline.execute(event, final_handler)
+                with local_execution():
+                    await self._pipeline.execute(event, final_handler)

hexcore-3.0.0/hexcore/application/cqrs/registry.py

@@ -0,0 +1,185 @@
+"""
+Registro central de handlers CQRS.
+Mapea tipos de Command/Query a sus handlers correspondientes.
+"""
+from __future__ import annotations
+
+import threading
+import typing as t
+
+from hexcore.domain.cqrs.commands import Command
+from hexcore.domain.cqrs.queries import Query
+from hexcore.domain.cqrs.handlers import ICommandHandler, IQueryHandler
+from hexcore.domain.cqrs.exceptions import HandlerNotFoundError, DuplicateHandlerError
+
+
+# Tipos para factories de handlers (para DI/lazy instantiation)
+CommandHandlerFactory = t.Callable[[], ICommandHandler[t.Any, t.Any]]
+QueryHandlerFactory = t.Callable[[], IQueryHandler[t.Any, t.Any]]
+
+TFactory = t.TypeVar("TFactory")
+
+
+class HandlerFactory(t.Generic[TFactory]):
+    """
+    Marcador explícito de "esto es un factory, no un handler".
+
+    `callable(entry) and not isinstance(entry, ICommandHandler)` es ambiguo: un handler
+    que implemente `__call__` se confundiría con un factory, y un factory que herede de
+    la interfaz se confundiría con un handler. Envolver el callable elimina la
+    heurística.
+
+    No es obligatorio: registrar un `lambda` sigue funcionando (se detecta por
+    heurística, igual que antes) y `HandlerRegistry.factory()` construye el marcador
+    por ti.
+    """
+
+    __slots__ = ("build",)
+
+    def __init__(self, build: t.Callable[[], TFactory]) -> None:
+        self.build = build
+
+    def __call__(self) -> TFactory:
+        return self.build()
+
+
+class HandlerRegistry:
+    """
+    Registro de handlers para Commands y Queries.
+
+    Soporta dos modos de registro:
+
+    1. Registro directo de instancias (eager)
+    2. Registro de factories (lazy, para DI containers)
+
+    **Thread-safety.** El registro y la resolución están protegidos por un
+    `threading.RLock`. Hace falta porque `resolve_*` hace lazy-init con escritura en el
+    dict: sin lock, dos hilos (o dos hilos reales bajo el free-threading de Python
+    3.14) pueden instanciar el mismo handler dos veces y quedarse cada uno con la suya.
+
+    Uso::
+
+        registry = HandlerRegistry()
+
+        # Registro directo
+        registry.register_command_handler(CreateUserCommand, CreateUserHandler())
+
+        # Registro con factory (lazy) — marcador explícito
+        registry.register_command_handler(
+            CreateUserCommand, HandlerRegistry.factory(lambda: container.get(CreateUserHandler))
+        )
+
+        # Resolución
+        handler = registry.resolve_command_handler(CreateUserCommand)
+    """
+
+    def __init__(self, *, allow_override: bool = False) -> None:
+        self._command_handlers: dict[
+            type[Command], ICommandHandler[t.Any, t.Any] | CommandHandlerFactory
+        ] = {}
+        self._query_handlers: dict[
+            type[Query[t.Any]], IQueryHandler[t.Any, t.Any] | QueryHandlerFactory
+        ] = {}
+        self._allow_override = allow_override
+        # Reentrante: un factory puede resolver otro handler del mismo registry.
+        self._lock = threading.RLock()
+
+    # ── Factories ─────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def factory(build: t.Callable[[], t.Any]) -> HandlerFactory[t.Any]:
+        """
+        Envuelve un callable para registrarlo como factory sin ambigüedad.
+
+        Preferí esto a pasar el callable pelado cuando tu handler implementa
+        `__call__`, porque entonces la heurística no puede distinguirlos.
+        """
+        return HandlerFactory(build)
+
+    # ── Command Handlers ──────────────────────────────────────────
+
+    def register_command_handler(
+        self,
+        command_type: type[Command],
+        handler: ICommandHandler[t.Any, t.Any] | CommandHandlerFactory,
+    ) -> "HandlerRegistry":
+        """Registra un handler (o factory) para un tipo de command. Retorna self para fluent API."""
+        with self._lock:
+            if not self._allow_override and command_type in self._command_handlers:
+                raise DuplicateHandlerError(command_type)
+            self._command_handlers[command_type] = handler
+        return self
+
+    def resolve_command_handler(
+        self, command_type: type[Command]
+    ) -> ICommandHandler[t.Any, t.Any]:
+        """Resuelve el handler para el tipo de command dado."""
+        with self._lock:
+            entry = self._command_handlers.get(command_type)
+            if entry is None:
+                raise HandlerNotFoundError(command_type)
+            if _is_factory(entry, ICommandHandler):
+                # Es un factory, invocar y cachear la instancia
+                handler = t.cast(CommandHandlerFactory, entry)()
+                self._command_handlers[command_type] = handler
+                return handler
+            return t.cast(ICommandHandler[t.Any, t.Any], entry)
+
+    # ── Query Handlers ────────────────────────────────────────────
+
+    def register_query_handler(
+        self,
+        query_type: type[Query[t.Any]],
+        handler: IQueryHandler[t.Any, t.Any] | QueryHandlerFactory,
+    ) -> "HandlerRegistry":
+        """Registra un handler (o factory) para un tipo de query. Retorna self para fluent API."""
+        with self._lock:
+            if not self._allow_override and query_type in self._query_handlers:
+                raise DuplicateHandlerError(query_type)
+            self._query_handlers[query_type] = handler
+        return self
+
+    def resolve_query_handler(
+        self, query_type: type[Query[t.Any]]
+    ) -> IQueryHandler[t.Any, t.Any]:
+        """Resuelve el handler para el tipo de query dado."""
+        with self._lock:
+            entry = self._query_handlers.get(query_type)
+            if entry is None:
+                raise HandlerNotFoundError(query_type)
+            if _is_factory(entry, IQueryHandler):
+                handler = t.cast(QueryHandlerFactory, entry)()
+                self._query_handlers[query_type] = handler
+                return handler
+            return t.cast(IQueryHandler[t.Any, t.Any], entry)
+
+    # ── Introspección ─────────────────────────────────────────────
+
+    @property
+    def registered_commands(self) -> frozenset[type[Command]]:
+        """Retorna los tipos de command registrados."""
+        with self._lock:
+            return frozenset(self._command_handlers.keys())
+
+    @property
+    def registered_queries(self) -> frozenset[type[Query[t.Any]]]:
+        """Retorna los tipos de query registrados."""
+        with self._lock:
+            return frozenset(self._query_handlers.keys())
+
+
+def _is_factory(entry: t.Any, handler_interface: type) -> bool:
+    """
+    Decide si `entry` es un factory de handlers o el handler mismo.
+
+    El marcador `HandlerFactory` es inequívoco. Para los callables pelados se mantiene
+    la heurística anterior por retrocompatibilidad, con una comprobación extra: un
+    objeto con método `handle` es un handler aunque además sea callable.
+    """
+    if isinstance(entry, HandlerFactory):
+        return True
+    if isinstance(entry, handler_interface):
+        return False
+    if hasattr(entry, "handle"):
+        return False
+    return callable(entry)