flock-core 0.1.2__py3-none-any.whl → 0.2.2__py3-none-any.whl

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