flock-core 0.4.0b45__py3-none-any.whl → 0.4.0b48__py3-none-any.whl

flock/core/flock.py

@@ -4,6 +4,7 @@
 from __future__ import annotations  # Ensure forward references work
 
 import asyncio
+import concurrent.futures  # Added import
 import os
 import uuid
 from collections.abc import Callable, Sequence
@@ -115,6 +116,19 @@ class Flock(BaseModel, Serializable):
         default=True,
         description="If True (default) and enable_temporal=True, start a temporary in-process worker for development/testing convenience. Set to False when using dedicated workers.",
     )
+
+    benchmark_agent_name: str | None = Field(
+        default=None,
+        description="The name of the agent to use for the benchmark.",
+    )
+    benchmark_eval_field: str | None = Field(
+        default=None,
+        description="The output field to use for the benchmark.",
+    )
+    benchmark_input_field: str | None = Field(
+        default=None,
+        description="The input field to use for the benchmark.",
+    )
     # Internal agent storage - not part of the Pydantic model for direct serialization
     # Marked with underscore to indicate it's managed internally and accessed via property
     _agents: dict[str, FlockAgent]
@@ -190,6 +204,8 @@ class Flock(BaseModel, Serializable):
         # Ensure session ID exists in baggage
         self._ensure_session_id()
 
+        FlockRegistry.discover_and_register_components()
+
         logger.info(
             "Flock instance initialized",
             name=self.name,
@@ -197,6 +213,46 @@ class Flock(BaseModel, Serializable):
             enable_temporal=self.enable_temporal,
         )
 
+    def prepare_benchmark(self, agent: FlockAgent | str | None = None, input_field: str | None = None, eval_field: str | None = None):
+        """Prepare a benchmark for the Flock instance."""
+        from flock.core.flock_agent import FlockAgent as ConcreteFlockAgent
+
+        logger.info(f"Preparing benchmark for Flock instance '{self.name}' with agent '{agent}'.")
+
+        name = agent.name if isinstance(agent, ConcreteFlockAgent) else agent
+
+        if self._agents.get(name) is None:
+            raise ValueError(f"Agent '{name}' not found in Flock instance '{self.name}'.")
+
+        self.benchmark_agent_name = name
+        self.benchmark_eval_field = eval_field
+        self.benchmark_input_field = input_field
+
+
+
+    def inspect(self):
+        """Inspect the Flock instance."""
+        logger.info(f"Inspecting Flock instance '{self.name}' with start agent '{self.benchmark_agent_name}' and input '{input}'.")
+
+        async def run(input: dict[str, Any])-> dict[str, Any]:
+            """Inspect the Flock instance."""
+            logger.info(f"Inspecting Flock instance '{self.name}' with start agent '{self.benchmark_agent_name}' and input '{input}'.")
+            msg_content = input.get("messages")[0].get("content")
+
+            agent_input = {
+                self.benchmark_input_field: msg_content
+            }
+
+            result = await self.run_async(start_agent=self.benchmark_agent_name, input=agent_input, box_result=False)
+
+            agent_output = result.get(self.benchmark_eval_field, "No answer found")
+
+            return {
+                "output": agent_output,
+            }
+
+        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
@@ -302,45 +358,37 @@ class Flock(BaseModel, Serializable):
         agents: list[FlockAgent] | None = None,
     ) -> Box | dict:
         """Entry point for running an agent system synchronously."""
+        # Prepare the coroutine that needs to be run
+        coro = self.run_async(
+            start_agent=start_agent,
+            input=input,
+            context=context,
+            run_id=run_id,
+            box_result=box_result,  # run_async handles boxing
+            agents=agents,
+        )
+
         try:
+            # Check if an event loop is already running in the current thread
             loop = asyncio.get_running_loop()
