camel-ai 0.1.5.3__py3-none-any.whl → 0.1.5.5__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.5'
 
 __all__ = [
     '__version__',

camel/agents/knowledge_graph_agent.py

@@ -13,7 +13,10 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from typing import Optional, Union
 
-from unstructured.documents.elements import Element
+try:
+    from unstructured.documents.elements import Element
+except ImportError:
+    Element = None
 
 from camel.agents import ChatAgent
 from camel.messages import BaseMessage

camel/configs/__init__.py

@@ -14,11 +14,13 @@
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
 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 +31,8 @@ __all__ = [
     'OpenSourceConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
+    'OllamaConfig',
+    'OLLAMA_API_PARAMS',
+    'ZhipuAIConfig',
+    'ZHIPUAI_API_PARAMS',
 ]

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/base.py

@@ -11,8 +11,10 @@
 # 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 abc import ABC, abstractmethod
-from typing import Any, Generic, List, TypeVar
+from typing import Any, Generic, TypeVar
 
 T = TypeVar('T')
 
@@ -23,19 +25,18 @@ class BaseEmbedding(ABC, Generic[T]):
     @abstractmethod
     def embed_list(
         self,
-        objs: List[T],
+        objs: list[T],
         **kwargs: Any,
-    ) -> List[List[float]]:
+    ) -> list[list[float]]:
         r"""Generates embeddings for the given texts.
 
         Args:
-            objs (List[T]): The objects for which to generate the embeddings.
+            objs (list[T]): The objects for which to generate the embeddings.
             **kwargs (Any): Extra kwargs passed to the embedding API.
 
         Returns:
-            List[List[float]]: A list that represents the
-            generated embedding as a list of floating-point numbers or a
-            numpy matrix with embeddings.
+            list[list[float]]: A list that represents the
+                generated embedding as a list of floating-point numbers.
         """
         pass
 
@@ -43,7 +44,7 @@ class BaseEmbedding(ABC, Generic[T]):
         self,
         obj: T,
         **kwargs: Any,
-    ) -> List[float]:
+    ) -> list[float]:
         r"""Generates an embedding for the given text.
 
         Args:
@@ -51,7 +52,7 @@ class BaseEmbedding(ABC, Generic[T]):
             **kwargs (Any): Extra kwargs passed to the embedding API.
 
         Returns:
-            List[float]: A list of floating-point numbers representing the
+            list[float]: A list of floating-point numbers representing the
                 generated embedding.
         """
         return self.embed_list([obj], **kwargs)[0]

camel/embeddings/openai_embedding.py

@@ -11,24 +11,29 @@
 # 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
+
 import os
-from typing import Any, List, Optional
+from typing import Any
 
-from openai import OpenAI
+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]):
     r"""Provides text embedding functionalities using OpenAI's models.
 
     Args:
-        model (OpenAiEmbeddingModel, optional): The model type to be used for
-            generating embeddings. (default: :obj:`ModelType.ADA_2`)
-        api_key (Optional[str]): The API key for authenticating with the
+        model_type (EmbeddingModelType, optional): The model type to be
+            used for text embeddings.
+            (default: :obj:`TEXT_EMBEDDING_3_SMALL`)
+        api_key (str, optional): The API key for authenticating with the
             OpenAI service. (default: :obj:`None`)
+        dimensions (int, optional): The text embedding output dimensions.
+            (default: :obj:`NOT_GIVEN`)
 
     Raises:
         RuntimeError: If an unsupported model type is specified.
@@ -36,36 +41,44 @@ class OpenAIEmbedding(BaseEmbedding[str]):
 
     def __init__(
         self,
-        model_type: EmbeddingModelType = EmbeddingModelType.ADA_2,
-        api_key: Optional[str] = None,
+        model_type: EmbeddingModelType = (
+            EmbeddingModelType.TEXT_EMBEDDING_3_SMALL
+        ),
+        api_key: str | None = None,
+        dimensions: int | NotGiven = NOT_GIVEN,
     ) -> None:
         if not model_type.is_openai:
             raise ValueError("Invalid OpenAI embedding model type.")
         self.model_type = model_type
-        self.output_dim = model_type.output_dim
+        if dimensions == NOT_GIVEN:
+            self.output_dim = model_type.output_dim
+        else:
+            assert isinstance(dimensions, int)
+            self.output_dim = dimensions
         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],
+        objs: list[str],
         **kwargs: Any,
-    ) -> List[List[float]]:
+    ) -> list[list[float]]:
         r"""Generates embeddings for the given texts.
 
         Args:
