flock-core 0.4.0b20__tar.gz → 0.4.0b21__tar.gz

{flock_core-0.4.0b20 → flock_core-0.4.0b21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b20
+Version: 0.4.0b21
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE

{flock_core-0.4.0b20 → flock_core-0.4.0b21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.4.0b-20"
+version = "0.4.0b-21"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [

{flock_core-0.4.0b20 → flock_core-0.4.0b21}/src/flock/core/flock.py

@@ -350,13 +350,9 @@ class Flock(BaseModel, Serializable):
             try:
                 resolved_start_agent = self._agents.get(start_agent_name)
                 if not resolved_start_agent:
-                    resolved_start_agent = FlockRegistry.get_agent(
-                        start_agent_name
-                    )
+                    resolved_start_agent = FlockRegistry.get_agent(start_agent_name)
                     if not resolved_start_agent:
-                        raise ValueError(
-                            f"Start agent '{start_agent_name}' not found."
-                        )
+                        raise ValueError(f"Start agent '{start_agent_name}' not found.")
                     self.add_agent(resolved_start_agent)
 
                 run_context = context if context else FlockContext()
@@ -388,20 +384,15 @@ class Flock(BaseModel, Serializable):
 
                 # Execute workflow
                 if not self.enable_temporal:
-                    result = await run_local_workflow(
-                        run_context, box_result=False
-                    )
+                    result = await run_local_workflow(run_context, box_result=False)
                 else:
-                    result = await run_temporal_workflow(
-                        run_context, box_result=False
-                    )
+                    result = await run_temporal_workflow(run_context, box_result=False)
 
                 span.set_attribute("result.type", str(type(result)))
                 result_str = str(result)
                 span.set_attribute(
                     "result.preview",
-                    result_str[:1000]
-                    + ("..." if len(result_str) > 1000 else ""),
+                    result_str[:1000] + ("..." if len(result_str) > 1000 else ""),
                 )
 
                 if box_result:
@@ -409,17 +400,13 @@ class Flock(BaseModel, Serializable):
                         logger.debug("Boxing final result.")
                         return Box(result)
                     except ImportError:
-                        logger.warning(
-                            "Box library not installed, returning raw dict."
-                        )
+                        logger.warning("Box library not installed, returning raw dict.")
                         return result
                 else:
                     return result
 
             except Exception as e:
-                logger.error(
-                    f"Flock run '{self.name}' failed: {e}", exc_info=True
-                )
+                logger.error(f"Flock run '{self.name}' failed: {e}", exc_info=True)
                 span.record_exception(e)
                 span.set_status(trace.Status(trace.StatusCode.ERROR, str(e)))
                 return {

{flock_core-0.4.0b20 → flock_core-0.4.0b21}/src/flock/core/logging/logging.py

@@ -144,9 +144,7 @@ def custom_format(record):
     level_name = record["level"].name
     category = record["extra"].get("category", "unknown")
     trace_id = record["extra"].get("trace_id", "no-trace")
-    color_tag = color_for_category(
-        category
-    )  # Get the color tag name (e.g., "yellow")
+    color_tag = color_for_category(category)  # Get the color tag name (e.g., "yellow")
 
     message = record["message"]
     message = message.replace("{", "{{").replace("}", "}}")
@@ -155,8 +153,7 @@ def custom_format(record):
     if len(message) > MAX_LENGTH:
         truncated_chars = len(message) - MAX_LENGTH
         message = (
-            message[:MAX_LENGTH]
-            + f"<yellow>...+({truncated_chars} chars)</yellow>"
+            message[:MAX_LENGTH] + f"<yellow>...+({truncated_chars} chars)</yellow>"
         )
 
     # Determine if category needs bolding (can refine this logic)
@@ -164,13 +161,9 @@ def custom_format(record):
 
     # Apply tags sequentially
     category_styled = f"[{category}]"  # Start with the plain category name
-    category_styled = (
-        f"<{color_tag}>{category_styled}</{color_tag}>"  # Wrap with color
-    )
+    category_styled = f"<{color_tag}>{category_styled}</{color_tag}>"  # Wrap with color
     if needs_bold:
-        category_styled = (
-            f"<bold>{category_styled}</bold>"  # Wrap with bold if needed
-        )
+        category_styled = f"<bold>{category_styled}</bold>"  # Wrap with bold if needed
 
     # Final format string using sequential tags for category
     return (
@@ -311,8 +304,7 @@ class FlockLogger:
         if len(message) > max_length:
             truncated_chars = len(message) - max_length
             return (
-                message[:max_length]
-                + f"...<yellow>+({truncated_chars} chars)</yellow>"
+                message[:max_length] + f"...<yellow>+({truncated_chars} chars)</yellow>"
             )
         return message
 
@@ -454,10 +446,7 @@ def get_module_loggers() -> list[FlockLogger]:
 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)"
-        )
+        return obj[:max_item_length] + f"... ({len(obj) - max_item_length} more chars)"
     elif isinstance(obj, dict):
         if len(obj) > max_items:
             return {

{flock_core-0.4.0b20 → flock_core-0.4.0b21}/src/flock/core/mixin/dspy_integration.py

@@ -93,26 +93,20 @@ def _resolve_type_string(type_str: str) -> type:
     if generic_match:
         base_name = generic_match.group(1).strip()
         args_str = generic_match.group(2).strip()
-        logger.debug(
-            f"Detected generic pattern: Base='{base_name}', Args='{args_str}'"
-        )
+        logger.debug(f"Detected generic pattern: Base='{base_name}', Args='{args_str}'")
 
         try:
             # Get the base generic type (e.g., list, dict, Optional) from registry/builtins
             BaseType = FlockRegistry.get_type(
                 base_name
             )  # Expects List, Dict etc. to be registered
-            logger.debug(
-                f"Resolved base generic type '{base_name}' to: {BaseType}"
-            )
+            logger.debug(f"Resolved base generic type '{base_name}' to: {BaseType}")
 
             # Special handling for Literal
             if BaseType is typing.Literal:
                 # Split literal values, remove quotes, strip whitespace
                 literal_args_raw = split_top_level(args_str)
-                literal_args = tuple(
-                    s.strip().strip("'\"") for s in literal_args_raw
-                )
+                literal_args = tuple(s.strip().strip("'\"") for s in literal_args_raw)
                 logger.debug(
                     f"Parsing Literal arguments: {literal_args_raw} -> {literal_args}"
                 )
@@ -127,9 +121,7 @@ def _resolve_type_string(type_str: str) -> type:
             if not arg_strs:
                 raise ValueError("Generic type has no arguments.")
 
-            resolved_arg_types = tuple(
-                _resolve_type_string(arg) for arg in arg_strs
-            )
+            resolved_arg_types = tuple(_resolve_type_string(arg) for arg in arg_strs)
             logger.debug(f"Resolved generic arguments: {resolved_arg_types}")
 
             # Construct the generic type hint
@@ -137,9 +129,7 @@ def _resolve_type_string(type_str: str) -> type:
                 if len(resolved_arg_types) != 1:
                     raise ValueError("Optional requires exactly one argument.")
                 resolved_type = typing.Union[resolved_arg_types[0], type(None)]  # type: ignore
-                logger.debug(
-                    f"Constructed Optional type as Union: {resolved_type}"
-                )
+                logger.debug(f"Constructed Optional type as Union: {resolved_type}")
                 return resolved_type
             elif BaseType is typing.Union:
                 if not resolved_arg_types:
@@ -151,9 +141,7 @@ def _resolve_type_string(type_str: str) -> type:
                 BaseType, "__getitem__"
             ):  # Check if subscriptable (like list, dict, List, Dict)
                 resolved_type = BaseType[resolved_arg_types]  # type: ignore
-                logger.debug(
-                    f"Constructed subscripted generic type: {resolved_type}"
-                )
+                logger.debug(f"Constructed subscripted generic type: {resolved_type}")
                 return resolved_type
             else:
                 # Base type found but cannot be subscripted
@@ -244,15 +232,11 @@ class DSPyIntegrationMixin:
                     )
 
                     FieldClass = (
-                        dspy.InputField
-                        if field_kind == "input"
-                        else dspy.OutputField
+                        dspy.InputField if field_kind == "input" else dspy.OutputField
                     )
                     # DSPy Fields use 'desc' for description
                     class_dict[name] = (
-                        FieldClass(desc=desc)
-                        if desc is not None
-                        else FieldClass()
+                        FieldClass(desc=desc) if desc is not None else FieldClass()
                     )
 
         try:
@@ -263,15 +247,11 @@ class DSPyIntegrationMixin:
                 f"Error processing fields for DSPy signature '{agent_name}': {e}",
                 exc_info=True,
             )
-            raise ValueError(
-                f"Could not process fields for signature: {e}"
-            ) from e
+            raise ValueError(f"Could not process fields for signature: {e}") from e
 
         # Create and return the dynamic class
         try:
-            DynamicSignature = type(
-                "dspy_" + agent_name, (base_class,), class_dict
-            )
+            DynamicSignature = type("dspy_" + agent_name, (base_class,), class_dict)
             logger.info(
                 f"Successfully created DSPy Signature: {DynamicSignature.__name__} "
                 f"with fields: {DynamicSignature.__annotations__}"
@@ -344,9 +324,7 @@ class DSPyIntegrationMixin:
         try:
             import dspy
         except ImportError:
-            logger.error(
-                "DSPy library is not installed. Cannot select DSPy task."
-            )
+            logger.error("DSPy library is not installed. Cannot select DSPy task.")
             raise ImportError("DSPy is required for this functionality.")
 
         processed_tools = []
@@ -365,9 +343,7 @@ class DSPyIntegrationMixin:
 
         # Determine type if not overridden
         if not selected_type:
-            selected_type = (
-                "ReAct" if processed_tools else "Predict"
-            )  # Default logic
+            selected_type = "ReAct" if processed_tools else "Predict"  # Default logic
 
         logger.debug(
             f"Selecting DSPy program type: {selected_type} (Tools provided: {bool(processed_tools)})"
@@ -390,9 +366,7 @@ class DSPyIntegrationMixin:
                 )
                 dspy_program = dspy.Predict(signature)
 
-            logger.info(
-                f"Instantiated DSPy program: {type(dspy_program).__name__}"
-            )
+            logger.info(f"Instantiated DSPy program: {type(dspy_program).__name__}")
             return dspy_program
         except Exception as e:
             logger.error(
@@ -416,9 +390,7 @@ class DSPyIntegrationMixin:
                 output_dict = dict(result.items())
             elif hasattr(result, "__dict__"):  # Fallback for other object types
                 output_dict = {
-                    k: v
-                    for k, v in result.__dict__.items()
-                    if not k.startswith("_")
+                    k: v for k, v in result.__dict__.items() if not k.startswith("_")
                 }
             else:
                 # If it's already a dict (less common for DSPy results directly)

{flock_core-0.4.0b20 → flock_core-0.4.0b21}/src/flock/core/serialization/serialization_utils.py

@@ -57,9 +57,7 @@ def _format_type_to_string(type_hint: type) -> str:
             inner_type = next(t for t in args if t is not type(None))
             return _format_type_to_string(inner_type)
         # return f"Optional[{_format_type_to_string(inner_type)}]"
-        return (
-            f"Union[{', '.join(_format_type_to_string(arg) for arg in args)}]"
-        )
+        return f"Union[{', '.join(_format_type_to_string(arg) for arg in args)}]"
     elif origin is Literal:
         formatted_args = []
         for arg in args:
@@ -68,9 +66,7 @@ def _format_type_to_string(type_hint: type) -> str:
             else:
                 formatted_args.append(str(arg))
         return f"Literal[{', '.join(formatted_args)}]"
-    elif hasattr(
-        type_hint, "__forward_arg__"
-    ):  # Handle ForwardRefs if necessary
+    elif hasattr(type_hint, "__forward_arg__"):  # Handle ForwardRefs if necessary
         return type_hint.__forward_arg__
     elif hasattr(type_hint, "__name__"):
         # Handle custom types registered in registry (get preferred name)
@@ -87,9 +83,7 @@ def _format_type_to_string(type_hint: type) -> str:
         type_repr = str(type_hint).replace("typing.", "")  # Basic cleanup
         type_repr = str(type_hint).replace("| None", "")
         type_repr = type_repr.strip()
-        logger.debug(
-            f"Using fallback string representation for type: {type_repr}"
-        )
+        logger.debug(f"Using fallback string representation for type: {type_repr}")
         return type_repr
 
 
@@ -199,9 +193,7 @@ def serialize_item(item: Any) -> Any:
         dumped = item.model_dump(mode="json", exclude_none=True)
         return serialize_item(dumped)
     elif callable(item) and not isinstance(item, type):
-        path_str = FlockRegistry.get_callable_path_string(
-            item
-        )  # Use registry helper
+        path_str = FlockRegistry.get_callable_path_string(item)  # Use registry helper
         if path_str:
             return {"__callable_ref__": path_str}
         else:
@@ -226,9 +218,7 @@ def serialize_item(item: Any) -> Any:
         )  # Check regular types/classes by path
         if type_name:
             return {"__type_ref__": type_name}
-        logger.warning(
-            f"Could not serialize type object {item}, storing as string."
-        )
+        logger.warning(f"Could not serialize type object {item}, storing as string.")
         return str(item)
     else:
         # Return basic types as is
@@ -283,9 +273,7 @@ def deserialize_item(item: Any) -> Any:
                         mod = importlib.import_module(module_name)
                     type_obj = getattr(mod, class_name)
                     if isinstance(type_obj, type):
-                        FlockRegistry.register_type(
-                            type_obj, type_name
-                        )  # Cache it
+                        FlockRegistry.register_type(type_obj, type_name)  # Cache it
                         return type_obj
                     else:
                         raise TypeError()
@@ -306,9 +294,7 @@ def deserialize_item(item: Any) -> Any:
 
 
 # --- Component Deserialization Helper ---
-def deserialize_component(
-    data: dict | None, expected_base_type: type
-) -> Any | None:
+def deserialize_component(data: dict | None, expected_base_type: type) -> Any | None:
     """Deserializes a component (Module, Evaluator, Router) from its dict representation.
     Uses the 'type' field to find the correct class via FlockRegistry.
     """
@@ -320,14 +306,10 @@ def deserialize_component(
     if data is None:
         return None
     if not isinstance(data, dict):
-        logger.error(
-            f"Expected dict for component deserialization, got {type(data)}"
-        )
+        logger.error(f"Expected dict for component deserialization, got {type(data)}")
         return None
 
-    type_name = data.get(
-        "type"
-    )  # Assuming 'type' key holds the class name string
+    type_name = data.get("type")  # Assuming 'type' key holds the class name string
     if not type_name:
         logger.error(f"Component data missing 'type' field: {data}")
         return None
@@ -335,9 +317,7 @@ def deserialize_component(
     try:
         ComponentClass = FlockRegistry.get_component(type_name)  # Use registry
         # Optional: Keep the base type check
-        if COMPONENT_BASE_TYPES and not issubclass(
-            ComponentClass, expected_base_type
-        ):
+        if COMPONENT_BASE_TYPES and not issubclass(ComponentClass, expected_base_type):
             raise TypeError(
                 f"Deserialized class {type_name} is not a subclass of {expected_base_type.__name__}"
             )

{flock_core-0.4.0b20 → flock_core-0.4.0b21}/src/flock/core/util/cli_helper.py

@@ -64,14 +64,14 @@ def init_console(clear_screen: bool = True, show_banner: bool = True):
     if show_banner:
         console.print(banner_text)
     console.print(
-        f"[italic]'Magpie'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
+        "[italic]'Magpie'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
     )
 
 
 def display_banner_no_version():
     """Display the Flock banner."""
     banner_text = Text(
-        f"""
+        """
 🦆    🐓     🐤     🐧
 ╭━━━━━━━━━━━━━━━━━━━━━━━━╮
 │ ▒█▀▀▀ █░░ █▀▀█ █▀▀ █░█ │
@@ -84,4 +84,4 @@ def display_banner_no_version():
         style="bold orange3",
     )
     console.print(banner_text)
-    console.print(f"[bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n")
+    console.print("[bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n")

{flock_core-0.4.0b20 → flock_core-0.4.0b21}/src/flock/core/util/hydrator.py

@@ -21,9 +21,7 @@ logger = get_logger("hydrator")
 T = TypeVar("T", bound=BaseModel)
 
 
-def flockclass(
-    model: str = "openai/gpt-4o", agent_description: str | None = None
-):
+def flockclass(model: str = "openai/gpt-4o", agent_description: str | None = None):
     """Decorator to add a .hydrate() method to a Pydantic class.
     Leverages a dynamic Flock agent to fill missing (None) fields.
 
@@ -90,9 +88,7 @@ def flockclass(
                 return self  # Return early if agent run failed
 
             # Update object fields with results
-            _update_fields_with_results(
-                self, result, missing_fields, class_name
-            )
+            _update_fields_with_results(self, result, missing_fields, class_name)
 
             return self
 
@@ -109,9 +105,7 @@ def flockclass(
                     import concurrent.futures
 
                     with concurrent.futures.ThreadPoolExecutor() as executor:
-                        future = executor.submit(
-                            asyncio.run, hydrate_async(self)
-                        )
+                        future = executor.submit(asyncio.run, hydrate_async(self))
                         return future.result()
                 else:
                     # There's a loop but it's not running
@@ -124,9 +118,7 @@ def flockclass(
         # Attach the methods to the class
         setattr(cls, "hydrate_async", hydrate_async)
         setattr(cls, "hydrate", hydrate)
-        setattr(
-            cls, "hydrate_sync", hydrate
-        )  # Alias for backward compatibility
+        setattr(cls, "hydrate_sync", hydrate)  # Alias for backward compatibility
 
         logger.debug(f"Attached hydrate methods to class {cls.__name__}")
         return cls
@@ -141,14 +133,10 @@ def _get_model_fields(
     try:
         if hasattr(obj, "model_fields"):  # Pydantic v2
             all_fields = obj.model_fields
-            type_hints = {
-                name: field.annotation for name, field in all_fields.items()
-            }
+            type_hints = {name: field.annotation for name, field in all_fields.items()}
         else:  # Pydantic v1 fallback
             type_hints = get_type_hints(obj.__class__)
-            all_fields = getattr(
-                obj, "__fields__", {name: None for name in type_hints}
-            )
+            all_fields = getattr(obj, "__fields__", {name: None for name in type_hints})
         return all_fields, type_hints
     except Exception as e:
         logger.error(
@@ -268,9 +256,7 @@ async def _run_hydration_agent(
             else {"context_info": {"object_type": class_name}}
         )
 
-        logger.info(
-            f"Running hydration agent '{agent_name}' for {class_name}..."
-        )
+        logger.info(f"Running hydration agent '{agent_name}' for {class_name}...")
 
         # Run agent
         result = await temp_flock.run_async(
@@ -278,9 +264,7 @@ async def _run_hydration_agent(
             input=agent_input_data,
             box_result=False,
         )
-        logger.info(
-            f"Hydration agent returned for {class_name}: {list(result.keys())}"
-        )
+        logger.info(f"Hydration agent returned for {class_name}: {list(result.keys())}")
 
         return result
 

{flock_core-0.4.0b20 → flock_core-0.4.0b21}/src/flock/evaluators/declarative/declarative_evaluator.py

@@ -35,9 +35,7 @@ class DeclarativeEvaluatorConfig(FlockEvaluatorConfig):
     kwargs: dict[str, Any] = Field(default_factory=dict)
 
 
-class DeclarativeEvaluator(
-    FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin
-):
+class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
     """Evaluator that uses DSPy for generation."""
 
     config: DeclarativeEvaluatorConfig = Field(
@@ -91,14 +89,10 @@ class DeclarativeEvaluator(
 
         # --- Conditional Evaluation (Stream vs No Stream) ---
         if self.config.stream:
-            logger.info(
-                f"Evaluating agent '{agent.name}' with async streaming."
-            )
+            logger.info(f"Evaluating agent '{agent.name}' with async streaming.")
             if not callable(agent_task):
                 logger.error("agent_task is not callable, cannot stream.")
-                raise TypeError(
-                    "DSPy task could not be created or is not callable."
-                )
+                raise TypeError("DSPy task could not be created or is not callable.")
 
             streaming_task = dspy.streamify(agent_task)
             stream_generator: Generator = streaming_task(**inputs)
@@ -118,9 +112,7 @@ class DeclarativeEvaluator(
                 if delta_content:
                     console.print(delta_content, end="")
 
-                result_dict, cost, lm_history = self._process_result(
-                    chunk, inputs
-                )
+                result_dict, cost, lm_history = self._process_result(chunk, inputs)
                 self.cost = cost
                 self.lm_history = lm_history
 
@@ -134,9 +126,7 @@ class DeclarativeEvaluator(
             try:
                 # Ensure the call is awaited if the underlying task is async
                 result_obj = agent_task(**inputs)
-                result_dict, cost, lm_history = self._process_result(
-                    result_obj, inputs
-                )
+                result_dict, cost, lm_history = self._process_result(result_obj, inputs)
                 self.cost = cost
                 self.lm_history = lm_history
                 return self.filter_thought_process(

{flock_core-0.4.0b20 → flock_core-0.4.0b21}/uv.lock

@@ -1245,7 +1245,7 @@ wheels = [
 
 [[package]]
 name = "flock-core"
-version = "0.4.0b20"
+version = "0.4.0b21"
 source = { editable = "." }
 dependencies = [
     { name = "azure-search-documents" },