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

lionagi/integrations/anthropic_/AnthropicModel.py

@@ -4,7 +4,6 @@
 
 from pathlib import Path
 
-import yaml
 from dotenv import load_dotenv
 from pydantic import (
     BaseModel,
@@ -34,6 +33,12 @@ price_config_file_name = path / "anthropic_price_data.yaml"
 max_output_token_file_name = path / "anthropic_max_output_token_data.yaml"
 
 
+class _ModuleImportClass:
+    from lionagi.libs.package.imports import check_import
+
+    yaml = check_import("yaml", pip_name="pyyaml")
+
+
 class AnthropicModel(BaseModel):
     model: str = Field(description="ID of the model to use.")
 
@@ -234,7 +239,7 @@ class AnthropicModel(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
 
@@ -256,7 +261,7 @@ class AnthropicModel(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/integrations/anthropic_/AnthropicService.py

@@ -111,3 +111,7 @@ class AnthropicService(Service):
         return self.check_rate_limiter(
             model_obj, limit_requests=limit_requests, limit_tokens=limit_tokens
         )
+
+    @property
+    def allowed_roles(self):
+        return ["user", "assistant"]

lionagi/integrations/groq_/GroqModel.py

@@ -5,7 +5,6 @@
 import warnings
 from pathlib import Path
 
-import yaml
 from dotenv import load_dotenv
 from pydantic import (
     BaseModel,
@@ -34,6 +33,12 @@ max_output_token_file_name = path / "groq_max_output_token_data.yaml"
 rate_limits_file_name = path / "groq_rate_limits.yaml"
 
 
+class _ModuleImportClass:
+    from lionagi.libs.package.imports import check_import
+
+    yaml = check_import("yaml", pip_name="pyyaml")
+
+
 class GroqModel(BaseModel):
     model: str = Field(description="ID of the model to use.")
     request_model: GroqRequest = Field(description="Making requests")
@@ -67,7 +72,7 @@ class GroqModel(BaseModel):
         # Load rate limits from YAML
         try:
             with open(rate_limits_file_name) as file:
-                rate_limits = yaml.safe_load(file)
+                rate_limits = _ModuleImportClass.yaml.safe_load(file)
                 model_name = data.get("model")
                 model_limits = None
 
@@ -261,7 +266,9 @@ class GroqModel(BaseModel):
         if estimated_output_len == 0:
             try:
                 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, 2048
                     )  # Default to 2048
@@ -297,7 +304,7 @@ class GroqModel(BaseModel):
 
         try:
             with open(price_config_file_name) as file:
-                price_config = yaml.safe_load(file)
+                price_config = _ModuleImportClass.yaml.safe_load(file)
         except FileNotFoundError:
             raise ValueError(
                 f"Price config file not found: {price_config_file_name}"

lionagi/integrations/groq_/GroqService.py

@@ -145,3 +145,7 @@ class GroqService(Service):
             model_obj,
             limit_requests=limit_requests,
         )
+
+    @property
+    def allowed_roles(self):
+        return ["user", "assistant", "system"]

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_ = {
@@ -67,3 +65,7 @@ class LiteiModel:
                 v = str(v)
             hashable_items.append((k, v))
         return hash(frozenset(hashable_items))
+
+    @property
+    def allowed_roles(self):
+        return ["user", "assistant", "system"]

lionagi/integrations/ollama_/OllamaService.py

@@ -136,3 +136,7 @@ class OllamaService(Service):
     # List Running Models
     def list_running_models(self):
         return OllamaRequest(endpoint="ps", method="GET")
+
+    @property
+    def allowed_roles(self):
+        return ["user", "assistant", "system"]

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]
@@ -412,3 +417,7 @@ class OpenAIModel(BaseModel):
                 "Estimating price currently only supports chat/completions endpoint"
             )
         return estimated_price
+
+    @property
+    def allowed_roles(self):
+        return ["user", "assistant", "system"]

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/integrations/perplexity_/PerplexityService.py

@@ -107,3 +107,7 @@ class PerplexityService(Service):
         return self.check_rate_limiter(
             model_obj, limit_requests=limit_requests, limit_tokens=limit_tokens
         )
+
+    @property
+    def allowed_roles(self):
+        return ["user", "assistant", "system"]

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 (