flock-core 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

flock/core/handoff/handoff_base.py

@@ -1,12 +0,0 @@
-from typing import Any
-
-from flock.core.agent import Agent
-from flock.core.context import FlockContext
-
-
-class HandoffBase:
-    """Base class for handoff implementations."""
-
-    next_agent: str | Agent
-    input: dict[str, Any]
-    context: FlockContext

flock/core/logging/error_handler.py

@@ -1,84 +0,0 @@
-import sys
-from types import TracebackType
-
-from temporalio import workflow
-
-with workflow.unsafe.imports_passed_through():
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.syntax import Syntax
-    from rich.traceback import Traceback
-
-from flock.core.logging.logger import flock_logger
-
-
-class ErrorHandler:
-    """Handles error formatting and display using Rich."""
-
-    def __init__(self, console: Console | None = None):
-        self.console = console or Console()
-
-    def format_exception(
-        self,
-        exc_type: type[BaseException],
-        exc_value: BaseException,
-        exc_tb: TracebackType,
-        *,
-        show_locals: bool = True,
-    ) -> Panel:
-        """Format an exception with Rich styling."""
-        # Create a Rich traceback
-        rich_tb = Traceback.from_exception(
-            exc_type,
-            exc_value,
-            exc_tb,
-            show_locals=show_locals,
-        )
-
-        # If there's source code available, syntax highlight it
-        if exc_tb and exc_tb.tb_frame.f_code.co_filename != "<string>":
-            try:
-                with open(exc_tb.tb_frame.f_code.co_filename) as f:
-                    source = f.read()
-                syntax = Syntax(
-                    source,
-                    "python",
-                    line_numbers=True,
-                    highlight_lines={exc_tb.tb_lineno},
-                )
-            except:
-                syntax = None
-        else:
-            syntax = None
-
-        # Create a panel with the traceback
-        return Panel(
-            rich_tb,
-            title=f"[red]{exc_type.__name__}[/]: {exc_value!s}",
-            border_style="red",
-            padding=(1, 2),
-        )
-
-    def handle_exception(
-        self,
-        exc_type: type[BaseException],
-        exc_value: BaseException,
-        exc_tb: TracebackType,
-    ) -> None:
-        """Handle an exception by formatting and displaying it."""
-        panel = self.format_exception(exc_type, exc_value, exc_tb)
-        self.console.print(panel)
-        # Also log the error through our logger
-        flock_logger.error(
-            f"Exception occurred: {exc_type.__name__}: {exc_value!s}",
-            error_type=exc_type.__name__,
-            error_details=str(exc_value),
-        )
-
-    def install(self) -> None:
-        """Install this error handler as the default exception handler."""
-        sys.excepthook = self.handle_exception
-
-
-# Global error handler instance
-error_handler = ErrorHandler()

flock/core/logging/formatters.py

