flock-core 0.4.543__py3-none-any.whl → 0.5.0__py3-none-any.whl

flock/core/util/splitter.py

@@ -1,219 +0,0 @@
-import re
-
-
-def split_top_level(spec: str) -> list[str]:
-    """Return raw field strings, split on *top-level* commas."""
-    fields: list[str] = []
-    start = 0
-    depth = 0
-    quote_char: str | None = None
-    i = 0
-    ident_re = re.compile(r"[A-Za-z_]\w*")  # cheap identifier
-
-    while i < len(spec):
-        ch = spec[i]
-
-        # ---------- string handling ----------
-        if quote_char:
-            if ch == "\\":
-                i += 2  # skip escaped char
-                continue
-            if ch == quote_char:
-                quote_char = None
-            i += 1
-            continue
-
-        if ch in {"'", '"'}:
-            prev = spec[i - 1] if i else " "
-            if (
-                depth or prev.isspace() or prev in "=([{,:"
-            ):  # looks like a quote
-                quote_char = ch
-            i += 1
-            continue
-
-        # ---------- bracket / brace / paren ----------
-        if ch in "([{":
-            depth += 1
-            i += 1
-            continue
-        if ch in ")]}":
-            depth = max(depth - 1, 0)
-            i += 1
-            continue
-
-        # ---------- field separators ----------
-        if ch == "," and depth == 0:
-            j = i + 1
-            while j < len(spec) and spec[j].isspace():
-                j += 1
-            if j >= len(spec):  # comma at end – split
-                fields.append(spec[start:i].strip())
-                start = i + 1
-                i += 1
-                continue
-
-            id_match = ident_re.match(spec, j)
-            if id_match:
-                k = id_match.end()
-                while k < len(spec) and spec[k].isspace():
-                    k += 1
-                if k >= len(spec) or spec[k] in {":", "|", ","}:
-                    # confirmed: comma separates two fields
-                    fields.append(spec[start:i].strip())
-                    start = i + 1
-                    i += 1
-                    continue
-
-        i += 1
-
-    fields.append(spec[start:].strip())
-    return [f for f in fields if f]  # prune empties
-
-
-def parse_schema(spec: str) -> list[tuple[str, str, str]]:
-    """Turn *spec* into a list of (name, python_type, description)."""
-    result: list[tuple[str, str, str]] = []
-
-    for field in split_top_level(spec):
-        name = ""
-        type_str = "str"  # default type
-        description = ""
-
-        name_part, _, desc_part = field.partition("|")
-        description = desc_part.strip()
-        main_part = name_part.strip()
-
-        if ":" in main_part:
-            name, type_candidate = main_part.split(":", 1)
-            name = name.strip()
-            type_candidate = type_candidate.strip()
-            if type_candidate:
-                type_str = type_candidate
-        else:
-            name = main_part  # keeps default type
-
-        if name:  # skip broken pieces
-            result.append((name, type_str, description))
-
-    return result
-
-
-# ------------------------------ demo ------------------------------
-if __name__ == "__main__":
-    SAMPLE_1 = (
-        " name: str | The character's full name,"
-        "race: str | The character's fantasy race,"
-        "class: Literal['mage','thief'] | The character's profession,"
-        "background: str | A brief backstory for the character"
-    )
-
-    SAMPLE_2 = (
-        "field_with_internal_quotes: Literal['type_A', "
-        '"type_B_with_\'_apostrophe"] | A literal with mixed quotes,'
-        " another_field :str| A field with a description"
-    )
-
-    SAMPLE_3 = (
-        "field_with_internal_quotes: Literal['type_A', "
-        '"type_B_with_\'_apostrophe"] | A literal with mixed quotes,'
-        " another_field | A field with a description"
-    )
-
-    SAMPLE_4 = "input, query, output"
-
-    SAMPLE_5 = (
-        "name: str | The character's full name,"
-        "race: str | The character's fantasy race,"
-        "class: Literal['mage','thief'] | The character's profession, which can be either mage or thief,"
-        "background: str | A brief backstory for the character"
-    )
-
-    SAMPLE_6 = (
-        "summary: str | A short blurb, e.g. key:value pairs that appear in logs"
-    )
-    # ➜ [('summary', 'str',
-    #     'A short blurb, e.g. key:value pairs that appear in logs')]
-
-    SAMPLE_7 = "path: str | The literal string 'C:\\\\Program Files\\\\My,App'"
-
-    # ➜ [('path', 'str',
-    #     "The literal string 'C:\\Program Files\\My,App'")]
-
-    SAMPLE_8 = (
-        "transform: Callable[[int, str], bool] | Function that returns True on success,"
-        "retries: int | How many times to retry"
-    )
-    # ➜ ('transform', 'Callable[[int, str], bool]', 'Function that returns True on success')
-    #    ('retries',   'int',                         'How many times to retry')
-
-    SAMPLE_9 = (
-        r"regex: str | Pattern such as r'^[A-Z\|a-z]+$',"
-        "flags: int | re flags to use"
-    )
-    # ➜ ('regex', 'str', "Pattern such as r'^[A-Z\\|a-z]+$'")
-    #    ('flags', 'int', 're flags to use')
-
-    SAMPLE_10 = "id:int, name:str,"  # note the final comma!
-    # ➜ ('id', 'int', '')
-    #    ('name', 'str', '')
-
-    SAMPLE_11 = "id:int | Primary key\nname:str | Display name\nactive:bool"
-    # ➜ should not work!
-
-    SAMPLE_12 = (
-        'comment:str | The text "done | failed" goes here,'
-        'status:Literal["done","failed"]'
-    )
-    # ➜ ('comment', 'str',    'The text "done | failed" goes here')
-    #    ('status',  'Literal["done","failed"]', '')
-
-    SAMPLE_13 = "choice: Literal['He said \\'yes\\'', 'no'] | User response"
-    # ➜ ('choice', "Literal['He said \\'yes\\'', 'no']", 'User response')
-
-    SAMPLE_14 = ""
-    # ➜ []
-
-    SAMPLE_15 = "username"
-    # ➜ [('username', 'str', '')]
-
-    SAMPLE_16 = (
-        "payload: dict[str, list[dict[str, tuple[int,str]]]] "
-        "| Arbitrarily complex structure"
-    )
-    # ➜ ('payload', 'dict[str, list[dict[str, tuple[int,str]]]]',
-    #     '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"
-
-
-    SAMPLE_19 = "title, headings: list[str], entities_and_metadata: list[dict[str, str]], type:Literal['news', 'blog', 'opinion piece', 'tweet']"
-    # ➜ [('münze', 'str', "Deutsche Münzbezeichnung, engl. 'coin'")]
-
-    for title, spec in [
-        ("Sample-1", SAMPLE_1),
-        ("Sample-2", SAMPLE_2),
-        ("Sample-3", SAMPLE_3),
-        ("Sample-4", SAMPLE_4),
-        ("Sample-5", SAMPLE_5),
-        ("Sample-6", SAMPLE_6),
-        ("Sample-7", SAMPLE_7),
-        ("Sample-8", SAMPLE_8),
-        ("Sample-9", SAMPLE_9),
-        ("Sample-10", SAMPLE_10),
-        ("Sample-11", SAMPLE_11),
-        ("Sample-12", SAMPLE_12),
-        ("Sample-13", SAMPLE_13),
-        ("Sample-14", SAMPLE_14),
-        ("Sample-15", SAMPLE_15),
-        ("Sample-16", SAMPLE_16),
-        ("Sample-17", SAMPLE_17),
-        ("Sample-18", SAMPLE_18),
-        ("Sample-19", SAMPLE_19),
-    ]:
-        print(f"\n{title}")
-        for row in parse_schema(spec):
-            print(row)

flock/di.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-"""Flock – Dependency-Injection helpers.
-
-This module provides a very small façade over the `wd.di` container so that
-other parts of the codebase do not need to know where the active container is
-stored.  The bootstrap code – usually located in the runner initialisation –
-should store the `ServiceProvider` instance (returned by ``ServiceCollection.
-build()``) on the `FlockContext` under the key ``di.container``.
-
-Example
--------
->>> from wd.di import ServiceCollection
->>> sc = ServiceCollection()
->>> sc.add_singleton(str, lambda _: "hello")
->>> container = sc.build()
->>> ctx = FlockContext()
->>> ctx.set_variable("di.container", container)
->>> from flock.di import get_current_container
->>> assert get_current_container(ctx).get_service(str) == "hello"
-"""
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:  # pragma: no cover
-    from wd.di.container import (
-        ServiceProvider,  # noqa: F401 – import only for typing
-    )
-
-    from flock.core.context.context import FlockContext
-
-
-def get_current_container(context: FlockContext | None = None):
-    """Return the active `wd.di` container from *context* if present.
-
-    If *context* is ``None`` or no container has been attached to it the
-    function returns ``None``.
-    """
-    if context is None:
-        return None
-    return context.get_variable("di.container")

flock/evaluators/__init__.py

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

flock/evaluators/declarative/__init__.py

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

