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

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)]

camel/toolkits/github_toolkit.py

@@ -18,8 +18,8 @@ from datetime import datetime, timedelta
 from typing import List, Optional
 
 from camel.functions import OpenAIFunction
-
-from .base import BaseToolkit
+from camel.toolkits.base import BaseToolkit
+from camel.utils import dependencies_required
 
 
 @dataclass
@@ -130,6 +130,7 @@ class GithubToolkit(BaseToolkit):
             `get_github_access_token` method.
     """
 
+    @dependencies_required('github')
     def __init__(
         self, repo_name: str, access_token: Optional[str] = None
     ) -> None:
@@ -144,13 +145,8 @@ class GithubToolkit(BaseToolkit):
         if access_token is None:
             access_token = self.get_github_access_token()
 
-        try:
-            from github import Auth, Github
-        except ImportError:
-            raise ImportError(
-                "Please install `github` first. You can install it by running "
-                "`pip install pygithub`."
-            )
+        from github import Auth, Github
+
         self.github = Github(auth=Auth.Token(access_token))
         self.repo = self.github.get_repo(repo_name)
 

camel/types/enums.py

@@ -30,15 +30,19 @@ class ModelType(Enum):
     GPT_4_TURBO = "gpt-4-turbo"
     GPT_4O = "gpt-4o"
     GLM_4 = "glm-4"
+    GLM_4_OPEN_SOURCE = "glm-4-open-source"
     GLM_4V = 'glm-4v'
     GLM_3_TURBO = "glm-3-turbo"
 
     STUB = "stub"
 
     LLAMA_2 = "llama-2"
+    LLAMA_3 = "llama-3"
     VICUNA = "vicuna"
     VICUNA_16K = "vicuna-16k"
 
+    QWEN_2 = "qwen-2"
+
     # Legacy anthropic models
     # NOTE: anthropic lagecy models only Claude 2.1 has system prompt support
     CLAUDE_2_1 = "claude-2.1"
@@ -87,6 +91,9 @@ class ModelType(Enum):
         r"""Returns whether this type of models is open-source."""
         return self in {
             ModelType.LLAMA_2,
+            ModelType.LLAMA_3,
+            ModelType.QWEN_2,
+            ModelType.GLM_4_OPEN_SOURCE,
             ModelType.VICUNA,
             ModelType.VICUNA_16K,
         }
@@ -135,7 +142,7 @@ class ModelType(Enum):
             return 128000
         elif self is ModelType.GPT_4O:
             return 128000
-        elif self == ModelType.GLM_4:
+        elif self == ModelType.GLM_4_OPEN_SOURCE:
             return 8192
         elif self == ModelType.GLM_3_TURBO:
             return 8192
@@ -145,6 +152,12 @@ class ModelType(Enum):
             return 4096
         elif self is ModelType.LLAMA_2:
             return 4096
+        elif self is ModelType.LLAMA_3:
+            return 8192
+        elif self is ModelType.QWEN_2:
+            return 128000
+        elif self is ModelType.GLM_4:
+            return 8192
         elif self is ModelType.VICUNA:
             # reference: https://lmsys.org/blog/2023-03-30-vicuna/
             return 2048
@@ -184,6 +197,20 @@ class ModelType(Enum):
                 self.value in model_name.lower()
                 or "llama2" in model_name.lower()
             )
+        elif self is ModelType.LLAMA_3:
+            return (
+                self.value in model_name.lower()
+                or "llama3" in model_name.lower()
+            )
+        elif self is ModelType.QWEN_2:
+            return (
+                self.value in model_name.lower()
+                or "qwen2" in model_name.lower()
+            )
+        elif self is ModelType.GLM_4_OPEN_SOURCE:
+            return (
+                'glm-4' in model_name.lower() or "glm4" in model_name.lower()
+            )
         else:
             return self.value in model_name.lower()
 
@@ -374,3 +401,10 @@ class VoiceType(Enum):
             VoiceType.NOVA,
             VoiceType.SHIMMER,
         }
+
+
+class JinaReturnFormat(Enum):
+    DEFAULT = None
+    MARKDOWN = "markdown"
+    HTML = "html"
+    TEXT = "text"

camel/utils/__init__.py

@@ -23,7 +23,7 @@ from .commons import (
     get_prompt_template_key_words,
     get_system_information,
     get_task_list,
-    model_api_key_required,
+    is_docker_running,
     print_text_animated,
     text_extract_from_web,
     to_pascal,
@@ -39,7 +39,6 @@ from .token_counting import (
 )
 
 __all__ = [
-    'model_api_key_required',
     'print_text_animated',
     'get_prompt_template_key_words',
     'get_first_int',
@@ -60,4 +59,5 @@ __all__ = [
     'create_chunks',
     'dependencies_required',
     'api_keys_required',
+    'is_docker_running',
 ]

camel/utils/async_func.py

@@ -0,0 +1,42 @@
+# =========== 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
+from copy import deepcopy
+
+from camel.functions.openai_function import OpenAIFunction
+
+
+def sync_funcs_to_async(funcs: list[OpenAIFunction]) -> list[OpenAIFunction]:
+    r"""Convert a list of Python synchronous functions to Python
+    asynchronous functions.
+
+    Args:
+        funcs (list[OpenAIFunction]): List of Python synchronous
+            functions in the :obj:`OpenAIFunction` format.
+
+    Returns:
+        list[OpenAIFunction]: List of Python asynchronous functions
+            in the :obj:`OpenAIFunction` format.
+    """
+    async_funcs = []
+    for func in funcs:
+        sync_func = func.func
+
+        def async_callable(*args, **kwargs):
+            return asyncio.to_thread(sync_func, *args, **kwargs)  # noqa: B023
+
+        async_funcs.append(
+            OpenAIFunction(async_callable, deepcopy(func.openai_tool_schema))
+        )
+    return async_funcs

camel/utils/commons.py

@@ -16,6 +16,7 @@ import os
 import platform
 import re
 import socket
+import subprocess
 import time
 import zipfile
 from functools import wraps
@@ -30,48 +31,6 @@ from camel.types import TaskType
 F = TypeVar('F', bound=Callable[..., Any])
 
 
-def model_api_key_required(func: F) -> F:
-    r"""Decorator that checks if the API key is available either as an
-    environment variable or passed directly for a model.
-
-    Args:
-        func (callable): The function to be wrapped.
-
-    Returns:
-        callable: The decorated function.
-
-    Raises:
-        ValueError: If the API key is not found, either as an environment
-            variable or directly passed.
-
-    Note:
-        Supported model type: `OpenAI` and `Anthropic`.
-    """
-
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        if self.model_type.is_openai:
-            if not self._api_key and 'OPENAI_API_KEY' not in os.environ:
-                raise ValueError('OpenAI API key not found.')
-            return func(self, *args, **kwargs)
-        elif self.model_type.is_zhipuai:
-            if 'ZHIPUAI_API_KEY' not in os.environ:
-                raise ValueError('ZhiPuAI API key not found.')
-            return func(self, *args, **kwargs)
-        elif self.model_type.is_anthropic:
-            if not self._api_key and 'ANTHROPIC_API_KEY' not in os.environ:
-                raise ValueError('Anthropic API key not found.')
-            return func(self, *args, **kwargs)
-        elif self.model_type.is_nvidia:
-            if not self._api_key and 'NVIDIA_API_KEY' not in os.environ:
-                raise ValueError('NVIDIA API key not found.')
-            return func(self, *args, **kwargs)
-        else:
-            raise ValueError('Unsupported model type.')
-
-    return cast(F, wrapper)
-
-
 def print_text_animated(text, delay: float = 0.02, end: str = ""):
     r"""Prints the given text with an animated effect.
 
