flock-core 0.5.0b28__py3-none-any.whl → 0.5.0b51__py3-none-any.whl

flock/{core/logging → logging}/formatters/themed_formatter.py

@@ -5,21 +5,21 @@ import random
 import re
 from typing import Any
 
-from temporalio import workflow
-
-from flock.core.logging.formatters.themes import OutputTheme
+import toml  # install with: pip install toml
+from pydantic import BaseModel
 
-with workflow.unsafe.imports_passed_through():
-    from pygments.style import Style
-    from pygments.token import Token
-    from rich import box
-    from rich.console import Console, Group
-    from rich.panel import Panel
-    from rich.syntax import PygmentsSyntaxTheme, Syntax
-    from rich.table import Table
-    from rich.theme import Theme
+# with workflow.unsafe.imports_passed_through():
+from pygments.style import Style
+from pygments.token import Token
+from rich import box
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.syntax import PygmentsSyntaxTheme, Syntax
+from rich.table import Table
+from rich.theme import Theme
 
-import toml  # install with: pip install toml
+# from temporalio import workflow
+from flock.logging.formatters.themes import OutputTheme
 
 
 def resolve_style_string(style_str: str, theme: dict) -> str:
@@ -76,18 +76,10 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
         cursor_cursor = theme["colors"]["cursor"].get("cursor", "#d0d0d0")
         cursor_text = theme["colors"]["cursor"].get("text", "#151515")
 
-        primary_background = theme["colors"]["primary"].get(
-            "background", "#161719"
-        )
-        primary_foreground = theme["colors"]["primary"].get(
-            "foreground", "#c5c8c6"
-        )
-        selection_background = theme["colors"]["selection"].get(
-            "background", "#444444"
-        )
-        selection_text = theme["colors"]["selection"].get(
-            "text", primary_foreground
-        )
+        primary_background = theme["colors"]["primary"].get("background", "#161719")
+        primary_foreground = theme["colors"]["primary"].get("foreground", "#c5c8c6")
+        selection_background = theme["colors"]["selection"].get("background", "#444444")
+        selection_text = theme["colors"]["selection"].get("text", primary_foreground)
     else:
         bright_black = "black"
         bright_blue = "blue"
@@ -155,9 +147,7 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
         "panel_padding": random.choice([[1, 2], [1, 1], [2, 2], [0, 2]]),
         "panel_title_align": random.choice(["left", "center", "right"]),
         # Add table_row_styles property.
-        "table_row_styles": random.choice(
-            [["", "dim"], ["", "italic"], ["", "underline"]]
-        ),
+        "table_row_styles": random.choice([["", "dim"], ["", "italic"], ["", "underline"]]),
     }
     # Extra table layout properties (non content properties).
     default_extra_table_props = {
@@ -178,13 +168,12 @@ def generate_default_rich_block(theme: dict | None = None) -> dict[str, Any]:
         "table_highlight": False,
     }
     # Combine all defaults.
