flock-core 0.4.0b1__tar.gz → 0.4.0b3__tar.gz

{flock_core-0.4.0b1 → flock_core-0.4.0b3}/PKG-INFO

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

{flock_core-0.4.0b1 → flock_core-0.4.0b3}/examples/01_introduction/01_simple_example.py

@@ -15,7 +15,7 @@ MODEL = "openai/gpt-4o"
 # Create the flock and context
 # --------------------------------
 # The flock is the place where all the agents are at home
-flock = Flock(name="Example 01", model=MODEL, enable_logging=False)
+flock = Flock(name="Example 01", model=MODEL, enable_logging=True)
 
 # --------------------------------
 # Create an agent

flock_core-0.4.0b1/examples/01_introduction/08_serialization.py → flock_core-0.4.0b3/examples/01_introduction/08a_serialization.py

@@ -11,10 +11,7 @@ Usage:
     python file_path_demo.py
 """
 
-import os
-import tempfile
-from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict
 
 from pydantic import BaseModel, Field
 
@@ -27,11 +24,8 @@ from flock.core import (
     FlockModuleConfig,
     flock_type,
     flock_component,
-    get_registry,
     flock_tool,
 )
-from rich.console import Console
-from rich.table import Table
 
 
 
@@ -42,12 +36,14 @@ class GreetingModuleConfig(FlockModuleConfig):
 
 # The module has a greeting dictionary
 # and will replace the result["greeting"] with the appropriate greeting
+# decoraters add the decorated entity to the registry
 @flock_component
 class GreetingModule(FlockModule):
     """A simple module that generates greetings."""
     config: GreetingModuleConfig = Field(default_factory=GreetingModuleConfig)
     greetings: dict[str, str] = Field(default_factory=dict)
 
+    # The initialize method is called when the agent is initialized
     async def initialize(self, agent: FlockAgent, inputs: Dict, context: FlockContext) -> None:
         """Initialize the module."""
         self.greetings = {
@@ -57,6 +53,8 @@ class GreetingModule(FlockModule):
             "de": "Guten Tag",
         }
 
+    # The post_evaluate method is called after the agent has evaluated
+    # we modify the result before it is returned
     async def post_evaluate(self, agent: FlockAgent, inputs: Dict, result: Dict, context: FlockContext) -> Dict:
         """Post-evaluate the module."""
         name = inputs.get("name", "World")
@@ -69,6 +67,7 @@ class GreetingModule(FlockModule):
     
 
 # Define a custom type
+# The type is added to the registry
 @flock_type
 class Person(BaseModel):
     """A simple person model."""
@@ -77,21 +76,19 @@ class Person(BaseModel):
     languages: list[str] = Field(default_factory=list)
 
 
+# Define a tool
+# The tool is added to the registry
 @flock_tool
 def get_mobile_number(name: str) -> str:
     """A tool that returns a mobile number to a name."""
     return f"1234567890"
 
 
-def demo_file_path_support():
-    """Run the file path support demo."""
-    # Get the current file path to simulate loading from file path
-    current_file_path = os.path.abspath(__file__)
-    print(f"Current file path: {current_file_path}")
-    registry = get_registry()
+def serialization():
+    """Run the serialization demo."""
     
     # Create a Flock instance
-    flock = Flock(name="file_path_demo")
+    flock = Flock(name="file_path_demo", enable_logging=True)
 
     greeting_module = GreetingModule(name="greeting_module", config=GreetingModuleConfig(language="es"))
     
@@ -116,44 +113,16 @@ def demo_file_path_support():
     flock.add_agent(person_agent)
 
     print(f"\nSerializing Flock to: file_path_demo.flock.yaml")
-    flock.to_yaml_file("file_path_demo.flock.yaml", path_type="relative")
+    flock.to_yaml_file("examples/01_introduction/data/file_path_demo.flock.yaml", path_type="relative")
 
     # Display the YAML content
     print("\nYAML Content:")
-    with open("file_path_demo.flock.yaml", "r") as f:
+    with open("examples/01_introduction/data/file_path_demo.flock.yaml", "r") as f:
         yaml_content = f.read()
         print(yaml_content)
 
-
-    try:
-        # Attempt to load the Flock
-        loaded_flock = Flock.load_from_file("file_path_demo.flock.yaml")
-        
-        # Test the loaded Flock
-        print("\nTesting loaded Flock:")
-        result = loaded_flock.run(
-            start_agent="greeter",
-            input={"name": "File Path User"}
-        )
-        print(f"Greeting result by the greeting module: {result}")
-        
-        # Test the person agent
-        person_result = loaded_flock.run(
-            start_agent="person_creator",
-            input={
-                "name": "File Path Person",
-                "age": 30,
-                "languages": ["en", "es"]
-            }
-        )
-        print(f"Person result as Person type: {person_result.person}")
-        
-        print("\nSuccessfully loaded and executed Flock using file path fallback!")
-        
-    except Exception as e:
-        print(f"Error loading Flock: {e}")
     
 
 
 if __name__ == "__main__":
-    demo_file_path_support() 
+    serialization() 

flock_core-0.4.0b3/examples/01_introduction/08b_deserialization.py

@@ -0,0 +1,57 @@
+"""
+Demo of File Path Support in Flock Serialization
+
+This example demonstrates:
+1. Creating a custom component class
+2. Creating a Flock with that component
+3. Serializing it to YAML with file paths
+4. Loading it back using file path fallback
+
+Usage:
+    python file_path_demo.py
+"""
+
+
+
+from flock.core import (
+    Flock,
+)
+
+
+
+def deserialization():
+    """Run the deserialization demo."""
+    
+  
+    try:
+        # Attempt to load the Flock
+        loaded_flock = Flock.load_from_file("examples/01_introduction/data/file_path_demo.flock.yaml")
+        
+        # Test the loaded Flock
+        print("\nTesting loaded Flock:")
+        result = loaded_flock.run(
+            start_agent="greeter",
+            input={"name": "File Path User"}
+        )
+        print(f"Greeting result by the greeting module: {result}")
+        
+        # Test the person agent
+        person_result = loaded_flock.run(
+            start_agent="person_creator",
+            input={
+                "name": "File Path Person",
+                "age": 30,
+                "languages": ["en", "es"]
+            }
+        )
+        print(f"Person result as Person type: {person_result.person}")
+        
+        print("\nSuccessfully loaded and executed Flock using file path fallback!")
+        
+    except Exception as e:
+        print(f"Error loading Flock: {e}")
+    
+
+
+if __name__ == "__main__":
+    deserialization() 

flock_core-0.4.0b3/examples/01_introduction/data/file_path_demo.flock.yaml

@@ -0,0 +1,165 @@
+name: file_path_demo
+model: openai/gpt-4o
+enable_temporal: false
+enable_logging: true
+show_flock_banner: true
+agents:
+  greeter:
+    name: greeter
+    model: openai/gpt-4o
+    input: 'name: str'
+    output: 'greeting: str, mobile_number: str'
+    use_cache: true
+    evaluator:
+      name: default
+      config:
+        model: openai/gpt-4o
+        use_cache: true
+        temperature: 0.0
+        max_tokens: 4096
+      type: DeclarativeEvaluator
+    modules:
+      output:
+        name: output
+        config:
+          enabled: true
+          theme: abernathy
+          render_table: false
+          max_length: 1000
+          wait_for_input: false
+          write_to_file: false
+          output_dir: output/
+          truncate_long_values: true
+          show_metadata: true
+          format_code_blocks: true
+          custom_formatters: {}
+          no_output: false
+          print_context: false
+        type: OutputModule
+      metrics:
+        name: metrics
+        config:
+          enabled: true
+          collect_timing: true
+          collect_memory: true
+          collect_token_usage: true
+          collect_cpu: true
+          storage_type: json
+          metrics_dir: metrics/
+          aggregation_interval: 1h
+          retention_days: 30
+          alert_on_high_latency: true
+          latency_threshold_ms: 30000
+        type: MetricsModule
+      greeting_module:
+        name: greeting_module
+        config:
+          enabled: true
+          language: es
+        greetings: {}
+        type: GreetingModule
+    tools:
+    - get_mobile_number
+  person_creator:
+    name: person_creator
+    model: openai/gpt-4o
+    input: 'name: str, age: int, languages: list[str]'
+    output: 'person: Person'
+    use_cache: true
+    evaluator:
+      name: default
+      config:
+        model: openai/gpt-4o
+        use_cache: true
+        temperature: 0.0
+        max_tokens: 4096
+      type: DeclarativeEvaluator
+    modules:
+      output:
+        name: output
+        config:
+          enabled: true
+          theme: abernathy
+          render_table: false
+          max_length: 1000
+          wait_for_input: false
+          write_to_file: false
+          output_dir: output/
+          truncate_long_values: true
+          show_metadata: true
+          format_code_blocks: true
+          custom_formatters: {}
+          no_output: false
+          print_context: false
+        type: OutputModule
+      metrics:
+        name: metrics
+        config:
+          enabled: true
+          collect_timing: true
+          collect_memory: true
+          collect_token_usage: true
+          collect_cpu: true
+          storage_type: json
+          metrics_dir: metrics/
+          aggregation_interval: 1h
+          retention_days: 30
+          alert_on_high_latency: true
+          latency_threshold_ms: 30000
+        type: MetricsModule
+types:
+  Person:
+    module_path: __main__
+    type: pydantic.BaseModel
+    schema:
+      description: A simple person model.
+      properties:
+        name:
+          description: The name of the person IN ALL CAPS
+          title: Name
+          type: string
+        age:
+          title: Age
+          type: integer
+        languages:
+          items:
+            type: string
+          title: Languages
+          type: array
+      required:
+      - name
+      - age
+      type: object
+    imports:
+    - from __main__ import Person
+components:
+  DeclarativeEvaluator:
+    type: flock_component
+    module_path: flock.evaluators.declarative.declarative_evaluator
+    file_path: src/flock/evaluators/declarative/declarative_evaluator.py
+    description: Evaluator that uses DSPy for generation.
+  OutputModule:
+    type: flock_component
+    module_path: flock.modules.output.output_module
+    file_path: src/flock/modules/output/output_module.py
+    description: Module that handles output formatting and display.
+  MetricsModule:
+    type: flock_component
+    module_path: flock.modules.performance.metrics_module
+    file_path: src/flock/modules/performance/metrics_module.py
+    description: Module for collecting and analyzing agent performance metrics.
+  GreetingModule:
+    type: flock_component
+    module_path: __main__
+    file_path: examples/01_introduction/08a_serialization.py
+    description: A simple module that generates greetings.
+  get_mobile_number:
+    type: flock_callable
+    module_path: __main__
+    file_path: examples/01_introduction/08a_serialization.py
+    description: A tool that returns a mobile number to a name.
+dependencies:
+- pydantic>=2.0.0
+- flock>=0.3.41
+metadata:
+  path_type: relative

{flock_core-0.4.0b1 → flock_core-0.4.0b3}/examples/03_apps/story_gen/main.py

@@ -108,10 +108,11 @@ story_agent = FlockFactory.create_default_agent(name="story_agent",
 
 
 flock.add_agent(story_agent)
-result = flock.run(start_agent=story_agent, 
-                   input={'story_idea': 
-                       'In a world right at the cusp between LLMs and AGI some guy is experiencing the most peculiar story.' 
-                       'Absurdist Fiction, Satire, Technological Comedy. As much content as possible. At least 10.000 words'}) 
+flock.to_yaml_file("story_agent.flock.yaml")
+# result = flock.run(start_agent=story_agent, 
+#                    input={'story_idea': 
+#                        'In a world right at the cusp between LLMs and AGI some guy is experiencing the most peculiar story.' 
+#                        'Absurdist Fiction, Satire, Technological Comedy. As much content as possible. At least 10.000 words'}) 
 
 
 

{flock_core-0.4.0b1 → flock_core-0.4.0b3}/pyproject.toml

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

{flock_core-0.4.0b1 → flock_core-0.4.0b3}/src/flock/core/flock.py

@@ -23,6 +23,10 @@ from flock.core.context.context_manager import initialize_context
 from flock.core.execution.local_executor import run_local_workflow
 from flock.core.execution.temporal_executor import run_temporal_workflow
 from flock.core.logging.logging import LOGGERS, get_logger, get_module_loggers
+from flock.core.serialization.serialization_utils import (
+    extract_pydantic_models_from_type_string,
+)
+from flock.core.util.input_resolver import split_top_level
 
 # Import FlockAgent using TYPE_CHECKING to avoid circular import at runtime
 if TYPE_CHECKING:
@@ -90,6 +94,14 @@ 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.",
+    )
     # --- Runtime Attributes (Excluded from Serialization) ---
     # Store agents internally but don't make it part of the Pydantic model definition
     # Use a regular attribute, initialized in __init__
@@ -126,6 +138,8 @@ class Flock(BaseModel, Serializable):
             model=model,
             description=description,
             enable_temporal=enable_temporal,
+            enable_logging=enable_logging,
+            show_flock_banner=show_flock_banner,
             **kwargs,  # Pass extra kwargs to Pydantic BaseModel
         )
 
@@ -275,30 +289,21 @@ class Flock(BaseModel, Serializable):
         # Check if an event loop is already running
         try:
             loop = asyncio.get_running_loop()
-            # If we get here, an event loop is already running
-            # Run directly in this loop using run_until_complete
-            return loop.run_until_complete(
-                self.run_async(
-                    start_agent=start_agent,
-                    input=input,
-                    context=context,
-                    run_id=run_id,
-                    box_result=box_result,
-                    agents=agents,
-                )
-            )
-        except RuntimeError:
-            # No running event loop, create a new one with asyncio.run
-            return asyncio.run(
-                self.run_async(
-                    start_agent=start_agent,
-                    input=input,
-                    context=context,
-                    run_id=run_id,
-                    box_result=box_result,
-                    agents=agents,
-                )
+        except (
+            RuntimeError
+        ):  # 'RuntimeError: There is no current event loop...'
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        return loop.run_until_complete(
+            self.run_async(
+                start_agent=start_agent,
+                input=input,
+                context=context,
+                run_id=run_id,
+                box_result=box_result,
+                agents=agents,
             )
+        )
 
     async def run_async(
         self,
@@ -476,6 +481,21 @@ class Flock(BaseModel, Serializable):
                 agent_data = agent_instance.to_dict()
                 data["agents"][name] = agent_data
 
+                if agent_instance.input:
+                    logger.debug(
+                        f"Extracting type information from agent '{name}' input: {agent_instance.input}"
+                    )
+                    input_types = self._extract_types_from_signature(
+                        agent_instance.input
+                    )
+                    if input_types:
+                        logger.debug(
+                            f"Found input types in agent '{name}': {input_types}"
+                        )
+                        custom_types.update(
+                            self._get_type_definitions(input_types)
+                        )
+
                 # Extract type information from agent outputs
                 if agent_instance.output:
                     logger.debug(
@@ -590,39 +610,49 @@ class Flock(BaseModel, Serializable):
         if not signature:
             return []
 
+        signature_parts = split_top_level(signature)
+
         # Basic type extraction - handles simple cases like "result: TypeName" or "list[TypeName]"
         custom_types = []
 
         # Look for type annotations (everything after ":")
-        parts = signature.split(":")
-        if len(parts) > 1:
-            type_part = parts[1].strip()
-
-            # Extract from list[Type]
-            if "list[" in type_part:
-                inner_type = type_part.split("list[")[1].split("]")[0].strip()
-                if inner_type and inner_type.lower() not in [
-                    "str",
-                    "int",
-                    "float",
-                    "bool",
-                    "dict",
-                    "list",
-                ]:
-                    custom_types.append(inner_type)
-
-            # Extract direct type references
-            elif type_part and type_part.lower() not in [
-                "str",
-                "int",
-                "float",
-                "bool",
-                "dict",
-                "list",
-            ]:
-                custom_types.append(
-                    type_part.split()[0]
-                )  # Take the first word in case there's a description
+        for part in signature_parts:
+            parts = part.split(":")
+            if len(parts) > 1:
+                type_part = parts[1].strip()
+
+            pydantic_models = extract_pydantic_models_from_type_string(
+                type_part
+            )
+            if pydantic_models:
+                for model in pydantic_models:
+                    custom_types.append(model.__name__)
+
+            # # Extract from list[Type]
+            # if "list[" in type_part:
+            #     inner_type = type_part.split("list[")[1].split("]")[0].strip()
+            #     if inner_type and inner_type.lower() not in [
+            #         "str",
+            #         "int",
+            #         "float",
+            #         "bool",
+            #         "dict",
+            #         "list",
+            #     ]:
+            #         custom_types.append(inner_type)
+
+            # # Extract direct type references
+            # elif type_part and type_part.lower() not in [
+            #     "str",
+            #     "int",
+            #     "float",
+            #     "bool",
+            #     "dict",
+            #     "list",
+            # ]:
+            #     custom_types.append(
+            #         type_part.split()[0]
+            #     )  # Take the first word in case there's a description
 
         return custom_types
 

{flock_core-0.4.0b1 → flock_core-0.4.0b3}/src/flock/core/flock_registry.py

@@ -259,7 +259,7 @@ class FlockRegistry:
                     f"Type '{type_name}' already registered. Overwriting."
                 )
             self._types[type_name] = type_obj
-            # logger.debug(f"Registered type: {type_name}")
+            logger.debug(f"Registered type: {type_name}")
             return type_name
         return None
 

{flock_core-0.4.0b1 → flock_core-0.4.0b3}/src/flock/core/serialization/serializable.py

@@ -87,7 +87,7 @@ class Serializable(ABC):
     # --- YAML Methods ---
     def to_yaml(
         self,
-        path_type: Literal["absolute", "relative"],
+        path_type: Literal["absolute", "relative"] = "relative",
         sort_keys=False,
         default_flow_style=False,
     ) -> str:
@@ -144,7 +144,7 @@ class Serializable(ABC):
     def to_yaml_file(
         self,
         path: Path | str,
-        path_type: Literal["absolute", "relative"] = "absolute",
+        path_type: Literal["absolute", "relative"] = "relative",
         **yaml_dump_kwargs,
     ) -> None:
         """Serialize to YAML file.