flock-core 0.5.11__py3-none-any.whl → 0.5.20__py3-none-any.whl

flock/engines/examples/simple_batch_engine.py

@@ -4,9 +4,9 @@ from __future__ import annotations
 
 from pydantic import BaseModel, Field
 
-from flock.components import EngineComponent
+from flock.components.agent import EngineComponent
 from flock.registry import flock_type
-from flock.runtime import EvalInputs, EvalResult
+from flock.utils.runtime import EvalInputs, EvalResult
 
 
 @flock_type(name="BatchItem")

flock/examples.py

@@ -13,17 +13,17 @@ from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, Field
 
-from flock.artifacts import Artifact
-from flock.components import EngineComponent
-from flock.orchestrator import Flock
+from flock.components.agent import EngineComponent
+from flock.core import Flock
+from flock.core.artifacts import Artifact
+from flock.core.store import BlackboardStore
 from flock.registry import flock_tool, flock_type, type_registry
-from flock.runtime import EvalInputs, EvalResult
-from flock.store import BlackboardStore
-from flock.utilities import LoggingUtility, MetricsUtility
+from flock.utils.runtime import EvalInputs, EvalResult
+from flock.utils.utilities import LoggingUtility, MetricsUtility
 
 
 if TYPE_CHECKING:
-    from flock.agent import AgentBuilder
+    from flock.core import AgentBuilder
 
 
 @flock_type

flock/logging/logging.py

