flock-core 0.4.0b30__tar.gz → 0.4.0b32__tar.gz

{flock_core-0.4.0b30 → flock_core-0.4.0b32}/PKG-INFO

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

{flock_core-0.4.0b30 → flock_core-0.4.0b32}/pyproject.toml

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

{flock_core-0.4.0b30 → flock_core-0.4.0b32}/src/flock/core/flock_agent.py

@@ -239,6 +239,10 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                 if self.write_to_file:
                     self._save_output(self.name, result)
 
+                if self.wait_for_input:
+                    # simple input prompt
+                    input("Press Enter to continue...")
+
             except Exception as module_error:
                 logger.error(
                     "Error during terminate",

{flock_core-0.4.0b30 → flock_core-0.4.0b32}/src/flock/core/mixin/dspy_integration.py

@@ -6,6 +6,7 @@ import typing
 from typing import Any, Literal
 
 from flock.core.logging.logging import get_logger
+from flock.core.util.spliter import split_top_level
 
 # Import split_top_level (assuming it's moved or copied appropriately)
 # Option 1: If moved to a shared util
@@ -19,48 +20,6 @@ logger = get_logger("mixin.dspy")
 AgentType = Literal["ReAct", "Completion", "ChainOfThought"] | None
 
 
-# Helper function needed by _resolve_type_string (copied from input_resolver.py/previous response)
-def split_top_level(s: str) -> list[str]:
-    """Split a string on commas that are not enclosed within brackets, parentheses, or quotes."""
-    parts = []
-    current = []
-    level = 0
-    in_quote = False
-    quote_char = ""
-    i = 0
-    while i < len(s):
-        char = s[i]
-        # Handle escapes within quotes
-        if in_quote and char == "\\" and i + 1 < len(s):
-            current.append(char)
-            current.append(s[i + 1])
-            i += 1  # Skip next char
-        elif in_quote:
-            current.append(char)
-            if char == quote_char:
-                in_quote = False
-        elif char in ('"', "'"):
-            in_quote = True
-            quote_char = char
-            current.append(char)
-        elif char in "([{":
-            level += 1
-            current.append(char)
-        elif char in ")]}":
-            level -= 1
-            current.append(char)
-        elif char == "," and level == 0:
-            parts.append("".join(current).strip())
-            current = []
-        else:
-            current.append(char)
-        i += 1
-    if current:
-        parts.append("".join(current).strip())
-    # Filter out empty strings that might result from trailing commas etc.
-    return [part for part in parts if part]
-
-
 # Helper function to resolve type strings (can be static or module-level)
 def _resolve_type_string(type_str: str) -> type:
     """Resolves a type string into a Python type object.
@@ -93,20 +52,26 @@ def _resolve_type_string(type_str: str) -> type:
     if generic_match:
         base_name = generic_match.group(1).strip()
         args_str = generic_match.group(2).strip()
-        logger.debug(f"Detected generic pattern: Base='{base_name}', Args='{args_str}'")
+        logger.debug(
+            f"Detected generic pattern: Base='{base_name}', Args='{args_str}'"
+        )
 
         try:
             # Get the base generic type (e.g., list, dict, Optional) from registry/builtins
             BaseType = FlockRegistry.get_type(
                 base_name
             )  # Expects List, Dict etc. to be registered
-            logger.debug(f"Resolved base generic type '{base_name}' to: {BaseType}")
+            logger.debug(
+                f"Resolved base generic type '{base_name}' to: {BaseType}"
+            )
 
             # Special handling for Literal
             if BaseType is typing.Literal:
                 # Split literal values, remove quotes, strip whitespace
                 literal_args_raw = split_top_level(args_str)
-                literal_args = tuple(s.strip().strip("'\"") for s in literal_args_raw)
+                literal_args = tuple(
+                    s.strip().strip("'\"") for s in literal_args_raw
+                )
                 logger.debug(
                     f"Parsing Literal arguments: {literal_args_raw} -> {literal_args}"
                 )
@@ -121,7 +86,9 @@ def _resolve_type_string(type_str: str) -> type:
             if not arg_strs:
                 raise ValueError("Generic type has no arguments.")
 
-            resolved_arg_types = tuple(_resolve_type_string(arg) for arg in arg_strs)
+            resolved_arg_types = tuple(
+                _resolve_type_string(arg) for arg in arg_strs
+            )
             logger.debug(f"Resolved generic arguments: {resolved_arg_types}")
 
             # Construct the generic type hint
@@ -129,7 +96,9 @@ def _resolve_type_string(type_str: str) -> type:
                 if len(resolved_arg_types) != 1:
                     raise ValueError("Optional requires exactly one argument.")
                 resolved_type = typing.Union[resolved_arg_types[0], type(None)]  # type: ignore
-                logger.debug(f"Constructed Optional type as Union: {resolved_type}")
+                logger.debug(
+                    f"Constructed Optional type as Union: {resolved_type}"
+                )
                 return resolved_type
             elif BaseType is typing.Union:
                 if not resolved_arg_types:
@@ -141,7 +110,9 @@ def _resolve_type_string(type_str: str) -> type:
                 BaseType, "__getitem__"
             ):  # Check if subscriptable (like list, dict, List, Dict)
                 resolved_type = BaseType[resolved_arg_types]  # type: ignore
-                logger.debug(f"Constructed subscripted generic type: {resolved_type}")
+                logger.debug(
+                    f"Constructed subscripted generic type: {resolved_type}"
+                )
                 return resolved_type
             else:
                 # Base type found but cannot be subscripted
@@ -221,7 +192,8 @@ class DSPyIntegrationMixin:
             if not fields_string or not fields_string.strip():
                 return
 
-            for field in split_top_level(fields_string):
+            split_fields = split_top_level(fields_string)
+            for field in split_fields:
                 if field.strip():
                     parsed = parse_field(field)
                     if not parsed:
@@ -232,11 +204,15 @@ class DSPyIntegrationMixin:
                     )
 
                     FieldClass = (
-                        dspy.InputField if field_kind == "input" else dspy.OutputField
+                        dspy.InputField
+                        if field_kind == "input"
+                        else dspy.OutputField
                     )
                     # DSPy Fields use 'desc' for description
                     class_dict[name] = (
-                        FieldClass(desc=desc) if desc is not None else FieldClass()
+                        FieldClass(desc=desc)
+                        if desc is not None
+                        else FieldClass()
                     )
 
         try:
@@ -247,11 +223,15 @@ class DSPyIntegrationMixin:
                 f"Error processing fields for DSPy signature '{agent_name}': {e}",
                 exc_info=True,
             )
-            raise ValueError(f"Could not process fields for signature: {e}") from e
+            raise ValueError(
+                f"Could not process fields for signature: {e}"
+            ) from e
 
         # Create and return the dynamic class
         try:
-            DynamicSignature = type("dspy_" + agent_name, (base_class,), class_dict)
+            DynamicSignature = type(
+                "dspy_" + agent_name, (base_class,), class_dict
+            )
             logger.info(
                 f"Successfully created DSPy Signature: {DynamicSignature.__name__} "
                 f"with fields: {DynamicSignature.__annotations__}"
@@ -324,7 +304,9 @@ class DSPyIntegrationMixin:
         try:
             import dspy
         except ImportError:
-            logger.error("DSPy library is not installed. Cannot select DSPy task.")
+            logger.error(
+                "DSPy library is not installed. Cannot select DSPy task."
+            )
             raise ImportError("DSPy is required for this functionality.")
 
         processed_tools = []
@@ -343,7 +325,9 @@ class DSPyIntegrationMixin:
 
         # Determine type if not overridden
         if not selected_type:
-            selected_type = "ReAct" if processed_tools else "Predict"  # Default logic
+            selected_type = (
+                "ReAct" if processed_tools else "Predict"
+            )  # Default logic
 
         logger.debug(
             f"Selecting DSPy program type: {selected_type} (Tools provided: {bool(processed_tools)})"
@@ -366,7 +350,9 @@ class DSPyIntegrationMixin:
                 )
                 dspy_program = dspy.Predict(signature)
 
-            logger.info(f"Instantiated DSPy program: {type(dspy_program).__name__}")
+            logger.info(
+                f"Instantiated DSPy program: {type(dspy_program).__name__}"
+            )
             return dspy_program
         except Exception as e:
             logger.error(
@@ -390,7 +376,9 @@ class DSPyIntegrationMixin:
                 output_dict = dict(result.items())
             elif hasattr(result, "__dict__"):  # Fallback for other object types
                 output_dict = {
-                    k: v for k, v in result.__dict__.items() if not k.startswith("_")
+                    k: v
+                    for k, v in result.__dict__.items()
+                    if not k.startswith("_")
                 }
             else:
                 # If it's already a dict (less common for DSPy results directly)

{flock_core-0.4.0b30 → flock_core-0.4.0b32}/src/flock/core/util/input_resolver.py

@@ -1,6 +1,7 @@
 """Utility functions for resolving input keys to their corresponding values."""
 
 from flock.core.context.context import FlockContext
+from flock.core.util.spliter import split_top_level
 
 
 def get_callable_members(obj):
@@ -22,60 +23,6 @@ def get_callable_members(obj):
     return callables
 
 
-def split_top_level(s: str) -> list[str]:
-    """Split a string on commas that are not enclosed within brackets, parentheses, or quotes.
-
-    This function iterates over the string while keeping track of the nesting level. It
-    only splits on commas when the nesting level is zero. It also properly handles quoted
-    substrings.
-
-    Args:
-        s (str): The input string.
-
-    Returns:
-        List[str]: A list of substrings split at top-level commas.
-    """
-    parts = []
-    current = []
-    level = 0
-    in_quote = False
-    quote_char = ""
-
-    for char in s:
-        # If inside a quote, only exit when the matching quote is found.
-        if in_quote:
-            current.append(char)
-            if char == quote_char:
-                in_quote = False
-            elif char == "\\":
-                # Include escape sequences
-                continue
-            continue
-
-        # Check for the start of a quote.
-        if char in ('"', "'"):
-            in_quote = True
-            quote_char = char
-            current.append(char)
-            continue
-
-        # Track nesting.
-        if char in "([{":
-            level += 1
-        elif char in ")]}":
-            level -= 1
-
-        # Split on commas if not nested.
-        if char == "," and level == 0:
-            parts.append("".join(current).strip())
-            current = []
-        else:
-            current.append(char)
-    if current:
-        parts.append("".join(current).strip())
-    return parts
-
-
 def _parse_keys(keys: list[str]) -> list[str]:
     """Split a comma‐separated string and strip any type annotations.
 

flock_core-0.4.0b32/src/flock/core/util/spliter.py

@@ -0,0 +1,126 @@
+import re
+
+
+def split_top_level(spec: str) -> list[str]:
+    """Split *spec* on commas that are truly between fields (i.e. that
+    are **not** inside brackets, braces, parentheses, string literals,
+    or the free-form description).
+
+    Strategy
+    --------
+    1. Single pass, char-by-char.
+    2. Track    • nesting depth for (), [], {}
+                • whether we are inside a quoted string
+    3. Consider a comma a separator *only* if depth == 0, we are not
+       inside quotes **and** the text that follows matches
+       `optional-ws + identifier + optional-ws + ':'`
+       which can only be the start of the next field.
+    """
+    fields: list[str] = []
+    start = 0
+    depth = 0
+    quote_char: str | None = None
+    i = 0
+    ident_re = re.compile(r"[A-Za-z_]\w*")  # cheap Python identifier
+
+    while i < len(spec):
+        ch = spec[i]
+
+        # ---------------- string handling ----------------
+        if quote_char:
+            if ch == quote_char:
+                quote_char = None
+            i += 1
+            continue
+
+        if ch in {"'", '"'}:
+            # treat as string delimiter only in places regular Python would
+            prev = spec[i - 1] if i else " "
+            if depth or prev.isspace() or prev in "=([{,:":  # likely 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):
+                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) and spec[k] == ":":
+                        # confirmed: the comma ends the current field
+                        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 the raw *spec* into List[(name, python_type, description)]."""
+    result: list[tuple[str, str, str]] = []
+
+    for field in split_top_level(spec):
+        if ":" not in field:
+            raise ValueError(f"Malformed field (missing ':'): {field!r}")
+
+        name_part, rest = field.split(":", 1)
+        name = name_part.strip()
+
+        type_part, _, desc_part = rest.partition("|")
+        type_str = type_part.strip()
+        description = desc_part.strip()
+
+        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"
+    )
+
+    print(f"Sample 1: {SAMPLE_1}")
+    print(f"Sample 2: {SAMPLE_2}")
+
+    print("\nSplitting Sample 1:")
+    split_sample_1 = split_top_level(SAMPLE_1)
+    print(split_sample_1)
+    for field in split_sample_1:
+        print(parse_schema(field))
+
+    print("\nSplitting Sample 2:")
+    split_sample_2 = split_top_level(SAMPLE_2)
+    print(split_sample_2)
+    for field in split_sample_2:
+        print(parse_schema(field))

{flock_core-0.4.0b30 → flock_core-0.4.0b32}/uv.lock

@@ -1208,7 +1208,7 @@ wheels = [
 
 [[package]]
 name = "flock-core"
-version = "0.4.0b30"
+version = "0.4.0b32"
 source = { editable = "." }
 dependencies = [
     { name = "azure-search-documents" },