lionagi 0.17.11__py3-none-any.whl → 0.18.1__py3-none-any.whl

lionagi/_errors.py

@@ -13,7 +13,6 @@ __all__ = (
     "ObservationError",
     "ResourceError",
     "RateLimitError",
-    "IDError",
     "RelationError",
     "OperationError",
     "ExecutionError",
@@ -127,10 +126,6 @@ class RateLimitError(LionError):
         object.__setattr__(self, "retry_after", retry_after)
 
 
-class IDError(LionError):
-    pass
-
-
 class RelationError(LionError):
     pass
 

lionagi/fields.py

@@ -0,0 +1,83 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .operations.fields import (
+        ActionRequestModel,
+        ActionResponseModel,
+        Instruct,
+        Reason,
+        get_default_field,
+    )
+
+_lazy_imports = {}
+
+
+def __getattr__(name: str):
+    if name in _lazy_imports:
+        return _lazy_imports[name]
+
+    if name == "ActionRequestModel":
+        from .operations.fields import ActionRequestModel
+
+        _lazy_imports[name] = ActionRequestModel
+        return ActionRequestModel
+
+    if name == "ActionResponseModel":
+        from .operations.fields import ActionResponseModel
+
+        _lazy_imports[name] = ActionResponseModel
+        return ActionResponseModel
+
+    if name == "Instruct":
+        from .operations.fields import Instruct
+
+        _lazy_imports[name] = Instruct
+        return Instruct
+
+    if name == "Reason":
+        from .operations.fields import Reason
+
+        _lazy_imports[name] = Reason
+        return Reason
+
+    from .operations.fields import get_default_field
+
+    if name == "get_default_field":
+
+        _lazy_imports[name] = get_default_field
+        return get_default_field
+
+    if name == "ACTION_REQUESTS_FIELD":
+        return get_default_field("action_requests")
+
+    if name == "ACTION_RESPONSES_FIELD":
+        return get_default_field("action_responses")
+
+    if name == "ACTION_REQUIRED_FIELD":
+        return get_default_field("action_required")
+
+    if name == "INSTRUCT_FIELD":
+        return get_default_field("instruct")
+
+    if name == "LIST_INSTRUCT_FIELD_MODEL":
+        return get_default_field("instruct", listable=True)
+
+    if name == "REASON_FIELD":
+        return get_default_field("reason")
+
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+
+__all__ = (
+    "ACTION_REQUESTS_FIELD",
+    "ACTION_RESPONSES_FIELD",
+    "ACTION_REQUIRED_FIELD",
+    "INSTRUCT_FIELD",
+    "LIST_INSTRUCT_FIELD_MODEL",
+    "REASON_FIELD",
+    "ActionRequestModel",
+    "ActionResponseModel",
+    "Instruct",
+    "Reason",
+    "get_default_field",
+)

lionagi/libs/schema/minimal_yaml.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Any
+
+import orjson
+import yaml
+
+# --- YAML Dumper with minimal, readable settings --------------------------------
+
+
+class MinimalDumper(yaml.SafeDumper):
+    # Disable anchors/aliases (&id001, *id001) for repeated objects.
+    def ignore_aliases(self, data: Any) -> bool:  # type: ignore[override]
+        return True
+
+
+def _represent_str(dumper: yaml.SafeDumper, data: str):
+    # Use block scalars for multiline text; plain style otherwise.
+    if "\n" in data:
+        return dumper.represent_scalar(
+            "tag:yaml.org,2002:str", data, style="|"
+        )
+    return dumper.represent_scalar("tag:yaml.org,2002:str", data)
+
+
+MinimalDumper.add_representer(str, _represent_str)
+
+# --- Optional pruning of empty values -------------------------------------------
+
+
+def _is_empty(x: Any) -> bool:
+    """
+    Define 'empty' for pruning. Keeps 0 and False.
+    - None or '' (after strip) are empty
+    - Empty containers are empty
+    """
+    if x is None:
+        return True
+    if isinstance(x, str):
+        return x.strip() == ""
+    if isinstance(x, dict):
+        return len(x) == 0
+    if isinstance(x, (list, tuple, set)):
+        return len(x) == 0
+    # Keep numbers (including 0) and booleans (including False)
+    return False
+
+
+def _prune(x: Any) -> Any:
+    """Recursively remove empty leaves and empty containers produced thereby."""
+    if isinstance(x, dict):
+        pruned = {k: _prune(v) for k, v in x.items() if not _is_empty(v)}
+        # Remove keys that became empty after recursion
+        return {k: v for k, v in pruned.items() if not _is_empty(v)}
+    if isinstance(x, list):
+        pruned_list = [_prune(v) for v in x if not _is_empty(v)]
+        return [v for v in pruned_list if not _is_empty(v)]
+    if isinstance(x, tuple):
+        pruned_list = [_prune(v) for v in x if not _is_empty(v)]
+        return tuple(v for v in pruned_list if not _is_empty(v))
+    if isinstance(x, set):
+        pruned_set = {_prune(v) for v in x if not _is_empty(v)}
+        return {v for v in pruned_set if not _is_empty(v)}
+    return x
+
+
+# --- Public API ------------------------------------------------------------------
+
+
+def minimal_yaml(
+    value: Any,
+    *,
+    drop_empties: bool = True,
+    indent: int = 2,
+    line_width: int = 2**31 - 1,  # avoid PyYAML inserting line-wraps
+    sort_keys: bool = False,
+) -> str:
+    """
+    Convert any Python value (dict/list/scalars) to a minimal, readable YAML string.
+    - Lists -> YAML sequences with '- '
+    - Dicts -> 'key: value' mappings
+    - Multiline strings -> block scalars (|)
+    - Optional pruning of empty values (keeps 0 and False)
+    - No aliases/anchors
+    """
+    if isinstance(value, str):
+        value = orjson.loads(value)
+
+    data = _prune(value) if drop_empties else value
+    return yaml.dump(
+        data,
+        Dumper=MinimalDumper,
+        default_flow_style=False,  # block style
+        sort_keys=sort_keys,  # preserve insertion order
+        allow_unicode=True,
+        indent=indent,
+        width=line_width,
+    )

lionagi/ln/__init__.py

@@ -1,4 +1,4 @@
-from ._async_call import alcall, bcall
+from ._async_call import AlcallParams, BcallParams, alcall, bcall
 from ._hash import hash_dict
 from ._json_dump import (
     get_orjson_default,
@@ -80,4 +80,6 @@ __all__ = (
     "not_sentinel",
     "to_dict",
     "fuzzy_validate_mapping",
+    "AlcallParams",
+    "BcallParams",
 )

lionagi/ln/concurrency/primitives.py

@@ -142,15 +142,15 @@ class CapacityLimiter:
         """Get the number of currently available tokens."""
         return self._lim.available_tokens
 
-    def acquire_on_behalf_of(self, borrower: object) -> None:
-        """Synchronously acquire capacity on behalf of another object.
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        """Asynchronously acquire capacity on behalf of another object.
 
         For resource pooling where the acquirer differs from the releaser.
 
         Args:
             borrower: Object that will be responsible for releasing.
         """
-        self._lim.acquire_on_behalf_of(borrower)
+        await self._lim.acquire_on_behalf_of(borrower)
 
     def release_on_behalf_of(self, borrower: object) -> None:
         """Release capacity that was acquired on behalf of an object.
@@ -326,6 +326,6 @@ class Condition:
         """Wake up all tasks waiting on this condition."""
         self._condition.notify_all()
 
-    def statistics(self) -> anyio.abc.ConditionStatistics:
+    def statistics(self) -> anyio.ConditionStatistics:
         """Return statistics about waiting tasks."""
         return self._condition.statistics()

lionagi/ln/concurrency/task.py

@@ -7,6 +7,7 @@ from contextlib import asynccontextmanager
 from typing import Any, TypeVar
 
 import anyio
+import anyio.abc
 
 T = TypeVar("T")
 R = TypeVar("R")

lionagi/ln/types.py

@@ -232,10 +232,13 @@ class Params:
         dict_.update(kw_)
         return dict_
 
-    def to_dict(self) -> dict[str, str]:
+    def to_dict(self, exclude: set[str] = None) -> dict[str, str]:
         data = {}
+        exclude = exclude or set()
         for k in self.allowed():
-            if not self._is_sentinel(v := getattr(self, k, Undefined)):
+            if k not in exclude and not self._is_sentinel(
+                v := getattr(self, k, Undefined)
+            ):
                 data[k] = v
         return data
 
@@ -249,6 +252,12 @@ class Params:
             return False
         return hash(self) == hash(other)
 
+    def with_updates(self, **kwargs: Any) -> DataClass:
+        """Return a new instance with updated fields."""
+        dict_ = self.to_dict()
+        dict_.update(kwargs)
+        return type(self)(**dict_)
+
 
 @dataclass(slots=True)
 class DataClass:
@@ -296,11 +305,13 @@ class DataClass:
         for k in self.allowed():
             _validate_strict(k)
 
-    def to_dict(self) -> dict[str, str]:
+    def to_dict(self, exclude: set[str] = None) -> dict[str, str]:
         data = {}
-        print(self.allowed())
+        exclude = exclude or set()
         for k in type(self).allowed():
-            if not self._is_sentinel(v := getattr(self, k)):
+            if k not in exclude and not self._is_sentinel(
+                v := getattr(self, k)
+            ):
                 data[k] = v
         return data
 
@@ -311,6 +322,22 @@ class DataClass:
             return True
         return is_sentinel(value)
 
+    def with_updates(self, **kwargs: Any) -> DataClass:
+        """Return a new instance with updated fields."""
+        dict_ = self.to_dict()
+        dict_.update(kwargs)
+        return type(self)(**dict_)
+
+    def __hash__(self) -> int:
+        from ._hash import hash_dict
+
+        return hash_dict(self.to_dict())
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, DataClass):
+            return False
+        return hash(self) == hash(other)
+
 
 KeysLike = Sequence[str] | KeysDict
 

lionagi/models/field_model.py

@@ -84,7 +84,7 @@ class FieldModel(Params):
     base_type: type[Any]
     metadata: tuple[Meta, ...]
 
-    def __init__(self, **kwargs: Any) -> None:
+    def __init__(self, base_type: type[Any] = None, **kwargs: Any) -> None:
         """Initialize FieldModel with legacy compatibility.
 
         Handles backward compatibility by converting old-style kwargs to the new
@@ -94,6 +94,8 @@ class FieldModel(Params):
             **kwargs: Arbitrary keyword arguments, including legacy ones
         """
         # Convert legacy kwargs to proper format
+        if base_type is not None:
+            kwargs["base_type"] = base_type
         converted = self._convert_kwargs_to_params(**kwargs)
 
         # Set fields directly and validate
@@ -513,6 +515,15 @@ class FieldModel(Params):
                     # These are FieldTemplate markers, don't pass to FieldInfo
                     pass
                 else:
+                    # Filter out unserializable objects from json_schema_extra
+                    # to avoid Pydantic serialization errors when generating JSON schema
+                    from pydantic import BaseModel
+
+                    # Skip model classes and other unserializable types
+                    if isinstance(meta.value, type):
+                        # Skip type objects (including model classes) - they can't be serialized
+                        continue
+
                     # Any other metadata goes in json_schema_extra
                     if "json_schema_extra" not in field_kwargs:
                         field_kwargs["json_schema_extra"] = {}
@@ -529,7 +540,7 @@ class FieldModel(Params):
         field_info = PydanticField(**field_kwargs)
 
         # Set the annotation from base_type for backward compatibility
-        field_info.annotation = self.base_type
+        field_info.annotation = self.annotation
 
         return field_info
 
@@ -736,8 +747,14 @@ class FieldModel(Params):
 
     @property
     def annotation(self) -> type[Any]:
-        """Get field annotation (base_type) for backward compatibility."""
-        return Any if self._is_sentinel(self.base_type) else self.base_type
+        if self._is_sentinel(self.base_type):
+            return Any
+        t_ = self.base_type
+        if self.is_listable:
+            t_ = list[t_]
+        if self.is_nullable:
+            t_ = t_ | None
+        return t_
 
     def to_dict(self) -> dict[str, Any]:
         """Convert field model to dictionary for backward compatibility.

lionagi/models/hashable_model.py

@@ -94,12 +94,11 @@ class HashableModel(BaseModel):
 def _get_default_hashable_serializer():
     global _DEFAULT_HASHABLE_SERIALIZER
     if _DEFAULT_HASHABLE_SERIALIZER is None:
-        from lionagi.protocols.ids import Element, IDType
+        from lionagi.protocols.ids import Element
 
         _DEFAULT_HASHABLE_SERIALIZER = ln.get_orjson_default(
-            order=[IDType, Element, BaseModel],
+            order=[Element, BaseModel],
             additional={
-                IDType: lambda o: str(o),
                 Element: lambda o: o.to_dict(),
                 BaseModel: lambda o: o.model_dump(mode="json"),
             },