flock-core 0.4.0b1__py3-none-any.whl → 0.4.0b3__py3-none-any.whl

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/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/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.

flock/core/serialization/serialization_utils.py

@@ -1,9 +1,12 @@
 # src/flock/core/serialization/serialization_utils.py
 """Utilities for recursive serialization/deserialization with callable handling."""
 
+import ast
+import builtins
 import importlib
+import sys
 from collections.abc import Mapping, Sequence
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, get_args, get_origin
 
 from pydantic import BaseModel
 
@@ -21,6 +24,98 @@ logger = get_logger("serialization.utils")
 # --- Serialization Helper ---
 
 
+def extract_identifiers_from_type_str(type_str: str) -> set[str]:
+    """Extract all identifiers from a type annotation string using the AST."""
+    tree = ast.parse(type_str, mode="eval")
+    identifiers = set()
+
+    class IdentifierVisitor(ast.NodeVisitor):
+        def visit_Name(self, node):
+            identifiers.add(node.id)
+
+        def visit_Attribute(self, node):
+            # Optionally support dotted names like mymodule.MyModel
+            full_name = []
+            while isinstance(node, ast.Attribute):
+                full_name.append(node.attr)
+                node = node.value
+            if isinstance(node, ast.Name):
+                full_name.append(node.id)
+                identifiers.add(".".join(reversed(full_name)))
+
+    IdentifierVisitor().visit(tree)
+    return identifiers
+
+
+def resolve_name(name: str):
+    """Resolve a name to a Python object from loaded modules."""
+    # Try dotted names first
+    parts = name.split(".")
+    obj = None
+
+    if len(parts) == 1:
+        # Search globals and builtins
+        if parts[0] in globals():
+            return globals()[parts[0]]
+        if parts[0] in builtins.__dict__:
+            return builtins.__dict__[parts[0]]
+    else:
+        try:
+            obj = sys.modules[parts[0]]
+            for part in parts[1:]:
+                obj = getattr(obj, part)
+            return obj
+        except Exception:
+            return None
+
+    # Try all loaded modules' symbols
+    for module in list(sys.modules.values()):
+        if module is None or not hasattr(module, "__dict__"):
+            continue
+        if parts[0] in module.__dict__:
+            return module.__dict__[parts[0]]
+
+    return None
+
+
+def extract_pydantic_models_from_type_string(
+    type_str: str,
+) -> list[type[BaseModel]]:
+    identifiers = extract_identifiers_from_type_str(type_str)
+    models = []
+    for name in identifiers:
+        resolved = resolve_name(name)
+        if (
+            isinstance(resolved, type)
+            and issubclass(resolved, BaseModel)
+            and resolved is not BaseModel
+        ):
+            models.append(resolved)
+    return models
+
+
+def collect_pydantic_models(
+    type_hint, seen: set[type[BaseModel]] | None = None
+) -> set[type[BaseModel]]:
+    if seen is None:
+        seen = set()
+
+    origin = get_origin(type_hint)
+    args = get_args(type_hint)
+
+    # Direct BaseModel
+    if isinstance(type_hint, type) and issubclass(type_hint, BaseModel):
+        seen.add(type_hint)
+        return seen
+
+    # For Unions, Lists, Dicts, Tuples, etc.
+    if origin is not None:
+        for arg in args:
+            collect_pydantic_models(arg, seen)
+
+    return seen
+
+
 def serialize_item(item: Any) -> Any:
     """Recursively prepares an item for serialization (e.g., to dict for YAML/JSON).
     Converts known callables to their path strings using FlockRegistry.

{flock_core-0.4.0b1.dist-info → flock_core-0.4.0b3.dist-info}/METADATA

@@ -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.dist-info → flock_core-0.4.0b3.dist-info}/RECORD

@@ -16,12 +16,12 @@ flock/cli/view_results.py,sha256=dOzK0O1FHSIDERnx48y-2Xke9BkOHS7pcOhs64AyIg0,781
 flock/cli/yaml_editor.py,sha256=K3N0bh61G1TSDAZDnurqW9e_-hO6CtSQKXQqlDhCjVo,12527
 flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
 flock/core/__init__.py,sha256=R64A7zi51Uz6jzzCFWGol9SZQnMFz3ynEse5ivhSkEA,805
-flock/core/flock.py,sha256=aU3WXCDllLu6mJampQsSFNEwNkgat2M8BE3ITrTRhCo,61164
+flock/core/flock.py,sha256=jKhI1UyrgPpel-r8Qjwp82Zwz2AghHMudKQYgy-8kYA,62329
 flock/core/flock_agent.py,sha256=L5sZ6weY4pNFbk8CEUrRD1506ojq_tx1jjQy02qEdC8,29126
 flock/core/flock_evaluator.py,sha256=dOXZeDOGZcAmJ9ahqq_2bdGUU1VOXY4skmwTVpAjiVw,1685
 flock/core/flock_factory.py,sha256=MGTkJCP1WGpV614f87r1vwe0tqAvBCoH9PlqtqDyJDk,2828
 flock/core/flock_module.py,sha256=96aFVYAgwpKN53xGbivQDUpikOYGFCxK5mqhclOcxY0,3003
-flock/core/flock_registry.py,sha256=CzJUH2i5MrjNKJUFV_fiTwd0BqySxa1uULnpCFpigps,20832
+flock/core/flock_registry.py,sha256=ax2pIxv6hVqRw3eJCPQ9jAul_ocYWfl9BZttmu054d0,20830
 flock/core/flock_router.py,sha256=A5GaxcGvtiFlRLHBTW7okh5RDm3BdKam2uXvRHRaj7k,2187
 flock/core/api/__init__.py,sha256=OKlhzDWZJfA6ddBwxQUmATY0TSzESsH032u00iVGvdA,228
 flock/core/api/endpoints.py,sha256=m-QAyizCHGh3sd5IXaDEhquSxNgTZLpUVTXLdVjiDVw,9086
@@ -55,8 +55,8 @@ flock/core/serialization/__init__.py,sha256=CML7fPgG6p4c0CDBlJ_uwV1aZZhJKK9uy3Io
 flock/core/serialization/callable_registry.py,sha256=sUZECTZWsM3fJ8FDRQ-FgLNW9hF26nY17AD6fJKADMc,1419
 flock/core/serialization/json_encoder.py,sha256=gAKj2zU_8wQiNvdkby2hksSA4fbPNwTjup_yz1Le1Vw,1229
 flock/core/serialization/secure_serializer.py,sha256=n5-zRvvXddgJv1FFHsaQ2wuYdL3WUSGPvG_LGaffEJo,6144
-flock/core/serialization/serializable.py,sha256=mw1bIH64Ws5NIofrlqb72ELNWtnoxEQ2f54MuuFe_VE,12116
-flock/core/serialization/serialization_utils.py,sha256=YxlPoHFPtj5otWUlKEsKphWxnd_d6b8yMZN_5MDlzB4,7577
+flock/core/serialization/serializable.py,sha256=qlv8TsTqRuklXiNuCMrvro5VKz764xC2i3FlgLJSkdk,12129
+flock/core/serialization/serialization_utils.py,sha256=ONv7KUhc66e4sKYu9uFc3qU1jOg4DvIXRJ5QXaTIQj0,10298
 flock/core/tools/azure_tools.py,sha256=9Bi6IrB5pzBTBhBSxpCVMgx8HBud8nl4gDp8aN0NT6c,17031
 flock/core/tools/basic_tools.py,sha256=hEG14jNZ2itVvubCHTfsWkuJK6yuNwBtuFj2Js0VHZs,9043
 flock/core/tools/llm_tools.py,sha256=Bdt4Dpur5dGpxd2KFEQyxjfZazvW1HCDKY6ydMj6UgQ,21811
@@ -430,8 +430,8 @@ flock/workflow/activities.py,sha256=eVZDnxGJl_quNO-UTV3YgvTV8LrRaHN3QDAA1ANKzac,
 flock/workflow/agent_activities.py,sha256=NhBZscflEf2IMfSRa_pBM_TRP7uVEF_O0ROvWZ33eDc,963
 flock/workflow/temporal_setup.py,sha256=VWBgmBgfTBjwM5ruS_dVpA5AVxx6EZ7oFPGw4j3m0l0,1091
 flock/workflow/workflow.py,sha256=I9MryXW_bqYVTHx-nl2epbTqeRy27CAWHHA7ZZA0nAk,1696
-flock_core-0.4.0b1.dist-info/METADATA,sha256=R0xeR3s341pdXAXBvnicJlkMHcwDxUfGSMiIqtcI9h0,20773
-flock_core-0.4.0b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.4.0b1.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.4.0b1.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.4.0b1.dist-info/RECORD,,
+flock_core-0.4.0b3.dist-info/METADATA,sha256=1YKIfl_aB2pXjolghE3WcrQW8p6pJWsarwWc_zLZyDo,20773
+flock_core-0.4.0b3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.4.0b3.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.4.0b3.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.4.0b3.dist-info/RECORD,,