flock/evaluators/declarative/declarative_evaluator.py

@@ -1,217 +0,0 @@
-from collections.abc import Generator
-from typing import Any
-
-from temporalio import workflow
-
-with workflow.unsafe.imports_passed_through():
-    import dspy
-
-from pydantic import Field, PrivateAttr
-
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
-from flock.core.flock_registry import flock_component
-from flock.core.logging.logging import get_logger
-from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
-from flock.core.mixin.prompt_parser import PromptParserMixin
-
-logger = get_logger("evaluators.declarative")
-
-
-class DeclarativeEvaluatorConfig(FlockEvaluatorConfig):
-    """Configuration for the DeclarativeEvaluator."""
-
-    override_evaluator_type: str | None = None
-    model: str | None = "openai/gpt-4o"
-    use_cache: bool = True
-    temperature: float = 1.0
-    max_tokens: int = 4096
-    max_retries: int = 3
-    max_tool_calls: int = 10
-    stream: bool = Field(
-        default=False,
-        description="Enable streaming output from the underlying DSPy program.",
-    )
-    include_thought_process: bool = Field(
-        default=False,
-        description="Include the thought process in the output.",
-    )
-    include_reasoning: bool = Field(
-        default=False,
-        description="Include the reasoning in the output.",
-    )
-    kwargs: dict[str, Any] = Field(default_factory=dict)
-
-
-@flock_component(config_class=DeclarativeEvaluatorConfig)
-class DeclarativeEvaluator(
-    FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin
-):
-    """Evaluator that uses DSPy for generation."""
-
-    config: DeclarativeEvaluatorConfig = Field(
-        default_factory=DeclarativeEvaluatorConfig,
-        description="Evaluator configuration",
-    )
-
-    _cost: float = PrivateAttr(default=0.0)
-    _lm_history: list = PrivateAttr(default_factory=list)
-
-    # def __init__(self, name: str, config: DeclarativeEvaluatorConfig) -> None:
-    #     super().__init__(name=name, config=config)
-    # self._configure_language_model(
-    #     model=config.model,
-    #     use_cache=config.use_cache,
-    #     temperature=config.temperature,
-    #     max_tokens=config.max_tokens,
-    # )
-
-    async def evaluate(
-        self,
-        agent: FlockAgent,
-        inputs: dict[str, Any],
-        tools: list[Any],
-        mcp_tools: list[Any] | None = None,
-    ) -> dict[str, Any]:
-        """Evaluate using DSPy, with optional asynchronous streaming."""
-        # --- Setup Signature and LM ---
-
-        with dspy.context(
-            lm=dspy.LM(
-                model=self.config.model or agent.model,
-                cache=self.config.use_cache,
-                temperature=self.config.temperature,
-                max_tokens=self.config.max_tokens,
-                num_retries=self.config.max_retries,
-            )
-        ):
-            try:
-                from rich.console import Console
-
-                console = Console()
-                _dspy_signature = self.create_dspy_signature_class(
-                    agent.name,
-                    agent.description,
-                    f"{agent.input} -> {agent.output}",
-                )
-                # --- Get output field names ---
-                # dspy.Signature holds fields in .output_fields attribute
-                output_field_names = list(_dspy_signature.output_fields.keys())
-                if not output_field_names:
-                    logger.warning(
-                        f"DSPy signature for agent '{agent.name}' has no defined output fields. Streaming might not produce text."
-                    )
-                # -----------------------------
-
-                agent_task = self._select_task(
-                    _dspy_signature,
-                    override_evaluator_type=self.config.override_evaluator_type,
-                    tools=tools,
-                    max_tool_calls=self.config.max_tool_calls,
-                    mcp_tools=mcp_tools,
-                    kwargs=self.config.kwargs,
-                )
-            except Exception as setup_error:
-                logger.error(
-                    f"Error setting up DSPy task for agent '{agent.name}': {setup_error}",
-                    exc_info=True,
-                )
-                raise RuntimeError(
-                    f"DSPy task setup failed: {setup_error}"
-                ) from setup_error
-
-            # --- Conditional Evaluation (Stream vs No Stream) ---
-            if self.config.stream:
-                logger.info(
-                    f"Evaluating agent '{agent.name}' with async streaming."
-                )
-                if not callable(agent_task):
-                    logger.error("agent_task is not callable, cannot stream.")
-                    raise TypeError(
-                        "DSPy task could not be created or is not callable."
-                    )
-
-                streaming_task = dspy.streamify(
-                    agent_task, is_async_program=True
-                )
-                stream_generator: Generator = streaming_task(**inputs)
-                delta_content = ""
-
-                console.print("\n")
-                async for chunk in stream_generator:
-                    if (
-                        hasattr(chunk, "choices")
-                        and chunk.choices
-                        and hasattr(chunk.choices[0], "delta")
-                        and chunk.choices[0].delta
-                        and hasattr(chunk.choices[0].delta, "content")
-                    ):
-                        delta_content = chunk.choices[0].delta.content
-
-                    if delta_content:
-                        console.print(delta_content, end="")
-
-                    result_dict, cost, lm_history = self._process_result(
-                        chunk, inputs
-                    )
-                    self._cost = cost
-                    self._lm_history = lm_history
-
-                console.print("\n")
-                result_dict = self.filter_reasoning(
-                    result_dict, self.config.include_reasoning
-                )
-                return self.filter_thought_process(
-                    result_dict, self.config.include_thought_process
-                )
-
-            else:  # Non-streaming path
-                logger.info(
-                    f"Evaluating agent '{agent.name}' without streaming."
-                )
-                try:
-                    # Ensure the call is awaited if the underlying task is async
-                    result_obj = await agent_task.acall(**inputs)
-                    result_dict, cost, lm_history = self._process_result(
-                        result_obj, inputs
-                    )
-                    self._cost = cost
-                    self._lm_history = lm_history
-                    result_dict = self.filter_reasoning(
-                        result_dict, self.config.include_reasoning
-                    )
-                    return self.filter_thought_process(
-                        result_dict, self.config.include_thought_process
-                    )
-                except Exception as e:
-                    logger.error(
-                        f"Error during non-streaming evaluation for agent '{agent.name}': {e}",
-                        exc_info=True,
-                    )
-                    raise RuntimeError(f"Evaluation failed: {e}") from e
-
-    def filter_thought_process(
-        self, result_dict: dict[str, Any], include_thought_process: bool
-    ) -> dict[str, Any]:
-        """Filter out thought process from the result dictionary."""
-        if include_thought_process:
-            return result_dict
-        else:
-            return {
-                k: v
-                for k, v in result_dict.items()
-                if not (k.startswith("trajectory"))
-            }
-
-    def filter_reasoning(
-        self, result_dict: dict[str, Any], include_reasoning: bool
-    ) -> dict[str, Any]:
-        """Filter out reasoning from the result dictionary."""
-        if include_reasoning:
-            return result_dict
-        else:
-            return {
-                k: v
-                for k, v in result_dict.items()
-                if not (k.startswith("reasoning"))
-            }

flock/evaluators/memory/memory_evaluator.py

@@ -1,90 +0,0 @@
-from typing import Any, Literal
-
-from pydantic import Field
-
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
-from flock.core.flock_registry import flock_component
-from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
-from flock.core.mixin.prompt_parser import PromptParserMixin
-from flock.modules.memory.memory_module import MemoryModule, MemoryModuleConfig
-
-
-class MemoryEvaluatorConfig(FlockEvaluatorConfig):
-    folder_path: str = Field(
-        default="concept_memory/",
-        description="Directory where memory file and concept graph will be saved",
-    )
-    concept_graph_file: str = Field(
-        default="concept_graph.png",
-        description="Base filename for the concept graph image",
-    )
-
-    file_path: str | None = Field(
-        default="agent_memory.json", description="Path to save memory file"
-    )
-    memory_mapping: str | None = Field(
-        default=None, description="Memory mapping configuration"
-    )
-    similarity_threshold: float = Field(
-        default=0.5, description="Threshold for semantic similarity"
-    )
-    max_length: int = Field(
-        default=1000, description="Max length of memory entry before splitting"
-    )
-    save_after_update: bool = Field(
-        default=True, description="Whether to save memory after each update"
-    )
-    splitting_mode: Literal["summary", "semantic", "characters", "none"] = (
-        Field(default="none", description="Mode to split memory content")
-    )
-    enable_read_only_mode: bool = Field(
-        default=False, description="Whether to enable read only mode"
-    )
-    number_of_concepts_to_extract: int = Field(
-        default=3, description="Number of concepts to extract from the memory"
-    )
-
-
-@flock_component(config_class=MemoryEvaluatorConfig)
-class MemoryEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
-    """Evaluator that uses DSPy for generation."""
-
-    config: MemoryEvaluatorConfig = Field(
-        default_factory=MemoryEvaluatorConfig,
-        description="Evaluator configuration",
-    )
-
-    async def evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
-    ) -> dict[str, Any]:
-        """Simple evaluator that uses a memory concept graph.
-
-        if inputs contain "query", it searches memory for the query and returns the facts.
-        if inputs contain "data", it adds the data to memory
-        """
-        result = {}
-        memory_module = MemoryModule(
-            name=self.name,
-            config=MemoryModuleConfig(
-                folder_path=self.config.folder_path,
-                concept_graph_file=self.config.concept_graph_file,
-                file_path=self.config.file_path,
-                memory_mapping=self.config.memory_mapping,
-                similarity_threshold=self.config.similarity_threshold,
-                max_length=self.config.max_length,
-                save_after_update=self.config.save_after_update,
-                splitting_mode=self.config.splitting_mode,
-                enable_read_only_mode=self.config.enable_read_only_mode,
-                number_of_concepts_to_extract=self.config.number_of_concepts_to_extract,
-            ),
-        )
-
-        if "query" in inputs:
-            facts = await memory_module.search_memory(agent, inputs)
-            result = {"facts": facts}
-
-        if "data" in inputs:
-            await memory_module.add_to_memory(agent, inputs)
-            result = {"message": "Data added to memory"}
-        return result

