flock-core 0.4.5__tar.gz → 0.4.503__tar.gz

{flock_core-0.4.5 → flock_core-0.4.503}/.github/workflows/deploy-documentation.yml

@@ -2,7 +2,7 @@ name: Deploy MkDocs
 on:
   push:
     branches:
-      - master  # or master
+      - main  # or master
       - docs/*  # or docs/*
 
 jobs:

{flock_core-0.4.5 → flock_core-0.4.503}/.github/workflows/deploy-whiteduck-pypi.yml

@@ -5,7 +5,7 @@ name: Publish Python Package
 on:
   push:
     branches:
-      - master # Replace with your default branch
+      - main # Replace with your default branch
     paths:
       - 'pyproject.toml'  # Only trigger on changes to pyproject.toml (version number)
 

{flock_core-0.4.5 → flock_core-0.4.503}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.5
+Version: 0.4.503
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -36,7 +36,7 @@ Requires-Dist: pillow>=10.4.0
 Requires-Dist: prometheus-client>=0.21.1
 Requires-Dist: psutil>=6.1.1
 Requires-Dist: pydantic-settings>=2.7.1
-Requires-Dist: pydantic>=2.10.5
+Requires-Dist: pydantic==2.10.5
 Requires-Dist: python-box>=7.3.2
 Requires-Dist: python-decouple>=3.8
 Requires-Dist: python-dotenv>=1.0.1
@@ -252,6 +252,43 @@ if __name__ == "__main__":
 <img width="300" alt="image" src="https://github.com/user-attachments/assets/34c2fe2f-6dd2-498c-a826-1687cb158755" />
 </p>
 
+### MCP Support - Declaratively connect to 1000s of different tools!
+
+Create a server
+
+```python 
+ws_fetch_server = FlockFactory.create_mcp_server(
+    name="fetch_server",
+    enable_tools_feature=True,
+    connection_params=FlockFactory.WebsocketParams(
+        url="ws://localhost:4001/message"
+    ),
+```
+
+Add it to Flock
+
+```python 
+flock = Flock(
+    name="mcp_testbed",
+    servers=[
+        ws_fetch_server
+    ]
+)
+```
+
+And tell the flock agents which server to use
+
+```python 
+webcrawler_agent = FlockFactory.create_default_agent(
+    name="webcrawler_agent",
+    description="Expert for looking up and retrieving web content",
+    input="query: str | User-Query, initial_url: Optional[str] | Optional url to start search from.",
+    output="answer: str | Answer to user-query, page_url: str | The url of the page where the answer was found on, page_content: str | Markdown content of the page where the answer was found.",
+    servers=[ws_fetch_server], # servers are passed here.
+)
+```
+
+Done! The Flock agent has now access to every tool the server offers.
 
 
 ### 🚀 REST API – Deploy Flock Agents as REST API Endpoints
@@ -327,7 +364,6 @@ Take note how even custom types like `FantasyCharacter` are serialized so the ta
 name: pydantic_example
 model: openai/gpt-4o
 enable_temporal: false
-enable_logging: false
 show_flock_banner: false
 temporal_start_in_process_worker: true
 agents:

{flock_core-0.4.5 → flock_core-0.4.503}/README.md

@@ -174,6 +174,43 @@ if __name__ == "__main__":
 <img width="300" alt="image" src="https://github.com/user-attachments/assets/34c2fe2f-6dd2-498c-a826-1687cb158755" />
 </p>
 
+### MCP Support - Declaratively connect to 1000s of different tools!
+
+Create a server
+
+```python 
+ws_fetch_server = FlockFactory.create_mcp_server(
+    name="fetch_server",
+    enable_tools_feature=True,
+    connection_params=FlockFactory.WebsocketParams(
+        url="ws://localhost:4001/message"
+    ),
+```
+
+Add it to Flock
+
+```python 
+flock = Flock(
+    name="mcp_testbed",
+    servers=[
+        ws_fetch_server
+    ]
+)
+```
+
+And tell the flock agents which server to use
+
+```python 
+webcrawler_agent = FlockFactory.create_default_agent(
+    name="webcrawler_agent",
+    description="Expert for looking up and retrieving web content",
+    input="query: str | User-Query, initial_url: Optional[str] | Optional url to start search from.",
+    output="answer: str | Answer to user-query, page_url: str | The url of the page where the answer was found on, page_content: str | Markdown content of the page where the answer was found.",
+    servers=[ws_fetch_server], # servers are passed here.
+)
+```
+
+Done! The Flock agent has now access to every tool the server offers.
 
 
 ### 🚀 REST API – Deploy Flock Agents as REST API Endpoints
@@ -249,7 +286,6 @@ Take note how even custom types like `FantasyCharacter` are serialized so the ta
 name: pydantic_example
 model: openai/gpt-4o
 enable_temporal: false
-enable_logging: false
 show_flock_banner: false
 temporal_start_in_process_worker: true
 agents:

{flock_core-0.4.5 → flock_core-0.4.503}/docs/getting-started/configuration.md

@@ -80,12 +80,15 @@ You can also override or set configurations directly when creating Flock or Floc
 ### Configure Flock instance
 ```python
 from flock.core import Flock, FlockAgent, FlockFactory
+from flock.core.logging.logging import configure_logging
+
+# Only show error logs
+configure_logging("ERROR")
 
 my_flock = Flock(
     name="ConfiguredFlock",
     model="anthropic/claude-3-sonnet-20240229", # Override default model
     enable_temporal=False, # Force local execution
-    enable_logging=True    # Enable logging for this flock instance
 )
 ```
 

{flock_core-0.4.5 → flock_core-0.4.503}/docs/guides/temporal-configuration.md

@@ -152,9 +152,9 @@ async def main():
     )
 
     # 2. Create Flock with Temporal Config
+    configure_logging("ERROR")  # show only errors
     flock = Flock(
         enable_temporal=True, # MUST be True to use Temporal config
-        enable_logging=True,
         temporal_config=workflow_config
     )
 

{flock_core-0.4.5 → flock_core-0.4.503}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.4.5"
+version = "0.4.503"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [
@@ -37,7 +37,7 @@ dependencies = [
     "pillow>=10.4.0",
     "prometheus-client>=0.21.1",
     "psutil>=6.1.1",
-    "pydantic>=2.10.5",
+    "pydantic==2.10.5",
     "pydantic-settings>=2.7.1",
     "python-box>=7.3.2",
     "python-decouple>=3.8",

{flock_core-0.4.5 → flock_core-0.4.503}/src/flock/cli/create_flock.py

@@ -74,19 +74,12 @@ def create_flock():
     # ).ask()
     enable_temporal = False
 
-    # Logging configuration
-    enable_logging = questionary.confirm(
-        "Enable logging?",
-        default=True,
-    ).ask()
-
     # Create the Flock instance
     flock = Flock(
         name=flock_name,
         model=model,
         description=description,
         enable_temporal=enable_temporal,
-        enable_logging=enable_logging,
     )
 
     console.print("\n[green]✓[/] Flock created successfully!")

{flock_core-0.4.5 → flock_core-0.4.503}/src/flock/cli/execute_flock.py

@@ -12,6 +12,7 @@ from rich.console import Console
 from rich.panel import Panel
 
 from flock.core.flock import Flock
+from flock.core.logging.logging import configure_logging
 from flock.core.util.cli_helper import init_console
 
 # Create console instance
@@ -109,9 +110,16 @@ def execute_flock(flock: Flock):
 
     # Logging options
     enable_logging = questionary.confirm(
-        "Enable detailed logging?",
+        "Enable logging?",
         default=False,
     ).ask()
+    if enable_logging:
+        log_level = questionary.select(
+            "Minimum log level:",
+            choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+            default="ERROR",
+        ).ask()
+        configure_logging(flock_level=log_level, external_level=log_level)
 
     # Preview input
     console.print("\n[bold]Input Preview:[/]")
@@ -130,10 +138,7 @@ def execute_flock(flock: Flock):
     console.print("\n[bold]Executing Flock...[/]")
 
     try:
-        # Handle logging settings
-        if enable_logging:
-            # Enable logging through the logging configuration method
-            flock._configure_logging(True)
+        # Logging was configured earlier if enabled
 
         # Run the Flock
         result = flock.run(
@@ -509,9 +514,16 @@ def execute_flock_batch(flock: Flock):
 
     # Logging options
     enable_logging = questionary.confirm(
-        "Enable detailed logging?",
+        "Enable logging?",
         default=False,
     ).ask()
+    if enable_logging:
+        log_level = questionary.select(
+            "Minimum log level:",
+            choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+            default="ERROR",
+        ).ask()
+        configure_logging(log_level)
 
     # Preview configuration
     console.print("\n[bold]Batch Configuration Preview:[/]")
@@ -554,9 +566,7 @@ def execute_flock_batch(flock: Flock):
     console.print("\n[bold]Executing Batch...[/]")
 
     try:
-        # Handle logging settings
-        if enable_logging:
-            flock._configure_logging(True)
+        # Logging was already configured above if enabled
 
         # Run the batch
         results = flock.run_batch(

{flock_core-0.4.5 → flock_core-0.4.503}/src/flock/core/flock.py

@@ -48,7 +48,7 @@ from flock.core.context.context_manager import initialize_context
 # Assuming run_temporal_workflow is correctly placed and importable
 from flock.core.execution.temporal_executor import run_temporal_workflow
 from flock.core.flock_evaluator import FlockEvaluator  # For type hint
-from flock.core.logging.logging import LOGGERS, get_logger, get_module_loggers
+from flock.core.logging.logging import get_logger
 from flock.core.serialization.serializable import Serializable
 from flock.core.util.cli_helper import init_console
 from flock.workflow.temporal_config import TemporalWorkflowConfig
@@ -103,10 +103,6 @@ class Flock(BaseModel, Serializable):
         default=False,
         description="If True, execute workflows via Temporal; otherwise, run locally.",
     )
-    enable_logging: bool = Field(
-        default=False,
-        description="If True, enable logging for the Flock instance.",
-    )
     show_flock_banner: bool = Field(
         default=True,
         description="If True, show the Flock banner on console interactions.",
@@ -183,7 +179,6 @@ class Flock(BaseModel, Serializable):
         description: str | None = None,
         show_flock_banner: bool = True,
         enable_temporal: bool = False,
-        enable_logging: bool | list[str] = False,
         agents: list[FlockAgent] | None = None,
         servers: list[FlockMCPServerBase] | None = None,
         temporal_config: TemporalWorkflowConfig | None = None,
@@ -200,7 +195,6 @@ class Flock(BaseModel, Serializable):
             model=model,
             description=description,
             enable_temporal=enable_temporal,
-            enable_logging=bool(enable_logging), # Store as bool, specific loggers handled by _configure
             show_flock_banner=show_flock_banner,
             temporal_config=temporal_config,
             temporal_start_in_process_worker=temporal_start_in_process_worker,
@@ -214,8 +208,6 @@ class Flock(BaseModel, Serializable):
         self._start_input = {}
         self._mgr = FlockServerManager()
 
-        # Set up logging based on the enable_logging flag
-        self._configure_logging(enable_logging) # Pass original value to _configure_logging
 
         # Register passed servers
         # (need to be registered first so that agents can retrieve them from the registry)
@@ -307,35 +299,6 @@ class Flock(BaseModel, Serializable):
 
         return run
 
-    def _configure_logging(self, enable_logging_config: bool | list[str]):
-        """Configure logging levels based on the enable_logging flag."""
-        is_enabled_globally = False
-        specific_loggers_to_enable = []
-
-        if isinstance(enable_logging_config, bool):
-            is_enabled_globally = enable_logging_config
-        elif isinstance(enable_logging_config, list):
-            is_enabled_globally = bool(enable_logging_config) # True if list is not empty
-            specific_loggers_to_enable = enable_logging_config
-
-        # Configure core loggers
-        for log_name in LOGGERS: # Assuming LOGGERS is a list of known logger names
-            log_instance = get_logger(log_name)
-            if is_enabled_globally or log_name in specific_loggers_to_enable:
-                log_instance.enable_logging = True
-            else:
-                log_instance.enable_logging = False
-
-        # Configure module loggers (existing ones)
-        module_loggers = get_module_loggers() # Assuming this returns list of FlockLogger instances
-        for mod_log in module_loggers:
-            if is_enabled_globally or mod_log.name in specific_loggers_to_enable:
-                mod_log.enable_logging = True
-            else:
-                mod_log.enable_logging = False
-
-        # Update the instance's Pydantic field
-        self.enable_logging = is_enabled_globally or bool(specific_loggers_to_enable)
 
 
     def _set_temporal_debug_flag(self):

{flock_core-0.4.5 → flock_core-0.4.503}/src/flock/core/flock_registry.py

@@ -392,7 +392,7 @@ class FlockRegistry:
         else:
             # Consider adding dynamic import attempts for types if needed,
             # but explicit registration is generally safer for types.
-            logger.error(f"Type '{type_name}' not found in registry.")
+            logger.warning(f"Type '{type_name}' not found in registry. Will attempt to build it from builtins.")
             raise KeyError(
                 f"Type '{type_name}' not found. Ensure it is registered."
             )

{flock_core-0.4.5 → flock_core-0.4.503}/src/flock/core/logging/__init__.py

@@ -1,2 +1,6 @@
 """Flock logging system with Rich integration and structured logging support."""
 
+from .logging import configure_logging
+
+__all__ = ["configure_logging"]
+

{flock_core-0.4.5 → flock_core-0.4.503}/src/flock/core/logging/logging.py

@@ -10,7 +10,9 @@ Key points:
   - Outside workflows, we use Loguru with rich formatting.
 """
 
+import logging
 import sys
+from typing import Literal
 
 from opentelemetry import trace
 
@@ -20,6 +22,19 @@ from temporalio import workflow
 with workflow.unsafe.imports_passed_through():
     from loguru import logger as loguru_logger
 
+# ENABLED_FLOCK_LOGGER_LEVELS constant removed
+
+# Mapping from level names to numeric values
+LOG_LEVELS: dict[str, int] = {
+    "CRITICAL": logging.CRITICAL,
+    "ERROR": logging.ERROR,
+    "WARNING": logging.WARNING,
+    "INFO": logging.INFO,
+    "DEBUG": logging.DEBUG,
+    "SUCCESS": 35,  # Custom success level
+    "NO_LOGS": 100,  # Special level to disable logging
+}
+
 
 def in_workflow_context() -> bool:
     """Returns True if this code is running inside a Temporal workflow context.
@@ -85,6 +100,7 @@ COLOR_MAP = {
 
 LOGGERS = [
     "flock",  # Core Flock orchestration
+    "flock.api", # Flock API specific logs
     "agent",  # General agent operations
     "context",  # Context management
     "registry",  # Unified registry operations (new)
@@ -238,6 +254,50 @@ loguru_logger.add(
 # 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:
+    """Get the default severity for a given level."""
+    if isinstance(level, str):
+        level_str = level.upper()
+        return LOG_LEVELS.get(level_str, LOG_LEVELS["ERROR"])
+    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:
+    """Configure both external and internal Flock logging systems.
+
+    Args:
+        flock_level (str | int): The default logging level (e.g., "INFO", "ERROR", "DEBUG") or numeric level for Flock logging.
+        external_level (str | int): The default logging level (e.g., "INFO", "ERROR", "DEBUG") or numeric level for external logging.
+        specific_levels (dict[str, str | int] | None, optional): A dictionary mapping
+            logger names to their specific logging levels. Defaults to None.
+    """
+    # Get default severity
+
+    external_severity = get_default_severity(external_level)
+    logging.basicConfig(level=external_severity)
+
+
+    flock_severity = get_default_severity(flock_level)
+
+    specific_severities = {}
+    if specific_levels:
+        for name, logger_level in specific_levels.items():
+            severity = get_default_severity(logger_level)
+            specific_severities[name] = severity
+
+    # Apply to all cached loggers
+    for logger_name, log_instance in _LOGGER_CACHE.items():
+        target_severity = flock_severity
+        if logger_name in specific_severities:
+            target_severity = specific_severities[logger_name]
+
+        log_instance.min_level_severity = target_severity
+
+
+
+
 # Define a dummy logger that does nothing
 class DummyLogger:
     """A dummy logger that does nothing when called."""
@@ -276,19 +336,17 @@ class FlockLogger:
     - Otherwise, it uses Loguru.
     """
 
-    def __init__(self, name: str, enable_logging: bool = False):
+    def __init__(self, name: str, initial_min_level_severity: int):
         """Initialize the FlockLogger.
 
         Args:
             name (str): The name of the logger.
-            enable_logging (bool, optional): Whether to enable logging. Defaults to False.
+            initial_min_level_severity (int): The minimum severity level for messages to be logged.
         """
         self.name = name
-        self.enable_logging = enable_logging
+        self.min_level_severity = initial_min_level_severity
 
     def _get_logger(self):
-        if not self.enable_logging:
-            return dummy_logger
         if in_workflow_context():
             # Use Temporal's workflow.logger inside a workflow context.
             return workflow.logger
@@ -316,6 +374,10 @@ class FlockLogger:
         max_length: int = MAX_LENGTH,
         **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:
+            return
         """Debug a message.
 
         Args:
@@ -334,6 +396,10 @@ class FlockLogger:
         max_length: int = MAX_LENGTH,
         **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:
+            return
         """Info a message.
 
         Args:
@@ -352,6 +418,10 @@ class FlockLogger:
         max_length: int = MAX_LENGTH,
         **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:
+            return
         """Warning a message.
 
         Args:
@@ -370,6 +440,10 @@ class FlockLogger:
         max_length: int = MAX_LENGTH,
         **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:
+            return
         """Error a message.
 
         Args:
@@ -388,6 +462,10 @@ 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:
+            return
         """Exception a message.
 
         Args:
@@ -406,6 +484,10 @@ class FlockLogger:
         max_length: int = MAX_LENGTH,
         **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:
+            return
         """Success a message.
 
         Args:
@@ -420,16 +502,21 @@ class FlockLogger:
 _LOGGER_CACHE: dict[str, FlockLogger] = {}
 
 
-def get_logger(name: str = "flock", enable_logging: bool = True) -> FlockLogger:
+def get_logger(name: str = "flock") -> FlockLogger:
     """Return a cached FlockLogger instance for the given name.
 
-    If the logger doesn't exist, create it.
-    If it does exist, update 'enable_logging' if a new value is passed.
+    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 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:
-        _LOGGER_CACHE[name] = FlockLogger(name, enable_logging)
-    else:
-        _LOGGER_CACHE[name].enable_logging = enable_logging
+        # New loggers default to errors-only (min_level_severity = ERROR_SEVERITY)
+        # until explicitly configured by configure_logging()
+        _LOGGER_CACHE[name] = FlockLogger(name, LOG_LEVELS["NO_LOGS"])
+    # The min_level_severity state of existing or newly created loggers
+    # should be managed by the configure_logging() function.
     return _LOGGER_CACHE[name]
 
 

{flock_core-0.4.5 → flock_core-0.4.503}/src/flock/core/util/hydrator.py

@@ -244,7 +244,6 @@ async def _run_hydration_agent(
         temp_flock = Flock(
             name=f"temp_hydrator_flock_{agent_name}",
             model=hydration_model,
-            enable_logging=False,
             show_flock_banner=False,
         )
         temp_flock.add_agent(dynamic_agent)

{flock_core-0.4.5 → flock_core-0.4.503}/src/flock/webapp/app/main.py

@@ -970,7 +970,7 @@ if __name__ == "__main__":
     temp_run_store = RunStore()
     # Create a default/dummy Flock instance for standalone UI testing
     # This allows the UI to function without being started by `Flock.start_api()`
-    dev_flock_instance = Flock(name="DevStandaloneFlock", model="test/dummy", enable_logging=True, show_flock_banner=False)
+    dev_flock_instance = Flock(name="DevStandaloneFlock", model="test/dummy", show_flock_banner=False)
 
     set_global_flock_services(dev_flock_instance, temp_run_store)
     app.state.flock_instance = dev_flock_instance

{flock_core-0.4.5 → flock_core-0.4.503}/src/flock/webapp/app/services/flock_service.py

@@ -84,7 +84,6 @@ def create_new_flock_service(
         model=effective_model,
         description=description,
         show_flock_banner=False,
-        enable_logging=True,
     )
     default_filename = f"{name.replace(' ', '_').lower()}.flock.yaml"
 

{flock_core-0.4.5 → flock_core-0.4.503}/tests/core/test_flock_batch.py

@@ -12,7 +12,7 @@ from flock.evaluators.test.test_case_evaluator import TestCaseEvaluator, TestCas
 @pytest.fixture
 def basic_flock() -> Flock:
     """Fixture for a basic Flock instance."""
-    return Flock(name="test_basic_flock", model="test-model", enable_logging=False, show_flock_banner=False)
+    return Flock(name="test_basic_flock", model="test-model", show_flock_banner=False)
 
 @pytest.fixture
 def simple_agent() -> FlockAgent: