lionagi 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

lionagi/operations/parse/parse.py

@@ -0,0 +1,125 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import TYPE_CHECKING, Any, Literal
+
+from pydantic import BaseModel
+
+from lionagi.libs.validate.fuzzy_validate_mapping import fuzzy_validate_mapping
+from lionagi.operatives.types import Operative
+from lionagi.utils import breakdown_pydantic_annotation
+
+if TYPE_CHECKING:
+    from lionagi.session.branch import Branch
+
+
+async def parse(
+    branch: "Branch",
+    text: str,
+    handle_validation: Literal[
+        "raise", "return_value", "return_none"
+    ] = "return_value",
+    max_retries: int = 3,
+    request_type: type[BaseModel] = None,
+    operative: Operative = None,
+    similarity_algo="jaro_winkler",
+    similarity_threshold: float = 0.85,
+    fuzzy_match: bool = True,
+    handle_unmatched: Literal[
+        "ignore", "raise", "remove", "fill", "force"
+    ] = "force",
+    fill_value: Any = None,
+    fill_mapping: dict[str, Any] | None = None,
+    strict: bool = False,
+    suppress_conversion_errors: bool = False,
+    response_format=None,
+):
+    """Attempts to parse text into a structured Pydantic model.
+
+    Uses optional fuzzy matching to handle partial or unclear fields.
+
+    Args:
+        text (str): The raw text to parse.
+        handle_validation (Literal["raise","return_value","return_none"]):
+            What to do if parsing fails. Defaults to "return_value".
+        max_retries (int):
+            How many times to retry parsing if it fails.
+        request_type (type[BaseModel], optional):
+            The Pydantic model to parse into.
+        operative (Operative, optional):
+            If provided, uses its model and max_retries setting.
+        similarity_algo (str):
+            The similarity algorithm for fuzzy field matching.
+        similarity_threshold (float):
+            A threshold for fuzzy matching (0.0 - 1.0).
+        fuzzy_match (bool):
+            If True, tries to match unrecognized keys to known ones.
+        handle_unmatched (Literal["ignore","raise","remove","fill","force"]):
+            How to handle unmatched fields.
+        fill_value (Any):
+            A default value used when fill is needed.
+        fill_mapping (dict[str, Any] | None):
+            A mapping from field -> fill value override.
+        strict (bool):
+            If True, raises errors on ambiguous fields or data types.
+        suppress_conversion_errors (bool):
+            If True, logs or ignores errors during data conversion.
+
+    Returns:
+        BaseModel | Any | None:
+            The parsed model instance, or a dict/string/None depending
+            on the handling mode.
+    """
+    _should_try = True
+    num_try = 0
+    response_model = text
+    if operative is not None:
+        max_retries = operative.max_retries
+        response_format = operative.request_type
+
+    while (
+        _should_try
+        and num_try < max_retries
+        and not isinstance(response_model, BaseModel)
+    ):
+        num_try += 1
+        _, res = await branch.chat(
+            instruction="reformat text into specified model",
+            guidane="follow the required response format, using the model schema as a guide",
+            context=[{"text_to_format": text}],
+            response_format=response_format or request_type,
+            sender=branch.user,
+            recipient=branch.id,
+            imodel=branch.parse_model,
+            return_ins_res_message=True,
+        )
+        if operative is not None:
+            response_model = operative.update_response_model(res.response)
+        else:
+            response_model = fuzzy_validate_mapping(
+                res.response,
+                breakdown_pydantic_annotation(request_type),
+                similarity_algo=similarity_algo,
+                similarity_threshold=similarity_threshold,
+                fuzzy_match=fuzzy_match,
+                handle_unmatched=handle_unmatched,
+                fill_value=fill_value,
+                fill_mapping=fill_mapping,
+                strict=strict,
+                suppress_conversion_errors=suppress_conversion_errors,
+            )
+            response_model = request_type.model_validate(response_model)
+
+    if not isinstance(response_model, BaseModel):
+        match handle_validation:
+            case "return_value":
+                return response_model
+            case "return_none":
+                return None
+            case "raise":
+                raise ValueError(
+                    "Failed to parse response into request format"
+                )
+
+    return response_model

