camel-ai 0.1.5.3__py3-none-any.whl → 0.1.5.5__py3-none-any.whl

camel/models/ollama_model.py

@@ -11,12 +11,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-import os
 from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import OPENAI_API_PARAMS
+from camel.configs import OLLAMA_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import BaseTokenCounter, OpenAITokenCounter
@@ -25,39 +24,34 @@ from camel.utils import BaseTokenCounter, OpenAITokenCounter
 class OllamaModel:
     r"""Ollama service interface."""
 
-    # NOTE: Current `ModelType and `TokenCounter` desigen is not suitable,
-    # stream mode is not supported
-
     def __init__(
         self,
         model_type: str,
         model_config_dict: Dict[str, Any],
-        api_key: Optional[str] = None,
         url: Optional[str] = None,
     ) -> None:
         r"""Constructor for Ollama backend with OpenAI compatibility.
 
+        # Reference: https://github.com/ollama/ollama/blob/main/docs/openai.md
+
         Args:
             model_type (str): Model for which a backend is created.
             model_config_dict (Dict[str, Any]): A dictionary that will
                 be fed into openai.ChatCompletion.create().
-            api_key (Optional[str]): The API key for authenticating with the
-                model service. (default: :obj:`None`)
-            url (Optional[str]): The url to the model service.
+            url (Optional[str]): The url to the model service. (default:
+                :obj:`None`)
         """
         self.model_type = model_type
         self.model_config_dict = model_config_dict
-        self._url = url or os.environ.get('OPENAI_API_BASE_URL')
-        self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
         # Use OpenAI cilent as interface call Ollama
-        # Reference: https://github.com/ollama/ollama/blob/main/docs/openai.md
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
-            base_url=self._url,
-            api_key=self._api_key,
+            base_url=url,
+            api_key="ollama",  # required but ignored
         )
         self._token_counter: Optional[BaseTokenCounter] = None
+        self.check_model_config()
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -74,17 +68,17 @@ class OllamaModel:
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any
-        unexpected arguments to OpenAI API.
+        unexpected arguments to Ollama API.
 
         Raises:
             ValueError: If the model configuration dictionary contains any
                 unexpected arguments to OpenAI API.
         """
         for param in self.model_config_dict:
-            if param not in OPENAI_API_PARAMS:
+            if param not in OLLAMA_API_PARAMS:
                 raise ValueError(
                     f"Unexpected argument `{param}` is "
-                    "input into OpenAI model backend."
+                    "input into Ollama model backend."
                 )
 
     def run(

camel/models/openai_audio_models.py

@@ -25,10 +25,18 @@ class OpenAIAudioModels:
 
     def __init__(
         self,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
     ) -> None:
         r"""Initialize an instance of OpenAI."""
-        url = os.environ.get('OPENAI_API_BASE_URL')
-        self._client = OpenAI(timeout=120, max_retries=3, base_url=url)
+        self._url = url or os.environ.get("OPENAI_API_BASE_URL")
+        self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
+        self._client = OpenAI(
+            timeout=120,
+            max_retries=3,
+            base_url=self._url,
+            api_key=self._api_key,
+        )
 
     def text_to_speech(
         self,

camel/models/openai_model.py

@@ -23,7 +23,7 @@ from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
-    model_api_key_required,
+    api_keys_required,
 )
 
 
@@ -46,7 +46,8 @@ class OpenAIModel(BaseModelBackend):
                 be fed into openai.ChatCompletion.create().
             api_key (Optional[str]): The API key for authenticating with the
                 OpenAI service. (default: :obj:`None`)
-            url (Optional[str]): The url to the OpenAI service.
+            url (Optional[str]): The url to the OpenAI service. (default:
+                :obj:`None`)
         """
         super().__init__(model_type, model_config_dict, api_key, url)
         self._url = url or os.environ.get("OPENAI_API_BASE_URL")
@@ -71,7 +72,7 @@ class OpenAIModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(self.model_type)
         return self._token_counter
 
-    @model_api_key_required
+    @api_keys_required("OPENAI_API_KEY")
     def run(
         self,
         messages: List[OpenAIMessage],

camel/models/zhipuai_model.py

@@ -17,14 +17,14 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import OPENAI_API_PARAMS
+from camel.configs import ZHIPUAI_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
 from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
-    model_api_key_required,
+    api_keys_required,
 )
 
 
@@ -47,10 +47,16 @@ class ZhipuAIModel(BaseModelBackend):
                 be fed into openai.ChatCompletion.create().
             api_key (Optional[str]): The API key for authenticating with the
                 ZhipuAI service. (default: :obj:`None`)
+            url (Optional[str]): The url to the ZhipuAI service. (default:
+                :obj:`None`)
         """
         super().__init__(model_type, model_config_dict)
         self._url = url or os.environ.get("ZHIPUAI_API_BASE_URL")
         self._api_key = api_key or os.environ.get("ZHIPUAI_API_KEY")
+        if not self._url or not self._api_key:
+            raise ValueError(
+                "ZHIPUAI_API_BASE_URL and ZHIPUAI_API_KEY should be set."
+            )
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
@@ -59,7 +65,7 @@ class ZhipuAIModel(BaseModelBackend):
         )
         self._token_counter: Optional[BaseTokenCounter] = None
 
-    @model_api_key_required
+    @api_keys_required("ZHIPUAI_API_KEY")
     def run(
         self,
         messages: List[OpenAIMessage],
@@ -104,13 +110,13 @@ class ZhipuAIModel(BaseModelBackend):
 
         Raises:
             ValueError: If the model configuration dictionary contains any
-                unexpected arguments to OpenAI API.
+                unexpected arguments to ZhipuAI API.
         """
         for param in self.model_config_dict:
-            if param not in OPENAI_API_PARAMS:
+            if param not in ZHIPUAI_API_PARAMS:
                 raise ValueError(
                     f"Unexpected argument `{param}` is "
-                    "input into OpenAI model backend."
+                    "input into ZhipuAI model backend."
                 )
         pass
 

camel/retrievers/auto_retriever.py

@@ -159,11 +159,11 @@ class AutoRetriever:
     ) -> str:
         r"""Retrieves the last modified date and time of a given file. This
         function takes vector storage instance as input and returns the last
-        modified date from the meta data.
+        modified date from the metadata.
 
         Args:
             vector_storage_instance (BaseVectorStorage): The vector storage
-                where modified date is to be retrieved from meta data.
+                where modified date is to be retrieved from metadata.
 
         Returns:
             str: The last modified date from vector storage.

camel/retrievers/bm25_retriever.py

@@ -17,6 +17,7 @@ import numpy as np
 
 from camel.loaders import UnstructuredIO
 from camel.retrievers import BaseRetriever
+from camel.utils import dependencies_required
 
 DEFAULT_TOP_K_RESULTS = 1
 
@@ -40,16 +41,10 @@ class BM25Retriever(BaseRetriever):
         https://github.com/dorianbrown/rank_bm25
     """
 
+    @dependencies_required('rank_bm25')
     def __init__(self) -> None:
         r"""Initializes the BM25Retriever."""
-
-        try:
-            from rank_bm25 import BM25Okapi
-        except ImportError as e:
-            raise ImportError(
-                "Package `rank_bm25` not installed, install by running 'pip "
-                "install rank_bm25'"
-            ) from e
+        from rank_bm25 import BM25Okapi
 
         self.bm25: BM25Okapi = None
         self.content_input_path: str = ""

camel/retrievers/cohere_rerank_retriever.py

@@ -15,6 +15,7 @@ import os
 from typing import Any, Dict, List, Optional
 
 from camel.retrievers import BaseRetriever
+from camel.utils import dependencies_required
 
 DEFAULT_TOP_K_RESULTS = 1
 