@@ -42,13 +42,6 @@ def in_workflow_context() -> bool:
     if successful. Otherwise, it returns False.
     """
     return False
-    # try:
-    #     workflow.logger.debug("Checking if in workflow context...")
-    #     # loguru_logger.debug("Checking if in workflow context...")
-    #     # This call will succeed only if we're in a workflow context.
-    #     return bool(hasattr(workflow.info(), "is_replaying"))
-    # except Exception:
-    #     return False
 
 
 def get_current_trace_id() -> str:
@@ -374,9 +367,6 @@ class FlockLogger:
         self.min_level_severity = initial_min_level_severity
 
     def _get_logger(self):
-        # if in_workflow_context():
-        #     # Use Temporal's workflow.logger inside a workflow context.
-        #     return workflow.logger
         # Bind our logger with category and trace_id
         return loguru_logger.bind(
             name=self.name,
@@ -562,12 +552,7 @@ def get_logger(name: str = "flock") -> FlockLogger:
 
 def get_module_loggers() -> list[FlockLogger]:
     """Return a cached FlockLogger instance for the given module name."""
-    result = []
-    for kvp in _LOGGER_CACHE:
-        if kvp.startswith("module."):
-            result.append(_LOGGER_CACHE[kvp])
-
-    return result
+    return [_LOGGER_CACHE[kvp] for kvp in _LOGGER_CACHE if kvp.startswith("module.")]
 
 
 def truncate_for_logging(obj, max_item_length=100, max_items=10):

flock/models/__init__.py

@@ -0,0 +1,10 @@
+"""System data models for Flock.
+
+This module contains system-level artifact types used by the orchestrator
+for error handling, workflow tracking, and internal communication.
+"""
+
+from flock.models.system_artifacts import WorkflowError
+
+
+__all__ = ["WorkflowError"]

flock/orchestrator/__init__.py

@@ -0,0 +1,45 @@
+"""Orchestrator implementation modules.
+
+This package contains internal implementation details for the Flock orchestrator.
+
+Phase 5A Additions:
+- ContextBuilder: Security-critical context building with provider resolution
+- EventEmitter: Dashboard WebSocket event emission
+- LifecycleManager: Background task coordination for batches and correlations
+
+Phase 3 Additions (Orchestrator Simplification):
+- TracingManager: Unified tracing and trace database management
+- ServerManager: HTTP service startup and dashboard integration
+- OrchestratorInitializer: Component setup and state initialization
+"""
+
+from flock.orchestrator.artifact_collector import ArtifactCollector
+from flock.orchestrator.artifact_manager import ArtifactManager
+from flock.orchestrator.batch_accumulator import BatchAccumulator
+from flock.orchestrator.component_runner import ComponentRunner
+from flock.orchestrator.context_builder import ContextBuilder
+from flock.orchestrator.correlation_engine import CorrelationEngine
+from flock.orchestrator.event_emitter import EventEmitter
+from flock.orchestrator.initialization import OrchestratorInitializer
+from flock.orchestrator.lifecycle_manager import LifecycleManager
+from flock.orchestrator.mcp_manager import MCPManager
+from flock.orchestrator.scheduler import AgentScheduler
+from flock.orchestrator.server_manager import ServerManager
+from flock.orchestrator.tracing import TracingManager
+
+
+__all__ = [
+    "AgentScheduler",
+    "ArtifactCollector",
+    "ArtifactManager",
+    "BatchAccumulator",
+    "ComponentRunner",
+    "ContextBuilder",
+    "CorrelationEngine",
+    "EventEmitter",
+    "LifecycleManager",
+    "MCPManager",
+    "OrchestratorInitializer",
+    "ServerManager",
+    "TracingManager",
+]

flock/{artifact_collector.py → orchestrator/artifact_collector.py}

@@ -17,9 +17,9 @@ from typing import TYPE_CHECKING
 
 
 if TYPE_CHECKING:
-    from flock.agent import Agent
-    from flock.artifacts import Artifact
-    from flock.subscription import Subscription
+    from flock.core import Agent
+    from flock.core.artifacts import Artifact
+    from flock.core.subscription import Subscription
 
 
 class ArtifactCollector:

flock/orchestrator/artifact_manager.py

@@ -0,0 +1,168 @@
+"""Artifact publishing and persistence."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any
+from uuid import uuid4
+
+from pydantic import BaseModel
+
+from flock.core.artifacts import Artifact
+from flock.core.visibility import PublicVisibility, Visibility
+from flock.registry import type_registry
+
+
+if TYPE_CHECKING:
+    from flock.core import Flock
+    from flock.core.store import BlackboardStore
+    from flock.orchestrator import AgentScheduler
+
+
+class ArtifactManager:
+    """Manages artifact publishing and persistence.
+
+    Responsibilities:
+    - Normalize different input types (BaseModel, dict, Artifact)
+    - Persist artifacts to store
+    - Trigger scheduling after publish
+    - Handle batch publishing
+    """
+
+    def __init__(
+        self, orchestrator: Flock, store: BlackboardStore, scheduler: AgentScheduler
+    ):
+        """Initialize artifact manager.
+
+        Args:
+            orchestrator: Flock orchestrator instance
+            store: Blackboard store for persistence
+            scheduler: Scheduler for triggering agent execution
+        """
+        self._orchestrator = orchestrator
+        self._store = store
+        self._scheduler = scheduler
+        self._logger = orchestrator._logger
+
+    async def publish(
+        self,
+        obj: BaseModel | dict | Artifact,
+        *,
+        visibility: Visibility | None = None,
+        correlation_id: str | None = None,
+        partition_key: str | None = None,
+        tags: set[str] | None = None,
+        is_dashboard: bool = False,
+    ) -> Artifact:
+        """Publish an artifact to the blackboard (event-driven).
+
+        All agents with matching subscriptions will be triggered according to
+        their filters (type, predicates, visibility, etc).
+
+        Args:
+            obj: Object to publish (BaseModel instance, dict, or Artifact)
+            visibility: Access control (defaults to PublicVisibility)
+            correlation_id: Optional correlation ID for request tracing
+            partition_key: Optional partition key for sharding
+            tags: Optional tags for channel-based routing
+            is_dashboard: Internal flag for dashboard events
+
+        Returns:
+            The published Artifact
+
+        Examples:
+            >>> # Publish a model instance (recommended)
+            >>> task = Task(name="Deploy", priority=5)
+            >>> await artifact_manager.publish(task)
+
+            >>> # Publish with custom visibility
+            >>> await artifact_manager.publish(
+            ...     task, visibility=PrivateVisibility(agents={"admin"})
+            ... )
+        """
+        # Handle different input types
+        if isinstance(obj, Artifact):
+            # Already an artifact - publish as-is
+            artifact = obj
+        elif isinstance(obj, BaseModel):
+            # BaseModel instance - get type from registry
+            type_name = type_registry.name_for(type(obj))
+            artifact = Artifact(
+                type=type_name,
+                payload=obj.model_dump(),
+                produced_by="external",
+                visibility=visibility or PublicVisibility(),
+                correlation_id=correlation_id or uuid4(),
+                partition_key=partition_key,
+                tags=tags or set(),
+            )
+        elif isinstance(obj, dict):
+            # Dict must have 'type' key
+            if "type" not in obj:
+                raise ValueError(
+                    "Dict input must contain 'type' key. "
+                    "Example: {'type': 'Task', 'name': 'foo', 'priority': 5}"
+                )
+            # Support both {'type': 'X', 'payload': {...}} and {'type': 'X', ...}
+            type_name = obj["type"]
+            if "payload" in obj:
+                payload = obj["payload"]
+            else:
+                payload = {k: v for k, v in obj.items() if k != "type"}
+
+            artifact = Artifact(
+                type=type_name,
+                payload=payload,
+                produced_by="external",
+                visibility=visibility or PublicVisibility(),
+                correlation_id=correlation_id,
+                partition_key=partition_key,
+                tags=tags or set(),
+            )
+        else:
+            raise TypeError(
+                f"Cannot publish object of type {type(obj).__name__}. "
+                "Expected BaseModel, dict, or Artifact."
+            )
+
+        # Persist and schedule matching agents
+        await self.persist_and_schedule(artifact)
+        return artifact
+
+    async def publish_many(
+        self, objects: Iterable[BaseModel | dict | Artifact], **kwargs: Any
+    ) -> list[Artifact]:
+        """Publish multiple artifacts at once (event-driven).
+
+        Args:
+            objects: Iterable of objects to publish
+            **kwargs: Passed to each publish() call (visibility, tags, etc)
+
+        Returns:
+            List of published Artifacts
+
+        Example:
+            >>> tasks = [
+            ...     Task(name="Deploy", priority=5),
+            ...     Task(name="Test", priority=3),
+            ... ]
+            >>> await artifact_manager.publish_many(tasks, tags={"sprint-3"})
+        """
+        artifacts = []
+        for obj in objects:
+            artifact = await self.publish(obj, **kwargs)
+            artifacts.append(artifact)
+        return artifacts
+
+    async def persist_and_schedule(self, artifact: Artifact) -> None:
+        """Persist artifact to store and trigger scheduling.
+
+        Args:
+            artifact: Artifact to publish
+        """
+        await self._store.publish(artifact)
+        self._orchestrator.metrics["artifacts_published"] += 1
+        await self._scheduler.schedule_artifact(artifact)
+
+
+__all__ = ["ArtifactManager"]

flock/{batch_accumulator.py → orchestrator/batch_accumulator.py}

@@ -16,8 +16,8 @@ from typing import TYPE_CHECKING
 
 
 if TYPE_CHECKING:
-    from flock.artifacts import Artifact
-    from flock.subscription import BatchSpec, Subscription
+    from flock.core.artifacts import Artifact
+    from flock.core.subscription import BatchSpec, Subscription
 
 
 class BatchAccumulator: