flock-core 0.3.15__py3-none-any.whl → 0.3.17__py3-none-any.whl

flock/cli/assets/release_notes.md

@@ -69,6 +69,7 @@ Like a hummingbird, modules are small and nimble code packages. Put enough of th
 - **Output Module** – Advanced output formatting and storage  
 - **Metrics Module** – Detailed performance tracking  
 - **Zep Module** – Uses Zep for Knowledge Graphs
+- **Azure Search Tools** – Integration with Azure AI Search for vector search and document retrieval
 
 ---
 

flock/core/context/context.py

@@ -1,9 +1,10 @@
 import uuid
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict
 from datetime import datetime
 from typing import Any, Literal
 
 from opentelemetry import trace
+from pydantic import BaseModel, Field
 
 from flock.core.context.context_vars import FLOCK_LAST_AGENT, FLOCK_LAST_RESULT
 from flock.core.logging.logging import get_logger
@@ -13,34 +14,31 @@ logger = get_logger("context")
 tracer = trace.get_tracer(__name__)
 
 
-@dataclass
-class AgentRunRecord:
-    id: str = field(default="")
-    agent: str = field(default="")
-    data: dict[str, Any] = field(default_factory=dict)
-    timestamp: str = field(default="")
-    hand_off: dict = field(default_factory=dict)
-    called_from: str = field(default="")
+class AgentRunRecord(BaseModel):
+    id: str = Field(default="")
+    agent: str = Field(default="")
+    data: dict[str, Any] = Field(default_factory=dict)
+    timestamp: str = Field(default="")
+    hand_off: dict | None = Field(default_factory=dict)
+    called_from: str = Field(default="")
 
 
-@dataclass
-class AgentDefinition:
-    agent_type: str = field(default="")
-    agent_name: str = field(default="")
-    agent_data: dict = field(default_factory=dict)
-    serializer: Literal["json", "cloudpickle", "msgpack"] = field(
+class AgentDefinition(BaseModel):
+    agent_type: str = Field(default="")
+    agent_name: str = Field(default="")
+    agent_data: dict = Field(default_factory=dict)
+    serializer: Literal["json", "cloudpickle", "msgpack"] = Field(
         default="cloudpickle"
     )
 
 
-@dataclass
-class FlockContext(Serializable):
-    state: dict[str, Any] = field(default_factory=dict)
-    history: list[AgentRunRecord] = field(default_factory=list)
-    agent_definitions: dict[str, AgentDefinition] = field(default_factory=dict)
-    run_id: str = field(default="")
-    workflow_id: str = field(default="")
-    workflow_timestamp: str = field(default="")
+class FlockContext(Serializable, BaseModel):
+    state: dict[str, Any] = Field(default_factory=dict)
+    history: list[AgentRunRecord] = Field(default_factory=list)
+    agent_definitions: dict[str, AgentDefinition] = Field(default_factory=dict)
+    run_id: str = Field(default="")
+    workflow_id: str = Field(default="")
+    workflow_timestamp: str = Field(default="")
 
     def record(
         self,

flock/core/flock_agent.py

@@ -11,6 +11,7 @@ import cloudpickle
 from opentelemetry import trace
 from pydantic import BaseModel, Field
 
+from flock.core.context.context import FlockContext
 from flock.core.flock_evaluator import FlockEvaluator
 from flock.core.flock_module import FlockModule
 from flock.core.flock_router import FlockRouter
@@ -73,6 +74,11 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
         description="FlockModules attached to this agent",
     )
 
+    context: FlockContext | None = Field(
+        default=None,
+        description="Context associated with flock",
+    )
+
     def add_module(self, module: FlockModule) -> None:
         """Add a module to this agent."""
         self.modules[module.name] = module
@@ -95,6 +101,13 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
         with tracer.start_as_current_span("agent.initialize") as span:
             span.set_attribute("agent.name", self.name)
             span.set_attribute("inputs", str(inputs))
+            if not self.context:
+                self.context = FlockContext()
+
+            if self.name not in self.context.agent_definitions:
+                self.context.add_agent_definition(
+                    type(self), self.name, self.to_dict()
+                )
 
             try:
                 for module in self.get_enabled_modules():
@@ -102,7 +115,7 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
                         f"agent.initialize - module {module.name}",
                         agent=self.name,
                     )
-                    await module.initialize(self, inputs)
+                    await module.initialize(self, inputs, self.context)
             except Exception as module_error:
                 logger.error(
                     "Error during initialize",
@@ -124,7 +137,7 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
             )
             try:
                 for module in self.get_enabled_modules():
-                    await module.terminate(self, inputs, inputs)
+                    await module.terminate(self, inputs, inputs, self.context)
             except Exception as module_error:
                 logger.error(
                     "Error during terminate",
@@ -139,7 +152,7 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
             span.set_attribute("inputs", str(inputs))
             try:
                 for module in self.get_enabled_modules():
-                    await module.on_error(self, error, inputs)
+                    await module.on_error(self, error, inputs, self.context)
             except Exception as module_error:
                 logger.error(
                     "Error during on_error",
@@ -154,13 +167,15 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
             span.set_attribute("inputs", str(inputs))
 
             for module in self.get_enabled_modules():
-                inputs = await module.pre_evaluate(self, inputs)
+                inputs = await module.pre_evaluate(self, inputs, self.context)
 
             try:
                 result = await self.evaluator.evaluate(self, inputs, self.tools)
 
                 for module in self.get_enabled_modules():
-                    result = await module.post_evaluate(self, inputs, result)
+                    result = await module.post_evaluate(
+                        self, inputs, result, self.context
+                    )
 
                 span.set_attribute("result", str(result))
 

flock/core/flock_factory.py

@@ -35,6 +35,7 @@ class FlockFactory:
         max_tokens: int = 4096,
         alert_latency_threshold_ms: int = 30000,
         no_output: bool = False,
+        print_context: bool = False,
     ) -> FlockAgent:
         """Creates a default FlockAgent.
 
@@ -65,6 +66,7 @@ class FlockFactory:
             theme=output_theme,
             wait_for_input=wait_for_input,
             no_output=no_output,
+            print_context=print_context,
         )
         output_module = OutputModule("output", config=output_config)
 

flock/core/flock_module.py

@@ -5,6 +5,8 @@ from typing import Any, TypeVar
 
 from pydantic import BaseModel, Field, create_model
 
+from flock.core.context.context import FlockContext
+
 T = TypeVar("T", bound="FlockModuleConfig")
 
 
@@ -50,30 +52,50 @@ class FlockModule(BaseModel, ABC):
         default_factory=FlockModuleConfig, description="Module configuration"
     )
 
-    async def initialize(self, agent: Any, inputs: dict[str, Any]) -> None:
+    async def initialize(
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
+    ) -> None:
         """Called when the agent starts running."""
         pass
 
     async def pre_evaluate(
-        self, agent: Any, inputs: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Called before agent evaluation, can modify inputs."""
         return inputs
 
     async def post_evaluate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Called after agent evaluation, can modify results."""
         return result
 
     async def terminate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Called when the agent finishes running."""
         pass
 
     async def on_error(
-        self, agent: Any, error: Exception, inputs: dict[str, Any]
+        self,
+        agent: Any,
+        error: Exception,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Called when an error occurs during agent execution."""
         pass

flock/core/tools/azure_tools.py

@@ -0,0 +1,496 @@
+import os
+from typing import Any
+
+from azure.core.credentials import AzureKeyCredential
+from azure.search.documents import SearchClient
+from azure.search.documents.indexes import SearchIndexClient
+from azure.search.documents.indexes.models import (
+    ExhaustiveKnnAlgorithmConfiguration,
+    HnswAlgorithmConfiguration,
+    SearchableField,
+    SearchField,
+    SearchFieldDataType,
+    SearchIndex,
+    SimpleField,
+    VectorSearch,
+    VectorSearchProfile,
+)
+from azure.search.documents.models import VectorizedQuery
+
+from flock.core.logging.trace_and_logged import traced_and_logged
+
+
+def _get_default_endpoint() -> str:
+    """Get the default Azure Search endpoint from environment variables."""
+    endpoint = os.environ.get("AZURE_SEARCH_ENDPOINT")
+    if not endpoint:
+        raise ValueError(
+            "AZURE_SEARCH_ENDPOINT environment variable is not set"
+        )
+    return endpoint
+
+
+def _get_default_api_key() -> str:
+    """Get the default Azure Search API key from environment variables."""
+    api_key = os.environ.get("AZURE_SEARCH_API_KEY")
+    if not api_key:
+        raise ValueError("AZURE_SEARCH_API_KEY environment variable is not set")
+    return api_key
+
+
+def _get_default_index_name() -> str:
+    """Get the default Azure Search index name from environment variables."""
+    index_name = os.environ.get("AZURE_SEARCH_INDEX_NAME")
+    if not index_name:
+        raise ValueError(
+            "AZURE_SEARCH_INDEX_NAME environment variable is not set"
+        )
+    return index_name
+
+
+@traced_and_logged
+def azure_search_initialize_clients(
+    endpoint: str | None = None,
+    api_key: str | None = None,
+    index_name: str | None = None,
+) -> dict[str, Any]:
+    """Initialize Azure AI Search clients.
+
+    Args:
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+        index_name: Optional index name for SearchClient initialization (defaults to AZURE_SEARCH_INDEX_NAME env var if not None)
+
+    Returns:
+        Dictionary containing the initialized clients
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+
+    credential = AzureKeyCredential(api_key)
+
+    # Create the search index client
+    search_index_client = SearchIndexClient(
+        endpoint=endpoint, credential=credential
+    )
+
+    # Create clients dictionary
+    clients = {
+        "index_client": search_index_client,
+    }
+
+    # Add search client if index_name was provided or available in env
+    if index_name is None and os.environ.get("AZURE_SEARCH_INDEX_NAME"):
+        index_name = _get_default_index_name()
+
+    if index_name:
+        search_client = SearchClient(
+            endpoint=endpoint, index_name=index_name, credential=credential
+        )
+        clients["search_client"] = search_client
+
+    return clients
+
+
+@traced_and_logged
+def azure_search_create_index(
+    index_name: str | None = None,
+    fields: list[SearchField] = None,
+    vector_search: VectorSearch | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Create a new search index in Azure AI Search.
+
+    Args:
+        index_name: Name of the search index to create (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        fields: List of field definitions for the index
+        vector_search: Optional vector search configuration
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        Dictionary containing information about the created index
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    if fields is None:
+        raise ValueError("Fields must be provided for index creation")
+
+    clients = azure_search_initialize_clients(endpoint, api_key)
+    index_client = clients["index_client"]
+
+    # Create the index
+    index = SearchIndex(
+        name=index_name, fields=fields, vector_search=vector_search
+    )
+
+    result = index_client.create_or_update_index(index)
+
+    return {
+        "index_name": result.name,
+        "fields": [field.name for field in result.fields],
+        "created": True,
+    }
+
+
+@traced_and_logged
+def azure_search_upload_documents(
+    documents: list[dict[str, Any]],
+    index_name: str | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Upload documents to an Azure AI Search index.
+
+    Args:
+        documents: List of documents to upload (as dictionaries)
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        Dictionary containing the upload results
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key, index_name)
+    search_client = clients["search_client"]
+
+    result = search_client.upload_documents(documents=documents)
+
+    # Process results
+    succeeded = sum(1 for r in result if r.succeeded)
+
+    return {
+        "succeeded": succeeded,
+        "failed": len(result) - succeeded,
+        "total": len(result),
+    }
+
+
+@traced_and_logged
+def azure_search_query(
+    search_text: str | None = None,
+    filter: str | None = None,
+    select: list[str] | None = None,
+    top: int | None = 50,
+    vector: list[float] | None = None,
+    vector_field: str | None = None,
+    vector_k: int | None = 10,
+    index_name: str | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> list[dict[str, Any]]:
+    """Search documents in an Azure AI Search index.
+
+    Args:
+        search_text: Optional text to search for (keyword search)
+        filter: Optional OData filter expression
+        select: Optional list of fields to return
+        top: Maximum number of results to return
+        vector: Optional vector for vector search
+        vector_field: Name of the field containing vectors for vector search
+        vector_k: Number of nearest neighbors to retrieve in vector search
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        List of search results as dictionaries
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key, index_name)
+    search_client = clients["search_client"]
+
+    # Set up vector query if vector is provided
+    vectorized_query = None
+    if vector and vector_field:
+        vectorized_query = VectorizedQuery(
+            vector=vector, k=vector_k, fields=[vector_field]
+        )
+
+    # Execute the search
+    results = search_client.search(
+        search_text=search_text,
+        filter=filter,
+        select=select,
+        top=top,
+        vector_queries=[vectorized_query] if vectorized_query else None,
+    )
+
+    # Convert results to list of dictionaries
+    result_list = [dict(result) for result in results]
+
+    return result_list
+
+
+@traced_and_logged
+def azure_search_get_document(
+    key: str,
+    select: list[str] | None = None,
+    index_name: str | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Retrieve a specific document from an Azure AI Search index by key.
+
+    Args:
+        key: The unique key of the document to retrieve
+        select: Optional list of fields to return
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        The retrieved document as a dictionary
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key, index_name)
+    search_client = clients["search_client"]
+
+    result = search_client.get_document(key=key, selected_fields=select)
+
+    return dict(result)
+
+
+@traced_and_logged
+def azure_search_delete_documents(
+    keys: list[str],
+    key_field_name: str = "id",
+    index_name: str | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Delete documents from an Azure AI Search index.
+
+    Args:
+        keys: List of document keys to delete
+        key_field_name: Name of the key field (defaults to "id")
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        Dictionary containing the deletion results
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key, index_name)
+    search_client = clients["search_client"]
+
+    # Format documents for deletion (only need the key field)
+    documents_to_delete = [{key_field_name: key} for key in keys]
+
+    result = search_client.delete_documents(documents=documents_to_delete)
+
+    # Process results
+    succeeded = sum(1 for r in result if r.succeeded)
+
+    return {
+        "succeeded": succeeded,
+        "failed": len(result) - succeeded,
+        "total": len(result),
+    }
+
+
+@traced_and_logged
+def azure_search_list_indexes(
+    endpoint: str | None = None, api_key: str | None = None
+) -> list[dict[str, Any]]:
+    """List all indexes in the Azure AI Search service.
+
+    Args:
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        List of indexes as dictionaries
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+
+    clients = azure_search_initialize_clients(endpoint, api_key)
+    index_client = clients["index_client"]
+
+    result = index_client.list_indexes()
+
+    # Convert index objects to dictionaries with basic information
+    indexes = [
+        {
+            "name": index.name,
+            "fields": [field.name for field in index.fields],
+            "field_count": len(index.fields),
+        }
+        for index in result
+    ]
+
+    return indexes
+
+
+@traced_and_logged
+def azure_search_get_index_statistics(
+    index_name: str | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Get statistics for a specific Azure AI Search index.
+
+    Args:
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        Dictionary containing index statistics
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key, index_name)
+    search_client = clients["search_client"]
+
+    stats = search_client.get_document_count()
+
+    return {"document_count": stats}
+
+
+@traced_and_logged
+def azure_search_create_vector_index(
+    fields: list[dict[str, Any]],
+    vector_dimensions: int,
+    index_name: str | None = None,
+    algorithm_kind: str = "hnsw",
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Create a vector search index in Azure AI Search.
+
+    Args:
+        fields: List of field configurations (dicts with name, type, etc.)
+        vector_dimensions: Dimensions of the vector field
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        algorithm_kind: Vector search algorithm ("hnsw" or "exhaustive")
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        Dictionary with index creation result
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key)
+    index_client = clients["index_client"]
+
+    # Convert field configurations to SearchField objects
+    index_fields = []
+    vector_fields = []
+
+    for field_config in fields:
+        field_name = field_config["name"]
+        field_type = field_config["type"]
+        field_searchable = field_config.get("searchable", False)
+        field_filterable = field_config.get("filterable", False)
+        field_sortable = field_config.get("sortable", False)
+        field_key = field_config.get("key", False)
+        field_vector = field_config.get("vector", False)
+
+        if field_searchable and field_type == "string":
+            field = SearchableField(
+                name=field_name,
+                type=SearchFieldDataType.String,
+                key=field_key,
+                filterable=field_filterable,
+                sortable=field_sortable,
+            )
+        else:
+            data_type = None
+            if field_type == "string":
+                data_type = SearchFieldDataType.String
+            elif field_type == "int":
+                data_type = SearchFieldDataType.Int32
+            elif field_type == "double":
+                data_type = SearchFieldDataType.Double
+            elif field_type == "boolean":
+                data_type = SearchFieldDataType.Boolean
+            elif field_type == "collection":
+                data_type = SearchFieldDataType.Collection(
+                    SearchFieldDataType.String
+                )
+
+            field = SimpleField(
+                name=field_name,
+                type=data_type,
+                key=field_key,
+                filterable=field_filterable,
+                sortable=field_sortable,
+            )
+
+        index_fields.append(field)
+
+        if field_vector:
+            vector_fields.append(field_name)
+
+    # Set up vector search configuration
+    algorithm_config = None
+    if algorithm_kind.lower() == "hnsw":
+        algorithm_config = HnswAlgorithmConfiguration(
+            name="hnsw-config",
+            parameters={"m": 4, "efConstruction": 400, "efSearch": 500},
+        )
+    else:
+        algorithm_config = ExhaustiveKnnAlgorithmConfiguration(
+            name="exhaustive-config"
+        )
+
+    # Create vector search configuration
+    vector_search = VectorSearch(
+        algorithms=[algorithm_config],
+        profiles=[
+            VectorSearchProfile(
+                name="vector-profile",
+                algorithm_configuration_name=algorithm_config.name,
+            )
+        ],
+    )
+
+    # Create the search index
+    index = SearchIndex(
+        name=index_name, fields=index_fields, vector_search=vector_search
+    )
+
+    try:
+        result = index_client.create_or_update_index(index)
+        return {
+            "index_name": result.name,
+            "vector_fields": vector_fields,
+            "vector_dimensions": vector_dimensions,
+            "algorithm": algorithm_kind,
+            "created": True,
+        }
+    except Exception as e:
+        return {"error": str(e), "created": False}

flock/core/tools/basic_tools.py

@@ -1,9 +1,10 @@
 """This module contains basic agentic tools for performing various tasks."""
 
 import importlib
+import json
 import os
 import re
-from typing import Literal
+from typing import Any, Literal
 
 from flock.core.interpreter.python_interpreter import PythonInterpreter
 from flock.core.logging.trace_and_logged import traced_and_logged
@@ -201,8 +202,6 @@ def extract_numbers(text: str) -> list[float]:
 
 @traced_and_logged
 def json_parse_safe(text: str) -> dict:
-    import json
-
     try:
         result = json.loads(text)
         return result
@@ -221,9 +220,98 @@ def save_to_file(content: str, filename: str):
 
 @traced_and_logged
 def read_from_file(filename: str) -> str:
+    with open(filename, encoding="utf-8") as file:
+        return file.read()
+
+
+@traced_and_logged
+def json_search(
+    json_file_path: str, search_query: str, case_sensitive: bool = False
+) -> list:
+    """Search a JSON file for objects containing the specified search query.
+
+    Args:
+        json_file_path (str): Path to the JSON file to search
+        search_query (str): Text to search for within the JSON objects
+        case_sensitive (bool, optional): Whether to perform a case-sensitive search. Defaults to False.
+
+    Returns:
+        list: List of JSON objects (as dicts) that contain the search query
+
+    Example:
+        >>> matching_tickets = json_search("tickets.json", "error 404")
+        >>> print(
+        ...     f"Found {len(matching_tickets)} tickets mentioning '404 error'"
+        ... )
+    """
     try:
-        with open(filename) as f:
-            content = f.read()
-        return content
-    except Exception:
-        raise
+        # Read the JSON file
+        file_content = read_from_file(json_file_path)
+
+        # Parse the JSON content
+        json_data = json_parse_safe(file_content)
+
+        # Convert search query to lowercase if case-insensitive search
+        if not case_sensitive:
+            search_query = search_query.lower()
+
+        results = []
+
+        # Determine if the JSON root is an object or array
+        if isinstance(json_data, dict):
+            # Handle case where root is a dictionary object
+            for key, value in json_data.items():
+                if isinstance(value, list):
+                    # If this key contains a list of objects, search within them
+                    matching_items = _search_in_list(
+                        value, search_query, case_sensitive
+                    )
+                    results.extend(matching_items)
+                elif _contains_text(value, search_query, case_sensitive):
+                    # The entire object matches
+                    results.append(json_data)
+                    break
+        elif isinstance(json_data, list):
+            # Handle case where root is an array
+            matching_items = _search_in_list(
+                json_data, search_query, case_sensitive
+            )
+            results.extend(matching_items)
+
+        return results
+
+    except Exception as e:
+        return [{"error": f"Error searching JSON file: {e!s}"}]
+
+
+def _search_in_list(
+    items: list, search_query: str, case_sensitive: bool
+) -> list:
+    """Helper function to search for text in a list of items."""
+    matching_items = []
+    for item in items:
+        if _contains_text(item, search_query, case_sensitive):
+            matching_items.append(item)
+    return matching_items
+
+
+def _contains_text(obj: Any, search_query: str, case_sensitive: bool) -> bool:
+    """Recursively check if an object contains the search query in any of its string values."""
+    if isinstance(obj, str):
+        # For string values, check if they contain the search query
+        if case_sensitive:
+            return search_query in obj
+        else:
+            return search_query in obj.lower()
+    elif isinstance(obj, dict):
+        # For dictionaries, check each value
+        for value in obj.values():
+            if _contains_text(value, search_query, case_sensitive):
+                return True
+    elif isinstance(obj, list):
+        # For lists, check each item
+        for item in obj:
+            if _contains_text(item, search_query, case_sensitive):
+                return True
+    # For other types (numbers, booleans, None), return False
+    return False

flock/modules/callback/callback_module.py

@@ -6,6 +6,7 @@ from typing import Any
 from pydantic import Field
 
 from flock.core import FlockModule, FlockModuleConfig
+from flock.core.context.context import FlockContext
 
 
 class CallbackModuleConfig(FlockModuleConfig):
@@ -44,13 +45,21 @@ class CallbackModule(FlockModule):
         description="Callback module configuration",
     )
 
-    async def pre_initialize(self, agent: Any, inputs: dict[str, Any]) -> None:
+    async def pre_initialize(
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
+    ) -> None:
         """Run initialize callback if configured."""
         if self.config.initialize_callback:
             await self.config.initialize_callback(agent, inputs)
 
     async def pre_evaluate(
-        self, agent: Any, inputs: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Run evaluate callback if configured."""
         if self.config.evaluate_callback:
@@ -58,14 +67,22 @@ class CallbackModule(FlockModule):
         return inputs
 
     async def pre_terminate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Run terminate callback if configured."""
         if self.config.terminate_callback:
             await self.config.terminate_callback(agent, inputs, result)
 
     async def on_error(
-        self, agent: Any, error: Exception, inputs: dict[str, Any]
+        self,
+        agent: Any,
+        error: Exception,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Run error callback if configured."""
         if self.config.on_error_callback:

flock/modules/memory/memory_module.py

@@ -7,6 +7,7 @@ from pydantic import Field
 from tqdm import tqdm
 
 from flock.core import FlockAgent, FlockModule, FlockModuleConfig
+from flock.core.context.context import FlockContext
 from flock.core.logging.logging import get_logger
 from flock.modules.memory.memory_parser import MemoryMappingParser
 from flock.modules.memory.memory_storage import FlockMemoryStore, MemoryEntry
@@ -77,7 +78,10 @@ class MemoryModule(FlockModule):
         )
 
     async def initialize(
-        self, agent: FlockAgent, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Initialize memory store if needed."""
         if not self.memory_store:
@@ -92,7 +96,10 @@ class MemoryModule(FlockModule):
         logger.debug(f"Initialized memory module for agent {agent.name}")
 
     async def pre_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Check memory before evaluation."""
         if not self.memory_store:
@@ -214,7 +221,11 @@ class MemoryModule(FlockModule):
             logger.warning(f"Memory storage failed: {e}", agent=agent.name)
 
     async def post_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Store results in memory after evaluation."""
         if not self.memory_store:
@@ -229,7 +240,11 @@ class MemoryModule(FlockModule):
         return result
 
     async def terminate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Save memory store if configured."""
         if self.config.save_after_update and self.memory_store:

flock/modules/output/output_module.py

@@ -8,6 +8,7 @@ from typing import Any
 from pydantic import Field
 
 from flock.core import FlockAgent
+from flock.core.context.context import FlockContext
 from flock.core.flock_module import FlockModule, FlockModuleConfig
 from flock.core.logging.formatters.themed_formatter import (
     ThemedAgentResultFormatter,
@@ -58,6 +59,10 @@ class OutputModuleConfig(FlockModuleConfig):
         default=False,
         description="Whether to suppress output",
     )
+    print_context: bool = Field(
+        default=False,
+        description="Whether to print the context",
+    )
 
 
 class OutputModule(FlockModule):
@@ -159,12 +164,18 @@ class OutputModule(FlockModule):
             json.dump(output_data, f, indent=2)
 
     async def post_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Format and display the output."""
         logger.debug("Formatting and displaying output")
         if self.config.no_output:
             return result
+        if self.config.print_context:
+            result["context"] = context
         # Display the result using the formatter
         self._formatter.display_result(result, agent.name)
 

flock/modules/performance/metrics_module.py

@@ -11,6 +11,7 @@ import numpy as np
 import psutil
 from pydantic import BaseModel, Field, validator
 
+from flock.core.context.context import FlockContext
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_module import FlockModule, FlockModuleConfig
 
@@ -222,7 +223,11 @@ class MetricsModule(FlockModule):
         return stats
 
     async def terminate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Clean up and final metric recording."""
         if self.config.storage_type == "json":
@@ -331,7 +336,10 @@ class MetricsModule(FlockModule):
         return False
 
     async def initialize(
-        self, agent: FlockAgent, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Initialize metrics collection."""
         self._start_time = time.time()
@@ -370,7 +378,10 @@ class MetricsModule(FlockModule):
             return token_count, total_cost
 
     async def pre_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Record pre-evaluation metrics."""
         if self.config.collect_token_usage:
@@ -408,7 +419,11 @@ class MetricsModule(FlockModule):
         return inputs
 
     async def post_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Record post-evaluation metrics."""
         if self.config.collect_timing and self._start_time:
@@ -463,7 +478,11 @@ class MetricsModule(FlockModule):
         return result
 
     async def on_error(
-        self, agent: FlockAgent, error: Exception, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        error: Exception,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Record error metrics."""
         self._record_metric(

flock/modules/zep/zep_module.py

@@ -5,6 +5,7 @@ from pydantic import Field
 from zep_python.client import Zep
 from zep_python.types import Message as ZepMessage, SessionSearchResult
 
+from flock.core.context.context import FlockContext
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_module import FlockModule, FlockModuleConfig
 from flock.core.logging.logging import get_logger
@@ -139,7 +140,11 @@ class ZepModule(FlockModule):
         return response.results
 
     async def post_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Format and display the output."""
         if not self.config.enable_write:
@@ -152,7 +157,10 @@ class ZepModule(FlockModule):
         return result
 
     async def pre_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Format and display the output."""
         if not self.config.enable_read:

flock/workflow/activities.py

@@ -50,7 +50,7 @@ async def run_agent(context: FlockContext) -> dict:
             # Create a nested span for this iteration.
             with tracer.start_as_current_span("agent_iteration") as iter_span:
                 iter_span.set_attribute("agent.name", agent.name)
-
+                agent.context = context
                 # Resolve inputs for the agent.
                 agent_inputs = resolve_inputs(
                     agent.input, context, previous_agent_name
@@ -160,7 +160,7 @@ async def run_agent(context: FlockContext) -> dict:
                     agent.name,
                     result,
                     timestamp=datetime.now().isoformat(),
-                    hand_off=handoff_data,
+                    hand_off=handoff_data.model_dump(),
                     called_from=previous_agent_name,
                 )
                 previous_agent_name = agent.name

{flock_core-0.3.15.dist-info → flock_core-0.3.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.15
+Version: 0.3.17
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -8,6 +8,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
+Requires-Dist: azure-search-documents>=11.5.2
 Requires-Dist: chromadb>=0.6.3
 Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: devtools>=0.12.2
@@ -29,6 +30,7 @@ Requires-Dist: prometheus-client>=0.21.1
 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
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: sentence-transformers>=3.4.1

{flock_core-0.3.15.dist-info → flock_core-0.3.17.dist-info}/RECORD

@@ -8,16 +8,16 @@ flock/cli/load_examples.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 flock/cli/load_flock.py,sha256=3JdECvt5X7uyOG2vZS3-Zk5C5SI_84_QZjcsB3oJmfA,932
 flock/cli/load_release_notes.py,sha256=qFcgUrMddAE_TP6x1P-6ZywTUjTknfhTDW5LTxtg1yk,599
 flock/cli/settings.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
-flock/cli/assets/release_notes.md,sha256=-RuE-G9Sn8z1LWEdr9iqjuQN7N1K_JMaCzHYoyLR42U,4793
+flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
 flock/core/__init__.py,sha256=mPlvKc0SxC2qCvSlgYeP_7EyV8ptmdn24NO8mlQoCSo,559
 flock/core/flock.py,sha256=IURlcuNvdsnqKkvgXtX4v_pGWQ8Lfb60X--MT0zvxHo,19881
-flock/core/flock_agent.py,sha256=qG6j-aSxSTEcvv5tjMyw3RTCaBooIGF7IVhAUOrhPOo,11946
+flock/core/flock_agent.py,sha256=QPyRSa1X_aAK2MSgqLNHBiL-_cnYHOSSnrFup2YTzss,12509
 flock/core/flock_api.py,sha256=2rHnmEdtT5KPZYwGesRT7LqwbrgKClODHT-O56u7pcQ,7140
 flock/core/flock_evaluator.py,sha256=j7riJj_KsWoBnKmLiGp-U0CRhxDyJbgEdLGN26tfKm8,1588
-flock/core/flock_factory.py,sha256=lprpvkk4RJkI0_5ouPU04KEEJA-0bjuQJDIP-KQhfis,2672
-flock/core/flock_module.py,sha256=3DmxOc39gQS-tiJcgUCjMaLr8QDDJR4acV_M76Xcf6I,2602
+flock/core/flock_factory.py,sha256=7nV0WAh197INdBckJ-NhnhSSZOSzZC1MlYfeZm2x8Xc,2750
+flock/core/flock_module.py,sha256=96aFVYAgwpKN53xGbivQDUpikOYGFCxK5mqhclOcxY0,3003
 flock/core/flock_router.py,sha256=A5GaxcGvtiFlRLHBTW7okh5RDm3BdKam2uXvRHRaj7k,2187
-flock/core/context/context.py,sha256=AW0qKIAkgZucVroGsulrPVPc4WmWuqWIrVPHf2qaOLI,6380
+flock/core/context/context.py,sha256=3sj5BrnY7OBG8Xk-uoT0yPKQjCzUU6a3VH26xuHo2KI,6407
 flock/core/context/context_manager.py,sha256=FANSWa6DEhdhtZ7t_9Gza0v80UdpoDOhHbfVOccmjkA,1181
 flock/core/context/context_vars.py,sha256=zYTMi9b6mNSSEHowEQUOTpEDurmAjaUcyBCgfKY6-cU,300
 flock/core/execution/local_executor.py,sha256=rnIQvaJOs6zZORUcR3vvyS6LPREDJTjaygl_Db0M8ao,952
@@ -40,7 +40,8 @@ flock/core/mixin/prompt_parser.py,sha256=eOqI-FK3y17gVqpc_y5GF-WmK1Jv8mFlkZxTcgw
 flock/core/registry/agent_registry.py,sha256=TUClh9e3eA6YzZC1CMTlsTPvQeqb9jYHewi-zPpcWM8,4987
 flock/core/serialization/secure_serializer.py,sha256=n5-zRvvXddgJv1FFHsaQ2wuYdL3WUSGPvG_LGaffEJo,6144
 flock/core/serialization/serializable.py,sha256=SymJ0YrjBx48mOBItYSqoRpKuzIc4vKWRS6ScTzre7s,2573
-flock/core/tools/basic_tools.py,sha256=P1-RWkw57U2vSxPTCd5awlNg4MME4GkBLEB5HiiKmkw,5715
+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
 flock/core/tools/markdown_tools.py,sha256=W6fGM48yGHbifVlaOk1jOtVcybfRbRmf20VbDOZv8S4,6031
 flock/core/tools/dev_tools/github.py,sha256=a2OTPXS7kWOVA4zrZHynQDcsmEi4Pac5MfSjQOLePzA,5308
@@ -53,13 +54,13 @@ flock/evaluators/memory/memory_evaluator.py,sha256=SmerXyNaqm8DTV0yw-WqWkn9DXIf6
 flock/evaluators/natural_language/natural_language_evaluator.py,sha256=6nVEeh8_uwv_h-d3FWlA0GbzDzRtdhvxCGKirHtyvOU,2012
 flock/evaluators/zep/zep_evaluator.py,sha256=9NOELl7JAuUcx_FQrxY6b-_vN3MjwDyW7ZppPIGeCFc,1954
 flock/modules/azure-search/azure_search_module.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flock/modules/callback/callback_module.py,sha256=SQ9LGNVvcSRrr5BPYwWfTUvHqEdwB5f9voFkQTZwwtU,2503
-flock/modules/memory/memory_module.py,sha256=Ej2tCTrexf_c4MUxUg8DcwevHSIp2xDVF-95DUJAeEU,14417
+flock/modules/callback/callback_module.py,sha256=volGGgHtY19qj1wHR6m5a_hmXSbV3Ca3uY6I76YmcfU,2833
+flock/modules/memory/memory_module.py,sha256=dZ30eOFqIlAz0a5IKJMoXgJ-VyPEqApAOX0OQjhGA1I,14733
 flock/modules/memory/memory_parser.py,sha256=FLH7GL8XThvHiCMfX3eQH7Sz-f62fzhAUmO6_gaDI7U,4372
 flock/modules/memory/memory_storage.py,sha256=CNcLDMmvv0x7Z3YMKr6VveS_VCa7rKPw8l2d-XgqokA,27246
-flock/modules/output/output_module.py,sha256=ygk553PxKulmoGlRL0F_iP_FMiDteEtAcz9zUfYYTdI,7153
-flock/modules/performance/metrics_module.py,sha256=JsLIVs-2PZ_A8GyYLNVBsNXdSFyrVid3YGd0fu4HXyM,16404
-flock/modules/zep/zep_module.py,sha256=BIJ5K-hg2bLeJmGKoDcVY1rVN7_0yYETiSaVrO-gtMI,5830
+flock/modules/output/output_module.py,sha256=MPs5QV5g5DZQGqR07dS0eBug_TGpkdjX5zTrcrDphq8,7467
+flock/modules/performance/metrics_module.py,sha256=UD9OjY4-zAvauMD7YyDYqE1gyIhzpdr3JkBT8j9knxY,16790
+flock/modules/zep/zep_module.py,sha256=x7JG6O6xnwwum0RETIqKYbA3xzdcvX2aUuns0Cl0c2Q,6014
 flock/platform/docker_tools.py,sha256=fpA7-6rJBjPOUBLdQP4ny2QPgJ_042nmqRn5GtKnoYw,1445
 flock/platform/jaeger_install.py,sha256=MyOMJQx4TQSMYvdUJxfiGSo3YCtsfkbNXcAcQ9bjETA,2898
 flock/routers/__init__.py,sha256=w9uL34Auuo26-q_EGlE8Z9iHsw6S8qutTAH_ZI7pn7M,39
@@ -407,12 +408,12 @@ flock/themes/zenburned.toml,sha256=UEmquBbcAO3Zj652XKUwCsNoC2iQSlIh-q5c6DH-7Kc,1
 flock/themes/zenwritten-dark.toml,sha256=To5l6520_3UqAGiEumpzGWsHhXxqu9ThrMildXKgIO0,1669
 flock/themes/zenwritten-light.toml,sha256=G1iEheCPfBNsMTGaVpEVpDzYBHA_T-MV27rolUYolmE,1666
 flock/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flock/workflow/activities.py,sha256=JDfcmn99k5UTN3QNm5hAdn_eRjWRYhWSIw1U0kMOAh4,9014
+flock/workflow/activities.py,sha256=yah-lHjMW6_Ww1gt7hMXBis1cJRlcbHx0uLsMB9oNZ0,9066
 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.3.15.dist-info/METADATA,sha256=t66Wek4_NowqINrTeZkvZRwiYBdVVpBCyYPE9s62twU,20502
-flock_core-0.3.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.3.15.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.3.15.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.3.15.dist-info/RECORD,,
+flock_core-0.3.17.dist-info/METADATA,sha256=UBhR7vepYychz81nFEj8gvsjukAXFX4kv25HKiCk2Bw,20584
+flock_core-0.3.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.3.17.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.3.17.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.3.17.dist-info/RECORD,,