-    defaults = {
+    return {
         **default_color_props,
         **extra_color_props,
         **default_non_color_props,
         **default_extra_table_props,
     }
-    return defaults
 
 
 def load_theme_from_file(filepath: str) -> dict:
@@ -221,9 +210,7 @@ def get_default_styles(theme: dict | None) -> dict[str, Any]:
     else:
         defaults = generate_default_rich_block(theme)
         rich_props = theme.get("rich", {})
-        final_styles = {
-            key: rich_props.get(key, defaults[key]) for key in defaults
-        }
+        final_styles = {key: rich_props.get(key, defaults[key]) for key in defaults}
 
     # Ensure that panel_padding and table_padding are tuples.
     final_styles["panel_padding"] = tuple(final_styles["panel_padding"])
@@ -256,14 +243,6 @@ def create_rich_renderable(
     if styles is None:
         styles = get_default_styles(theme)
 
-    # Convert Pydantic BaseModel instances to dicts for rendering
-    try:
-        from pydantic import BaseModel
-        if isinstance(value, BaseModel):
-            value = value.model_dump()
-    except ImportError:
-        pass
-
     # If the value is a dictionary, render it as a table.
     if isinstance(value, dict):
         # Convert table_box string into an actual box style.
@@ -309,41 +288,31 @@ def create_rich_renderable(
         return table
 
     # If the value is a list or tuple, render each item.
-    elif isinstance(value, list | tuple):
+    if isinstance(value, list | tuple):
         if all(isinstance(item, dict) for item in value):
             sub_tables = []
             for i, item in enumerate(value):
                 sub_tables.append(f"[bold]Item {i + 1}[/bold]")
                 sub_tables.append(
-                    create_rich_renderable(
-                        item, level + 1, theme, styles, max_length=max_length
-                    )
+                    create_rich_renderable(item, level + 1, theme, styles, max_length=max_length)
                 )
             return Group(*sub_tables)
-        else:
-            rendered_items = [
-                create_rich_renderable(
-                    item, level + 1, theme, styles, max_length=max_length
-                )
-                for item in value
-            ]
-            if all(isinstance(item, str) for item in rendered_items):
-                return "\n".join(rendered_items)
-            else:
-                return Group(*rendered_items)
+        rendered_items = [
+            create_rich_renderable(item, level + 1, theme, styles, max_length=max_length)
+            for item in value
+        ]
+        if all(isinstance(item, str) for item in rendered_items):
+            return "\n".join(rendered_items)
+        return Group(*rendered_items)
 
     # Otherwise, return a string representation.
-    else:
-        s = str(value).strip()
-        if max_length > 0 and len(s) > max_length:
-            omitted = len(s) - max_length
-            s = (
-                s[:max_length]
-                + f"[bold bright_yellow]...(+{omitted}chars)[/bold bright_yellow]"
-            )
-        if isinstance(value, str) and "\n" in value:
-            return f"\n{s}\n"
-        return s
+    s = str(value).strip()
+    if max_length > 0 and len(s) > max_length:
+        omitted = len(s) - max_length
+        s = s[:max_length] + f"[bold bright_yellow]...(+{omitted}chars)[/bold bright_yellow]"
+    if isinstance(value, str) and "\n" in value:
+        return f"\n{s}\n"
+    return s
 
 
 def load_syntax_theme_from_file(filepath: str) -> dict:
@@ -352,12 +321,10 @@ def load_syntax_theme_from_file(filepath: str) -> dict:
         theme = toml.load(f)
 
     if "colors" not in theme:
-        raise ValueError(
-            f"Theme file {filepath} does not contain a 'colors' section."
-        )
+        raise ValueError(f"Theme file {filepath} does not contain a 'colors' section.")
 
     # Map theme colors to syntax categories
-    syntax_theme = {
+    return {
         "background": theme["colors"]["primary"].get("background", "#161719"),
         "text": theme["colors"]["primary"].get("foreground", "#c5c8c6"),
         "comment": theme["colors"]["normal"].get("black", "#666666"),
@@ -371,8 +338,6 @@ def load_syntax_theme_from_file(filepath: str) -> dict:
         "error": theme["colors"]["bright"].get("red", "#ff5555"),
     }
 
-    return syntax_theme
-
 
 def create_rich_syntax_theme(syntax_theme: dict) -> Theme:
     """Convert a syntax theme dict to a Rich-compatible Theme."""
@@ -476,6 +441,7 @@ class ThemedAgentResultFormatter:
         table = Table(**table_kwargs)
         table.add_column("Output", style=styles["column_output"])
         table.add_column("Value", style=styles["column_value"])
+
         for key, value in result.items():
             rich_renderable = create_rich_renderable(
                 value,
@@ -497,58 +463,46 @@ class ThemedAgentResultFormatter:
                 padding=styles["panel_padding"],
                 style=styles["panel_style"],
             )
-        else:
-            syntax = Syntax(
-                s,  # The formatted string
-                "python",  # Highlight as Python (change this for other formats)
-                theme=self.syntax_style,  # Choose a Rich theme (matches your color setup)
-                line_numbers=False,
-            )
-            return Panel(
-                syntax,
-                title=agent_name,
-                title_align=styles["panel_title_align"],
-                border_style=styles["panel_border_style"],
-                padding=styles["panel_padding"],
-                style=styles["panel_style"],
-            )
+        syntax = Syntax(
+            s,  # The formatted string
+            "python",  # Highlight as Python (change this for other formats)
+            theme=self.syntax_style,  # Choose a Rich theme (matches your color setup)
+            line_numbers=False,
+        )
+        return Panel(
+            syntax,
+            title=agent_name,
+            title_align=styles["panel_title_align"],
+            border_style=styles["panel_border_style"],
+            padding=styles["panel_padding"],
+            style=styles["panel_style"],
+        )
 
-    def display_result(self, result: dict[str, Any], agent_name: str) -> None:
+    def display_result(self, result: list[BaseModel], agent_name: str) -> None:
         """Print an agent's result using Rich formatting."""
         theme = self.theme
-        themes_dir = (
-            pathlib.Path(__file__).parent.parent.parent.parent / "themes"
-        )
+        themes_dir = pathlib.Path(__file__).parent.parent.parent / "themes"
         all_themes = list(themes_dir.glob("*.toml"))
-        theme = (
-            theme.value + ".toml"
-            if not theme.value.endswith(".toml")
-            else theme.value
-        )
-        theme = (
-            pathlib.Path(__file__).parent.parent.parent.parent
-            / "themes"
-            / theme
-        )
+        theme = theme.value + ".toml" if not theme.value.endswith(".toml") else theme.value
+        theme = pathlib.Path(__file__).parent.parent.parent / "themes" / theme
 
         if pathlib.Path(theme) not in all_themes:
-            raise ValueError(
-                f"Invalid theme: {theme}\nAvailable themes: {all_themes}"
-            )
+            raise ValueError(f"Invalid theme: {theme}\nAvailable themes: {all_themes}")
 
         theme_dict = load_theme_from_file(theme)
 
         styles = get_default_styles(theme_dict)
         self.styles = styles
-        self.syntax_style = create_pygments_syntax_theme(
-            load_syntax_theme_from_file(theme)
-        )
+        self.syntax_style = create_pygments_syntax_theme(load_syntax_theme_from_file(theme))
 
         console = Console()
-        panel = self.format_result(
-            result=result,
-            agent_name=agent_name,
-            theme=theme_dict,
-            styles=styles,
-        )
-        console.print(panel)
+        for item in result:
+            # basemodel to dict
+            item = item.model_dump()
+            panel = self.format_result(
+                result=item,
+                agent_name=agent_name,
+                theme=theme_dict,
+                styles=styles,
+            )
+            console.print(panel)

flock/{core/logging → logging}/logging.py

@@ -14,13 +14,12 @@ import logging
 import sys
 from typing import Literal
 
-from opentelemetry import trace
-
 # Always import Temporal workflow (since it's part of the project)
-from temporalio import workflow
+# from temporalio import workflow
+# with workflow.unsafe.imports_passed_through():
+from loguru import logger as loguru_logger
+from opentelemetry import trace
 
-with workflow.unsafe.imports_passed_through():
-    from loguru import logger as loguru_logger
 
 # ENABLED_FLOCK_LOGGER_LEVELS constant removed
 
@@ -42,13 +41,14 @@ def in_workflow_context() -> bool:
     It does this by attempting to call workflow.info() and returning True
     if successful. Otherwise, it returns 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
+    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:
@@ -108,7 +108,7 @@ COLOR_MAP = {
 
 LOGGERS = [
     "flock",  # Core Flock orchestration
-    "flock.api", # Flock API specific logs
+    "flock.api",  # Flock API specific logs
     "agent",  # General agent operations
     "context",  # Context management
     "registry",  # Unified registry operations (new)
@@ -177,9 +177,7 @@ def custom_format(record):
     # MAX_LENGTH = 500 # Example value
     if len(message) > MAX_LENGTH:
         truncated_chars = len(message) - MAX_LENGTH
-        message = (
-            message[:MAX_LENGTH] + f"<yellow>...+({truncated_chars} chars)</yellow>"
-        )
+        message = message[:MAX_LENGTH] + f"<yellow>...+({truncated_chars} chars)</yellow>"
 
     # Determine if category needs bolding (can refine this logic)
     needs_bold = category in BOLD_CATEGORIES
@@ -247,7 +245,6 @@ class PrintAndFlushSink:
 
         Already flushed on every write call.
         """
-        pass
 
 
 # Configure Loguru for non-workflow (local/worker) contexts.
@@ -264,7 +261,9 @@ logging.basicConfig(level=LOG_LEVELS["ERROR"])  # Default to ERROR level for fal
 # loguru_logger.add("logs/flock.log", rotation="100 MB", retention="30 days", level="DEBUG")
 
 
-def get_default_severity(level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int) -> int:
+def get_default_severity(
+    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int,
+) -> int:
     """Get the default severity for a given level."""
     if isinstance(level, str):
         level_str = level.upper()
@@ -272,9 +271,17 @@ def get_default_severity(level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CR
     return level
 
 
-def configure_logging(flock_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int,
-                      external_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int,
-                      specific_levels: dict[str, Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int] | None = None) -> None:
+def configure_logging(
+    flock_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"]
+    | int,
+    external_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"]
+    | int,
+    specific_levels: dict[
+        str,
+        Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int,
+    ]
+    | None = None,
+) -> None:
     """Configure both external and internal Flock logging systems.
 
     Args:
@@ -283,19 +290,21 @@ def configure_logging(flock_level: Literal["DEBUG", "INFO", "WARNING", "ERROR",
         specific_levels (dict[str, str | int] | None, optional): A dictionary mapping
             logger names to their specific logging levels. Defaults to None.
     """
-    # Get default severity
+    global _DEFAULT_FLOCK_SEVERITY, _SPECIFIC_SEVERITIES
 
+    # Get default severity
     external_severity = get_default_severity(external_level)
     logging.basicConfig(level=external_severity)
 
-
     flock_severity = get_default_severity(flock_level)
+    _DEFAULT_FLOCK_SEVERITY = flock_severity  # Store for future loggers
 
     specific_severities = {}
     if specific_levels:
         for name, logger_level in specific_levels.items():
             severity = get_default_severity(logger_level)
             specific_severities[name] = severity
+            _SPECIFIC_SEVERITIES[name] = severity  # Store for future loggers
 
     # Apply to all cached loggers
     for logger_name, log_instance in _LOGGER_CACHE.items():
@@ -306,28 +315,26 @@ def configure_logging(flock_level: Literal["DEBUG", "INFO", "WARNING", "ERROR",
         log_instance.min_level_severity = target_severity
 
 
-
-
 # Define a dummy logger that does nothing
 class DummyLogger:
     """A dummy logger that does nothing when called."""
 
-    def debug(self, *args, **kwargs):  # noqa: D102
+    def debug(self, *args, **kwargs):
         pass
 
-    def info(self, *args, **kwargs):  # noqa: D102
+    def info(self, *args, **kwargs):
         pass
 
-    def warning(self, *args, **kwargs):  # noqa: D102
+    def warning(self, *args, **kwargs):
         pass
 
-    def error(self, *args, **kwargs):  # noqa: D102
+    def error(self, *args, **kwargs):
         pass
 
-    def exception(self, *args, **kwargs):  # noqa: D102
+    def exception(self, *args, **kwargs):
         pass
 
-    def success(self, *args, **kwargs):  # noqa: D102
+    def success(self, *args, **kwargs):
         pass
 
 
@@ -357,9 +364,9 @@ 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
+        # 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,
@@ -371,9 +378,7 @@ class FlockLogger:
         """Truncate a message if it exceeds max_length and add truncation indicator."""
         if len(message) > max_length:
             truncated_chars = len(message) - max_length
-            return (
-                message[:max_length] + f"...<yellow>+({truncated_chars} chars)</yellow>"
-            )
+            return message[:max_length] + f"...<yellow>+({truncated_chars} chars)</yellow>"
         return message
 
     def debug(
@@ -385,8 +390,10 @@ class FlockLogger:
         **kwargs,
     ) -> None:
         current_method_severity = LOG_LEVELS["DEBUG"]
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Debug a message.
 
@@ -407,8 +414,10 @@ class FlockLogger:
         **kwargs,
     ) -> None:
         current_method_severity = LOG_LEVELS["INFO"]
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Info a message.
 
@@ -429,8 +438,10 @@ class FlockLogger:
         **kwargs,
     ) -> None:
         current_method_severity = LOG_LEVELS["WARNING"]
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Warning a message.
 
@@ -451,8 +462,10 @@ class FlockLogger:
         **kwargs,
     ) -> None:
         current_method_severity = LOG_LEVELS["ERROR"]
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Error a message.
 
@@ -472,9 +485,11 @@ class FlockLogger:
         max_length: int = MAX_LENGTH,
         **kwargs,
     ) -> None:
-        current_method_severity = LOG_LEVELS["ERROR"] # Exception implies ERROR level
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        current_method_severity = LOG_LEVELS["ERROR"]  # Exception implies ERROR level
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Exception a message.
 
@@ -495,8 +510,10 @@ class FlockLogger:
         **kwargs,
     ) -> None:
         current_method_severity = LOG_LEVELS["SUCCESS"]
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Success a message.
 
@@ -510,21 +527,22 @@ class FlockLogger:
 
 
 _LOGGER_CACHE: dict[str, FlockLogger] = {}
+_DEFAULT_FLOCK_SEVERITY: int = LOG_LEVELS["ERROR"]
+_SPECIFIC_SEVERITIES: dict[str, int] = {}
 
 
 def get_logger(name: str = "flock") -> FlockLogger:
     """Return a cached FlockLogger instance for the given name.
 
-    If the logger doesn't exist, it is created with 'enable_logging' set to False
-    by default (i.e., errors-only mode). Its state can then be changed by calling
-    the `configure_logging()` function.
+    If the logger doesn't exist, it is created using the configured severity level
+    from configure_logging() (default: ERROR). Respects specific_levels if configured.
     If a logger with the given name already exists in the cache, its 'min_level_severity'
     state is NOT modified by this function; it's simply returned.
     """
     if name not in _LOGGER_CACHE:
-        # New loggers default to errors-only (min_level_severity = ERROR_SEVERITY)
-        # until explicitly configured by configure_logging()
-        _LOGGER_CACHE[name] = FlockLogger(name, LOG_LEVELS["ERROR"])
+        # Check if there's a specific severity configured for this logger
+        severity = _SPECIFIC_SEVERITIES.get(name, _DEFAULT_FLOCK_SEVERITY)
+        _LOGGER_CACHE[name] = FlockLogger(name, severity)
     # The min_level_severity state of existing or newly created loggers
     # should be managed by the configure_logging() function.
     return _LOGGER_CACHE[name]
@@ -544,15 +562,13 @@ def truncate_for_logging(obj, max_item_length=100, max_items=10):
     """Truncate large data structures for logging purposes."""
     if isinstance(obj, str) and len(obj) > max_item_length:
         return obj[:max_item_length] + f"... ({len(obj) - max_item_length} more chars)"
-    elif isinstance(obj, dict):
+    if isinstance(obj, dict):
         if len(obj) > max_items:
             return {
-                k: truncate_for_logging(v)
-                for i, (k, v) in enumerate(obj.items())
-                if i < max_items
+                k: truncate_for_logging(v) for i, (k, v) in enumerate(obj.items()) if i < max_items
             }
         return {k: truncate_for_logging(v) for k, v in obj.items()}
-    elif isinstance(obj, list):
+    if isinstance(obj, list):
         if len(obj) > max_items:
             return [truncate_for_logging(item) for item in obj[:max_items]] + [
                 f"... ({len(obj) - max_items} more items)"