lionagi/operations/plan/plan.py

@@ -27,9 +27,9 @@ from .prompt import EXPANSION_PROMPT, PLAN_PROMPT
 class PlanOperation(BaseModel):
     """
     Stores all relevant outcomes for a multi-step Plan:
-      * initial: The result of the initial plan prompt
-      * plan: A list of plan steps (Instruct objects) generated from the initial planning
-      * execute: Any responses from executing those plan steps
+        * initial: The result of the initial plan prompt
+        * plan: A list of plan steps (Instruct objects) generated from the initial planning
+        * execute: Any responses from executing those plan steps
     """
 
     initial: Any

lionagi/operations/select/__init__.py

@@ -1,7 +1,3 @@
 # Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
 #
 # SPDX-License-Identifier: Apache-2.0
-
-from .select import select
-
-__all__ = ["select"]

lionagi/operations/select/select.py

@@ -2,56 +2,37 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-
 from enum import Enum
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
-from lionagi import Branch
 from lionagi.operatives.types import Instruct
 
-from .prompt import PROMPT
-from .utils import parse_selection, parse_to_representation
-
+from .utils import SelectionModel
 
-class SelectionModel(BaseModel):
-    """Model representing the selection output."""
-
-    selected: list[Any] = Field(default_factory=list)
+if TYPE_CHECKING:
+    from lionagi.session.branch import Branch
 
 
 async def select(
+    branch: "Branch",
     instruct: Instruct | dict[str, Any],
     choices: list[str] | type[Enum] | dict[str, Any],
     max_num_selections: int = 1,
-    branch: Branch | None = None,
     branch_kwargs: dict[str, Any] | None = None,
     return_branch: bool = False,
     verbose: bool = False,
     **kwargs: Any,
-) -> SelectionModel | tuple[SelectionModel, Branch]:
-    """Perform a selection operation from given choices.
-
-    Args:
-        instruct: Instruction model or dictionary.
-        choices: Options to select from.
-        max_num_selections: Maximum selections allowed.
-        branch: Existing branch or None to create a new one.
-        branch_kwargs: Additional arguments for branch creation.
-        return_branch: If True, return the branch with the selection.
-        verbose: Whether to enable verbose output.
-        **kwargs: Additional keyword arguments.
-
-    Returns:
-        A SelectionModel instance, optionally with the branch.
-    """
+) -> SelectionModel | tuple[SelectionModel, "Branch"]:
     if verbose:
         print(f"Starting selection with up to {max_num_selections} choices.")
 
+    from .utils import SelectionModel, parse_selection, parse_to_representation
+
     branch = branch or Branch(**(branch_kwargs or {}))
     selections, contents = parse_to_representation(choices)
-    prompt = PROMPT.format(
+    prompt = SelectionModel.PROMPT.format(
         max_num_selections=max_num_selections, choices=selections
     )
 
@@ -73,7 +54,7 @@ async def select(
     instruct["context"] = context
 
     response_model: SelectionModel = await branch.operate(
-        operative_model=SelectionModel,
+        response_format=SelectionModel,
         **kwargs,
         **instruct,
     )

lionagi/operations/select/utils.py

@@ -4,14 +4,25 @@
 
 import inspect
 from enum import Enum
-from typing import Any
+from typing import Any, ClassVar
 
-from pydantic import BaseModel, JsonValue
+from pydantic import BaseModel, Field, JsonValue
 
 from lionagi.libs.validate.string_similarity import string_similarity
 from lionagi.utils import is_same_dtype
 
 
+# TODO: Make select a field to be added into a model, much like reason and action
+class SelectionModel(BaseModel):
+    """Model representing the selection output."""
+
+    PROMPT: ClassVar[str] = (
+        "Please select up to {max_num_selections} items from the following list {choices}. Provide the selection(s) into appropriate field in format required, and no comments from you"
+    )
+
+    selected: list[Any] = Field(default_factory=list)
+
+
 def parse_to_representation(
     choices: Enum | dict | list | tuple | set,
 ) -> tuple[list[str], JsonValue]:

lionagi/operations/translate/translate.py

@@ -0,0 +1,47 @@
+from typing import TYPE_CHECKING, Literal
+
+from lionagi.service.imodel import iModel
+
+if TYPE_CHECKING:
+    from lionagi.session.branch import Branch
+
+
+async def translate(
+    branch: "Branch",
+    text: str,
+    technique: Literal["SynthLang"] = "SynthLang",
+    technique_kwargs: dict = None,
+    compress: bool = False,
+    chat_model: iModel = None,
+    compress_model: iModel = None,
+    compression_ratio: float = 0.2,
+    compress_kwargs=None,
+    verbose: bool = True,
+    new_branch: bool = True,
+    **kwargs,
+):
+    if technique == "SynthLang":
+        from lionagi.libs.token_transform.synthlang import (
+            translate_to_synthlang,
+        )
+
+        if not technique_kwargs:
+            technique_kwargs = {}
+        if not technique_kwargs.get("template_name"):
+            technique_kwargs["template_name"] = "symbolic_systems"
+
+        technique_kwargs = {**technique_kwargs, **kwargs}
+
+        return await translate_to_synthlang(
+            text=text,
+            compress=compress,
+            chat_model=chat_model or branch.chat_model,
+            compress_model=compress_model,
+            compression_ratio=compression_ratio,
+            compress_kwargs=compress_kwargs,
+            verbose=verbose,
+            branch=branch if not new_branch else None,
+            **technique_kwargs,
+        )
+
+    raise ValueError(f"Technique {technique} is not supported.")

lionagi/operations/types.py

@@ -2,6 +2,28 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from .brainstorm import *
-from .plan import *
-from .select import *
+from .brainstorm.brainstorm import brainstorm
+from .chat.chat import chat
+from .communicate.communicate import communicate
+from .instruct.instruct import instruct
+from .interpret.interpret import interpret
+from .operate.operate import operate
+from .parse.parse import parse
+from .plan.plan import plan
+from .ReAct.ReAct import ReAct
+from .select.select import select
+from .translate.translate import translate
+
+__all__ = (
+    "brainstorm",
+    "plan",
+    "select",
+    "chat",
+    "communicate",
+    "instruct",
+    "interpret",
+    "operate",
+    "parse",
+    "ReAct",
+    "translate",
+)

lionagi/operatives/action/function_calling.py

@@ -7,7 +7,7 @@ from typing import Any, Self
 
 from pydantic import Field, model_validator
 
-from lionagi.protocols.types import Event, EventStatus
+from lionagi.protocols.generic.event import Event, EventStatus
 from lionagi.utils import is_coro_func
 
 from .tool import Tool

lionagi/operatives/action/manager.py

@@ -4,13 +4,9 @@
 
 from typing import Any
 
-from lionagi.protocols.types import (
-    ActionRequest,
-    EventStatus,
-    Execution,
-    Log,
-    Manager,
-)
+from lionagi.protocols._concepts import Manager
+from lionagi.protocols.generic.event import Execution
+from lionagi.protocols.messages.action_request import ActionRequest
 from lionagi.utils import to_list
 
 from .function_calling import FunctionCalling
@@ -116,19 +112,28 @@ class ActionManager(Manager):
         ]
 
     def match_tool(
-        self, action_request: ActionRequest | ActionRequestModel
+        self, action_request: ActionRequest | ActionRequestModel | dict
     ) -> FunctionCalling:
-        if not isinstance(action_request, ActionRequest | ActionRequestModel):
+        if not isinstance(
+            action_request, ActionRequest | ActionRequestModel | dict
+        ):
             raise TypeError(f"Unsupported type {type(action_request)}")
 
-        tool = self.registry.get(action_request.function, None)
-        if not isinstance(tool, Tool):
-            raise ValueError(
-                f"Function {action_request.function} is not registered."
-            )
-        return FunctionCalling(
-            func_tool=tool, arguments=action_request.arguments
+        func = (
+            action_request["function"]
+            if isinstance(action_request, dict)
+            else action_request.function
+        )
+        args = (
+            action_request["arguments"]
+            if isinstance(action_request, dict)
+            else action_request.arguments
         )
+        tool = self.registry.get(func, None)
+
+        if not isinstance(tool, Tool):
+            raise ValueError(f"Function {func} is not registered.")
+        return FunctionCalling(func_tool=tool, arguments=args)
 
     async def invoke(
         self, func_call: ActionRequestModel | ActionRequest
@@ -151,16 +156,7 @@ class ActionManager(Manager):
         Raises:
             ValueError: If function not registered or call format invalid.
         """
-        try:
-            function_calling = self.match_tool(func_call)
-        except ValueError as e:
-            return Log(
-                content={
-                    "event_type": "function_call",
-                    "status": EventStatus.FAILED,
-                    "error": str(e),
-                }
-            )
+        function_calling = self.match_tool(func_call)
         await function_calling.invoke()
         return function_calling
 

lionagi/operatives/action/tool.py

@@ -10,7 +10,7 @@ from pydantic import Field, field_validator, model_validator
 
 from lionagi.libs.schema.function_to_schema import function_to_schema
 from lionagi.libs.validate.common_field_validators import validate_callable
-from lionagi.protocols.types import Element
+from lionagi.protocols.generic.element import Element
 
 __all__ = (
     "Tool",

lionagi/operatives/strategies/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/{operations → operatives}/strategies/params.py

@@ -10,9 +10,25 @@ from lionagi.operatives.instruct.instruct import (
     LIST_INSTRUCT_FIELD_MODEL,
     Instruct,
 )
-from lionagi.protocols.types import FieldModel, SchemaModel
+from lionagi.operatives.types import FieldModel, SchemaModel
 from lionagi.session.session import Branch, Session
-from lionagi.utils import RCallParams
+
+
+class RCallParams(SchemaModel):
+    """Parameters for remote function calls."""
+
+    timeout: float = Field(
+        default=60, description="Timeout for remote function call"
+    )
+    max_retries: int = Field(
+        default=3, description="Maximum number of retries"
+    )
+    retry_delay: float = Field(
+        default=0.5, description="Delay between retries"
+    )
+    retry_backoff: float = Field(
+        default=2, description="Backoff factor for retry delay"
+    )
 
 
 class StrategyParams(SchemaModel):

lionagi/protocols/adapters/adapter.py

@@ -0,0 +1,95 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from typing import Any, Protocol, TypeVar, runtime_checkable
+
+from typing_extensions import get_protocol_members
+
+T = TypeVar("T")
+
+__all__ = (
+    "Adapter",
+    "ADAPTER_MEMBERS",
+    "AdapterRegistry",
+)
+
+
+@runtime_checkable
+class Adapter(Protocol):
+
+    obj_key: str
+
+    @classmethod
+    def from_obj(
+        cls,
+        subj_cls: type[T],
+        obj: Any,
+        /,
+        *,
+        many: bool,
+        **kwargs,
+    ) -> dict | list[dict]: ...
+
+    @classmethod
+    def to_obj(
+        cls,
+        subj: T,
+        /,
+        *,
+        many: bool,
+        **kwargs,
+    ) -> Any: ...
+
+
+ADAPTER_MEMBERS = get_protocol_members(Adapter)  # duck typing
+
+
+class AdapterRegistry:
+
+    _adapters: dict[str, Adapter] = {}
+
+    @classmethod
+    def list_adapters(cls) -> list[tuple[str | type, ...]]:
+        return list(cls._adapters.keys())
+
+    @classmethod
+    def register(cls, adapter: type[Adapter]) -> None:
+        for member in ADAPTER_MEMBERS:
+            if not hasattr(adapter, member):
+                _str = getattr(adapter, "obj_key", None) or repr(adapter)
+                _str = _str[:50] if len(_str) > 50 else _str
+                raise AttributeError(
+                    f"Adapter {_str} missing required methods."
+                )
+
+        if isinstance(adapter, type):
+            cls._adapters[adapter.obj_key] = adapter()
+        else:
+            cls._adapters[adapter.obj_key] = adapter
+
+    @classmethod
+    def get(cls, obj_key: type | str) -> Adapter:
+        try:
+            return cls._adapters[obj_key]
+        except Exception as e:
+            logging.error(f"Error getting adapter for {obj_key}. Error: {e}")
+
+    @classmethod
+    def adapt_from(
+        cls, subj_cls: type[T], obj: Any, obj_key: type | str, **kwargs
+    ) -> dict | list[dict]:
+        try:
+            return cls.get(obj_key).from_obj(subj_cls, obj, **kwargs)
+        except Exception as e:
+            logging.error(f"Error adapting data from {obj_key}. Error: {e}")
+            raise e
+
+    @classmethod
+    def adapt_to(cls, subj: T, obj_key: type | str, **kwargs) -> Any:
+        try:
+            return cls.get(obj_key).to_obj(subj, **kwargs)
+        except Exception as e:
+            logging.error(f"Error adapting data to {obj_key}. Error: {e}")
+            raise e

lionagi/protocols/adapters/json_adapter.py

@@ -0,0 +1,101 @@
+import json
+import logging
+from pathlib import Path
+
+from lionagi.protocols._concepts import Collective
+
+from .adapter import Adapter, T
+
+
+class JsonAdapter(Adapter):
+
+    obj_key = "json"
+
+    @classmethod
+    def from_obj(
+        cls,
+        subj_cls: type[T],
+        obj: str,
+        /,
+        *,
+        many: bool = False,
+        **kwargs,
+    ) -> dict | list[dict]:
+        """
+        kwargs for json.loads(s, **kwargs)
+        """
+        result = json.loads(obj, **kwargs)
+        if many:
+            return result if isinstance(result, list) else [result]
+        return (
+            result[0]
+            if isinstance(result, list) and len(result) > 0
+            else result
+        )
+
+    @classmethod
+    def to_obj(
+        cls,
+        subj: T,
+        *,
+        many: bool = False,
+        **kwargs,
+    ):
+        """
+        kwargs for json.dumps(obj, **kwargs)
+        """
+        if many:
+            if isinstance(subj, Collective):
+                return json.dumps([i.to_dict() for i in subj], **kwargs)
+            return json.dumps([subj.to_dict()], **kwargs)
+        return json.dumps(subj.to_dict(), **kwargs)
+
+
+class JsonFileAdapter(Adapter):
+
+    obj_key = ".json"
+
+    @classmethod
+    def from_obj(
+        cls,
+        subj_cls: type[T],
+        obj: str | Path,
+        /,
+        *,
+        many: bool = False,
+        **kwargs,
+    ) -> dict | list[dict]:
+        """
+        kwargs for json.load(fp, **kwargs)
+        """
+        with open(obj) as f:
+            result = json.load(f, **kwargs)
+        if many:
+            return result if isinstance(result, list) else [result]
+        return (
+            result[0]
+            if isinstance(result, list) and len(result) > 0
+            else result
+        )
+
+    @classmethod
+    def to_obj(
+        cls,
+        subj: T,
+        /,
+        *,
+        fp: str | Path,
+        many: bool = False,
+        **kwargs,
+    ):
+        """
+        kwargs for json.dump(obj, fp, **kwargs)
+        """
+        if many:
+            if isinstance(subj, Collective):
+                json.dump([i.to_dict() for i in subj], fp=fp, **kwargs)
+                return
+            json.dump([subj.to_dict()], fp=fp, **kwargs)
+            return
+        json.dump(subj.to_dict(), fp=fp, **kwargs)
+        logging.info(f"Successfully saved data to {fp}")