lionagi 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

lionagi/integrations/litellm_/imodel.py

@@ -5,13 +5,6 @@
 import json
 import os
 
-import litellm
-from dotenv import load_dotenv
-
-litellm.drop_params = True
-load_dotenv()
-
-
 RESERVED_PARAMS = [
     "invoke_action",
     "instruction",
@@ -21,6 +14,11 @@ RESERVED_PARAMS = [
 
 class LiteiModel:
 
+    from lionagi.libs.package.imports import check_import
+
+    litellm = check_import("litellm")
+    litellm.drop_params = True
+
     def __init__(self, **kwargs):
         if "api_key" in kwargs:
             try:
@@ -33,7 +31,7 @@ class LiteiModel:
             except Exception:
                 pass
         self.kwargs = kwargs
-        self.acompletion = litellm.acompletion
+        self.acompletion = self.litellm.acompletion
 
     def to_dict(self) -> dict:
         dict_ = {

lionagi/integrations/openai_/OpenAIModel.py

@@ -1,7 +1,6 @@
 import warnings
 from pathlib import Path
 
-import yaml
 from dotenv import load_dotenv
 from pydantic import (
     BaseModel,
@@ -35,6 +34,12 @@ price_config_file_name = path / "openai_max_output_token_data.yaml"
 max_output_token_file_name = path / "openai_price_data.yaml"
 
 
+class _ModuleImportClass:
+    from lionagi.libs.package.imports import check_import
+
+    yaml = check_import("yaml", pip_name="pyyaml")
+
+
 class OpenAIModel(BaseModel):
     model: str = Field(description="ID of the model to use.")
 
@@ -303,7 +308,7 @@ class OpenAIModel(BaseModel):
         )
         if estimated_output_len == 0:
             with open(max_output_token_file_name) as file:
-                output_token_config = yaml.safe_load(file)
+                output_token_config = _ModuleImportClass.yaml.safe_load(file)
                 estimated_output_len = output_token_config.get(self.model, 0)
                 self.estimated_output_len = (
                     estimated_output_len  # update to default max output len
@@ -388,7 +393,7 @@ class OpenAIModel(BaseModel):
 
         # read openai price info from config file
         with open(price_config_file_name) as file:
-            price_config = yaml.safe_load(file)
+            price_config = _ModuleImportClass.yaml.safe_load(file)
 
         if self.request_model.endpoint == "chat/completions":
             model_price_info_dict = price_config["model"][self.model]

lionagi/integrations/openai_/image_token_calculator/image_token_calculator.py

@@ -4,9 +4,6 @@ import os
 from io import BytesIO
 from typing import Literal
 
-import aiohttp
-import yaml
-from PIL import Image
 from pydantic import BaseModel, Field, field_validator
 
 image_token_config_file_name = os.path.join(
@@ -14,6 +11,15 @@ image_token_config_file_name = os.path.join(
 )
 
 
+class _ModuelImportClass:
+
+    from lionagi.libs.package.imports import check_import
+
+    yaml = check_import("yaml", pip_name="pyyaml")
+    Image = check_import("PIL.Image", pip_name="Pillow")
+    aiohttp = check_import("aiohttp")
+
+
 class OpenAIImageTokenCalculator(BaseModel):
     model: str = Field(description="ID of the model to use.")
 
@@ -21,7 +27,7 @@ class OpenAIImageTokenCalculator(BaseModel):
     @classmethod
     def validate_model_image_function(cls, value: str):
         with open(image_token_config_file_name) as file:
-            token_config = yaml.safe_load(file)
+            token_config = _ModuelImportClass.yaml.safe_load(file)
 
         token_config = token_config.get(value, None)
 
@@ -36,16 +42,16 @@ class OpenAIImageTokenCalculator(BaseModel):
             image_base64 = url.split("data:image/jpeg;base64,")[1]
             image_base64.strip("{}")
             image_data = base64.b64decode(image_base64)
-            image = Image.open(BytesIO(image_data))
+            image = _ModuelImportClass.Image.open(BytesIO(image_data))
         else:
             # image url
-            async with aiohttp.ClientSession() as client:
+            async with _ModuelImportClass.aiohttp.ClientSession() as client:
                 async with client.get(url=url) as response:
                     response.raise_for_status()
 
                     content = await response.read()
 
-                    image = Image.open(BytesIO(content))
+                    image = _ModuelImportClass.Image.open(BytesIO(content))
 
         return image.size
 
@@ -58,7 +64,7 @@ class OpenAIImageTokenCalculator(BaseModel):
             )
 
         with open(image_token_config_file_name) as file:
-            token_config = yaml.safe_load(file)
+            token_config = _ModuelImportClass.yaml.safe_load(file)
 
         token_config = token_config.get(self.model, None)
 

lionagi/integrations/perplexity_/PerplexityModel.py

@@ -5,7 +5,6 @@
 import os
 from pathlib import Path
 
-import yaml
 from dotenv import load_dotenv
 from pydantic import (
     BaseModel,
@@ -35,6 +34,12 @@ price_config_file_name = path / "perplexity_price_data.yaml"
 max_output_token_file_name = path / "perplexity_max_output_token_data.yaml"
 
 
+class _ModuleImportClass:
+    from lionagi.libs.package.imports import check_import
+
+    yaml = check_import("yaml", pip_name="pyyaml")
+
+
 class PerplexityModel(BaseModel):
     model: str = Field(description="ID of the model to use.")
 
@@ -235,7 +240,7 @@ class PerplexityModel(BaseModel):
         )
         if estimated_output_len == 0:
             with open(max_output_token_file_name) as file:
-                output_token_config = yaml.safe_load(file)
+                output_token_config = _ModuleImportClass.yaml.safe_load(file)
                 estimated_output_len = output_token_config.get(self.model, 0)
                 self.estimated_output_len = estimated_output_len
 
@@ -257,7 +262,7 @@ class PerplexityModel(BaseModel):
         num_of_input_tokens = self.text_token_calculator.calculate(input_text)
 
         with open(price_config_file_name) as file:
-            price_config = yaml.safe_load(file)
+            price_config = _ModuleImportClass.yaml.safe_load(file)
 
         model_price_info_dict = price_config["model"][self.model]
         estimated_price = (

lionagi/libs/func/async_calls/__init__.py

@@ -2,11 +2,11 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from .alcall import alcall
-from .bcall import bcall
+from .alcall import ALCallParams, alcall
+from .bcall import BCallParams, bcall
 from .mcall import mcall
 from .pcall import pcall
-from .rcall import rcall
+from .rcall import RCallParams, rcall
 from .tcall import tcall
 from .ucall import ucall
 
@@ -18,4 +18,7 @@ __all__ = [
     "rcall",
     "tcall",
     "ucall",
+    "ALCallParams",
+    "BCallParams",
+    "RCallParams",
 ]

lionagi/libs/func/async_calls/alcall.py

@@ -1,7 +1,10 @@
 import asyncio
 from collections.abc import Callable
+from dataclasses import dataclass
 from typing import Any, TypeVar
 
+from lionagi.libs.utils import DataClass
+
 from ...constants import UNDEFINED
 from ...parse import to_list
 from .ucall import ucall
@@ -9,6 +12,49 @@ from .ucall import ucall
 T = TypeVar("T")
 
 
+@dataclass
+class ALCallParams(DataClass):
+    function: Callable[..., T]
+    num_retries: int = 0
+    initial_delay: float = 0
+    retry_delay: float = 0
+    backoff_factor: float = 1
+    retry_default: Any = UNDEFINED
+    retry_timeout: float | None = None
+    retry_timing: bool = False
+    verbose: bool = True
+    error_msg: str | None = None
+    error_map: dict[type, Callable[[Exception], None]] | None = None
+    max_concurrent: int | None = None
+    throttle_period: float | None = None
+    flatten: bool = False
+    dropna: bool = False
+    unique: bool = False
+
+    async def __call__(self, input_, *args, **kwargs):
+        return await alcall(
+            input_,
+            self.function,
+            *args,
+            num_retries=self.num_retries,
+            initial_delay=self.initial_delay,
+            retry_delay=self.retry_delay,
+            backoff_factor=self.backoff_factor,
+            retry_default=self.retry_default,
+            retry_timeout=self.retry_timeout,
+            retry_timing=self.retry_timing,
+            verbose_retry=self.verbose,
+            error_msg=self.error_msg,
+            error_map=self.error_map,
+            max_concurrent=self.max_concurrent,
+            throttle_period=self.throttle_period,
+            flatten=self.flatten,
+            dropna=self.dropna,
+            unique=self.unique,
+            **kwargs,
+        )
+
+
 async def alcall(
     input_: list[Any],
     func: Callable[..., T],

lionagi/libs/func/async_calls/bcall.py

@@ -1,13 +1,61 @@
-import asyncio
 from collections.abc import AsyncGenerator, Callable
+from dataclasses import dataclass
 from typing import Any, TypeVar
 
+from lionagi.libs.constants import UNDEFINED
+from lionagi.libs.utils import DataClass
+
 from ...parse import to_list
 from .alcall import alcall
 
 T = TypeVar("T")
 
 
+@dataclass
+class BCallParams(DataClass):
+    function: Callable[..., T]
+    batch_size: int
+    num_retries: int = 0
+    initial_delay: float = 0
+    retry_delay: float = 0
+    backoff_factor: float = 1
+    retry_default: Any = UNDEFINED
+    retry_timeout: float | None = None
+    retry_timing: bool = False
+    verbose_retry: bool = True
+    error_msg: str | None = None
+    error_map: dict[type, Callable[[Exception], None]] | None = None
+    max_concurrent: int | None = None
+    throttle_period: float | None = None
+    flatten: bool = False
+    dropna: bool = False
+    unique: bool = False
+
+    async def __call__(self, input_, *args, **kwargs):
+        return await bcall(
+            input_,
+            self.function,
+            *args,
+            batch_size=self.batch_size,
+            num_retries=self.num_retries,
+            initial_delay=self.initial_delay,
+            retry_delay=self.retry_delay,
+            backoff_factor=self.backoff_factor,
+            default=self.retry_default,
+            timeout=self.retry_timeout,
+            timing=self.retry_timing,
+            verbose=self.verbose_retry,
+            error_msg=self.error_msg,
+            error_map=self.error_map,
+            max_concurrent=self.max_concurrent,
+            throttle_period=self.throttle_period,
+            flatten=self.flatten,
+            dropna=self.dropna,
+            unique=self.unique,
+            **kwargs,
+        )
+
+
 async def bcall(
     input_: Any,
     func: Callable[..., T],

lionagi/libs/func/async_calls/rcall.py

@@ -1,7 +1,10 @@
 import asyncio
 from collections.abc import Callable
+from dataclasses import dataclass
 from typing import Any, TypeVar
 
+from lionagi.libs.utils import DataClass
+
 from ...constants import UNDEFINED
 from ...utils import time as _t
 from .ucall import ucall
@@ -9,6 +12,35 @@ from .ucall import ucall
 T = TypeVar("T")
 
 
+@dataclass
+class RCallParams(DataClass):
+    function: Callable[..., T]
+    num_retries: int = 0
+    initial_delay: float = 0
+    retry_delay: float = 0
+    backoff_factor: float = 1
+    retry_default: Any = UNDEFINED
+    retry_timeout: float | None = None
+    retry_timing: bool = False
+    verbose_retry: bool = True
+
+    async def __call__(self, input_, *args, **kwargs):
+        return await rcall(
+            input_,
+            self.function,
+            *args,
+            num_retries=self.num_retries,
+            initial_delay=self.initial_delay,
+            retry_delay=self.retry_delay,
+            backoff_factor=self.backoff_factor,
+            retry_default=self.retry_default,
+            retry_timeout=self.retry_timeout,
+            retry_timing=self.retry_timing,
+            verbose_retry=self.verbose_retry,
+            **kwargs,
+        )
+
+
 async def rcall(
     func: Callable[..., T],
     /,

lionagi/libs/utils.py

@@ -8,13 +8,24 @@ import random
 import subprocess
 import sys
 from collections.abc import Mapping, Sequence
+from dataclasses import asdict
 from datetime import datetime, timezone
 from hashlib import sha256
-from typing import Literal, TypeVar
+from typing import Literal, Self, TypeVar
 
 T = TypeVar("T")
 
 
+class DataClass:
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Self:
+        return cls(**data)
+
+
 def unique_hash(n: int = 32) -> str:
     """unique random hash"""
     current_time = datetime.now().isoformat().encode("utf-8")

lionagi/operations/brainstorm/brainstorm.py

@@ -9,7 +9,7 @@ from lionagi.core.typing import ID, Any, BaseModel
 from lionagi.libs.func import alcall
 from lionagi.libs.parse import to_flat_list
 from lionagi.protocols.operatives.instruct import (
-    INSTRUCT_MODEL_FIELD,
+    INSTRUCT_FIELD_MODEL,
     Instruct,
     InstructResponse,
 )
@@ -118,8 +118,8 @@ async def brainstorm(
         print(f"Starting brainstorming...")
 
     field_models: list = kwargs.get("field_models", [])
-    if INSTRUCT_MODEL_FIELD not in field_models:
-        field_models.append(INSTRUCT_MODEL_FIELD)
+    if INSTRUCT_FIELD_MODEL not in field_models:
+        field_models.append(INSTRUCT_FIELD_MODEL)
 
     kwargs["field_models"] = field_models
     session, branch = prepare_session(session, branch, branch_kwargs)

lionagi/operations/plan/plan.py

@@ -7,7 +7,7 @@ from lionagi.core.session.branch import Branch
 from lionagi.core.session.session import Session
 from lionagi.core.typing import ID, Any, BaseModel, Literal
 from lionagi.protocols.operatives.instruct import (
-    INSTRUCT_MODEL_FIELD,
+    INSTRUCT_FIELD_MODEL,
     Instruct,
     InstructResponse,
 )
@@ -95,8 +95,8 @@ async def plan(
         print(f"Planning execution with {num_steps} steps...")
 
     field_models: list = kwargs.get("field_models", [])
-    if INSTRUCT_MODEL_FIELD not in field_models:
-        field_models.append(INSTRUCT_MODEL_FIELD)
+    if INSTRUCT_FIELD_MODEL not in field_models:
+        field_models.append(INSTRUCT_FIELD_MODEL)
     kwargs["field_models"] = field_models
     session, branch = prepare_session(session, branch, branch_kwargs)
     execute_branch: Branch = session.split(branch)

lionagi/protocols/__init__.py

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

lionagi/protocols/configs/__init__.py

@@ -1,15 +0,0 @@
-from .branch_config import BranchConfig, MessageConfig
-from .id_config import LionIDConfig
-from .imodel_config import iModelConfig
-from .log_config import LogConfig
-from .retry_config import RetryConfig, TimedFuncCallConfig
-
-__all__ = [
-    "LogConfig",
-    "LionIDConfig",
-    "RetryConfig",
-    "TimedFuncCallConfig",
-    "iModelConfig",
-    "BranchConfig",
-    "MessageConfig",
-]

lionagi/protocols/configs/branch_config.py

@@ -5,7 +5,7 @@
 from typing import Any, Literal
 
 from lionagi.core.models.schema_model import SchemaModel
-from lionagi.core.typing.pydantic_ import Field
+from lionagi.core.typing._pydantic import Field
 
 from .imodel_config import iModelConfig
 from .log_config import LogConfig

lionagi/protocols/configs/imodel_config.py

@@ -6,8 +6,8 @@ import json
 import os
 
 from lionagi.core.models.schema_model import SchemaModel
-from lionagi.core.typing.pydantic_ import Field
-from lionagi.core.typing.typing_ import Any
+from lionagi.core.typing._pydantic import Field
+from lionagi.core.typing._typing import Any
 
 
 class iModelConfig(SchemaModel):

lionagi/protocols/configs/log_config.py

@@ -8,7 +8,7 @@ from typing import Any
 from pydantic import field_validator
 
 from lionagi.core.models.schema_model import SchemaModel
-from lionagi.core.typing.pydantic_ import Field
+from lionagi.core.typing._pydantic import Field
 
 
 class LogConfig(SchemaModel):

lionagi/protocols/configs/types.py

@@ -0,0 +1,15 @@
+from .branch_config import BranchConfig, MessageConfig
+from .id_config import LionIDConfig
+from .imodel_config import iModelConfig
+from .log_config import LogConfig
+from .retry_config import RetryConfig, TimedFuncCallConfig
+
+__all__ = [
+    "LogConfig",
+    "LionIDConfig",
+    "RetryConfig",
+    "TimedFuncCallConfig",
+    "iModelConfig",
+    "BranchConfig",
+    "MessageConfig",
+]

lionagi/protocols/operatives/__init__.py

@@ -1,15 +1,3 @@
-from .action import ActionRequestModel, ActionResponseModel
-from .instruct import Instruct
-from .operative import Operative
-from .reason import ReasonModel
-from .step import Step, StepModel
-
-__all__: list[str] = [
-    "Operative",
-    "Step",
-    "ActionRequestModel",
-    "ActionResponseModel",
-    "StepModel",
-    "Instruct",
-    "ReasonModel",
-]
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/protocols/operatives/action.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 import re
 
 from lionagi.core.typing import (

lionagi/protocols/operatives/instruct.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 """Field definitions and validation for InstructModel components."""
 
 from typing import Any, ClassVar
@@ -169,7 +173,7 @@ class OperationInstruct(Instruct):
         return ACTIONS_FIELD.validator(cls, v)
 
 
-INSTRUCT_MODEL_FIELD = FieldModel(
+INSTRUCT_FIELD_MODEL = FieldModel(
     name="instruct_models",
     annotation=list[Instruct],
     default_factory=list,
@@ -191,6 +195,6 @@ __all__ = [
     "REASON_FIELD",
     "ACTIONS_FIELD",
     "Instruct",
-    "INSTRUCT_MODEL_FIELD",
+    "INSTRUCT_FIELD_MODEL",
     "InstructResponse",
 ]

lionagi/protocols/operatives/operative.py

@@ -1,25 +1,13 @@
-"""
-Copyright 2024 HaiyangLi
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-"""
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
 
 from typing import Self
 
 from pydantic import BaseModel, Field, PrivateAttr, model_validator
 from pydantic.fields import FieldInfo
 
-from lionagi.core.models import FieldModel, NewModelParams, OperableModel
+from lionagi.core.models import FieldModel, ModelParams, OperableModel
 from lionagi.core.typing import UNDEFINED
 from lionagi.libs.parse import to_json, validate_keys
 
@@ -29,10 +17,10 @@ class Operative(OperableModel):
 
     name: str | None = None
 
-    request_params: NewModelParams | None = Field(default=None)
+    request_params: ModelParams | None = Field(default=None)
     request_type: type[BaseModel] | None = Field(default=None)
 
-    response_params: NewModelParams | None = Field(default=None)
+    response_params: ModelParams | None = Field(default=None)
     response_type: type[BaseModel] | None = Field(default=None)
     response_model: OperableModel | None = Field(default=None)
     response_str_dict: dict | str | None = Field(default=None)
@@ -140,7 +128,7 @@ class Operative(OperableModel):
 
     def create_response_type(
         self,
-        response_params: NewModelParams | None = None,
+        response_params: ModelParams | None = None,
         field_models: list[FieldModel] | None = None,
         parameter_fields: dict[str, FieldInfo] | None = None,
         exclude_fields: list[str] | None = None,
@@ -154,7 +142,7 @@ class Operative(OperableModel):
         """Creates a new response type based on the provided parameters.
 
         Args:
-            response_params (NewModelParams, optional): Parameters for the new response model.
+            response_params (ModelParams, optional): Parameters for the new response model.
             field_models (list[FieldModel], optional): List of field models.
             parameter_fields (dict[str, FieldInfo], optional): Dictionary of parameter fields.
             exclude_fields (list, optional): List of fields to exclude.
@@ -165,7 +153,7 @@ class Operative(OperableModel):
             frozen (bool, optional): Whether the model is frozen.
             validators (dict, optional): Dictionary of validators.
         """
-        self.response_params = response_params or NewModelParams(
+        self.response_params = response_params or ModelParams(
             parameter_fields=parameter_fields,
             field_models=field_models,
             exclude_fields=exclude_fields,

lionagi/protocols/operatives/prompts.py

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

lionagi/protocols/operatives/reason.py

@@ -1,3 +1,7 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from pydantic import BaseModel, field_validator
 
 from lionagi.core.models import FieldModel