camel-ai 0.2.15a0__py3-none-any.whl → 0.2.17__py3-none-any.whl

camel/loaders/panda_reader.py

@@ -0,0 +1,337 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import os
+from functools import wraps
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
+
+import pandas as pd
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+    from pandasai import SmartDataframe
+
+
+def check_suffix(valid_suffixs: List[str]) -> Callable:
+    r"""A decorator to check the file suffix of a given file path.
+
+    Args:
+        valid_suffix (str): The required file suffix.
+
+    Returns:
+        Callable: The decorator function.
+    """
+
+    def decorator(func: Callable):
+        @wraps(func)
+        def wrapper(
+            self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+        ) -> "DataFrame":
+            suffix = Path(file_path).suffix
+            if suffix not in valid_suffixs:
+                raise ValueError(
+                    f"Only {', '.join(valid_suffixs)} files are supported"
+                )
+            return func(self, file_path, *args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+class PandaReader:
+    def __init__(self, config: Optional[Dict[str, Any]] = None) -> None:
+        r"""Initializes the PandaReader class.
+
+        Args:
+            config (Optional[Dict[str, Any]], optional): The configuration
+                dictionary that can include LLM API settings for LLM-based
+                processing. If not provided, it will use OpenAI with the API
+                key from the OPENAI_API_KEY environment variable. You can
+                customize the LLM configuration by providing a 'llm' key in
+                the config dictionary. (default: :obj:`None`)
+        """
+        from pandasai.llm import OpenAI  # type: ignore[import-untyped]
+
+        self.config = config or {}
+        if "llm" not in self.config:
+            self.config["llm"] = OpenAI(
+                api_token=os.getenv("OPENAI_API_KEY"),
+            )
+
+        self.__LOADER = {
+            ".csv": self.read_csv,
+            ".xlsx": self.read_excel,
+            ".xls": self.read_excel,
+            ".json": self.read_json,
+            ".parquet": self.read_parquet,
+            ".sql": self.read_sql,
+            ".html": self.read_html,
+            ".feather": self.read_feather,
+            ".dta": self.read_stata,
+            ".sas": self.read_sas,
+            ".pkl": self.read_pickle,
+            ".h5": self.read_hdf,
+            ".orc": self.read_orc,
+        }
+
+    def load(
+        self,
+        data: Union["DataFrame", str],
+        *args: Any,
+        **kwargs: Dict[str, Any],
+    ) -> "SmartDataframe":
+        r"""Loads a file or DataFrame and returns a SmartDataframe object.
+
+        args:
+            data (Union[DataFrame, str]): The data to load.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            SmartDataframe: The SmartDataframe object.
+        """
+        from pandas import DataFrame
+        from pandasai import SmartDataframe
+
+        if isinstance(data, DataFrame):
+            return SmartDataframe(data, config=self.config)
+        file_path = str(data)
+        path = Path(file_path)
+        if not file_path.startswith("http") and not path.exists():
+            raise FileNotFoundError(f"File {file_path} not found")
+        if path.suffix in self.__LOADER:
+            return SmartDataframe(
+                self.__LOADER[path.suffix](file_path, *args, **kwargs),  # type: ignore[operator]
+                config=self.config,
+            )
+        else:
+            raise ValueError(f"Unsupported file format: {path.suffix}")
+
+    @check_suffix([".csv"])
+    def read_csv(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads a CSV file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the CSV file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_csv(file_path, *args, **kwargs)
+
+    @check_suffix([".xlsx", ".xls"])
+    def read_excel(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads an Excel file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the Excel file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_excel(file_path, *args, **kwargs)
+
+    @check_suffix([".json"])
+    def read_json(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads a JSON file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the JSON file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_json(file_path, *args, **kwargs)
+
+    @check_suffix([".parquet"])
+    def read_parquet(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads a Parquet file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the Parquet file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_parquet(file_path, *args, **kwargs)
+
+    def read_sql(self, *args: Any, **kwargs: Dict[str, Any]) -> "DataFrame":
+        r"""Reads a SQL file and returns a DataFrame.
+
+        Args:
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_sql(*args, **kwargs)
+
+    def read_table(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads a table and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the table.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_table(file_path, *args, **kwargs)
+
+    def read_clipboard(
+        self, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads a clipboard and returns a DataFrame.
+
+        Args:
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_clipboard(*args, **kwargs)
+
+    @check_suffix([".html"])
+    def read_html(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads an HTML file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the HTML file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_html(file_path, *args, **kwargs)
+
+    @check_suffix([".feather"])
+    def read_feather(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads a Feather file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the Feather file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_feather(file_path, *args, **kwargs)
+
+    @check_suffix([".dta"])
+    def read_stata(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads a Stata file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the Stata file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_stata(file_path, *args, **kwargs)
+
+    @check_suffix([".sas"])
+    def read_sas(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads a SAS file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the SAS file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_sas(file_path, *args, **kwargs)
+
+    @check_suffix([".pkl"])
+    def read_pickle(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads a Pickle file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the Pickle file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_pickle(file_path, *args, **kwargs)
+
+    @check_suffix([".h5"])
+    def read_hdf(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads an HDF file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the HDF file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_hdf(file_path, *args, **kwargs)
+
+    @check_suffix([".orc"])
+    def read_orc(
+        self, file_path: str, *args: Any, **kwargs: Dict[str, Any]
+    ) -> "DataFrame":
+        r"""Reads an ORC file and returns a DataFrame.
+
+        Args:
+            file_path (str): The path to the ORC file.
+            *args (Any): Additional positional arguments.
+            **kwargs (Dict[str, Any]): Additional keyword arguments.
+
+        Returns:
+            DataFrame: The DataFrame object.
+        """
+        return pd.read_orc(file_path, *args, **kwargs)

camel/logger.py

@@ -26,18 +26,24 @@ def _configure_library_logging():
 
     if not logging.root.handlers and not _logger.handlers:
         logging.basicConfig(
-            level=os.environ.get('LOGLEVEL', 'INFO').upper(),
+            level=os.environ.get('CAMEL_LOGGING_LEVEL', 'WARNING').upper(),
             format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
             stream=sys.stdout,
         )
         logging.setLoggerClass(logging.Logger)
-        _logger.info("Camel library logging has been configured.")
+        _logger.info(
+            f"CAMEL library logging has been configured "
+            f"(level: {_logger.getEffectiveLevel()}). "
+            f"To change level, use set_log_level() or "
+            "set CAMEL_LOGGING_LEVEL env var. To disable logging, "
+            "set CAMEL_LOGGING_DISABLED=true or use disable_logging()"
+        )
     else:
         _logger.debug("Existing logger configuration found, using that.")
 
 
 def disable_logging():
-    r"""Disable all logging for the Camel library.
+    r"""Disable all logging for the CAMEL library.
 
     This function sets the log level to a value higher than CRITICAL,
     effectively disabling all log messages, and adds a NullHandler to
@@ -55,7 +61,7 @@ def disable_logging():
 
 
 def enable_logging():
-    r"""Enable logging for the Camel library.
+    r"""Enable logging for the CAMEL library.
 
     This function re-enables logging if it was previously disabled,
     and configures the library logging using the default settings.
@@ -67,7 +73,7 @@ def enable_logging():
 
 
 def set_log_level(level):
-    r"""Set the logging level for the Camel library.
+    r"""Set the logging level for the CAMEL library.
 
     Args:
         level (Union[str, int]): The logging level to set. This can be a string

camel/messages/__init__.py

@@ -11,11 +11,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from typing import Union
+
 from camel.types import (
     ChatCompletionAssistantMessageParam,
-    ChatCompletionFunctionMessageParam,
     ChatCompletionMessageParam,
     ChatCompletionSystemMessageParam,
+    ChatCompletionToolMessageParam,
     ChatCompletionUserMessageParam,
 )
 
@@ -32,9 +34,13 @@ from .conversion.sharegpt.function_call_formatter import (
 )
 
 OpenAISystemMessage = ChatCompletionSystemMessageParam
-OpenAIAssistantMessage = ChatCompletionAssistantMessageParam
+OpenAIAssistantMessage = Union[
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionToolMessageParam,
+]
 OpenAIUserMessage = ChatCompletionUserMessageParam
-OpenAIFunctionMessage = ChatCompletionFunctionMessageParam
+OpenAIToolMessageParam = ChatCompletionToolMessageParam
+
 OpenAIMessage = ChatCompletionMessageParam
 
 
@@ -45,7 +51,7 @@ __all__ = [
     'OpenAISystemMessage',
     'OpenAIAssistantMessage',
     'OpenAIUserMessage',
-    'OpenAIFunctionMessage',
+    'OpenAIToolMessageParam',
     'OpenAIMessage',
     'FunctionCallFormatter',
     'HermesFunctionFormatter',

camel/messages/conversion/conversation_models.py

@@ -69,6 +69,11 @@ class ShareGPTConversation(RootModel):
         for i in range(1, len(messages)):
             curr, prev = messages[i], messages[i - 1]
 
+            print("@@@@")
+            print(curr)
+            print(prev)
+            print("@@@@")
+
             if curr.from_ == "tool":
                 if prev.from_ != "gpt" or "<tool_call>" not in prev.value:
                     raise ValueError(

camel/messages/func_message.py

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import json
 from dataclasses import dataclass
 from typing import Any, Dict, Optional
 
@@ -18,8 +19,8 @@ from camel.messages import (
     BaseMessage,
     HermesFunctionFormatter,
     OpenAIAssistantMessage,
-    OpenAIFunctionMessage,
     OpenAIMessage,
+    OpenAIToolMessageParam,
 )
 from camel.messages.conversion import (
     ShareGPTMessage,
@@ -44,11 +45,14 @@ class FunctionCallingMessage(BaseMessage):
             function. (default: :obj:`None`)
         result (Optional[Any]): The result of function execution.
             (default: :obj:`None`)
+        tool_call_id (Optional[str]): The ID of the tool call, if available.
+            (default: :obj:`None`)
     """
 
     func_name: Optional[str] = None
     args: Optional[Dict] = None
     result: Optional[Any] = None
+    tool_call_id: Optional[str] = None
 
     def to_openai_message(
         self,
@@ -66,7 +70,7 @@ class FunctionCallingMessage(BaseMessage):
         if role_at_backend == OpenAIBackendRole.ASSISTANT:
             return self.to_openai_assistant_message()
         elif role_at_backend == OpenAIBackendRole.FUNCTION:
-            return self.to_openai_function_message()
+            return self.to_openai_tool_message()
         else:
             raise ValueError(f"Unsupported role: {role_at_backend}.")
 
@@ -120,24 +124,29 @@ class FunctionCallingMessage(BaseMessage):
                 " due to missing function name or arguments."
             )
 
-        msg_dict: OpenAIAssistantMessage = {
+        return {
             "role": "assistant",
-            "content": self.content,
-            "function_call": {
-                "name": self.func_name,
-                "arguments": str(self.args),
-            },
+            "content": self.content or "",
+            "tool_calls": [
+                {
+                    "id": self.tool_call_id or "null",
+                    "type": "function",
+                    "function": {
+                        "name": self.func_name,
+                        "arguments": json.dumps(self.args),
+                    },
+                }
+            ],
         }
 
-        return msg_dict
-
-    def to_openai_function_message(self) -> OpenAIFunctionMessage:
-        r"""Converts the message to an :obj:`OpenAIMessage` object
-        with the role being "function".
+    def to_openai_tool_message(self) -> OpenAIToolMessageParam:
+        r"""Converts the message to an :obj:`OpenAIToolMessageParam` object
+        with the role being "tool".
 
         Returns:
-            OpenAIMessage: The converted :obj:`OpenAIMessage` object
-                with its role being "function".
+            OpenAIToolMessageParam: The converted
+                :obj:`OpenAIToolMessageParam` object with its role being
+                "tool".
         """
         if not self.func_name:
             raise ValueError(
@@ -145,11 +154,10 @@ class FunctionCallingMessage(BaseMessage):
                 " due to missing function name."
             )
 
-        result_content = {"result": {str(self.result)}}
-        msg_dict: OpenAIFunctionMessage = {
-            "role": "function",
-            "name": self.func_name,
-            "content": f'{result_content}',
-        }
+        result_content = json.dumps(self.result)
 
-        return msg_dict
+        return {
+            "role": "tool",
+            "content": result_content,
+            "tool_call_id": self.tool_call_id or "null",
+        }

camel/models/__init__.py

@@ -19,6 +19,7 @@ from .deepseek_model import DeepSeekModel
 from .fish_audio_model import FishAudioModel
 from .gemini_model import GeminiModel
 from .groq_model import GroqModel
+from .internlm_model import InternLMModel
 from .litellm_model import LiteLLMModel
 from .mistral_model import MistralModel
 from .model_factory import ModelFactory
@@ -68,4 +69,5 @@ __all__ = [
     'ModelProcessingError',
     'DeepSeekModel',
     'FishAudioModel',
+    'InternLMModel',
 ]

camel/models/anthropic_model.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from camel.configs import ANTHROPIC_API_PARAMS, AnthropicConfig
 from camel.messages import OpenAIMessage
@@ -45,6 +45,11 @@ class AnthropicModel(BaseModelBackend):
             will be used. (default: :obj:`None`)
     """
 
+    @api_keys_required(
+        [
+            ("api_key", "ANTHROPIC_API_KEY"),
+        ]
+    )
     @dependencies_required('anthropic')
     def __init__(
         self,
@@ -97,28 +102,6 @@ class AnthropicModel(BaseModelBackend):
             self._token_counter = AnthropicTokenCounter(self.model_type)
         return self._token_counter
 
-    @dependencies_required('anthropic')
-    def count_tokens_from_prompt(
-        self, prompt: str, role: Literal["user", "assistant"]
-    ) -> int:
-        r"""Count the number of tokens from a prompt.
-
-        Args:
-            prompt (str): The prompt string.
-            role (Literal["user", "assistant"]): The role of the message
-                sender, either "user" or "assistant".
-
-        Returns:
-            int: The number of tokens in the prompt.
-        """
-        from anthropic.types.beta import BetaMessageParam
-
-        return self.client.beta.messages.count_tokens(
-            messages=[BetaMessageParam(content=prompt, role=role)],
-            model=self.model_type,
-        ).input_tokens
-
-    @api_keys_required("ANTHROPIC_API_KEY")
     def run(
         self,
         messages: List[OpenAIMessage],

camel/models/azure_openai_model.py

@@ -24,7 +24,7 @@ from camel.types import (
     ChatCompletionChunk,
     ModelType,
 )
-from camel.utils import BaseTokenCounter, OpenAITokenCounter, api_keys_required
+from camel.utils import BaseTokenCounter, OpenAITokenCounter
 
 
 class AzureOpenAIModel(BaseModelBackend):
@@ -107,7 +107,6 @@ class AzureOpenAIModel(BaseModelBackend):
             self._token_counter = OpenAITokenCounter(self.model_type)
         return self._token_counter
 
-    @api_keys_required("AZURE_OPENAI_API_KEY", "AZURE_API_VERSION")
     def run(
         self,
         messages: List[OpenAIMessage],

camel/models/cohere_model.py

@@ -43,6 +43,11 @@ except (ImportError, AttributeError):
 class CohereModel(BaseModelBackend):
     r"""Cohere API in a unified BaseModelBackend interface."""
 
+    @api_keys_required(
+        [
+            ("api_key", 'COHERE_API_KEY'),
+        ]
+    )
     def __init__(
         self,
         model_type: Union[ModelType, str],
@@ -210,7 +215,6 @@ class CohereModel(BaseModelBackend):
             )
         return self._token_counter
 
-    @api_keys_required("COHERE_API_KEY")
     def run(self, messages: List[OpenAIMessage]) -> ChatCompletion:
         r"""Runs inference of Cohere chat completion.
 
@@ -224,6 +228,14 @@ class CohereModel(BaseModelBackend):
 
         cohere_messages = self._to_cohere_chatmessage(messages)
 
+        # Removing 'strict': True from the dictionary for
+        # cohere client
+        if self.model_config_dict.get('tools') is not None:
+            for tool in self.model_config_dict.get('tools', []):
+                function_dict = tool.get('function', {})
+                if 'strict' in function_dict:
+                    del function_dict['strict']
+
         try:
             response = self._client.chat(
                 messages=cohere_messages,

camel/models/deepseek_model.py

@@ -50,6 +50,11 @@ class DeepSeekModel(BaseModelBackend):
         https://api-docs.deepseek.com/
     """
 
+    @api_keys_required(
+        [
+            ("api_key", "DEEPSEEK_API_KEY"),
+        ]
+    )
     def __init__(
         self,
         model_type: Union[ModelType, str],
@@ -90,7 +95,6 @@ class DeepSeekModel(BaseModelBackend):
             )
         return self._token_counter
 
-    @api_keys_required("DEEPSEEK_API_KEY")
     def run(
         self,
         messages: List[OpenAIMessage],