-            objs (List[str]): The texts for which to generate the embeddings.
+            objs (list[str]): The texts for which to generate the embeddings.
             **kwargs (Any): Extra kwargs passed to the embedding API.
 
         Returns:
-            List[List[float]]: A list that represents the generated embedding
+            list[list[float]]: A list that represents the generated embedding
                 as a list of floating-point numbers.
         """
         # TODO: count tokens
         response = self.client.embeddings.create(
             input=objs,
             model=self.model_type.value,
+            dimensions=self.output_dim,
             **kwargs,
         )
         return [data.embedding for data in response.data]

camel/embeddings/sentence_transformers_embeddings.py

@@ -11,51 +11,63 @@
 # 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 Any, List
+from __future__ import annotations
+
+from typing import Any
+
+from numpy import ndarray
 
 from camel.embeddings.base import BaseEmbedding
 
 
 class SentenceTransformerEncoder(BaseEmbedding[str]):
-    r"""This class provides functionalities to generate embeddings
-    using a specified model from `Sentence Transformers`.
+    r"""This class provides functionalities to generate text
+    embeddings using `Sentence Transformers`.
 
     References:
         https://www.sbert.net/
     """
 
-    def __init__(self, model_name: str = 'intfloat/e5-large-v2'):
+    def __init__(
+        self,
+        model_name: str = "intfloat/e5-large-v2",
+        **kwargs,
+    ):
         r"""Initializes the: obj: `SentenceTransformerEmbedding` class
         with the specified transformer model.
 
         Args:
             model_name (str, optional): The name of the model to use.
-                                        Defaults to `intfloat/e5-large-v2`.
+                (default: :obj:`intfloat/e5-large-v2`)
+            **kwargs (optional): Additional arguments of
+                :class:`SentenceTransformer`, such as :obj:`prompts` etc.
         """
         from sentence_transformers import SentenceTransformer
 
-        self.model = SentenceTransformer(model_name)
+        self.model = SentenceTransformer(model_name, **kwargs)
 
     def embed_list(
         self,
-        objs: List[str],
+        objs: list[str],
         **kwargs: Any,
-    ) -> List[List[float]]:
+    ) -> list[list[float]]:
         r"""Generates embeddings for the given texts using the model.
 
         Args:
-            objs (List[str]): The texts for which to generate the
-            embeddings.
+            objs (list[str]): The texts for which to generate the
+                embeddings.
 
         Returns:
-            List[List[float]]: A list that represents the generated embedding
+            list[list[float]]: A list that represents the generated embedding
                 as a list of floating-point numbers.
         """
         if not objs:
             raise ValueError("Input text list is empty")
-        return self.model.encode(
+        embeddings = self.model.encode(
             objs, normalize_embeddings=True, **kwargs
-        ).tolist()
+        )
+        assert isinstance(embeddings, ndarray)
+        return embeddings.tolist()
 
     def get_output_dim(self) -> int:
         r"""Returns the output dimension of the embeddings.
@@ -63,4 +75,6 @@ class SentenceTransformerEncoder(BaseEmbedding[str]):
         Returns:
             int: The dimensionality of the embeddings.
         """
-        return self.model.get_sentence_embedding_dimension()
+        output_dim = self.model.get_sentence_embedding_dimension()
+        assert isinstance(output_dim, int)
+        return output_dim

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',
 ]