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

camel/__init__.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
-__version__ = '0.1.5'
+__version__ = '0.1.5.6'
 
 __all__ = [
     '__version__',

camel/agents/knowledge_graph_agent.py

@@ -78,17 +78,16 @@ Expected Output:
 
 Nodes:
 
-Node(id='John', type='Person', properties={'agent_generated'})
-Node(id='XYZ Corporation', type='Organization', properties={'agent_generated'})
-Node(id='New York City', type='Location', properties={'agent_generated'})
+Node(id='John', type='Person')
+Node(id='XYZ Corporation', type='Organization')
+Node(id='New York City', type='Location')
 
 Relationships:
 
 Relationship(subj=Node(id='John', type='Person'), obj=Node(id='XYZ 
-Corporation', type='Organization'), type='WorksAt', properties=
-{'agent_generated'})
+Corporation', type='Organization'), type='WorksAt')
 Relationship(subj=Node(id='John', type='Person'), obj=Node(id='New York City', 
-type='Location'), type='ResidesIn', properties={'agent_generated'})
+type='Location'), type='ResidesIn')
 
 ===== TASK =====
 Please extracts nodes and relationships from given content and structures them 
@@ -211,11 +210,10 @@ class KnowledgeGraphAgent(ChatAgent):
         import re
 
         # Regular expressions to extract nodes and relationships
-        node_pattern = r"Node\(id='(.*?)', type='(.*?)', properties=(.*?)\)"
+        node_pattern = r"Node\(id='(.*?)', type='(.*?)'\)"
         rel_pattern = (
             r"Relationship\(subj=Node\(id='(.*?)', type='(.*?)'\), "
-            r"obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)', "
-            r"properties=\{(.*?)\}\)"
+            r"obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)'\)"
         )
 
         nodes = {}
@@ -223,8 +221,8 @@ class KnowledgeGraphAgent(ChatAgent):
 
         # Extract nodes
         for match in re.finditer(node_pattern, input_string):
-            id, type, properties = match.groups()
-            properties = eval(properties)
+            id, type = match.groups()
+            properties = {'source': 'agent_created'}
             if id not in nodes:
                 node = Node(id, type, properties)
                 if self._validate_node(node):
@@ -232,10 +230,8 @@ class KnowledgeGraphAgent(ChatAgent):
 
         # Extract relationships
         for match in re.finditer(rel_pattern, input_string):
-            subj_id, subj_type, obj_id, obj_type, rel_type, properties_str = (
-                match.groups()
-            )
-            properties = eval(properties_str)
+            subj_id, subj_type, obj_id, obj_type, rel_type = match.groups()
+            properties = {'source': 'agent_created'}
             if subj_id in nodes and obj_id in nodes:
                 subj = nodes[subj_id]
                 obj = nodes[obj_id]

camel/agents/task_agent.py

@@ -100,7 +100,6 @@ class TaskSpecifyAgent(ChatAgent):
 
         if meta_dict is not None:
             task_specify_prompt = task_specify_prompt.format(**meta_dict)
-
         task_msg = BaseMessage.make_user_message(
             role_name="Task Specifier", content=task_specify_prompt
         )

camel/configs/__init__.py

@@ -13,12 +13,18 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
+from .gemini_config import (
+    Gemini_API_PARAMS,
+    GeminiConfig,
+)
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
+from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import (
     OPENAI_API_PARAMS,
     ChatGPTConfig,
     OpenSourceConfig,
 )
+from .zhipuai_config import ZHIPUAI_API_PARAMS, ZhipuAIConfig
 
 __all__ = [
     'BaseConfig',
@@ -29,4 +35,10 @@ __all__ = [
     'OpenSourceConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
+    'OllamaConfig',
+    'OLLAMA_API_PARAMS',
+    'ZhipuAIConfig',
+    'ZHIPUAI_API_PARAMS',
+    'GeminiConfig',
+    'Gemini_API_PARAMS',
 ]

camel/configs/gemini_config.py

@@ -0,0 +1,97 @@
+# =========== 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 collections.abc import Iterable
+from dataclasses import asdict, dataclass
+from typing import Optional
+
+from camel.configs.base_config import BaseConfig
+
+
+@dataclass(frozen=True)
+class GeminiConfig(BaseConfig):
+    r"""A simple dataclass used to configure the generation parameters of
+    `GenerativeModel.generate_content`.
+
+    Args:
+        candidate_count (int, optional): Number of responses to return.
+        stop_sequences (Iterable[str], optional): The set of character
+            sequences (up to 5) that will stop output generation. If specified
+            the API will stop at the first appearance of a stop sequence.
+            The stop sequence will not be included as part of the response.
+        max_output_tokens (int, optional): The maximum number of tokens to
+            include in a candidate. If unset, this will default to
+            output_token_limit specified in the model's specification.
+        temperature (float, optional): Controls the randomness of the output.
+            Note: The default value varies by model, see the
+            `Model.temperature` attribute of the `Model` returned
+            the `genai.get_model` function. Values can range from [0.0,1.0],
+            inclusive. A value closer to 1.0 will produce responses that are
+            more varied and creative, while a value closer to 0.0 will
+            typically result in more straightforward responses from the model.
+        top_p (int, optional): The maximum cumulative probability of tokens to
+            consider when sampling. The model uses combined Top-k and nucleus
+            sampling. Tokens are sorted based on their assigned probabilities
+            so that only the most likely tokens are considered. Top-k sampling
+            directly limits the maximum number of tokens to consider, while
+            Nucleus sampling limits number of tokens
+            based on the cumulative probability. Note: The default value varies
+            by model, see the `Model.top_p` attribute of the `Model` returned
+            the `genai.get_model` function.
+        top_k (int, optional): The maximum number of tokens to consider when
+            sampling. The model uses combined Top-k and nucleus sampling.Top-k
+            sampling considers the set of `top_k` most probable tokens.
+            Defaults to 40. Note: The default value varies by model, see the
+            `Model.top_k` attribute of the `Model` returned the
+            `genai.get_model` function.
+        response_mime_type (str, optional): Output response mimetype of the
+            generated candidate text. Supported mimetype:
+            `text/plain`: (default) Text output.
+            `application/json`: JSON response in the candidates.
+        response_schema (Schema, optional): Specifies the format of the
+            JSON requested if response_mime_type is `application/json`.
+        safety_settings (SafetySettingOptions, optional):
+            Overrides for the model's safety settings.
+        tools (FunctionLibraryType, optional):
+            `protos.Tools` more info coming soon.
+        tool_config (ToolConfigType, optional):
+            more info coming soon.
+        request_options (RequestOptionsType, optional):
+            Options for the request.
+    """
+
+    from google.generativeai.protos import Schema
+    from google.generativeai.types.content_types import (
+        FunctionLibraryType,
+        ToolConfigType,
+    )
+    from google.generativeai.types.helper_types import RequestOptionsType
+    from google.generativeai.types.safety_types import SafetySettingOptions
+
+    candidate_count: Optional[int] = None
+    stop_sequences: Optional[Iterable[str]] = None
+    max_output_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    response_mime_type: Optional[str] = None
+    response_schema: Optional[Schema] = None
+    safety_settings: Optional[SafetySettingOptions] = None
+    tools: Optional[FunctionLibraryType] = None
+    tool_config: Optional[ToolConfigType] = None
+    request_options: Optional[RequestOptionsType] = None
+
+
+Gemini_API_PARAMS = {param for param in asdict(GeminiConfig()).keys()}

camel/configs/litellm_config.py

@@ -13,11 +13,14 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass, field
-from typing import List, Optional, Union
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, List, Optional, Union
 
 from camel.configs.base_config import BaseConfig
 
+if TYPE_CHECKING:
+    from camel.functions import OpenAIFunction
+
 
 @dataclass(frozen=True)
 class LiteLLMConfig(BaseConfig):
@@ -25,9 +28,6 @@ class LiteLLMConfig(BaseConfig):
     LiteLLM API.
 
     Args:
-        model (str): The name of the language model to use for text completion.
-        messages (List): A list of message objects representing the
-            conversation context. (default: [])
         timeout (Optional[Union[float, str]], optional): Request timeout.
             (default: None)
         temperature (Optional[float], optional): Temperature parameter for
@@ -65,12 +65,7 @@ class LiteLLMConfig(BaseConfig):
         deployment_id (Optional[str], optional): Deployment ID. (default: None)
         extra_headers (Optional[dict], optional): Additional headers for the
             request. (default: None)
-        base_url (Optional[str], optional): Base URL for the API. (default:
-            None)
         api_version (Optional[str], optional): API version. (default: None)
-        api_key (Optional[str], optional): API key. (default: None)
-        model_list (Optional[list], optional): List of API base, version,
-            keys. (default: None)
         mock_response (Optional[str], optional): Mock completion response for
             testing or debugging. (default: None)
         custom_llm_provider (Optional[str], optional): Non-OpenAI LLM
@@ -79,8 +74,6 @@ class LiteLLMConfig(BaseConfig):
             (default: None)
     """
 
-    model: str = "gpt-3.5-turbo"
-    messages: List = field(default_factory=list)
     timeout: Optional[Union[float, str]] = None
     temperature: Optional[float] = None
     top_p: Optional[float] = None
@@ -91,20 +84,17 @@ class LiteLLMConfig(BaseConfig):
     max_tokens: Optional[int] = None
     presence_penalty: Optional[float] = None
     frequency_penalty: Optional[float] = None
-    logit_bias: Optional[dict] = field(default_factory=dict)
+    logit_bias: Optional[dict] = None
     user: Optional[str] = None
     response_format: Optional[dict] = None
     seed: Optional[int] = None
-    tools: Optional[List] = field(default_factory=list)
+    tools: Optional[list[OpenAIFunction]] = None
     tool_choice: Optional[Union[str, dict]] = None
     logprobs: Optional[bool] = None
     top_logprobs: Optional[int] = None
     deployment_id: Optional[str] = None
-    extra_headers: Optional[dict] = field(default_factory=dict)
-    base_url: Optional[str] = None
+    extra_headers: Optional[dict] = None
     api_version: Optional[str] = None
-    api_key: Optional[str] = None
-    model_list: Optional[list] = field(default_factory=list)
     mock_response: Optional[str] = None
     custom_llm_provider: Optional[str] = None
     max_retries: Optional[int] = None

camel/configs/ollama_config.py

@@ -0,0 +1,85 @@
+# =========== 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 __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Sequence
+
+from openai._types import NOT_GIVEN, NotGiven
+
+from camel.configs.base_config import BaseConfig
+
+
+@dataclass(frozen=True)
+class OllamaConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility
+
+    Reference: https://github.com/ollama/ollama/blob/main/docs/openai.md
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.2`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`1.0`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Compatible with GPT-4 Turbo and all
+            GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length.
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`0.0`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`0.0`)
+    """
+
+    temperature: float = 0.2
+    top_p: float = 1.0
+    stream: bool = False
+    stop: str | Sequence[str] | NotGiven = NOT_GIVEN
+    max_tokens: int | NotGiven = NOT_GIVEN
+    presence_penalty: float = 0.0
+    response_format: dict | NotGiven = NOT_GIVEN
+    frequency_penalty: float = 0.0
+
+
+OLLAMA_API_PARAMS = {param for param in asdict(OllamaConfig()).keys()}

camel/configs/zhipuai_config.py

@@ -0,0 +1,78 @@
+# =========== 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 __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, Optional, Sequence
+
+from openai._types import NOT_GIVEN, NotGiven
+
+from camel.configs.base_config import BaseConfig
+
+if TYPE_CHECKING:
+    from camel.functions import OpenAIFunction
+
+
+@dataclass(frozen=True)
+class ZhipuAIConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility
+
+    Reference: https://open.bigmodel.cn/dev/api#glm-4v
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.2`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`0.6`)
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        tools (list[OpenAIFunction], optional): A list of tools the model may
+            call. Currently, only functions are supported as a tool. Use this
+            to provide a list of functions the model may generate JSON inputs
+            for. A max of 128 functions are supported.
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
+    """
+
+    temperature: float = 0.2
+    top_p: float = 0.6
+    stream: bool = False
+    stop: str | Sequence[str] | NotGiven = NOT_GIVEN
+    max_tokens: int | NotGiven = NOT_GIVEN
+    tools: Optional[list[OpenAIFunction]] = None
+    tool_choice: Optional[dict[str, str] | str] = None
+
+
+ZHIPUAI_API_PARAMS = {param for param in asdict(ZhipuAIConfig()).keys()}

camel/embeddings/openai_embedding.py

@@ -20,7 +20,7 @@ from openai import NOT_GIVEN, NotGiven, OpenAI
 
 from camel.embeddings.base import BaseEmbedding
 from camel.types import EmbeddingModelType
-from camel.utils import model_api_key_required
+from camel.utils import api_keys_required
 
 
 class OpenAIEmbedding(BaseEmbedding[str]):
@@ -58,7 +58,7 @@ class OpenAIEmbedding(BaseEmbedding[str]):
         self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
         self.client = OpenAI(timeout=60, max_retries=3, api_key=self._api_key)
 
-    @model_api_key_required
+    @api_keys_required("OPENAI_API_KEY")
     def embed_list(
         self,
         objs: list[str],

camel/functions/search_functions.py

@@ -15,8 +15,10 @@ import os
 from typing import Any, Dict, List
 
 from camel.functions.openai_function import OpenAIFunction
+from camel.utils import dependencies_required
 
 
+@dependencies_required('wikipedia')
 def search_wiki(entity: str) -> str:
     r"""Search the entity in WikiPedia and return the summary of the required
         page, containing factual information about the given entity.
@@ -28,13 +30,7 @@ def search_wiki(entity: str) -> str:
         str: The search result. If the page corresponding to the entity
             exists, return the summary of this entity in a string.
     """
-    try:
-        import wikipedia
-    except ImportError:
-        raise ImportError(
-            "Please install `wikipedia` first. You can install it by running "
-            "`pip install wikipedia`."
-        )
+    import wikipedia
 
     result: str
 
@@ -241,6 +237,7 @@ def search_google(
     return responses
 
 
+@dependencies_required('wolframalpha')
 def query_wolfram_alpha(query: str, is_detailed: bool) -> str:
     r"""Queries Wolfram|Alpha and returns the result. Wolfram|Alpha is an
     answer engine developed by Wolfram Research. It is offered as an online
@@ -255,13 +252,7 @@ def query_wolfram_alpha(query: str, is_detailed: bool) -> str:
     Returns:
         str: The result from Wolfram Alpha, formatted as a string.
     """
-    try:
-        import wolframalpha
-    except ImportError:
-        raise ImportError(
-            "Please install `wolframalpha` first. You can install it by"
-            " running `pip install wolframalpha`."
-        )
+    import wolframalpha
 
     WOLFRAMALPHA_APP_ID = os.environ.get('WOLFRAMALPHA_APP_ID')
     if not WOLFRAMALPHA_APP_ID:

camel/functions/slack_functions.py

@@ -19,6 +19,8 @@ import logging
 import os
 from typing import TYPE_CHECKING, List, Optional
 
+from camel.utils import dependencies_required
+
 if TYPE_CHECKING:
     from ssl import SSLContext
 
@@ -29,6 +31,7 @@ from camel.functions import OpenAIFunction
 logger = logging.getLogger(__name__)
 
 
+@dependencies_required('slack_sdk')
 def _login_slack(
     slack_token: Optional[str] = None,
     ssl: Optional[SSLContext] = None,
@@ -50,13 +53,8 @@ def _login_slack(
         KeyError: If SLACK_BOT_TOKEN or SLACK_USER_TOKEN environment variables
             are not set.
     """
-    try:
-        from slack_sdk import WebClient
-    except ImportError as e:
-        raise ImportError(
-            "Cannot import slack_sdk. Please install the package with \
-            `pip install slack_sdk`."
-        ) from e
+    from slack_sdk import WebClient
+
     if not slack_token:
         slack_token = os.environ.get("SLACK_BOT_TOKEN") or os.environ.get(
             "SLACK_USER_TOKEN"

camel/functions/twitter_function.py

@@ -20,6 +20,7 @@ from typing import List, Optional, Tuple, Union
 import requests
 
 from camel.functions import OpenAIFunction
+from camel.utils import dependencies_required
 
 TWEET_TEXT_LIMIT = 280
 
@@ -55,6 +56,7 @@ def get_twitter_api_key() -> Tuple[str, str]:
     return TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET
 
 
+@dependencies_required('requests_oauthlib')
 def get_oauth_session() -> requests.Session:
     r'''Initiates an OAuth1Session with Twitter's API and returns it.
 
@@ -75,14 +77,7 @@ def get_oauth_session() -> requests.Session:
         https://github.com/twitterdev/Twitter-API-v2-sample-code/blob/main/Manage-Tweets/create_tweet.py
         https://github.com/twitterdev/Twitter-API-v2-sample-code/blob/main/User-Lookup/get_users_me_user_context.py
     '''
-    try:
-        from requests_oauthlib import OAuth1Session
-    except ImportError:
-        raise ImportError(
-            "Please install `requests_oauthlib` first. You can "
-            "install it by running `pip install "
-            "requests_oauthlib`."
-        )
+    from requests_oauthlib import OAuth1Session
 
     consumer_key, consumer_secret = get_twitter_api_key()
 

camel/functions/weather_functions.py

@@ -15,6 +15,7 @@ import os
 from typing import List, Literal
 
 from camel.functions.openai_function import OpenAIFunction
+from camel.utils import dependencies_required
 
 
 def get_openweathermap_api_key() -> str:
@@ -37,6 +38,7 @@ def get_openweathermap_api_key() -> str:
     return OPENWEATHERMAP_API_KEY
 
 
+@dependencies_required('pyowm')
 def get_weather_data(
     city: str,
     temp_units: Literal['kelvin', 'celsius', 'fahrenheit'] = 'kelvin',
@@ -85,14 +87,7 @@ def get_weather_data(
     """
     # NOTE: This tool may not work as expected since the input arguments like
     # `time_units` should be enum types which are not supported yet.
-
-    try:
-        import pyowm
-    except ImportError:
-        raise ImportError(
-            "Please install `pyowm` first. You can install it by running "
-            "`pip install pyowm`."
-        )
+    import pyowm
 
     OPENWEATHERMAP_API_KEY = get_openweathermap_api_key()
     owm = pyowm.OWM(OPENWEATHERMAP_API_KEY)

camel/interpreters/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .base import BaseInterpreter
+from .docker_interpreter import DockerInterpreter
 from .internal_python_interpreter import InternalPythonInterpreter
 from .interpreter_error import InterpreterError
 from .subprocess_interpreter import SubprocessInterpreter
@@ -22,4 +23,5 @@ __all__ = [
     'InterpreterError',
     'InternalPythonInterpreter',
     'SubprocessInterpreter',
+    'DockerInterpreter',
 ]