@@ -260,7 +219,7 @@ def is_module_available(module_name: str) -> bool:
 
 def api_keys_required(*required_keys: str) -> Callable[[F], F]:
     r"""A decorator to check if the required API keys are
-    present in the environment variables.
+    presented in the environment variables or as an instance attribute.
 
     Args:
         required_keys (str): The required API keys to be checked.
@@ -271,7 +230,7 @@ def api_keys_required(*required_keys: str) -> Callable[[F], F]:
 
     Raises:
         ValueError: If any of the required API keys are missing in the
-            environment variables.
+            environment variables and the instance attribute.
 
     Example:
         ::
@@ -283,13 +242,18 @@ def api_keys_required(*required_keys: str) -> Callable[[F], F]:
 
     def decorator(func: F) -> F:
         @wraps(func)
-        def wrapper(*args: Any, **kwargs: Any) -> Any:
-            missing_keys = [k for k in required_keys if k not in os.environ]
-            if missing_keys:
+        def wrapper(self, *args: Any, **kwargs: Any) -> Any:
+            missing_environment_keys = [
+                k for k in required_keys if k not in os.environ
+            ]
+            if (
+                not getattr(self, '_api_key', None)
+                and missing_environment_keys
+            ):
                 raise ValueError(
-                    f"Missing API keys: {', '.join(missing_keys)}"
+                    f"Missing API keys: {', '.join(missing_environment_keys)}"
                 )
-            return func(*args, **kwargs)
+            return func(self, *args, **kwargs)
 
         return cast(F, wrapper)
 
@@ -400,3 +364,21 @@ def create_chunks(text: str, n: int) -> List[str]:
         chunks.append(text[i:j])
         i = j
     return chunks
+
+
+def is_docker_running() -> bool:
+    r"""Check if the Docker daemon is running.
+
+    Returns:
+        bool: True if the Docker daemon is running, False otherwise.
+    """
+    try:
+        result = subprocess.run(
+            ["docker", "info"],
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        return result.returncode == 0
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False