@@ -32,6 +33,7 @@ class CohereRerankRetriever(BaseRetriever):
         https://txt.cohere.com/rerank/
     """
 
+    @dependencies_required('cohere')
     def __init__(
         self,
         model_name: str = "rerank-multilingual-v2.0",
@@ -56,11 +58,7 @@ class CohereRerankRetriever(BaseRetriever):
             ValueError: If the API key is neither passed as an argument nor
                 set in the environment variable.
         """
-
-        try:
-            import cohere
-        except ImportError as e:
-            raise ImportError("Package 'cohere' is not installed") from e
+        import cohere
 
         try:
             self.api_key = api_key or os.environ["COHERE_API_KEY"]

camel/storages/__init__.py

@@ -17,6 +17,7 @@ from .graph_storages.neo4j_graph import Neo4jGraph
 from .key_value_storages.base import BaseKeyValueStorage
 from .key_value_storages.in_memory import InMemoryKeyValueStorage
 from .key_value_storages.json import JsonStorage
+from .key_value_storages.redis import RedisStorage
 from .vectordb_storages.base import (
     BaseVectorStorage,
     VectorDBQuery,
@@ -30,6 +31,7 @@ __all__ = [
     'BaseKeyValueStorage',
     'InMemoryKeyValueStorage',
     'JsonStorage',
+    'RedisStorage',
     'VectorRecord',
     'BaseVectorStorage',
     'VectorDBQuery',

camel/storages/graph_storages/graph_element.py

@@ -16,7 +16,10 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import List, Union
 
-from unstructured.documents.elements import Element
+try:
+    from unstructured.documents.elements import Element
+except ImportError:
+    Element = None
 
 
 @dataclass
@@ -72,3 +75,8 @@ class GraphElement:
     nodes: List[Node]
     relationships: List[Relationship]
     source: Element
+
+    def __post_init__(self):
+        if Element is None:
+            raise ImportError("""The 'unstructured' package is required to use
+                              the 'source' attribute.""")

camel/storages/graph_storages/neo4j_graph.py

@@ -16,6 +16,7 @@ from hashlib import md5
 from typing import Any, Dict, List, Optional
 
 from camel.storages.graph_storages import BaseGraphStorage, GraphElement
+from camel.utils import dependencies_required
 
 logger = logging.getLogger(__name__)
 
@@ -81,6 +82,7 @@ class Neo4jGraph(BaseGraphStorage):
             than `LIST_LIMIT` elements from results. Defaults to `False`.
     """
 
+    @dependencies_required('neo4j')
     def __init__(
         self,
         url: str,
@@ -91,13 +93,7 @@ class Neo4jGraph(BaseGraphStorage):
         truncate: bool = False,
     ) -> None:
         r"""Create a new Neo4j graph instance."""
-        try:
-            import neo4j
-        except ImportError:
-            raise ValueError(
-                "Could not import neo4j python package. "
-                "Please install it with `pip install neo4j`."
-            )
+        import neo4j
 
         self.driver = neo4j.GraphDatabase.driver(
             url, auth=(username, password)

camel/storages/key_value_storages/__init__.py

@@ -15,9 +15,11 @@
 from .base import BaseKeyValueStorage
 from .in_memory import InMemoryKeyValueStorage
 from .json import JsonStorage
+from .redis import RedisStorage
 
 __all__ = [
     'BaseKeyValueStorage',
     'InMemoryKeyValueStorage',
     'JsonStorage',
+    'RedisStorage',
 ]

camel/storages/key_value_storages/redis.py

@@ -0,0 +1,169 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# 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 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+import asyncio
+import json
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from camel.storages.key_value_storages import BaseKeyValueStorage
+
+if TYPE_CHECKING:
+    from redis.asyncio import Redis
+
+logger = logging.getLogger(__name__)
+
+
+class RedisStorage(BaseKeyValueStorage):
+    r"""A concrete implementation of the :obj:`BaseCacheStorage` using Redis as
+    the backend. This is suitable for distributed cache systems that require
+    persistence and high availability.
+    """
+
+    def __init__(
+        self,
+        sid: str,
+        url: str = "redis://localhost:6379",
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        **kwargs,
+    ) -> None:
+        r"""Initializes the RedisStorage instance with the provided URL and
+        options.
+
+        Args:
+            sid (str): The ID for the storage instance to identify the
+                       record space.
+            url (str): The URL for connecting to the Redis server.
+            **kwargs: Additional keyword arguments for Redis client
+                      configuration.
+
+        Raises:
+            ImportError: If the `redis.asyncio` module is not installed.
+        """
+        try:
+            import redis.asyncio as aredis
+        except ImportError as exc:
+            logger.error(
+                "Please install `redis` first. You can install it by "
+                "running `pip install redis`."
+            )
+            raise exc
+
+        self._client: Optional[aredis.Redis] = None
+        self._url = url
+        self._sid = sid
+        self._loop = loop or asyncio.get_event_loop()
+
+        self._create_client(**kwargs)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self._run_async(self.close())
+
+    async def close(self) -> None:
+        r"""Closes the Redis client asynchronously."""
+        if self._client:
+            await self._client.close()
+
+    def _create_client(self, **kwargs) -> None:
+        r"""Creates the Redis client with the provided URL and options.
+
+        Args:
+            **kwargs: Additional keyword arguments for Redis client
+                      configuration.
+        """
+        import redis.asyncio as aredis
+
+        self._client = aredis.from_url(self._url, **kwargs)
+
+    @property
+    def client(self) -> Optional["Redis"]:
+        r"""Returns the Redis client instance.
+
+        Returns:
+            redis.asyncio.Redis: The Redis client instance.
+        """
+        return self._client
+
+    def save(
+        self, records: List[Dict[str, Any]], expire: Optional[int] = None
+    ) -> None:
+        r"""Saves a batch of records to the key-value storage system."""
+        try:
+            self._run_async(self._async_save(records, expire))
+        except Exception as e:
+            logger.error(f"Error in save: {e}")
+
+    def load(self) -> List[Dict[str, Any]]:
+        r"""Loads all stored records from the key-value storage system.
+
+        Returns:
+            List[Dict[str, Any]]: A list of dictionaries, where each dictionary
+                represents a stored record.
+        """
+        try:
+            return self._run_async(self._async_load())
+        except Exception as e:
+            logger.error(f"Error in load: {e}")
+            return []
+
+    def clear(self) -> None:
+        r"""Removes all records from the key-value storage system."""
+        try:
+            self._run_async(self._async_clear())
+        except Exception as e:
+            logger.error(f"Error in clear: {e}")
+
+    async def _async_save(
+        self, records: List[Dict[str, Any]], expire: Optional[int] = None
+    ) -> None:
+        if self._client is None:
+            raise ValueError("Redis client is not initialized")
+        try:
+            value = json.dumps(records)
+            if expire:
+                await self._client.setex(self._sid, expire, value)
+            else:
+                await self._client.set(self._sid, value)
+        except Exception as e:
+            logger.error(f"Error saving records: {e}")
+
+    async def _async_load(self) -> List[Dict[str, Any]]:
+        if self._client is None:
+            raise ValueError("Redis client is not initialized")
+        try:
+            value = await self._client.get(self._sid)
+            if value:
+                return json.loads(value)
+            return []
+        except Exception as e:
+            logger.error(f"Error loading records: {e}")
+            return []
+
+    async def _async_clear(self) -> None:
+        if self._client is None:
+            raise ValueError("Redis client is not initialized")
+        try:
+            await self._client.delete(self._sid)
+        except Exception as e:
+            logger.error(f"Error clearing records: {e}")
+
+    def _run_async(self, coro):
+        if not self._loop.is_running():
+            return self._loop.run_until_complete(coro)
+        else:
+            future = asyncio.run_coroutine_threadsafe(coro, self._loop)
+            return future.result()

camel/storages/vectordb_storages/milvus.py

@@ -23,6 +23,7 @@ from camel.storages.vectordb_storages import (
     VectorDBStatus,
     VectorRecord,
 )
+from camel.utils import dependencies_required
 
 logger = logging.getLogger(__name__)
 
@@ -52,6 +53,7 @@ class MilvusStorage(BaseVectorStorage):
         ImportError: If `pymilvus` package is not installed.
     """
 
+    @dependencies_required('pymilvus')
     def __init__(
         self,
         vector_dim: int,
@@ -59,13 +61,7 @@ class MilvusStorage(BaseVectorStorage):
         collection_name: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
-        try:
-            from pymilvus import MilvusClient
-        except ImportError as exc:
-            raise ImportError(
-                "Please install `pymilvus` first. You can install it by "
-                "running `pip install pymilvus`."
-            ) from exc
+        from pymilvus import MilvusClient
 
         self._client: MilvusClient
         self._create_client(url_and_api_key, **kwargs)

camel/storages/vectordb_storages/qdrant.py

@@ -23,6 +23,7 @@ from camel.storages.vectordb_storages import (
     VectorRecord,
 )
 from camel.types import VectorDistance
+from camel.utils import dependencies_required
 
 _qdrant_local_client_map: Dict[str, Tuple[Any, int]] = {}
 
@@ -62,6 +63,7 @@ class QdrantStorage(BaseVectorStorage):
           be initialized with an in-memory storage (`":memory:"`).
     """
 
+    @dependencies_required('qdrant_client')
     def __init__(
         self,
         vector_dim: int,
@@ -72,13 +74,7 @@ class QdrantStorage(BaseVectorStorage):
         delete_collection_on_del: bool = False,
         **kwargs: Any,
     ) -> None:
-        try:
-            from qdrant_client import QdrantClient
-        except ImportError as exc:
-            raise ImportError(
-                "Please install `qdrant-client` first. You can install it by "
-                "running `pip install qdrant-client`."
-            ) from exc
+        from qdrant_client import QdrantClient
 
         self._client: QdrantClient
         self._local_path: Optional[str] = None

camel/toolkits/__init__.py

@@ -13,9 +13,11 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .base import BaseToolkit
+from .code_execution import CodeExecutionToolkit
 from .github_toolkit import GithubToolkit
 
 __all__ = [
     'BaseToolkit',
     'GithubToolkit',
+    'CodeExecutionToolkit',
 ]

camel/toolkits/code_execution.py

@@ -0,0 +1,69 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# 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 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+from typing import List, Literal
+
+from camel.functions import OpenAIFunction
+from camel.interpreters import InternalPythonInterpreter
+
+from .base import BaseToolkit
+
+
+class CodeExecutionToolkit(BaseToolkit):
+    r"""A tookit for code execution.
+
+    Args:
+        sandbox (str): the environment type used to execute code.
+    """
+
+    def __init__(
+        self,
+        sandbox: Literal[
+            "internal_python", "jupyter", "docker"
+        ] = "internal_python",
+        verbose: bool = False,
+    ) -> None:
+        # TODO: Add support for docker and jupyter.
+        self.verbose = verbose
+        if sandbox == "internal_python":
+            self.interpreter = InternalPythonInterpreter()
+        else:
+            raise RuntimeError(
+                f"The sandbox type `{sandbox}` is not supported."
+            )
+
+    def execute_code(self, code: str) -> str:
+        r"""Execute a given code snippet.
+
+        Args:
+            code (str): The input code to the Code Interpreter tool call.
+
+        Returns:
+            str: The text output from the Code Interpreter tool call.
+        """
+        output = self.interpreter.run(code, "python")
+        # ruff: noqa: E501
+        content = f"Executed the code below:\n```py\n{code}\n```\n> Executed Results:\n{output}"
+        if self.verbose:
+            print(content)
+        return content
+
+    def get_tools(self) -> List[OpenAIFunction]:
+        r"""Returns a list of OpenAIFunction objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[OpenAIFunction]: A list of OpenAIFunction objects
+                representing the functions in the toolkit.
+        """
+        return [OpenAIFunction(self.execute_code)]