@@ -1,122 +0,0 @@
-from typing import Any
-
-from devtools import pprint
-from temporalio import workflow
-
-with workflow.unsafe.imports_passed_through():
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
-    from rich.table import Table
-
-
-class StructuredFormatter:
-    """Formats structured data for Rich output."""
-
-    @staticmethod
-    def create_status_table(data: dict[str, Any]) -> Table:
-        """Create a Rich table for displaying status information."""
-        table = Table(show_header=True, header_style="bold magenta")
-        table.add_column("Key")
-        table.add_column("Value")
-
-        for key, value in data.items():
-            table.add_row(str(key), str(value))
-
-        return table
-
-    @staticmethod
-    def create_progress_bar(description: str = "Progress") -> Progress:
-        """Create a Rich progress bar with time tracking."""
-        return Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            BarColumn(),
-            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-            TimeElapsedColumn(),
-        )
-
-    @staticmethod
-    def create_workflow_panel(
-        workflow_id: str, status: str, details: dict[str, Any], title: str = "Workflow Status"
-    ) -> Panel:
-        """Create a Rich panel for workflow information."""
-        table = StructuredFormatter.create_status_table({"Workflow ID": workflow_id, "Status": status, **details})
-        return Panel(table, title=title, border_style="blue")
-
-    @staticmethod
-    def create_activity_panel(
-        activity_id: str, name: str, status: str, details: dict[str, Any], title: str = "Activity Status"
-    ) -> Panel:
-        """Create a Rich panel for activity information."""
-        table = StructuredFormatter.create_status_table(
-            {"Activity ID": activity_id, "Name": name, "Status": status, **details}
-        )
-        return Panel(table, title=title, border_style="magenta")
-
-
-class PerformanceFormatter:
-    """Formats performance metrics for Rich output."""
-
-    @staticmethod
-    def create_timing_tree(timings: dict[str, float]) -> str:
-        """Create a tree-like structure showing execution timings."""
-        if not timings:
-            return "No timings recorded"
-
-        result = "Performance Metrics:\n"
-        for operation, duration in timings.items():
-            result += f"├── {operation}: {duration:.3f}s\n"
-        return result[:-1]  # Remove trailing newline
-
-    @staticmethod
-    def create_performance_panel(metrics: dict[str, Any], title: str = "Performance Metrics") -> Panel:
-        """Create a panel showing performance metrics."""
-        table = StructuredFormatter.create_status_table(metrics)
-        return Panel(table, title=title, border_style="cyan")
-
-
-class AgentResultFormatter:
-    """Formats agent results in a beautiful Rich table."""
-
-    @staticmethod
-    def format_result(result: dict[str, Any], agent_name: str) -> Panel:
-        """Format an agent's result as a Rich panel containing a table."""
-        # Create a table with a nice header
-        table = Table(
-            show_header=True,
-            header_style="bold green",
-            title=f"Agent Results: {agent_name}",
-            title_style="bold blue",
-            border_style="bright_blue",
-        )
-        table.add_column("Output", style="cyan")
-        table.add_column("Value", style="green")
-
-        # Add each result to the table
-        for key, value in result.items():
-            # Format multi-line values (like blog headers) nicely
-            if isinstance(value, (list, tuple)) or (isinstance(value, str) and "\n" in value):
-                formatted_value = "\n".join(value) if isinstance(value, (list, tuple)) else value
-                # Add some padding for multi-line values
-                table.add_row(key, f"\n{formatted_value}\n")
-            else:
-                table.add_row(key, str(value))
-
-        pprint(result)
-
-        # Wrap the table in a panel for a nice border
-        return Panel(
-            table,
-            title="🎯 Agent Output",
-            title_align="left",
-            border_style="blue",
-            padding=(1, 2),
-        )
-
-    @staticmethod
-    def print_result(result: dict[str, Any], agent_name: str, console: Console | None = None) -> None:
-        """Print an agent's result using Rich formatting."""
-        console = console or Console()
-        panel = AgentResultFormatter.format_result(result, agent_name)
-        console.print(panel)

flock/core/logging/handlers.py

