krons 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

krons/utils/__init__.py

@@ -0,0 +1,85 @@
+from ._hash import (
+    GENESIS_HASH,
+    MAX_HASH_INPUT_BYTES,
+    HashAlgorithm,
+    compute_chain_hash,
+    compute_hash,
+    hash_obj,
+)
+from ._json_dump import json_dump, json_dumpb, json_lines_iter
+from ._to_list import to_list
+from ._to_num import to_num
+from ._utils import (
+    async_synchronized,
+    coerce_created_at,
+    create_path,
+    extract_types,
+    get_bins,
+    import_module,
+    is_import_installed,
+    load_type_from_string,
+    now_utc,
+    register_type_prefix,
+    synchronized,
+    to_uuid,
+)
+from .concurrency import alcall, is_coro_func
+from .fuzzy import (
+    SimilarityAlgo,
+    extract_json,
+    fuzzy_json,
+    fuzzy_match_keys,
+    string_similarity,
+    to_dict,
+)
+from .sql._sql_validation import (
+    MAX_IDENTIFIER_LENGTH,
+    SAFE_IDENTIFIER_PATTERN,
+    sanitize_order_by,
+    validate_identifier,
+)
+
+__all__ = (
+    # _hash
+    "GENESIS_HASH",
+    "MAX_HASH_INPUT_BYTES",
+    "HashAlgorithm",
+    "compute_chain_hash",
+    "compute_hash",
+    "hash_obj",
+    # _json_dump
+    "json_dump",
+    "json_dumpb",
+    "json_lines_iter",
+    # _to_list, _to_num
+    "to_list",
+    "to_num",
+    # _utils
+    "async_synchronized",
+    "coerce_created_at",
+    "create_path",
+    "extract_types",
+    "get_bins",
+    "import_module",
+    "is_import_installed",
+    "load_type_from_string",
+    "now_utc",
+    "register_type_prefix",
+    "synchronized",
+    "to_uuid",
+    # concurrency
+    "alcall",
+    "is_coro_func",
+    # fuzzy
+    "SimilarityAlgo",
+    "extract_json",
+    "fuzzy_json",
+    "fuzzy_match_keys",
+    "string_similarity",
+    "to_dict",
+    # sql
+    "MAX_IDENTIFIER_LENGTH",
+    "SAFE_IDENTIFIER_PATTERN",
+    "sanitize_order_by",
+    "validate_identifier",
+)

krons/utils/_function_arg_parser.py

@@ -0,0 +1,99 @@
+import types
+from typing import Any, Union, get_args, get_origin
+
+from pydantic import BaseModel
+
+
+def map_positional_args(
+    arguments: dict[str, Any], param_names: list[str]
+) -> dict[str, Any]:
+    """Map positional arguments (_pos_0, _pos_1, ...) to actual parameter names."""
+    mapped = {}
+    pos_count = 0
+
+    for key, value in arguments.items():
+        if key.startswith("_pos_"):
+            if pos_count >= len(param_names):
+                raise ValueError(
+                    f"Too many positional arguments (expected {len(param_names)})"
+                )
+            mapped[param_names[pos_count]] = value
+            pos_count += 1
+        else:
+            # Keep keyword arguments as-is
+            mapped[key] = value
+
+    return mapped
+
+
+def _get_nested_fields_from_annotation(annotation) -> set[str]:
+    """Extract all field names from an annotation that may be a Pydantic model or Union."""
+    origin = get_origin(annotation)
+
+    # Handle Union types (typing.Union or types.UnionType)
+    if origin is Union or isinstance(annotation, types.UnionType):
+        union_members = get_args(annotation)
+        all_fields = set()
+        for member in union_members:
+            if member is type(None):
+                continue
+            # Recursively check nested unions or models
+            nested = _get_nested_fields_from_annotation(member)
+            all_fields.update(nested)
+        return all_fields
+
+    # Handle direct Pydantic model
+    if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+        return set(annotation.model_fields.keys())
+
+    # Handle Pydantic model class (not instance)
+    if hasattr(annotation, "model_fields"):
+        return set(annotation.model_fields.keys())
+
+    return set()
+
+
+def nest_arguments_by_schema(arguments: dict[str, Any], schema_cls) -> dict[str, Any]:
+    """Restructure flat arguments into nested format based on schema structure."""
+    if not schema_cls or not hasattr(schema_cls, "model_fields"):
+        return arguments
+
+    # Get top-level field names
+    top_level_fields = set(schema_cls.model_fields.keys())
+
+    # Find fields that are nested objects (Pydantic models or unions)
+    nested_field_mappings = {}
+    for field_name, field_info in schema_cls.model_fields.items():
+        annotation = field_info.annotation
+        nested_fields = _get_nested_fields_from_annotation(annotation)
+        if nested_fields:
+            nested_field_mappings[field_name] = nested_fields
+
+    # If no nested fields detected, return as-is
+    if not nested_field_mappings:
+        return arguments
+
+    # Separate top-level args from nested args
+    result: dict[str, Any] = {}
+    nested_args: dict[str, dict[str, Any]] = {}
+
+    for key, value in arguments.items():
+        if key in top_level_fields:
+            # This is a top-level field
+            result[key] = value
+        else:
+            # Check if this belongs to a nested field
+            for nested_field, nested_keys in nested_field_mappings.items():
+                if key in nested_keys:
+                    if nested_field not in nested_args:
+                        nested_args[nested_field] = {}
+                    nested_args[nested_field][key] = value
+                    break
+            else:
+                # Unknown field - keep at top level (will fail validation later)
+                result[key] = value
+
+    # Add nested structures to result
+    result.update(nested_args)
+
+    return result

