lionagi 0.10.1__py3-none-any.whl → 0.10.3__py3-none-any.whl

lionagi/operations/ReAct/utils.py

@@ -4,34 +4,45 @@
 
 from typing import ClassVar, Literal
 
-from pydantic import BaseModel, Field
+from pydantic import Field, field_validator
 
+from lionagi.models import HashableModel
 
-class PlannedAction(BaseModel):
+
+class PlannedAction(HashableModel):
     """
-    Short descriptor for an upcoming action/tool invocation the LLM wants to perform.
-    The model can hold multiple actions in a single round if needed.
+    Short descriptor for an upcoming action/tool invocation the LLM wants to
+    perform. The model can hold multiple actions in a single round if needed.
     """
 
-    action_type: str = Field(
-        ...,
-        description="The name or type of tool/action to invoke (e.g., 'search_exa', 'reader_tool').",
+    action_type: str | None = Field(
+        default=None,
+        description=(
+            "The name or type of tool/action to invoke. "
+            "(e.g., 'search_exa', 'reader_tool')"
+        ),
     )
-    description: str = Field(
-        ...,
-        description="A short explanation of why or what is intended to achieve with this action.",
+    description: str | None = Field(
+        default=None,
+        description=(
+            "A short description of the action to perform. "
+            "This should be a concise summary of what the action entails."
+            "Also include your rationale for this action, if applicable."
+        ),
     )
 
 
-class ReActAnalysis(BaseModel):
+class ReActAnalysis(HashableModel):
     """
     Captures the ReAct chain-of-thought output each round:
     1) The LLM's 'analysis' (reasoning),
     2) A list of planned actions to perform before finalizing,
     3) Indication whether more expansions/rounds are needed,
     4) Additional tuning knobs: how to handle validation, how to execute actions, etc.
-    Remember do not repeat yourself, and aim to use the most efficient way to achieve
-    the goal to user's satisfaction.
+
+    Note:
+    - Retain from repeating yourself
+    - use the most efficient way to achieve the goal to user's satisfaction
     """
 
     # Standard ReAct strings for controlling expansions:
@@ -101,6 +112,16 @@ class ReActAnalysis(BaseModel):
     )
 
 
-class Analysis(BaseModel):
+class Analysis(HashableModel):
+
+    answer: str | None = None
 
-    answer: str
+    @field_validator("answer", mode="before")
+    def _validate_answer(cls, value):
+        if not value:
+            return None
+        if isinstance(value, str) and not value.strip():
+            return None
+        if not isinstance(value, str):
+            raise ValueError("Answer must be a non-empty string.")
+        return value.strip()

lionagi/operations/_act/act.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 from pydantic import BaseModel
 
-from lionagi.libs.fields.action import ActionResponseModel
+from lionagi.fields.action import ActionResponseModel
 from lionagi.protocols.types import ActionRequest, Log
 
 if TYPE_CHECKING:

lionagi/operations/brainstorm/brainstorm.py

@@ -7,7 +7,7 @@ from typing import Any, Literal
 
 from pydantic import BaseModel
 
-from lionagi.libs.fields.instruct import (
+from lionagi.fields.instruct import (
     LIST_INSTRUCT_FIELD_MODEL,
     Instruct,
     InstructResponse,

lionagi/operations/instruct/instruct.py

@@ -4,7 +4,7 @@
 
 from typing import TYPE_CHECKING, Any
 
-from lionagi.libs.fields.instruct import Instruct
+from lionagi.fields.instruct import Instruct
 
 if TYPE_CHECKING:
     from lionagi.session.branch import Branch

lionagi/operations/operate/operate.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Literal
 
 from pydantic import BaseModel, JsonValue
 
-from lionagi.libs.fields.instruct import Instruct
+from lionagi.fields.instruct import Instruct
 from lionagi.models import FieldModel, ModelParams
 from lionagi.protocols.types import (
     Instruction,

lionagi/operations/plan/plan.py

@@ -6,7 +6,7 @@ from typing import Any, Literal
 
 from pydantic import BaseModel
 
-from lionagi.libs.fields.instruct import (
+from lionagi.fields.instruct import (
     LIST_INSTRUCT_FIELD_MODEL,
     Instruct,
     InstructResponse,

lionagi/operations/select/select.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel
 
-from lionagi.libs.fields.instruct import Instruct
+from lionagi.fields.instruct import Instruct
 
 from .utils import SelectionModel
 

lionagi/operations/utils.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from lionagi.libs.fields.instruct import Instruct
+from lionagi.fields.instruct import Instruct
 from lionagi.session.session import Branch, Session
 
 

lionagi/protocols/action/manager.py

@@ -4,11 +4,11 @@
 
 from typing import Any
 
+from lionagi.fields.action import ActionRequestModel
 from lionagi.protocols._concepts import Manager
 from lionagi.protocols.messages.action_request import ActionRequest
 from lionagi.utils import to_list
 
-from ...libs.fields.action import ActionRequestModel
 from .function_calling import FunctionCalling
 from .tool import FuncTool, FuncToolRef, Tool, ToolRef
 

lionagi/protocols/operatives/step.py

@@ -5,14 +5,14 @@
 from pydantic import BaseModel, Field
 from pydantic.fields import FieldInfo
 
-from lionagi.libs.fields.action import (
+from lionagi.fields.action import (
     ACTION_REQUESTS_FIELD,
     ACTION_REQUIRED_FIELD,
     ACTION_RESPONSES_FIELD,
     ActionRequestModel,
     ActionResponseModel,
 )
-from lionagi.libs.fields.reason import REASON_FIELD, Reason
+from lionagi.fields.reason import REASON_FIELD, Reason
 from lionagi.models import FieldModel, ModelParams
 from lionagi.protocols.operatives.operative import Operative
 

lionagi/session/branch.py

@@ -4,25 +4,20 @@
 
 from collections.abc import AsyncGenerator
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Literal
+from typing import Any, Literal
 
 import pandas as pd
 from jinja2 import Template
 from pydantic import BaseModel, Field, JsonValue, PrivateAttr
 
+from lionagi.fields import Instruct
 from lionagi.libs.schema.as_readable import as_readable
 from lionagi.models.field_model import FieldModel
-from lionagi.models.model_params import ModelParams
-from lionagi.protocols.action.manager import ActionManager
 from lionagi.protocols.action.tool import FuncTool, Tool, ToolRef
-from lionagi.protocols.operatives.operative import Operative
-
-# Forward reference for Instruct which will be imported in the methods that use it
-# to avoid circular imports
-Instruct = Any
 from lionagi.protocols.types import (
     ID,
     MESSAGE_FIELDS,
+    ActionManager,
     ActionRequest,
     ActionResponse,
     AssistantResponse,
@@ -37,6 +32,7 @@ from lionagi.protocols.types import (
     Mailbox,
     MessageManager,
     MessageRole,
+    Operative,
     Package,
     PackageCategory,
     Pile,
@@ -54,10 +50,6 @@ from lionagi.utils import UNDEFINED, alcall, bcall, copy
 
 from .prompts import LION_SYSTEM_MESSAGE
 
-if TYPE_CHECKING:
-    # Forward references for type checking (e.g., in operations or extended modules)
-    from lionagi.session.branch import Branch
-
 __all__ = ("Branch",)
 
 
@@ -907,7 +899,6 @@ class Branch(Element, Communicatable, Relational):
         sender: SenderRecipient = None,
         recipient: SenderRecipient = None,
         progression: Progression = None,
-        imodel: iModel = None,  # deprecated, alias of chat_model
         chat_model: iModel = None,
         invoke_actions: bool = True,
         tool_schemas: list[dict] = None,
@@ -920,7 +911,6 @@ class Branch(Element, Communicatable, Relational):
         response_format: type[
             BaseModel
         ] = None,  # alias of operative.request_type
-        return_operative: bool = False,
         actions: bool = False,
         reason: bool = False,
         action_kwargs: dict = None,
@@ -931,15 +921,9 @@ class Branch(Element, Communicatable, Relational):
         verbose_action: bool = False,
         field_models: list[FieldModel] = None,
         exclude_fields: list | dict | None = None,
-        request_params: ModelParams = None,
-        request_param_kwargs: dict = None,
-        response_params: ModelParams = None,
-        response_param_kwargs: dict = None,
         handle_validation: Literal[
             "raise", "return_value", "return_none"
         ] = "return_value",
-        operative_model: type[BaseModel] = None,
-        request_model: type[BaseModel] = None,
         include_token_usage_to_model: bool = False,
         **kwargs,
     ) -> list | BaseModel | None | dict | str:
@@ -973,8 +957,7 @@ class Branch(Element, Communicatable, Relational):
                 The recipient ID for newly added messages.
             progression (Progression, optional):
                 Custom ordering of conversation messages.
-            imodel (iModel, deprecated):
-                Alias of `chat_model`.
+
             chat_model (iModel, optional):
                 The LLM used for the main chat operation. Defaults to `branch.chat_model`.
             invoke_actions (bool, optional):
@@ -995,8 +978,6 @@ class Branch(Element, Communicatable, Relational):
                 If provided, reuses an existing operative's config for parsing/validation.
             response_format (type[BaseModel], optional):
                 Expected Pydantic model for the final response (alias for `operative.request_type`).
-            return_operative (bool, optional):
-                If `True`, returns the entire `Operative` object after processing
                 rather than the structured or raw output.
             actions (bool, optional):
                 If `True`, signals that function-calling or "action" usage is expected.
@@ -1014,20 +995,8 @@ class Branch(Element, Communicatable, Relational):
                 Field-level definitions or overrides for the model schema.
             exclude_fields (list|dict|None, optional):
                 Which fields to exclude from final validation or model building.
-            request_params (ModelParams | None, optional):
-                Extra config for building the request model in the operative.
-            request_param_kwargs (dict|None, optional):
-                Additional kwargs passed to the `ModelParams` constructor for the request.
-            response_params (ModelParams | None, optional):
-                Config for building the response model after actions.
-            response_param_kwargs (dict|None, optional):
-                Additional kwargs passed to the `ModelParams` constructor for the response.
             handle_validation (Literal["raise","return_value","return_none"], optional):
                 How to handle parsing failures (default: "return_value").
-            operative_model (type[BaseModel], deprecated):
-                Alias for `response_format`.
-            request_model (type[BaseModel], optional):
-                Another alias for `response_format`.
             include_token_usage_to_model:
                 If `True`, includes token usage in the model messages.
             **kwargs:
@@ -1065,7 +1034,6 @@ class Branch(Element, Communicatable, Relational):
             tools=tools,
             operative=operative,
             response_format=response_format,
-            return_operative=return_operative,
             actions=actions,
             reason=reason,
             action_kwargs=action_kwargs,
@@ -1074,14 +1042,7 @@ class Branch(Element, Communicatable, Relational):
             verbose_action=verbose_action,
             field_models=field_models,
             exclude_fields=exclude_fields,
-            request_params=request_params,
-            request_param_kwargs=request_param_kwargs,
-            response_params=response_params,
-            response_param_kwargs=response_param_kwargs,
             handle_validation=handle_validation,
-            operative_model=operative_model,
-            request_model=request_model,
-            imodel=imodel,
             include_token_usage_to_model=include_token_usage_to_model,
             **kwargs,
         )
@@ -1096,19 +1057,15 @@ class Branch(Element, Communicatable, Relational):
         sender: SenderRecipient = None,
         recipient: SenderRecipient = None,
         progression: ID.IDSeq = None,
-        request_model: type[BaseModel] | BaseModel | None = None,
         response_format: type[BaseModel] = None,
         request_fields: dict | list[str] = None,
-        imodel: iModel = None,  # alias of chat_model
         chat_model: iModel = None,
         parse_model: iModel = None,
         skip_validation: bool = False,
         images: list = None,
         image_detail: Literal["low", "high", "auto"] = None,
         num_parse_retries: int = 3,
-        fuzzy_match_kwargs: dict = None,
         clear_messages: bool = False,
-        operative_model: type[BaseModel] = None,
         include_token_usage_to_model: bool = False,
         **kwargs,
     ):
@@ -1135,14 +1092,10 @@ class Branch(Element, Communicatable, Relational):
                 Recipient ID (defaults to `self.id`).
             progression (ID.IDSeq, optional):
                 Custom ordering of messages.
-            request_model (type[BaseModel] | BaseModel | None, optional):
-                Model for validating or structuring the LLM's response.
             response_format (type[BaseModel], optional):
                 Alias for `request_model`. If both are provided, raises ValueError.
             request_fields (dict|list[str], optional):
                 If you only need certain fields from the LLM's response.
-            imodel (iModel, optional):
-                Deprecated alias for `chat_model`.
             chat_model (iModel, optional):
                 An alternative to the default chat model.
             parse_model (iModel, optional):
@@ -1155,12 +1108,8 @@ class Branch(Element, Communicatable, Relational):
                 Image detail level (if used).
             num_parse_retries (int, optional):
                 Maximum parsing retries (capped at 5).
-            fuzzy_match_kwargs (dict, optional):
-                Additional settings for fuzzy field matching (if used).
             clear_messages (bool, optional):
                 Whether to clear stored messages before sending.
-            operative_model (type[BaseModel], optional):
-                Deprecated, alias for `response_format`.
             **kwargs:
                 Additional arguments for the underlying LLM call.
 
@@ -1182,18 +1131,15 @@ class Branch(Element, Communicatable, Relational):
             sender=sender,
             recipient=recipient,
             progression=progression,
-            request_model=request_model,
             response_format=response_format,
             request_fields=request_fields,
-            chat_model=kwargs.pop("chat_model", None) or chat_model or imodel,
+            chat_model=chat_model,
             parse_model=parse_model,
             skip_validation=skip_validation,
             images=images,
             image_detail=image_detail,
             num_parse_retries=num_parse_retries,
-            fuzzy_match_kwargs=fuzzy_match_kwargs,
             clear_messages=clear_messages,
-            operative_model=operative_model,
             include_token_usage_to_model=include_token_usage_to_model,
             **kwargs,
         )

lionagi/utils.py

@@ -6,6 +6,8 @@ import asyncio
 import contextlib
 import copy as _copy
 import functools
+import importlib.metadata
+import importlib.util
 import json
 import logging
 import re
@@ -2367,3 +2369,215 @@ def run_package_manager_command(
         check=True,
         capture_output=True,
     )
+
+
+def check_import(
+    package_name: str,
+    module_name: str | None = None,
+    import_name: str | None = None,
+    pip_name: str | None = None,
+    attempt_install: bool = True,
+    error_message: str = "",
+):
+    """
+    Check if a package is installed, attempt to install if not.
+
+    Args:
+        package_name: The name of the package to check.
+        module_name: The specific module to import (if any).
+        import_name: The specific name to import from the module (if any).
+        pip_name: The name to use for pip installation (if different).
+        attempt_install: Whether to attempt installation if not found.
+        error_message: Custom error message to use if package not found.
+
+    Raises:
+        ImportError: If the package is not found and not installed.
+        ValueError: If the import fails after installation attempt.
+    """
+    if not is_import_installed(package_name):
+        if attempt_install:
+            logging.info(
+                f"Package {package_name} not found. Attempting " "to install.",
+            )
+            try:
+                return install_import(
+                    package_name=package_name,
+                    module_name=module_name,
+                    import_name=import_name,
+                    pip_name=pip_name,
+                )
+            except ImportError as e:
+                raise ValueError(
+                    f"Failed to install {package_name}: {e}"
+                ) from e
+        else:
+            logging.info(
+                f"Package {package_name} not found. {error_message}",
+            )
+            raise ImportError(
+                f"Package {package_name} not found. {error_message}",
+            )
+
+    return import_module(
+        package_name=package_name,
+        module_name=module_name,
+        import_name=import_name,
+    )
+
+
+def import_module(
+    package_name: str,
+    module_name: str = None,
+    import_name: str | list = None,
+) -> Any:
+    """
+    Import a module by its path.
+
+    Args:
+        module_path: The path of the module to import.
+
+    Returns:
+        The imported module.
+
+    Raises:
+        ImportError: If the module cannot be imported.
+    """
+    try:
+        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
+            )
+            a = __import__(
+                full_import_path,
+                fromlist=import_name,
+            )
+            if len(import_name) == 1:
+                return getattr(a, import_name[0])
+            return [getattr(a, name) for name in import_name]
+        else:
+            return __import__(full_import_path)
+
+    except ImportError as e:
+        raise ImportError(
+            f"Failed to import module {full_import_path}: {e}"
+        ) from e
+
+
+def install_import(
+    package_name: str,
+    module_name: str | None = None,
+    import_name: str | None = None,
+    pip_name: str | None = None,
+):
+    """
+    Attempt to import a package, installing it if not found.
+
+    Args:
+        package_name: The name of the package to import.
+        module_name: The specific module to import (if any).
+        import_name: The specific name to import from the module (if any).
+        pip_name: The name to use for pip installation (if different).
+
+    Raises:
+        ImportError: If the package cannot be imported or installed.
+        subprocess.CalledProcessError: If pip installation fails.
+    """
+    pip_name = pip_name or package_name
+
+    try:
+        return import_module(
+            package_name=package_name,
+            module_name=module_name,
+            import_name=import_name,
+        )
+    except ImportError:
+        logging.info(f"Installing {pip_name}...")
+        try:
+            run_package_manager_command(["install", pip_name])
+            return import_module(
+                package_name=package_name,
+                module_name=module_name,
+                import_name=import_name,
+            )
+        except subprocess.CalledProcessError as e:
+            raise ImportError(f"Failed to install {pip_name}: {e}") from e
+        except ImportError as e:
+            raise ImportError(
+                f"Failed to import {pip_name} after installation: {e}"
+            ) from e
+
+
+def is_import_installed(package_name: str) -> bool:
+    """
+    Check if a package is installed.
+
+    Args:
+        package_name: The name of the package to check.
+
+    Returns:
+        bool: True if the package is installed, False otherwise.
+    """
+    return importlib.util.find_spec(package_name) is not None
+
+
+def read_image_to_base64(image_path: str | Path) -> str:
+    import base64
+
+    import cv2
+
+    image_path = str(image_path)
+    image = cv2.imread(image_path, cv2.COLOR_BGR2RGB)
+
+    if image is None:
+        raise ValueError(f"Could not read image from path: {image_path}")
+
+    file_extension = "." + image_path.split(".")[-1]
+
+    success, buffer = cv2.imencode(file_extension, image)
+    if not success:
+        raise ValueError(f"Could not encode image to {file_extension} format.")
+    encoded_image = base64.b64encode(buffer).decode("utf-8")
+    return encoded_image
+
+
+def pdf_to_images(
+    pdf_path: str, output_folder: str, dpi: int = 300, fmt: str = "jpeg"
+) -> list:
+    """
+    Convert a PDF file into images, one image per page.
+
+    Args:
+        pdf_path (str): Path to the input PDF file.
+        output_folder (str): Directory to save the output images.
+        dpi (int): Dots per inch (resolution) for conversion (default: 300).
+        fmt (str): Image format (default: 'jpeg'). Use 'png' if preferred.
+
+    Returns:
+        list: A list of file paths for the saved images.
+    """
+    import os
+
+    convert_from_path = check_import(
+        "pdf2image", import_name="convert_from_path"
+    )
+
+    # Ensure the output folder exists
+    os.makedirs(output_folder, exist_ok=True)
+
+    # Convert PDF to a list of PIL Image objects
+    images = convert_from_path(pdf_path, dpi=dpi)
+
+    saved_paths = []
+    for i, image in enumerate(images):
+        # Construct the output file name
+        image_file = os.path.join(output_folder, f"page_{i+1}.{fmt}")
+        image.save(image_file, fmt.upper())
+        saved_paths.append(image_file)
+
+    return saved_paths

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.10.1"
+__version__ = "0.10.3"

{lionagi-0.10.1.dist-info → lionagi-0.10.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.10.1
+Version: 0.10.3
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -221,11 +221,11 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: aiocache>=0.12.0
 Requires-Dist: aiohttp>=3.11.0
-Requires-Dist: jinja2>=3.1.0
+Requires-Dist: jinja2>=3.0.0
 Requires-Dist: pandas>=2.0.0
 Requires-Dist: pillow>=10.0.0
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: toml>=0.9.0
 Provides-Extra: llms