-            if loop.is_closed():
-                raise RuntimeError("Event loop is closed")
-        except RuntimeError:  # No running loop
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-        # Ensure the loop runs the task and handles closure if we created it
-        if asyncio.get_event_loop() is loop and not loop.is_running():
-            result = 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,
-                )
-            )
-            return result
+        except RuntimeError:
+            # No event loop is running in the current thread.
+            # We can safely use asyncio.run() to create a new loop,
+            # run the coroutine, and close the loop.
+            return asyncio.run(coro)
         else:
-            # If called from an already running loop (e.g. Jupyter, FastAPI endpoint)
-            # Create a future and run it to completion. This is tricky and
-            # ideally, one should use `await self.run_async` directly in async contexts.
-            # This simple run_until_complete on a future might block the existing loop.
-            # For truly non-blocking execution in an existing loop, one might need
-            # to schedule the coroutine differently or advise users to use `await`.
-            future = asyncio.ensure_future(
-                self.run_async(
-                    start_agent=start_agent,
-                    input=input,
-                    context=context,
-                    run_id=run_id,
-                    box_result=box_result,
-                    agents=agents,
-                )
+            # An event loop is already running in the current thread.
+            # Calling loop.run_until_complete() or asyncio.run() here would raise an error.
+            # To run the async code and wait for its result synchronously,
+            # we execute it in a separate thread with its own event loop.
+            logger.debug(
+                "Flock.run called in a context with an existing event loop. "
+                "Running async task in a separate thread to avoid event loop conflict."
             )
-            return loop.run_until_complete(future)
+            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+                future = executor.submit(asyncio.run, coro)
+                # Block and wait for the result from the other thread
+                return future.result()
 
 
     async def run_async(
@@ -555,14 +603,6 @@ class Flock(BaseModel, Serializable):
         delimiter: str = ",",
     ) -> list[Box | dict | None | Exception]:
         """Synchronous wrapper for run_batch_async."""
-        try:
-            loop = asyncio.get_running_loop()
-            if loop.is_closed():
-                raise RuntimeError("Event loop is closed")
-        except RuntimeError:  # No running loop
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
         coro = self.run_batch_async(
             start_agent=start_agent,
             batch_inputs=batch_inputs,
@@ -579,12 +619,18 @@ class Flock(BaseModel, Serializable):
             delimiter=delimiter,
         )
 
-        if asyncio.get_event_loop() is loop and not loop.is_running():
-            results = loop.run_until_complete(coro)
-            return results
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(coro)
         else:
-            future = asyncio.ensure_future(coro)
-            return loop.run_until_complete(future)
+            logger.debug(
+                "Flock.run_batch called in a context with an existing event loop. "
+                "Running async task in a separate thread."
+            )
+            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+                future = executor.submit(asyncio.run, coro)
+                return future.result()
 
     # --- Evaluation (Delegation) ---
     async def evaluate_async(
@@ -659,14 +705,6 @@ class Flock(BaseModel, Serializable):
         metadata_columns: list[str] | None = None,
     ) -> DataFrame | list[dict[str, Any]]: # type: ignore
         """Synchronous wrapper for evaluate_async."""
-        try:
-            loop = asyncio.get_running_loop()
-            if loop.is_closed():
-                raise RuntimeError("Event loop is closed")
-        except RuntimeError:  # No running loop
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
         coro = self.evaluate_async(
             dataset=dataset,
             start_agent=start_agent,
@@ -685,12 +723,18 @@ class Flock(BaseModel, Serializable):
             metadata_columns=metadata_columns,
         )
 
-        if asyncio.get_event_loop() is loop and not loop.is_running():
-            results = loop.run_until_complete(coro)
-            return results
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(coro)
         else:
-            future = asyncio.ensure_future(coro)
-            return loop.run_until_complete(future)
+            logger.debug(
+                "Flock.evaluate called in a context with an existing event loop. "
+                "Running async task in a separate thread."
+            )
+            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+                future = executor.submit(asyncio.run, coro)
+                return future.result()
 
     # --- Server & CLI Starters (Delegation) ---
     def start_api(

flock/core/flock_registry.py

@@ -8,6 +8,8 @@ from __future__ import annotations  # Add this at the very top
 import builtins
 import importlib
 import inspect
+import os
+import pkgutil
 import sys
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import is_dataclass
@@ -614,45 +616,50 @@ def flock_type(cls: ClassType | None = None, *, name: str | None = None) -> Any:
 
 
 # --- Auto-register known core components and tools ---
-def _auto_register_by_path():
-    components_to_register = [
-        (
-            "flock.evaluators.declarative.declarative_evaluator",
-            "DeclarativeEvaluator",
-        ),
-        ("flock.evaluators.memory.memory_evaluator", "MemoryEvaluator"),
-        ("flock.modules.output.output_module", "OutputModule"),
-        ("flock.modules.performance.metrics_module", "MetricsModule"),
-        ("flock.modules.memory.memory_module", "MemoryModule"),
-        # ("flock.modules.hierarchical.module", "HierarchicalMemoryModule"), # Uncomment if exists
-        ("flock.routers.default.default_router", "DefaultRouter"),
-        ("flock.routers.llm.llm_router", "LLMRouter"),
-        ("flock.routers.agent.agent_router", "AgentRouter"),
+def _auto_register_by_path(self):
+    # List of base packages to scan for components and tools
+    packages_to_scan = [
+        "flock.tools",
+        "flock.evaluators",
+        "flock.modules",
+        "flock.routers",
     ]
-    for module_path, class_name in components_to_register:
-        try:
-            module = importlib.import_module(module_path)
-            component_class = getattr(module, class_name)
-            _registry_instance.register_component(component_class)
-        except (ImportError, AttributeError) as e:
-            logger.warning(f"{class_name} not found for auto-registration: {e}")
-
-    # Auto-register standard tools by scanning modules
-    tool_modules = [
-        "flock.core.tools.basic_tools",
-        "flock.core.tools.azure_tools",
-        "flock.core.tools.dev_tools.github",
-        "flock.core.tools.llm_tools",
-        "flock.core.tools.markdown_tools",
-    ]
-    for module_path in tool_modules:
-        try:
-            _registry_instance.register_module_components(module_path)
-        except ImportError as e:
-            logger.warning(
-                f"Could not auto-register tools from {module_path}: {e}"
-            )
 
+    for package_name in packages_to_scan:
+        try:
+            package_spec = importlib.util.find_spec(package_name)
+            if package_spec and package_spec.origin:
+                package_path_list = [os.path.dirname(package_spec.origin)]
+                logger.info(f"Recursively scanning for modules in package: {package_name} (path: {package_path_list[0]})")
+
+                # Use walk_packages to recursively find all modules
+                for module_loader, module_name, is_pkg in pkgutil.walk_packages(
+                    path=package_path_list,
+                    prefix=package_name + ".", # Ensures module_name is fully qualified
+                    onerror=lambda name: logger.warning(f"Error importing module {name} during scan.")
+                ):
+                    if not is_pkg and not module_name.split('.')[-1].startswith("_"):
+                        # We are interested in actual modules, not sub-packages themselves for registration
+                        # And also skip modules starting with underscore (e.g. __main__.py)
+                        try:
+                            logger.debug(f"Attempting to auto-register components from module: {module_name}")
+                            _registry_instance.register_module_components(module_name)
+                        except ImportError as e:
+                            logger.warning(
+                                f"Could not auto-register from {module_name}: Module not found or import error: {e}"
+                            )
+                        except Exception as e: # Catch other potential errors during registration
+                            logger.error(
+                                f"Unexpected error during auto-registration of {module_name}: {e}",
+                                exc_info=True
+                            )
+            else:
+                logger.warning(f"Could not find package spec for '{package_name}' to auto-register components/tools.")
+        except Exception as e:
+            logger.error(f"Error while trying to dynamically register from '{package_name}': {e}", exc_info=True)
 
 # Bootstrapping the registry
-# _auto_register_by_path()
+# _auto_register_by_path() # Commented out or removed
+
+# Make the registration function public and rename it
+FlockRegistry.discover_and_register_components = _auto_register_by_path

flock/core/util/spliter.py

@@ -185,6 +185,9 @@ if __name__ == "__main__":
     #     'Arbitrarily complex structure')
 
     SAMPLE_17 = "münze: str | Deutsche Münzbezeichnung, engl. 'coin'"
+
+
+    SAMPLE_18 = "ticket_info : str, reasoning : str, search_queries : list[str], relevant_documents: dict[str, float] | dict of pdf_ids as keys and scores as values"
     # ➜ [('münze', 'str', "Deutsche Münzbezeichnung, engl. 'coin'")]
 
     for title, spec in [
@@ -205,6 +208,7 @@ if __name__ == "__main__":
         ("Sample-15", SAMPLE_15),
         ("Sample-16", SAMPLE_16),
         ("Sample-17", SAMPLE_17),
+        ("Sample-18", SAMPLE_18),
     ]:
         print(f"\n{title}")
         for row in parse_schema(spec):

flock/evaluators/__init__.py

@@ -0,0 +1 @@
+# Package for modules

flock/evaluators/declarative/__init__.py

@@ -0,0 +1 @@
+# Package for modules

flock/modules/__init__.py

@@ -0,0 +1 @@
+# Package for modules

flock/modules/assertion/__init__.py

@@ -0,0 +1 @@
+# Package for modules

flock/modules/callback/__init__.py

@@ -0,0 +1 @@
+# Package for modules

flock/modules/memory/__init__.py

@@ -0,0 +1 @@
+# Package for modules

flock/modules/output/__init__.py

@@ -0,0 +1 @@
+# Package for modules

flock/modules/performance/__init__.py

@@ -0,0 +1 @@
+# Package for modules

flock/modules/zep/__init__.py

@@ -0,0 +1 @@
+# Package for modules

flock/tools/__init__.py

@@ -0,0 +1,188 @@
+from .azure_tools import (
+    azure_search_create_index,
+    azure_search_create_vector_index,
+    azure_search_delete_documents,
+    azure_search_get_document,
+    azure_search_get_index_statistics,
+    azure_search_initialize_clients,
+    azure_search_list_indexes,
+    azure_search_query,
+    azure_search_upload_documents,
+    azure_storage_create_container,
+    azure_storage_delete_blob,
+    azure_storage_delete_container,
+    azure_storage_download_blob_to_bytes,
+    azure_storage_download_blob_to_file,
+    azure_storage_download_blob_to_text,
+    azure_storage_get_blob_properties,
+    azure_storage_list_blobs,
+    azure_storage_list_containers,
+    azure_storage_upload_blob_bytes,
+    azure_storage_upload_blob_from_file,
+    azure_storage_upload_blob_text,
+)
+from .code_tools import code_code_eval, code_evaluate_math
+from .file_tools import (
+    file_get_anything_as_markdown,
+    file_json_parse_safe,
+    file_json_search,
+    file_read_from_file,
+    file_save_to_file,
+)
+from .github_tools import (
+    github_create_files,
+    github_create_user_stories_as_github_issue,
+    github_upload_readme,
+)
+from .markdown_tools import (
+    markdown_extract_code_blocks,
+    markdown_extract_links,
+    markdown_extract_tables,
+    markdown_split_by_headers,
+    markdown_to_plain_text,
+)
+from .text_tools import (
+    text_calculate_hash,
+    text_chunking_for_embedding,
+    text_clean_text,
+    text_count_tokens,
+    text_count_tokens_estimate,
+    text_count_words,
+    text_detect_language,
+    text_extract_json_from_text,
+    text_extract_keywords,
+    text_extract_numbers,
+    text_extract_urls,
+    text_format_chat_history,
+    text_format_table_from_dicts,
+    text_recursive_splitter,
+    text_split_by_characters,
+    text_split_by_sentences,
+    text_split_by_separator,
+    text_split_by_tokens,
+    text_split_code_by_functions,
+    text_tiktoken_split,
+    text_truncate_to_token_limit,
+)
+from .web_tools import (
+    web_content_as_markdown,
+    web_search_bing,
+    web_search_duckduckgo,
+    web_search_tavily,
+)
+from .zendesk_tools import (
+    zendesk_get_article_by_id,
+    zendesk_get_articles,
+    zendesk_get_comments_by_ticket_id,
+    zendesk_get_ticket_by_id,
+    zendesk_get_tickets,
+    zendesk_search_articles,
+)
+
+storage_tools = [
+    azure_storage_list_containers,
+    azure_storage_create_container,
+    azure_storage_delete_container,
+    azure_storage_list_blobs,
+    azure_storage_upload_blob_text,
+    azure_storage_upload_blob_bytes,
+    azure_storage_upload_blob_from_file,
+    azure_storage_download_blob_to_text,
+    azure_storage_download_blob_to_bytes,
+    azure_storage_download_blob_to_file,
+    azure_storage_delete_blob,
+    azure_storage_get_blob_properties,
+]
+
+azure_search_tools = [
+    azure_search_initialize_clients,
+    azure_search_create_index,
+    azure_search_upload_documents,
+    azure_search_query,
+    azure_search_get_document,
+    azure_search_delete_documents,
+    azure_search_list_indexes,
+    azure_search_get_index_statistics,
+    azure_search_create_vector_index,
+]
+
+file_tools_collection = [
+    file_get_anything_as_markdown,
+    file_save_to_file,
+    file_read_from_file,
+    file_json_parse_safe,
+    file_json_search,
+]
+
+code_tools_collection = [code_evaluate_math, code_code_eval]
+
+web_tools_collection = [
+    web_content_as_markdown,
+    web_search_bing,
+    web_search_duckduckgo,
+    web_search_tavily,
+]
+
+github_tools_collection = [
+    github_create_user_stories_as_github_issue,
+    github_upload_readme,
+    github_create_files,
+]
+
+llm_processing_tools = [
+    text_split_by_sentences,
+    text_split_by_characters,
+    text_split_by_tokens,
+    text_split_by_separator,
+    text_recursive_splitter,
+    text_chunking_for_embedding,
+    text_split_code_by_functions,
+    text_count_tokens,
+    text_count_tokens_estimate,
+    text_truncate_to_token_limit,
+    text_extract_keywords,
+    text_clean_text,
+    text_format_chat_history,
+    text_extract_json_from_text,
+    text_calculate_hash,
+    text_format_table_from_dicts,
+    text_detect_language,
+    text_tiktoken_split,
+    text_count_words,
+    text_extract_urls,
+    text_extract_numbers,
+]
+
+markdown_processing_tools = [
+    markdown_split_by_headers,
+    markdown_extract_code_blocks,
+    markdown_extract_links,
+    markdown_extract_tables,
+    markdown_to_plain_text,
+]
+
+zendesk_tools_collection = [
+    zendesk_get_tickets,
+    zendesk_get_ticket_by_id,
+    zendesk_get_comments_by_ticket_id,
+    zendesk_get_article_by_id,
+    zendesk_get_articles,
+    zendesk_search_articles,
+]
+
+__all__ = [
+    "azure_search_tools",
+    "code_tools_collection",
+    "file_tools_collection",
+    "github_tools_collection",
+    "llm_processing_tools",
+    "markdown_processing_tools",
+    "storage_tools",
+    "web_tools_collection",
+    "zendesk_tools_collection",
+]
+
+# If there was existing content in __init__.py, this approach might overwrite it.
+# A safer approach if __init__.py might exist and have other critical initializations
+# would be to read it first, then append/modify.
+# For now, assuming a fresh creation or simple __init__.py.