krons/utils/_pythonic_function_call.py

@@ -0,0 +1,249 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+# SPDX-License-Identifier: Apache-2.0
+
+"""Function call parser with khive-mcp extensions for unified tool paradigm.
+
+Core parsing with support for:
+- Service namespacing: cognition.remember_episodic(...)
+- Batch parsing: [call1(...), call2(...)]
+- Reserved keyword handling: from= -> from_= (Python keywords as args)
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+from typing import Any
+
+# Python reserved keywords that might be used as field names
+# These get mapped to underscore versions for parsing
+RESERVED_KEYWORDS = {
+    "from",
+    "import",
+    "class",
+    "def",
+    "return",
+    "yield",
+    "async",
+    "await",
+}
+
+# Regex to match keyword arguments with reserved names
+# Matches: from="value" or from='value' at word boundary
+_RESERVED_KWARG_PATTERN = re.compile(
+    r"\b(" + "|".join(RESERVED_KEYWORDS) + r")\s*=", re.MULTILINE
+)
+
+__all__ = (
+    "parse_function_call",
+    "parse_batch_function_calls",
+)
+
+
+def _escape_reserved_keywords(call_str: str) -> str:
+    """Escape Python reserved keywords used as argument names.
+
+    Converts `from=` to `from_=` so ast.parse can handle it.
+    The underscore version is what Pydantic expects for aliased fields.
+
+    Args:
+        call_str: Function call string that may contain reserved keywords
+
+    Returns:
+        String with reserved keywords escaped
+    """
+    return _RESERVED_KWARG_PATTERN.sub(r"\1_=", call_str)
+
+
+def _ast_to_value(node: ast.AST) -> Any:
+    """Convert AST node to Python value with recursive dict/list processing.
+
+    Handles nested dicts, lists, tuples, and JSON-style literals (true/false/null).
+    Normalizes JSON literals: true->True, false->False, null->None.
+
+    Args:
+        node: AST node to convert
+
+    Returns:
+        Python value
+
+    Raises:
+        ValueError: If node cannot be converted to a value
+    """
+    # Handle JSON-style boolean/null names: true, false, null
+    if isinstance(node, ast.Name):
+        if node.id in ("true", "false", "null"):
+            return {"true": True, "false": False, "null": None}[node.id]
+        raise ValueError(f"Name '{node.id}' is not a valid literal")
+
+    # Handle dict nodes: {key1: val1, key2: val2, ...}
+    if isinstance(node, ast.Dict):
+        return {
+            _ast_to_value(k): _ast_to_value(v) for k, v in zip(node.keys, node.values)
+        }
+
+    # Handle list nodes: [elem1, elem2, ...]
+    if isinstance(node, ast.List):
+        return [_ast_to_value(elem) for elem in node.elts]
+
+    # Handle tuple nodes: (elem1, elem2, ...)
+    if isinstance(node, ast.Tuple):
+        return tuple(_ast_to_value(elem) for elem in node.elts)
+
+    # Handle simple literals (str, int, float, bool, None) via ast.literal_eval
+    try:
+        return ast.literal_eval(node)
+    except (ValueError, TypeError) as e:
+        raise ValueError(f"Cannot convert AST node: {type(node).__name__}") from e
+
+
+def parse_function_call(call_str: str) -> dict[str, Any]:
+    """Parse Python function call syntax into unified tool format.
+
+    Supports service namespacing for unified tool paradigm:
+        - Simple: search("query") -> {operation: "search", arguments: {...}}
+        - Namespaced: cognition.remember("...") -> {service: "cognition", ...}
+        - Deep: recall.search("...") -> {service: "recall", operation: "search", ...}
+
+    Examples:
+        >>> parse_function_call('search("AI news")')
+        {'operation': 'search', 'arguments': {'query': 'AI news'}}
+
+        >>> parse_function_call('cognition.remember_episodic(content="...")')
+        {'service': 'cognition', 'operation': 'remember_episodic', 'arguments': {'content': '...'}}
+
+    Args:
+        call_str: Python function call as string
+
+    Returns:
+        Dict with 'operation', optional 'service', and 'arguments' keys
+        Legacy 'tool' key also included for backward compatibility
+
+    Raises:
+        ValueError: If the string is not a valid function call
+    """
+    try:
+        # Escape reserved keywords before parsing (e.g., from= -> from_=)
+        escaped_str = _escape_reserved_keywords(call_str)
+
+        # Parse the call as a Python expression
+        tree = ast.parse(escaped_str, mode="eval")
+        call = tree.body
+
+        if not isinstance(call, ast.Call):
+            raise ValueError("Not a function call")
+
+        # Extract function name and service namespace
+        service = None
+        operation = None
+
+        if isinstance(call.func, ast.Name):
+            # Simple call: search(...)
+            operation = call.func.id
+        elif isinstance(call.func, ast.Attribute):
+            # Namespaced call: cognition.remember(...) or recall.search(...)
+            operation = call.func.attr
+
+            # Walk up the attribute chain to get service name
+            node = call.func.value
+            if isinstance(node, ast.Name):
+                service = node.id
+            elif isinstance(node, ast.Attribute):
+                # Multi-level: could be module.service.operation
+                # For now, take the last attribute as service
+                service = node.attr
+        else:
+            raise ValueError(f"Unsupported function type: {type(call.func)}")
+
+        # Extract arguments
+        arguments = {}
+
+        # Positional arguments (will be mapped by parameter order in schema)
+        for i, arg in enumerate(call.args):
+            # For now, use position-based keys; will be mapped to param names later
+            arguments[f"_pos_{i}"] = _ast_to_value(arg)
+
+        # Keyword arguments
+        for keyword in call.keywords:
+            if keyword.arg is None:
+                # **kwargs syntax
+                raise ValueError("**kwargs not supported")
+            arguments[keyword.arg] = _ast_to_value(keyword.value)
+
+        # Build result with new unified format
+        result = {
+            "operation": operation,
+            "arguments": arguments,
+            "tool": operation,  # Backward compatibility
+        }
+
+        if service:
+            result["service"] = service
+
+        return result
+
+    except (SyntaxError, ValueError) as e:
+        raise ValueError(f"Invalid function call syntax: {e}") from e
+
+
+def parse_batch_function_calls(batch_str: str) -> list[dict[str, Any]]:
+    """Parse batch function calls (array of function calls).
+
+    Supports:
+        - Same service batch: [remember(...), recall(...)]
+        - Cross-service batch: [cognition.remember(...), waves.check_in()]
+
+    Examples:
+        >>> parse_batch_function_calls('[search("A"), search("B")]')
+        [
+            {'operation': 'search', 'arguments': {'query': 'A'}},
+            {'operation': 'search', 'arguments': {'query': 'B'}}
+        ]
+
+        >>> parse_batch_function_calls('[cognition.remember(...), waves.check_in()]')
+        [
+            {'service': 'cognition', 'operation': 'remember', 'arguments': {...}},
+            {'service': 'waves', 'operation': 'check_in', 'arguments': {}}
+        ]
+
+    Args:
+        batch_str: String containing array of function calls
+
+    Returns:
+        List of parsed function call dicts
+
+    Raises:
+        ValueError: If the string is not a valid array of function calls
+    """
+    try:
+        # Remove whitespace for easier parsing
+        batch_str = batch_str.strip()
+
+        # Must start with [ and end with ]
+        if not (batch_str.startswith("[") and batch_str.endswith("]")):
+            raise ValueError("Batch call must be enclosed in [ ]")
+
+        # Escape reserved keywords before parsing (e.g., from= -> from_=)
+        escaped_str = _escape_reserved_keywords(batch_str)
+
+        # Parse as Python list expression
+        tree = ast.parse(escaped_str, mode="eval")
+        if not isinstance(tree.body, ast.List):
+            raise ValueError("Not a list expression")
+
+        results = []
+        for element in tree.body.elts:
+            if not isinstance(element, ast.Call):
+                raise ValueError(
+                    f"List element is not a function call: {ast.dump(element)}"
+                )
+
+            # Convert the Call node back to source code and parse it
+            call_str = ast.unparse(element)
+            parsed = parse_function_call(call_str)
+            results.append(parsed)
+
+        return results
+
+    except (SyntaxError, ValueError) as e:
+        raise ValueError(f"Invalid batch function call syntax: {e}") from e

{kronos → krons}/utils/_to_list.py

@@ -29,7 +29,7 @@ def _do_init() -> None:
     from pydantic import BaseModel
     from pydantic_core import PydanticUndefinedType
 
-    from kronos.types import UndefinedType, UnsetType
+    from krons.core.types import UndefinedType, UnsetType
 
     global _MODEL_LIKE, _MAP_LIKE, _SINGLETONE_TYPES, _SKIP_TYPE, _SKIP_TUPLE_SET
     _MODEL_LIKE = (BaseModel,)
@@ -117,7 +117,11 @@ def to_list(
         if isinstance(input_, _BYTE_LIKE):
             return list(input_) if use_values else [input_]
         if isinstance(input_, Mapping):
-            return list(input_.values()) if use_values and hasattr(input_, "values") else [input_]
+            return (
+                list(input_.values())
+                if use_values and hasattr(input_, "values")
+                else [input_]
+            )
         if isinstance(input_, _MODEL_LIKE):
             return [input_]
         if isinstance(input_, Iterable) and not isinstance(input_, _BYTE_LIKE):
@@ -129,7 +133,9 @@ def to_list(
 
     initial_list = _to_list_type(input_, use_values=use_values)
     skip_types: tuple[type, ...] = _SKIP_TYPE if flatten_tuple_set else _SKIP_TUPLE_SET
-    processed = _process_list(initial_list, flatten=flatten, dropna=dropna, skip_types=skip_types)
+    processed = _process_list(
+        initial_list, flatten=flatten, dropna=dropna, skip_types=skip_types
+    )
 
     if unique:
         seen = set()

{kronos → krons}/utils/_utils.py

@@ -13,7 +13,7 @@ from uuid import UUID, uuid4
 
 from anyio import Path as AsyncPath
 
-from kronos.protocols import Observable
+from krons.protocols import Observable
 
 __all__ = (
     "create_path",
@@ -163,10 +163,14 @@ def import_module(
         ImportError: If module or attribute not found.
     """
     try:
