camel-ai 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

camel/configs/internlm_config.py

@@ -0,0 +1,60 @@
+# ========= 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. =========
+
+from typing import Optional, Union
+
+from camel.configs.base_config import BaseConfig
+
+
+class InternLMConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    InternLM API. You can refer to the following link for more details:
+    https://internlm.intern-ai.org.cn/api/document
+
+    Args:
+        stream (bool, optional): Whether to stream the response.
+            (default: :obj:`False`)
+        temperature (float, optional): Controls the diversity and focus of
+            the generated results. Lower values make the output more focused,
+            while higher values make it more diverse. (default: :obj:`0.3`)
+        top_p (float, optional): Controls the diversity and focus of the
+            generated results. Higher values make the output more diverse,
+            while lower values make it more focused. (default: :obj:`0.9`)
+        max_tokens (Union[int, NotGiven], optional): Allows the model to
+            generate the maximum number of tokens.
+            (default: :obj:`NOT_GIVEN`)
+        tools (list, optional): Specifies an array of tools that the model can
+            call. It can contain one or more tool objects. During a function
+            call process, the model will select one tool from the array.
+            (default: :obj:`None`)
+        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.
+    """
+
+    stream: bool = False
+    temperature: float = 0.8
+    top_p: float = 0.9
+    max_tokens: Optional[int] = None
+    tool_choice: Optional[Union[dict[str, str], str]] = None
+
+
+INTERNLM_API_PARAMS = {param for param in InternLMConfig.model_fields.keys()}

camel/data_collector/base.py

@@ -27,7 +27,7 @@ class CollectorData:
         self,
         id: UUID,
         name: str,
-        role: Literal["user", "assistant", "system", "function"],
+        role: Literal["user", "assistant", "system", "tool"],
         message: Optional[str] = None,
         function_call: Optional[Dict[str, Any]] = None,
     ) -> None:
@@ -52,7 +52,7 @@ class CollectorData:
             ValueError: If neither message nor function call is provided.
 
         """
-        if role not in ["user", "assistant", "system", "function"]:
+        if role not in ["user", "assistant", "system", "tool"]:
             raise ValueError(f"Role {role} not supported")
         if role == "system" and function_call:
             raise ValueError("System role cannot have function call")
@@ -82,7 +82,7 @@ class CollectorData:
             name=name,
             role=context["role"],
             message=context["content"],
-            function_call=context.get("function_call", None),
+            function_call=context.get("tool_calls", None),
         )
 
 
@@ -98,7 +98,7 @@ class BaseDataCollector(ABC):
 
     def step(
         self,
-        role: Literal["user", "assistant", "system", "function"],
+        role: Literal["user", "assistant", "system", "tool"],
         name: Optional[str] = None,
         message: Optional[str] = None,
         function_call: Optional[Dict[str, Any]] = None,
@@ -106,7 +106,7 @@ class BaseDataCollector(ABC):
         r"""Record a message.
 
         Args:
-            role (Literal["user", "assistant", "system", "function"]):
+            role (Literal["user", "assistant", "system", "tool"]):
                 The role of the message.
             name (Optional[str], optional): The name of the agent.
                 (default: :obj:`None`)

camel/data_collector/sharegpt_collector.py

@@ -131,7 +131,7 @@ class ShareGPTDataCollector(BaseDataCollector):
                     conversations.append(
                         {"from": "gpt", "value": message.message}
                     )
-            elif role == "function":
+            elif role == "function" or role == "tool":
                 conversations.append(
                     {
                         "from": "observation",
@@ -182,7 +182,7 @@ class ShareGPTDataCollector(BaseDataCollector):
             if message.function_call:
                 context.append(prefix + json.dumps(message.function_call))
 
-            elif role == "function":
+            elif role == "function" or role == "tool":
                 context.append(prefix + json.dumps(message.message))  # type: ignore[attr-defined]
             else:
                 context.append(prefix + str(message.message))

camel/datagen/self_instruct/self_instruct.py

@@ -365,13 +365,13 @@ class SelfInstructPipeline:
         and instances.
         """
         while len(self.machine_tasks) < self.num_machine_instructions:
+            prompt, instruction = self.generate_machine_instruction()
             existing_instructions = [
                 t["instruction"] for t in self.human_tasks
             ] + [t["instruction"] for t in self.machine_tasks]
             for f in self.instruction_filter.filters:
                 if isinstance(f, RougeSimilarityFilter):
                     f.existing_instructions = existing_instructions
-            prompt, instruction = self.generate_machine_instruction()
             if self.instruction_filter.filter(prompt, instruction):
                 instruction_dict = {
                     "id": f"machine_task_{len(self.machine_tasks) + 1}",

camel/datagen/self_instruct/templates.py

@@ -269,22 +269,20 @@ class SelfInstructTemplates:
     '''
 
     input_first_template_for_gen = '''You will be given a task, 
-    Please generate at most two example instances illustrating how to 
+    Your job is to generate at most two example instances demonstrating how to 
     perform this task. For each instance:
-    - If the task requires input (as an actual instance of the task), 
-    provide it. if the task itself can be answered without an instance, 
-    skip the input.
-    - Then provide the correct output.
+    - If the task requires input (as an actual example of the task), provide it.
+    - If the task can be answered directly without requiring input, omit the input section.
     
-    Do not provide any additional commentary, explanations, or more than two instances. Just show the instances in the following format:
-        
-        Example 1
-        [Input if necessary]
-        Output: [oldest person]
-        
-        Example 2
-        [Input if necessary]
-        Output: [oldest person]
+    Example 1
+    Input: [Provide input here if needed, otherwise omit this section]
+    Output: [Provide the correct output]
+    
+    Example 2
+    Input: [Provide input here if needed, otherwise omit this section]
+    Output: [Provide the correct output]
+
+    Do not include any additional commentary, explanations, or more than two instances.
         
     Below are some examples:
 

camel/loaders/__init__.py

@@ -17,6 +17,7 @@ from .base_io import File, create_file, create_file_from_raw_bytes
 from .chunkr_reader import ChunkrReader
 from .firecrawl_reader import Firecrawl
 from .jina_url_reader import JinaURLReader
+from .panda_reader import PandaReader
 from .unstructured_io import UnstructuredIO
 
 __all__ = [
@@ -28,4 +29,5 @@ __all__ = [
     'Firecrawl',
     'Apify',
     'ChunkrReader',
+    'PandaReader',
 ]

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/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",
+        }