@@ -1,117 +0,0 @@
-import time
-
-from temporalio import workflow
-
-with workflow.unsafe.imports_passed_through():
-    from rich.console import Console
-    from rich.live import Live
-
-from collections.abc import Callable, Generator
-from contextlib import contextmanager
-from functools import wraps
-from typing import Any, TypeVar
-
-from flock.core.logging.formatters import PerformanceFormatter, StructuredFormatter
-
-T = TypeVar("T")
-
-
-class PerformanceHandler:
-    """Handles performance tracking and reporting."""
-
-    def __init__(self, console: Console | None = None):
-        self.console = console or Console()
-        self.timings: dict[str, float] = {}
-        self.enabled = False
-
-    def enable(self):
-        """Enable performance tracking."""
-        self.enabled = True
-
-    def disable(self):
-        """Disable performance tracking."""
-        self.enabled = False
-
-    def _get_time(self) -> float:
-        """Get current time in a workflow-safe way."""
-        try:
-            # Try to get workflow time first
-            return workflow.now().timestamp()
-        except workflow._NotInWorkflowEventLoopError:
-            # Fall back to system time if not in workflow
-            return time.time()
-
-    @contextmanager
-    def track_time(self, operation_name: str) -> Generator[None, None, None]:
-        """Context manager for tracking operation execution time."""
-        if not self.enabled:
-            yield
-            return
-
-        start_time = self._get_time()
-        try:
-            yield
-        finally:
-            end_time = self._get_time()
-            duration = end_time - start_time
-            self.timings[operation_name] = duration
-
-    def track_operation(self, operation_name: str) -> Callable[[Callable[..., T]], Callable[..., T]]:
-        """Decorator for tracking function execution time."""
-
-        def decorator(func: Callable[..., T]) -> Callable[..., T]:
-            @wraps(func)
-            def wrapper(*args: Any, **kwargs: Any) -> T:
-                with self.track_time(operation_name):
-                    return func(*args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-    def display_timings(self) -> None:
-        """Display all tracked timings in a tree format."""
-        if self.timings:
-            tree = PerformanceFormatter.create_timing_tree(self.timings)
-            self.console.print(tree)
-
-    def clear_timings(self) -> None:
-        """Clear all tracked timings."""
-        self.timings.clear()
-
-
-class LiveUpdateHandler:
-    """Handles live updates for long-running operations."""
-
-    def __init__(self, console: Console | None = None):
-        self.console = console or Console()
-
-    @contextmanager
-    def progress_tracker(self, description: str = "Progress") -> Generator[Any, None, None]:
-        """Context manager for tracking progress with a live display."""
-        progress = StructuredFormatter.create_progress_bar(description)
-        with Live(progress, console=self.console, refresh_per_second=4) as live:
-            task = progress.add_task(description, total=100)
-            try:
-                yield lambda p: progress.update(task, completed=p)
-            finally:
-                progress.update(task, completed=100)
-
-    def update_workflow_status(
-        self, workflow_id: str, status: str, details: dict[str, Any], refresh_per_second: int = 1
-    ) -> Live:
-        """Create a live updating workflow status panel."""
-        panel = StructuredFormatter.create_workflow_panel(workflow_id, status, details)
-        return Live(panel, console=self.console, refresh_per_second=refresh_per_second)
-
-    def update_activity_status(
-        self, activity_id: str, name: str, status: str, details: dict[str, Any], refresh_per_second: int = 1
-    ) -> Live:
-        """Create a live updating activity status panel."""
-        panel = StructuredFormatter.create_activity_panel(activity_id, name, status, details)
-        return Live(panel, console=self.console, refresh_per_second=refresh_per_second)
-
-
-# Global instances for convenience
-performance_handler = PerformanceHandler()
-live_update_handler = LiveUpdateHandler()

flock/core/logging/logger.py

@@ -1,107 +0,0 @@
-from typing import Any
-
-from temporalio import workflow
-
-from flock.core.logging.formatters import AgentResultFormatter
-
-with workflow.unsafe.imports_passed_through():
-    from rich.console import Console
-    from rich.theme import Theme
-
-# Custom theme for different log levels
-THEME = Theme({
-    "info": "cyan",
-    "warning": "yellow",
-    "error": "red",
-    "debug": "grey50",
-    "success": "green",
-    "workflow": "blue",
-    "activity": "magenta",
-})
-
-
-class LogLevel:
-    NONE = 0  # No logging except errors
-    MINIMAL = 1  # Only agent outputs
-    BASIC = 2  # Agent outputs + basic workflow info
-    VERBOSE = 3  # Everything including debug info
-
-
-class FlockLogger:
-    """Custom logger for Flock that integrates with Rich and respects Temporal constraints."""
-
-    def __init__(self, name: str = "flock", console: Console | None = None, level: int = LogLevel.MINIMAL):
-        self.name = name
-        self.console = console or Console(theme=THEME)
-        self._workflow_id: str | None = None
-        self._activity_id: str | None = None
-        self.level = level
-
-    def set_level(self, level: int) -> None:
-        """Set the logging level."""
-        self.level = level
-
-    def set_context(self, workflow_id: str | None = None, activity_id: str | None = None) -> None:
-        """Set the current workflow and activity context."""
-        self._workflow_id = workflow_id
-        self._activity_id = activity_id
-
-    def _format_message(self, level: str, message: str, **kwargs: Any) -> str:
-        """Format log message with context but without timestamps (for Temporal compatibility)."""
-        context_parts = []
-        if self._workflow_id:
-            context_parts.append(f"[workflow]workflow={self._workflow_id}[/]")
-        if self._activity_id:
-            context_parts.append(f"[activity]activity={self._activity_id}[/]")
-
-        # Add any additional context from kwargs
-        for key, value in kwargs.items():
-            if key not in ("workflow_id", "activity_id"):
-                context_parts.append(f"{key}={value}")
-
-        context_str = " ".join(context_parts)
-        return f"[{level}]{level.upper()}[/] {message} {context_str if context_str else ''}"
-
-    def info(self, message: str, **kwargs: Any) -> None:
-        """Log an info message."""
-        if self.level >= LogLevel.BASIC:
-            self.console.print(self._format_message("info", message, **kwargs))
-
-    def warning(self, message: str, **kwargs: Any) -> None:
-        """Log a warning message."""
-        if self.level >= LogLevel.BASIC:
-            self.console.print(self._format_message("warning", message, **kwargs))
-
-    def error(self, message: str, **kwargs: Any) -> None:
-        """Log an error message."""
-        # Errors are always logged regardless of level
-        self.console.print(self._format_message("error", message, **kwargs))
-
-    def debug(self, message: str, **kwargs: Any) -> None:
-        """Log a debug message."""
-        if self.level >= LogLevel.VERBOSE:
-            self.console.print(self._format_message("debug", message, **kwargs))
-
-    def success(self, message: str, **kwargs: Any) -> None:
-        """Log a success message."""
-        if self.level >= LogLevel.BASIC:
-            self.console.print(self._format_message("success", message, **kwargs))
-
-    def workflow_event(self, message: str, **kwargs: Any) -> None:
-        """Log a workflow-specific event."""
-        if self.level >= LogLevel.BASIC:
-            self.console.print(self._format_message("workflow", message, **kwargs))
-
-    def activity_event(self, message: str, **kwargs: Any) -> None:
-        """Log an activity-specific event."""
-        if self.level >= LogLevel.BASIC:
-            self.console.print(self._format_message("activity", message, **kwargs))
-
-    def result(self, message: dict, agent_name, **kwargs: Any) -> None:
-        """Log a result message."""
-        if self.level >= LogLevel.MINIMAL:
-            AgentResultFormatter.print_result(message, agent_name, self.console)
-
-
-# Global logger instance with minimal logging by default
-flock_logger = FlockLogger(level=LogLevel.MINIMAL)

flock/core/serializable.py

@@ -1,206 +0,0 @@
-"""Module for serializable objects in the system."""
-
-import json
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import Any, TypeVar
-
-import cloudpickle
-import msgpack
-
-from flock.core.logging import flock_logger, performance_handler
-
-T = TypeVar("T", bound="Serializable")
-
-
-class Serializable(ABC):
-    """Base class for all serializable objects in the system.
-
-    Provides methods for serializing/deserializing objects to various formats
-    with comprehensive logging and performance tracking.
-    """
-
-    @abstractmethod
-    def to_dict(self) -> dict[str, Any]:
-        """Convert instance to dictionary representation."""
-        pass
-
-    @classmethod
-    @abstractmethod
-    def from_dict(cls: type[T], data: dict[str, Any]) -> T:
-        """Create instance from dictionary representation."""
-        pass
-
-    def to_json(self) -> str:
-        """Serialize to JSON string."""
-        try:
-            with performance_handler.track_time("json_serialization"):
-                flock_logger.debug(
-                    "Serializing to JSON",
-                    class_name=self.__class__.__name__,
-                )
-                json_str = json.dumps(self.to_dict())
-                flock_logger.debug(
-                    "JSON serialization complete",
-                    size_bytes=len(json_str),
-                )
-                return json_str
-        except Exception as e:
-            flock_logger.error(
-                "JSON serialization failed",
-                class_name=self.__class__.__name__,
-                error=str(e),
-            )
-            raise
-
-    @classmethod
-    def from_json(cls: type[T], json_str: str) -> T:
-        """Create instance from JSON string."""
-        try:
-            with performance_handler.track_time("json_deserialization"):
-                flock_logger.debug(
-                    "Deserializing from JSON",
-                    class_name=cls.__name__,
-                    size_bytes=len(json_str),
-                )
-                instance = cls.from_dict(json.loads(json_str))
-                flock_logger.debug("JSON deserialization complete")
-                return instance
-        except Exception as e:
-            flock_logger.error(
-                "JSON deserialization failed",
-                class_name=cls.__name__,
-                error=str(e),
-            )
-            raise
-
-    def to_msgpack(self, path: Path | None = None) -> bytes:
-        """Serialize to msgpack bytes."""
-        try:
-            with performance_handler.track_time("msgpack_serialization"):
-                flock_logger.debug(
-                    "Serializing to msgpack",
-                    class_name=self.__class__.__name__,
-                )
-                msgpack_bytes = msgpack.packb(self.to_dict())
-
-                if path:
-                    flock_logger.debug(f"Writing msgpack to file: {path}")
-                    path.write_bytes(msgpack_bytes)
-
-                flock_logger.debug(
-                    "Msgpack serialization complete",
-                    size_bytes=len(msgpack_bytes),
-                    file_path=str(path) if path else None,
-                )
-                return msgpack_bytes
-        except Exception as e:
-            flock_logger.error(
-                "Msgpack serialization failed",
-                class_name=self.__class__.__name__,
-                file_path=str(path) if path else None,
-                error=str(e),
-            )
-            raise
-
-    @classmethod
-    def from_msgpack(cls: type[T], msgpack_bytes: bytes) -> T:
-        """Create instance from msgpack bytes."""
-        try:
-            with performance_handler.track_time("msgpack_deserialization"):
-                flock_logger.debug(
-                    "Deserializing from msgpack",
-                    class_name=cls.__name__,
-                    size_bytes=len(msgpack_bytes),
-                )
-                instance = cls.from_dict(msgpack.unpackb(msgpack_bytes))
-                flock_logger.debug("Msgpack deserialization complete")
-                return instance
-        except Exception as e:
-            flock_logger.error(
-                "Msgpack deserialization failed",
-                class_name=cls.__name__,
-                error=str(e),
-            )
-            raise
-
-    @classmethod
-    def from_msgpack_file(cls: type[T], path: Path) -> T:
-        """Create instance from msgpack file."""
-        try:
-            with performance_handler.track_time("msgpack_file_read"):
-                flock_logger.debug(
-                    f"Reading msgpack from file: {path}",
-                    class_name=cls.__name__,
-                )
-                return cls.from_msgpack(path.read_bytes())
-        except Exception as e:
-            flock_logger.error(
-                "Msgpack file read failed",
-                class_name=cls.__name__,
-                file_path=str(path),
-                error=str(e),
-            )
-            raise
-
-    def to_pickle(self) -> bytes:
-        """Serialize to pickle bytes."""
-        try:
-            with performance_handler.track_time("pickle_serialization"):
-                flock_logger.debug(
-                    "Serializing to pickle",
-                    class_name=self.__class__.__name__,
-                )
-                pickle_bytes = cloudpickle.dumps(self)
-                flock_logger.debug(
-                    "Pickle serialization complete",
-                    size_bytes=len(pickle_bytes),
-                )
-                return pickle_bytes
-        except Exception as e:
-            flock_logger.error(
-                "Pickle serialization failed",
-                class_name=self.__class__.__name__,
-                error=str(e),
-            )
-            raise
-
-    @classmethod
-    def from_pickle(cls, pickle_bytes: bytes) -> T:
-        """Create instance from pickle bytes."""
-        try:
-            with performance_handler.track_time("pickle_deserialization"):
-                flock_logger.debug(
-                    "Deserializing from pickle",
-                    class_name=cls.__name__,
-                    size_bytes=len(pickle_bytes),
-                )
-                instance = cloudpickle.loads(pickle_bytes)
-                flock_logger.debug("Pickle deserialization complete")
-                return instance
-        except Exception as e:
-            flock_logger.error(
-                "Pickle deserialization failed",
-                class_name=cls.__name__,
-                error=str(e),
-            )
-            raise
-
-    @classmethod
-    def from_pickle_file(cls: type[T], path: Path) -> T:
-        """Create instance from pickle file."""
-        try:
-            with performance_handler.track_time("pickle_file_read"):
-                flock_logger.debug(
-                    f"Reading pickle from file: {path}",
-                    class_name=cls.__name__,
-                )
-                return cls.from_pickle(path.read_bytes())
-        except Exception as e:
-            flock_logger.error(
-                "Pickle file read failed",
-                class_name=cls.__name__,
-                file_path=str(path),
-                error=str(e),
-            )
-            raise