-        full_import_path = f"{package_name}.{module_name}" if module_name else package_name
+        full_import_path = (
+            f"{package_name}.{module_name}" if module_name else package_name
+        )
 
         if import_name:
-            import_name = [import_name] if not isinstance(import_name, list) else import_name
+            import_name = (
+                [import_name] if not isinstance(import_name, list) else import_name
+            )
             a = __import__(
                 full_import_path,
                 fromlist=import_name,
@@ -188,7 +192,7 @@ def is_import_installed(package_name: str) -> bool:
 
 _TYPE_CACHE: dict[str, type] = {}
 
-_DEFAULT_ALLOWED_PREFIXES: frozenset[str] = frozenset({"kronos."})
+_DEFAULT_ALLOWED_PREFIXES: frozenset[str] = frozenset({"krons."})
 _ALLOWED_MODULE_PREFIXES: set[str] = set(_DEFAULT_ALLOWED_PREFIXES)
 
 
@@ -210,7 +214,7 @@ def register_type_prefix(prefix: str) -> None:
 
 
 def load_type_from_string(type_str: str) -> type:
-    """Load type from fully qualified path (e.g., 'kronos.core.Node').
+    """Load type from fully qualified path (e.g., 'krons.core.Node').
 
     Security: Only allowlisted module prefixes can be loaded.
 

{kronos → krons}/utils/concurrency/__init__.py

@@ -37,63 +37,63 @@ from typing import TYPE_CHECKING
 
 _LAZY_IMPORTS: dict[str, tuple[str, str]] = {
     # _cancel
-    "CancelScope": ("kronos.utils.concurrency._cancel", "CancelScope"),
-    "effective_deadline": ("kronos.utils.concurrency._cancel", "effective_deadline"),
-    "fail_after": ("kronos.utils.concurrency._cancel", "fail_after"),
-    "fail_at": ("kronos.utils.concurrency._cancel", "fail_at"),
-    "move_on_after": ("kronos.utils.concurrency._cancel", "move_on_after"),
-    "move_on_at": ("kronos.utils.concurrency._cancel", "move_on_at"),
+    "CancelScope": ("krons.utils.concurrency._cancel", "CancelScope"),
+    "effective_deadline": ("krons.utils.concurrency._cancel", "effective_deadline"),
+    "fail_after": ("krons.utils.concurrency._cancel", "fail_after"),
+    "fail_at": ("krons.utils.concurrency._cancel", "fail_at"),
+    "move_on_after": ("krons.utils.concurrency._cancel", "move_on_after"),
+    "move_on_at": ("krons.utils.concurrency._cancel", "move_on_at"),
     # _errors
     "get_cancelled_exc_class": (
-        "kronos.utils.concurrency._errors",
+        "krons.utils.concurrency._errors",
         "get_cancelled_exc_class",
     ),
-    "is_cancelled": ("kronos.utils.concurrency._errors", "is_cancelled"),
+    "is_cancelled": ("krons.utils.concurrency._errors", "is_cancelled"),
     "non_cancel_subgroup": (
-        "kronos.utils.concurrency._errors",
+        "krons.utils.concurrency._errors",
         "non_cancel_subgroup",
     ),
-    "shield": ("kronos.utils.concurrency._errors", "shield"),
+    "shield": ("krons.utils.concurrency._errors", "shield"),
     # _patterns
-    "CompletionStream": ("kronos.utils.concurrency._patterns", "CompletionStream"),
-    "bounded_map": ("kronos.utils.concurrency._patterns", "bounded_map"),
-    "gather": ("kronos.utils.concurrency._patterns", "gather"),
-    "race": ("kronos.utils.concurrency._patterns", "race"),
-    "retry": ("kronos.utils.concurrency._patterns", "retry"),
+    "CompletionStream": ("krons.utils.concurrency._patterns", "CompletionStream"),
+    "bounded_map": ("krons.utils.concurrency._patterns", "bounded_map"),
+    "gather": ("krons.utils.concurrency._patterns", "gather"),
+    "race": ("krons.utils.concurrency._patterns", "race"),
+    "retry": ("krons.utils.concurrency._patterns", "retry"),
     # _primitives
-    "CapacityLimiter": ("kronos.utils.concurrency._primitives", "CapacityLimiter"),
-    "Condition": ("kronos.utils.concurrency._primitives", "Condition"),
-    "Event": ("kronos.utils.concurrency._primitives", "Event"),
-    "Lock": ("kronos.utils.concurrency._primitives", "Lock"),
-    "Queue": ("kronos.utils.concurrency._primitives", "Queue"),
-    "Semaphore": ("kronos.utils.concurrency._primitives", "Semaphore"),
+    "CapacityLimiter": ("krons.utils.concurrency._primitives", "CapacityLimiter"),
+    "Condition": ("krons.utils.concurrency._primitives", "Condition"),
+    "Event": ("krons.utils.concurrency._primitives", "Event"),
+    "Lock": ("krons.utils.concurrency._primitives", "Lock"),
+    "Queue": ("krons.utils.concurrency._primitives", "Queue"),
+    "Semaphore": ("krons.utils.concurrency._primitives", "Semaphore"),
     # _priority_queue
-    "PriorityQueue": ("kronos.utils.concurrency._priority_queue", "PriorityQueue"),
-    "QueueEmpty": ("kronos.utils.concurrency._priority_queue", "QueueEmpty"),
-    "QueueFull": ("kronos.utils.concurrency._priority_queue", "QueueFull"),
+    "PriorityQueue": ("krons.utils.concurrency._priority_queue", "PriorityQueue"),
+    "QueueEmpty": ("krons.utils.concurrency._priority_queue", "QueueEmpty"),
+    "QueueFull": ("krons.utils.concurrency._priority_queue", "QueueFull"),
     # _resource_tracker
-    "LeakInfo": ("kronos.utils.concurrency._resource_tracker", "LeakInfo"),
-    "LeakTracker": ("kronos.utils.concurrency._resource_tracker", "LeakTracker"),
+    "LeakInfo": ("krons.utils.concurrency._resource_tracker", "LeakInfo"),
+    "LeakTracker": ("krons.utils.concurrency._resource_tracker", "LeakTracker"),
     "track_resource": (
-        "kronos.utils.concurrency._resource_tracker",
+        "krons.utils.concurrency._resource_tracker",
         "track_resource",
     ),
     "untrack_resource": (
-        "kronos.utils.concurrency._resource_tracker",
+        "krons.utils.concurrency._resource_tracker",
         "untrack_resource",
     ),
     # _run_async
-    "run_async": ("kronos.utils.concurrency._run_async", "run_async"),
+    "run_async": ("krons.utils.concurrency._run_async", "run_async"),
     # _task
-    "TaskGroup": ("kronos.utils.concurrency._task", "TaskGroup"),
-    "create_task_group": ("kronos.utils.concurrency._task", "create_task_group"),
+    "TaskGroup": ("krons.utils.concurrency._task", "TaskGroup"),
+    "create_task_group": ("krons.utils.concurrency._task", "create_task_group"),
     # _utils
-    "current_time": ("kronos.utils.concurrency._utils", "current_time"),
-    "is_coro_func": ("kronos.utils.concurrency._utils", "is_coro_func"),
-    "run_sync": ("kronos.utils.concurrency._utils", "run_sync"),
-    "sleep": ("kronos.utils.concurrency._utils", "sleep"),
-    "alcall": ("kronos.utils.concurrency._async_call", "alcall"),
-    "bcall": ("kronos.utils.concurrency._async_call", "bcall"),
+    "current_time": ("krons.utils.concurrency._utils", "current_time"),
+    "is_coro_func": ("krons.utils.concurrency._utils", "is_coro_func"),
+    "run_sync": ("krons.utils.concurrency._utils", "run_sync"),
+    "sleep": ("krons.utils.concurrency._utils", "sleep"),
+    "alcall": ("krons.utils.concurrency._async_call", "alcall"),
+    "bcall": ("krons.utils.concurrency._async_call", "bcall"),
 }
 
 _LOADED: dict[str, object] = {}
@@ -122,7 +122,7 @@ def __getattr__(name: str) -> object:
         _LOADED[name] = value
         return value
 
-    raise AttributeError(f"module 'kronos.utils.concurrency' has no attribute {name!r}")
+    raise AttributeError(f"module 'krons.utils.concurrency' has no attribute {name!r}")
 
 
 def __dir__() -> list[str]:

{kronos → krons}/utils/concurrency/_async_call.py

@@ -11,9 +11,9 @@ Primary exports:
 from collections.abc import AsyncGenerator, Callable
 from typing import Any, ParamSpec, TypeVar
 
-from kronos.types._sentinel import Unset, not_sentinel
-from kronos.utils._lazy_init import LazyInit
-from kronos.utils._to_list import to_list
+from krons.core.types._sentinel import Unset, not_sentinel
+from krons.utils._lazy_init import LazyInit
+from krons.utils._to_list import to_list
 
 from ._cancel import move_on_after
 from ._errors import get_cancelled_exc_class
@@ -66,7 +66,9 @@ def _validate_func(func: Any) -> Callable:
     try:
         func_list = list(func)
     except TypeError:
-        raise ValueError("func must be callable or an iterable containing one callable.")
+        raise ValueError(
+            "func must be callable or an iterable containing one callable."
+        )
 
     if len(func_list) != 1 or not callable(func_list[0]):
         raise ValueError("Only one callable function is allowed.")

{kronos → krons}/utils/concurrency/_errors.py

@@ -48,7 +48,9 @@ def is_cancelled(exc: BaseException) -> bool:
     return isinstance(exc, anyio.get_cancelled_exc_class())
 
 
-async def shield(func: Callable[P, Awaitable[T]], *args: P.args, **kwargs: P.kwargs) -> T:
+async def shield(
+    func: Callable[P, Awaitable[T]], *args: P.args, **kwargs: P.kwargs
+) -> T:
     """Execute async function protected from outer cancellation.
 
     Args:

{kronos → krons}/utils/concurrency/_patterns.py

@@ -39,7 +39,9 @@ __all__ = (
 )
 
 
-async def gather(*aws: Awaitable[T], return_exceptions: bool = False) -> list[T | BaseException]:
+async def gather(
+    *aws: Awaitable[T], return_exceptions: bool = False
+) -> list[T | BaseException]:
     """Run awaitables concurrently and collect results in input order.
 
     Args: