lionagi 0.6.1__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/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.operatives.types import Instruct
-from lionagi.session.branch import Branch
-
-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

@@ -3,11 +3,27 @@
 # SPDX-License-Identifier: Apache-2.0
 
 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/manager.py

@@ -5,8 +5,7 @@
 from typing import Any
 
 from lionagi.protocols._concepts import Manager
-from lionagi.protocols.generic.event import EventStatus, Execution
-from lionagi.protocols.generic.log import Log
+from lionagi.protocols.generic.event import Execution
 from lionagi.protocols.messages.action_request import ActionRequest
 from lionagi.utils import to_list
 
@@ -113,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
@@ -148,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/strategies/__init__.py

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