flock/evaluators/test/test_case_evaluator.py

@@ -1,38 +0,0 @@
-from typing import Any
-
-from pydantic import Field
-
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
-from flock.core.flock_registry import flock_component
-from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
-
-
-class TestCaseEvaluatorConfig(FlockEvaluatorConfig):
-    """Configuration for the TestCaseEvaluator."""
-
-    pass
-
-
-@flock_component(config_class=TestCaseEvaluatorConfig)
-class TestCaseEvaluator(FlockEvaluator, DSPyIntegrationMixin):
-    """Evaluator for test cases."""
-
-    config: TestCaseEvaluatorConfig = Field(
-        default_factory=TestCaseEvaluatorConfig,
-        description="Evaluator configuration",
-    )
-
-    async def evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
-    ) -> dict[str, Any]:
-        _dspy_signature = self.create_dspy_signature_class(
-            agent.name,
-            agent.description,
-            f"{agent.input} -> {agent.output}",
-        )
-        output_field_names = list(_dspy_signature.output_fields.keys())
-        result = {}
-        for output_field_name in output_field_names:
-            result[output_field_name] = "Test Result"
-        return result

flock/evaluators/zep/zep_evaluator.py

@@ -1,59 +0,0 @@
-from typing import Any
-
-from pydantic import Field
-
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
-from flock.core.flock_registry import flock_component
-from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
-from flock.core.mixin.prompt_parser import PromptParserMixin
-from flock.modules.zep.zep_module import ZepModule, ZepModuleConfig
-
-
-class ZepEvaluatorConfig(FlockEvaluatorConfig):
-    zep_url: str = "http://localhost:8000"
-    zep_api_key: str = "apikey"
-    min_fact_rating: float = Field(
-        default=0.7, description="Minimum rating for facts to be considered"
-    )
-
-
-@flock_component(config_class=ZepEvaluatorConfig)
-class ZepEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
-    """Evaluator that uses DSPy for generation."""
-
-    config: ZepEvaluatorConfig = Field(
-        default_factory=ZepEvaluatorConfig,
-        description="Evaluator configuration",
-    )
-
-    async def evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
-    ) -> dict[str, Any]:
-        """Simple evaluator that uses Zep.
-
-        if inputs contain "query", it searches memory for the query and returns the facts.
-        if inputs contain "data", it adds the data to memory
-        """
-        result = {}
-        zep = ZepModule(
-            name=self.name,
-            config=ZepModuleConfig(
-                zep_api_key=self.config.zep_api_key,
-                zep_url=self.config.zep_url,
-                min_fact_rating=self.config.min_fact_rating,
-                enable_read=True,
-                enable_write=True,
-            ),
-        )
-        client = zep.get_client()
-        if "query" in inputs:
-            query = inputs["query"]
-            facts = zep.search_memory(query, client)
-            result = {"facts": facts}
-
-        if "data" in inputs:
-            data = inputs["data"]
-            zep.add_to_memory(data, client)
-            result = {"message": "Data added to memory"}
-        return result

flock/modules/__init__.py

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

flock/modules/assertion/__init__.py

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