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

camel/configs/deepseek_config.py

@@ -30,7 +30,7 @@ class DeepSeekConfig(BaseConfig):
         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`)
+            (default: :obj:`1.0`)
         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:`1.0`)
@@ -86,7 +86,7 @@ class DeepSeekConfig(BaseConfig):
             :obj:`True`)
     """
 
-    temperature: float = 0.2  # deepseek default: 1.0
+    temperature: float = 1.0  # deepseek default: 1.0
     top_p: float = 1.0
     stream: bool = False
     stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN

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.8`)
+        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

@@ -171,6 +171,7 @@ class SelfInstructPipeline:
         )
 
         response = self.agent.step(prompt)
+        self.agent.reset()
         generated_tasks = [
             line.strip()
             for line in response.msgs[0].content.split("\n")
@@ -197,6 +198,7 @@ class SelfInstructPipeline:
             "{\n  \"answer\": false\n}\n"
         )
         response = self.agent.step(clf_prompt)
+        self.agent.reset()
         try:
             structured_response = AgentResponse.parse_raw(
                 response.msgs[0].content.strip()
@@ -241,6 +243,7 @@ class SelfInstructPipeline:
             )
 
         response = self.agent.step(prompt)
+        self.agent.reset()
         generated_text = response.msgs[0].content.strip()
 
         if classification:
@@ -365,13 +368,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/interpreters/internal_python_interpreter.py

@@ -73,7 +73,8 @@ class InternalPythonInterpreter(BaseInterpreter):
             module and its submodule or function name are separated by a period
             (:obj:`.`). (default: :obj:`None`)
         unsafe_mode (bool, optional): If `True`, the interpreter runs the code
-            by `eval()` without any security check. (default: :obj:`False`)
+            by `eval()` or `exec()` without any security check.
+            (default: :obj:`False`)
         raise_error (bool, optional): Raise error if the interpreter fails.
             (default: :obj:`False`)
     """
@@ -102,9 +103,9 @@ class InternalPythonInterpreter(BaseInterpreter):
         type is supported, and then executes the code. If `unsafe_mode` is
         set to `False`, the code is executed in a controlled environment using
         the `execute` method. If `unsafe_mode` is `True`, the code is executed
-        using `eval()` with the action space as the global context. An
-        `InterpreterError` is raised if the code type is unsupported or if any
-        runtime error occurs during execution.
+        using `eval()` or `exec()` with the action space as the global context.
+        An `InterpreterError` is raised if the code type is unsupported or if
+        any runtime error occurs during execution.
 
         Args:
             code (str): The python code to be executed.
@@ -125,10 +126,26 @@ class InternalPythonInterpreter(BaseInterpreter):
                 f"`{self.__class__.__name__}` only supports "
                 f"{', '.join(self._CODE_TYPES)}."
             )
-        if not self.unsafe_mode:
-            return str(self.execute(code))
+        if self.unsafe_mode:
+            import contextlib
+            import io
+
+            # Try to execute first and capture stdout
+            output_buffer = io.StringIO()
+            with contextlib.redirect_stdout(output_buffer):
+                exec(code, self.action_space)
+            result = output_buffer.getvalue()
+
+            # If no output was captured, try to evaluate the code
+            if not result:
+                try:
+                    result = str(eval(code, self.action_space))
+                except (SyntaxError, NameError):
+                    result = ""  # If eval fails, return empty string
+
+            return result
         else:
-            return str(eval(code, self.action_space))
+            return str(self.execute(code))
 
     def update_action_space(self, action_space: Dict[str, Any]) -> None:
         r"""Updates action space for *python* interpreter."""

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