camel-ai 0.2.24__py3-none-any.whl → 0.2.26__py3-none-any.whl

camel/interpreters/subprocess_interpreter.py

@@ -12,8 +12,9 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
-import shlex
+import os
 import subprocess
+import sys
 import tempfile
 from pathlib import Path
 from typing import Any, ClassVar, Dict, List
@@ -43,12 +44,14 @@ class SubprocessInterpreter(BaseInterpreter):
             the executed code. (default: :obj:`False`)
         print_stderr (bool, optional): If True, print the standard error of the
             executed code. (default: :obj:`True`)
+        execution_timeout (int, optional): Maximum time in seconds to wait for
+            code execution to complete. (default: :obj:`60`)
     """
 
-    _CODE_EXECUTE_CMD_MAPPING: ClassVar[Dict[str, str]] = {
-        "python": "python {file_name}",
-        "bash": "bash {file_name}",
-        "r": "Rscript {file_name}",
+    _CODE_EXECUTE_CMD_MAPPING: ClassVar[Dict[str, Dict[str, str]]] = {
+        "python": {"posix": "python {file_name}", "nt": "python {file_name}"},
+        "bash": {"posix": "bash {file_name}", "nt": "bash {file_name}"},
+        "r": {"posix": "Rscript {file_name}", "nt": "Rscript {file_name}"},
     }
 
     _CODE_EXTENSION_MAPPING: ClassVar[Dict[str, str]] = {
@@ -74,10 +77,12 @@ class SubprocessInterpreter(BaseInterpreter):
         require_confirm: bool = True,
         print_stdout: bool = False,
         print_stderr: bool = True,
+        execution_timeout: int = 60,
     ) -> None:
         self.require_confirm = require_confirm
         self.print_stdout = print_stdout
         self.print_stderr = print_stderr
+        self.execution_timeout = execution_timeout
 
     def run_file(
         self,
@@ -94,13 +99,9 @@ class SubprocessInterpreter(BaseInterpreter):
         Returns:
             str: A string containing the captured stdout and stderr of the
                 executed code.
-
-        Raises:
-            RuntimeError: If the provided file path does not point to a file.
-            InterpreterError: If the code type provided is not supported.
         """
         if not file.is_file():
-            raise RuntimeError(f"{file} is not a file.")
+            return f"{file} is not a file."
         code_type = self._check_code_type(code_type)
         if self._CODE_TYPE_MAPPING[code_type] == "python":
             # For Python code, use ast to analyze and modify the code
@@ -108,7 +109,7 @@ class SubprocessInterpreter(BaseInterpreter):
 
             import astor
 
-            with open(file, 'r') as f:
+            with open(file, 'r', encoding='utf-8') as f:
                 source = f.read()
 
             # Parse the source code
@@ -158,34 +159,88 @@ class SubprocessInterpreter(BaseInterpreter):
                     modified_source = astor.to_source(tree)
                     # Create a temporary file with the modified source
                     temp_file = self._create_temp_file(modified_source, "py")
-                    cmd = shlex.split(f"python {temp_file!s}")
-            except SyntaxError:
-                # If parsing fails, run the original file
-                cmd = shlex.split(
-                    self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
-                        file_name=str(file)
+                    cmd = ["python", str(temp_file)]
+            except (SyntaxError, TypeError, ValueError) as e:
+                logger.warning(f"Failed to parse Python code with AST: {e}")
+                platform_type = 'posix' if os.name != 'nt' else 'nt'
+                cmd_template = self._CODE_EXECUTE_CMD_MAPPING[code_type][
+                    platform_type
+                ]
+                base_cmd = cmd_template.split()[0]
+
+                # Check if command is available
+                if not self._is_command_available(base_cmd):
+                    raise InterpreterError(
+                        f"Command '{base_cmd}' not found. Please ensure it "
+                        f"is installed and available in your PATH."
                     )
-                )
+
+                cmd = [base_cmd, str(file)]
         else:
             # For non-Python code, use standard execution
-            cmd = shlex.split(
-                self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
-                    file_name=str(file)
+            platform_type = 'posix' if os.name != 'nt' else 'nt'
+            cmd_template = self._CODE_EXECUTE_CMD_MAPPING[code_type][
+                platform_type
+            ]
+            base_cmd = cmd_template.split()[0]  # Get 'python', 'bash', etc.
+
+            # Check if command is available
+            if not self._is_command_available(base_cmd):
+                raise InterpreterError(
+                    f"Command '{base_cmd}' not found. Please ensure it "
+                    f"is installed and available in your PATH."
                 )
-            )
 
-        proc = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
-        )
-        stdout, stderr = proc.communicate()
-        return_code = proc.returncode
+            cmd = [base_cmd, str(file)]
+
+        # Get current Python executable's environment
+        env = os.environ.copy()
+
+        # On Windows, ensure we use the correct Python executable path
+        if os.name == 'nt':
+            python_path = os.path.dirname(sys.executable)
+            if 'PATH' in env:
+                env['PATH'] = python_path + os.pathsep + env['PATH']
+            else:
+                env['PATH'] = python_path
+
+        try:
+            proc = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=env,
+                shell=False,  # Never use shell=True for security
+            )
+            # Add timeout to prevent hanging processes
+            stdout, stderr = proc.communicate(timeout=self.execution_timeout)
+            return_code = proc.returncode
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            stdout, stderr = proc.communicate()
+            return_code = proc.returncode
+            timeout_msg = (
+                f"Process timed out after {self.execution_timeout} seconds "
+                f"and was terminated."
+            )
+            stderr = f"{stderr}\n{timeout_msg}"
 
         # Clean up temporary file if it was created
-        if (
-            self._CODE_TYPE_MAPPING[code_type] == "python"
-            and 'temp_file' in locals()
-        ):
-            temp_file.unlink()
+        temp_file_to_clean = locals().get('temp_file')
+        if temp_file_to_clean is not None:
+            try:
+                if temp_file_to_clean.exists():
+                    try:
+                        temp_file_to_clean.unlink()
+                    except PermissionError:
+                        # On Windows, files might be locked
+                        logger.warning(
+                            f"Could not delete temp file "
+                            f"{temp_file_to_clean} (may be locked)"
+                        )
+            except Exception as e:
+                logger.warning(f"Failed to cleanup temporary file: {e}")
 
         if self.print_stdout and stdout:
             print("======stdout======")
@@ -240,7 +295,7 @@ class SubprocessInterpreter(BaseInterpreter):
                 "computer: {code}"
             )
             while True:
-                choice = input("Running code? [Y/n]:").lower()
+                choice = input("Running code? [Y/n]:").lower().strip()
                 if choice in ["y", "yes", "ye", ""]:
                     break
                 elif choice in ["no", "n"]:
@@ -249,22 +304,72 @@ class SubprocessInterpreter(BaseInterpreter):
                         "This choice stops the current operation and any "
                         "further code execution."
                     )
-        temp_file_path = self._create_temp_file(
-            code=code, extension=self._CODE_EXTENSION_MAPPING[code_type]
-        )
+                else:
+                    print("Please enter 'y' or 'n'.")
+
+        temp_file_path = None
+        temp_dir = None
+        try:
+            temp_file_path = self._create_temp_file(
+                code=code, extension=self._CODE_EXTENSION_MAPPING[code_type]
+            )
+            temp_dir = temp_file_path.parent
+            return self.run_file(temp_file_path, code_type)
+        finally:
+            # Clean up temp file and directory
+            try:
+                if temp_file_path and temp_file_path.exists():
+                    try:
+                        temp_file_path.unlink()
+                    except PermissionError:
+                        # On Windows, files might be locked
+                        logger.warning(
+                            f"Could not delete temp file {temp_file_path}"
+                        )
+
+                if temp_dir and temp_dir.exists():
+                    try:
+                        import shutil
+
+                        shutil.rmtree(temp_dir, ignore_errors=True)
+                    except Exception as e:
+                        logger.warning(f"Could not delete temp directory: {e}")
+            except Exception as e:
+                logger.warning(f"Error during cleanup: {e}")
 
-        result = self.run_file(temp_file_path, code_type)
+    def _create_temp_file(self, code: str, extension: str) -> Path:
+        r"""Creates a temporary file with the given code and extension.
 
-        temp_file_path.unlink()
-        return result
+        Args:
+            code (str): The code to write to the temporary file.
+            extension (str): The file extension to use.
 
-    def _create_temp_file(self, code: str, extension: str) -> Path:
-        with tempfile.NamedTemporaryFile(
-            mode="w", delete=False, suffix=f".{extension}"
-        ) as f:
-            f.write(code)
-            name = f.name
-        return Path(name)
+        Returns:
+            Path: The path to the created temporary file.
+        """
+        try:
+            # Create a temporary directory first to ensure we have write
+            # permissions
+            temp_dir = tempfile.mkdtemp()
+            # Create file path with appropriate extension
+            file_path = Path(temp_dir) / f"temp_code.{extension}"
+
+            # Write code to file with appropriate encoding
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(code)
+
+            return file_path
+        except Exception as e:
+            # Clean up temp directory if creation failed
+            if 'temp_dir' in locals():
+                try:
+                    import shutil
+
+                    shutil.rmtree(temp_dir, ignore_errors=True)
+                except Exception:
+                    pass
+            logger.error(f"Failed to create temporary file: {e}")
+            raise
 
     def _check_code_type(self, code_type: str) -> str:
         if code_type not in self._CODE_TYPE_MAPPING:
@@ -284,3 +389,39 @@ class SubprocessInterpreter(BaseInterpreter):
         raise RuntimeError(
             "SubprocessInterpreter doesn't support " "`action_space`."
         )
+
+    def _is_command_available(self, command: str) -> bool:
+        r"""Check if a command is available in the system PATH.
+
+        Args:
+            command (str): The command to check.
+
+        Returns:
+            bool: True if the command is available, False otherwise.
+        """
+        if os.name == 'nt':  # Windows
+            # On Windows, use where.exe to find the command
+            try:
+                with open(os.devnull, 'w') as devnull:
+                    subprocess.check_call(
+                        ['where', command],
+                        stdout=devnull,
+                        stderr=devnull,
+                        shell=False,
+                    )
+                return True
+            except subprocess.CalledProcessError:
+                return False
+        else:  # Unix-like systems
+            # On Unix-like systems, use which to find the command
+            try:
+                with open(os.devnull, 'w') as devnull:
+                    subprocess.check_call(
+                        ['which', command],
+                        stdout=devnull,
+                        stderr=devnull,
+                        shell=False,
+                    )
+                return True
+            except subprocess.CalledProcessError:
+                return False

camel/models/anthropic_model.py

@@ -35,13 +35,13 @@ class AnthropicModel(BaseModelBackend):
         model_type (Union[ModelType, str]): Model for which a backend is
             created, one of CLAUDE_* series.
         model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
-            that will be fed into Anthropic.messages.create().  If
+            that will be fed into `openai.ChatCompletion.create()`.  If
             :obj:`None`, :obj:`AnthropicConfig().as_dict()` will be used.
             (default: :obj:`None`)
         api_key (Optional[str], optional): The API key for authenticating with
             the Anthropic service. (default: :obj:`None`)
         url (Optional[str], optional): The url to the Anthropic service.
-            (default: :obj:`None`)
+            (default: :obj:`https://api.anthropic.com/v1/`)
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`AnthropicTokenCounter`
             will be used. (default: :obj:`None`)
@@ -61,43 +61,24 @@ class AnthropicModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        from anthropic import Anthropic, AsyncAnthropic
+        from openai import AsyncOpenAI, OpenAI
 
         if model_config_dict is None:
             model_config_dict = AnthropicConfig().as_dict()
         api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
-        url = url or os.environ.get("ANTHROPIC_API_BASE_URL")
+        url = (
+            url
+            or os.environ.get("ANTHROPIC_API_BASE_URL")
+            or "https://api.anthropic.com/v1/"
+        )
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self.client = Anthropic(api_key=self._api_key, base_url=self._url)
-        self.async_client = AsyncAnthropic(
-            api_key=self._api_key, base_url=self._url
-        )
+        self.client = OpenAI(base_url=self._url, api_key=self._api_key)
 
-    def _convert_response_from_anthropic_to_openai(self, response):
-        # openai ^1.0.0 format, reference openai/types/chat/chat_completion.py
-        obj = ChatCompletion.construct(
-            id=None,
-            choices=[
-                dict(
-                    index=0,
-                    message={
-                        "role": "assistant",
-                        "content": next(
-                            content.text
-                            for content in response.content
-                            if content.type == "text"
-                        ),
-                    },
-                    finish_reason=response.stop_reason,
-                )
-            ],
-            created=None,
-            model=response.model,
-            object="chat.completion",
+        self.async_client = AsyncOpenAI(
+            api_key=self._api_key, base_url=self._url
         )
-        return obj
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -126,22 +107,13 @@ class AnthropicModel(BaseModelBackend):
         Returns:
             ChatCompletion: Response in the OpenAI API format.
         """
-        from anthropic import NOT_GIVEN
-
-        if messages[0]["role"] == "system":
-            sys_msg = str(messages.pop(0)["content"])
-        else:
-            sys_msg = NOT_GIVEN  # type: ignore[assignment]
-        response = self.client.messages.create(
+        response = self.client.chat.completions.create(
             model=self.model_type,
-            system=sys_msg,
-            messages=messages,  # type: ignore[arg-type]
+            messages=messages,
             **self.model_config_dict,
+            tools=tools,  # type: ignore[arg-type]
         )
 
-        # format response to openai format
-        response = self._convert_response_from_anthropic_to_openai(response)
-
         return response
 
     async def _arun(
@@ -159,21 +131,14 @@ class AnthropicModel(BaseModelBackend):
         Returns:
             ChatCompletion: Response in the OpenAI API format.
         """
-        from anthropic import NOT_GIVEN
-
-        if messages[0]["role"] == "system":
-            sys_msg = str(messages.pop(0)["content"])
-        else:
-            sys_msg = NOT_GIVEN  # type: ignore[assignment]
-        response = await self.async_client.messages.create(
+        response = await self.async_client.chat.completions.create(
             model=self.model_type,
-            system=sys_msg,
-            messages=messages,  # type: ignore[arg-type]
+            messages=messages,
             **self.model_config_dict,
+            tools=tools,  # type: ignore[arg-type]
         )
 
-        # format response to openai format
-        return self._convert_response_from_anthropic_to_openai(response)
+        return response
 
     def check_model_config(self):
         r"""Check whether the model configuration is valid for anthropic
@@ -181,8 +146,7 @@ class AnthropicModel(BaseModelBackend):
 
         Raises:
             ValueError: If the model configuration dictionary contains any
-                unexpected arguments to OpenAI API, or it does not contain
-                :obj:`model_path` or :obj:`server_url`.
+                unexpected arguments to Anthropic API.
         """
         for param in self.model_config_dict:
             if param not in ANTHROPIC_API_PARAMS:

camel/models/sglang_model.py

@@ -97,9 +97,16 @@ class SGLangModel(BaseModelBackend):
     def _start_server(self) -> None:
         try:
             if not self._url:
+                tool_call_flag = self.model_config_dict.get("tools")
+                tool_call_arg = (
+                    f"--tool-call-parser {self._api_key} "
+                    if tool_call_flag
+                    else ""
+                )
                 cmd = (
                     f"python -m sglang.launch_server "
                     f"--model-path {self.model_type} "
+                    f"{tool_call_arg}"
                     f"--port 30000 "
                     f"--host 0.0.0.0"
                 )
@@ -265,6 +272,19 @@ class SGLangModel(BaseModelBackend):
         """
         return self.model_config_dict.get('stream', False)
 
+    def __del__(self):
+        r"""Properly clean up resources when the model is destroyed."""
+        self.cleanup()
+
+    def cleanup(self):
+        r"""Terminate the server process and clean up resources."""
+        with self._lock:
+            if self.server_process:
+                _terminate_process(self.server_process)
+                self.server_process = None
+                self._client = None
+                logging.info("Server process terminated during cleanup.")
+
 
 # Below are helper functions from sglang.utils
 def _terminate_process(process):
@@ -326,21 +346,25 @@ def _execute_shell_command(command: str) -> subprocess.Popen:
     return subprocess.Popen(parts, text=True, stderr=subprocess.STDOUT)
 
 
-def _wait_for_server(base_url: str, timeout: Optional[int] = None) -> None:
+def _wait_for_server(base_url: str, timeout: Optional[int] = 30) -> None:
     r"""Wait for the server to be ready by polling the /v1/models endpoint.
 
     Args:
         base_url: The base URL of the server
-        timeout: Maximum time to wait in seconds. None means wait forever.
+        timeout: Maximum time to wait in seconds. Default is 30 seconds.
     """
     import requests
 
+    # Set a default value if timeout is None
+    actual_timeout = 30 if timeout is None else timeout
+
     start_time = time.time()
     while True:
         try:
             response = requests.get(
                 f"{base_url}/v1/models",
                 headers={"Authorization": "Bearer None"},
+                timeout=5,  # Add a timeout for the request itself
             )
             if response.status_code == 200:
                 time.sleep(5)
@@ -356,9 +380,15 @@ def _wait_for_server(base_url: str, timeout: Optional[int] = None) -> None:
                 )
                 break
 
-            if timeout and time.time() - start_time > timeout:
+            if time.time() - start_time > actual_timeout:
+                raise TimeoutError(
+                    f"Server did not become ready within "
+                    f"{actual_timeout} seconds"
+                )
+        except (requests.exceptions.RequestException, TimeoutError) as e:
+            if time.time() - start_time > actual_timeout:
                 raise TimeoutError(
-                    "Server did not become ready within timeout period"
+                    f"Server did not become ready within "
+                    f"{actual_timeout} seconds: {e}"
                 )
-        except requests.exceptions.RequestException:
             time.sleep(1)

camel/storages/graph_storages/graph_element.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
-from typing import List, Union
+from typing import List, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -45,6 +45,7 @@ class Relationship(BaseModel):
         subj (Node): The subject/source node of the relationship.
         obj (Node): The object/target node of the relationship.
         type (str):  The type of the relationship.
+        timestamp (str, optional): The timestamp of the relationship.
         properties (dict): Additional properties associated with the
             relationship.
     """
@@ -52,6 +53,7 @@ class Relationship(BaseModel):
     subj: Node
     obj: Node
     type: str = "Relationship"
+    timestamp: Optional[str] = None
     properties: dict = Field(default_factory=dict)
 
 

camel/storages/graph_storages/neo4j_graph.py

@@ -339,18 +339,24 @@ class Neo4jGraph(BaseGraphStorage):
             ]
         )
 
-    def add_triplet(self, subj: str, obj: str, rel: str) -> None:
-        r"""Adds a relationship (triplet) between two entities in the database.
+    def add_triplet(
+        self, subj: str, obj: str, rel: str, timestamp: Optional[str] = None
+    ) -> None:
+        r"""Adds a relationship (triplet) between two entities
+            in the database with a timestamp.
 
         Args:
             subj (str): The identifier for the subject entity.
             obj (str): The identifier for the object entity.
             rel (str): The relationship between the subject and object.
+            timestamp (Optional[str]): The timestamp of the relationship.
+                                Defaults to None.
         """
         query = """
             MERGE (n1:`%s` {id:$subj})
             MERGE (n2:`%s` {id:$obj})
-            MERGE (n1)-[:`%s`]->(n2)
+            MERGE (n1)-[r:`%s`]->(n2)
+            SET r.timestamp = $timestamp
         """
 
         prepared_statement = query % (
@@ -361,7 +367,10 @@ class Neo4jGraph(BaseGraphStorage):
 
         # Execute the query within a database session
         with self.driver.session(database=self.database) as session:
-            session.run(prepared_statement, {"subj": subj, "obj": obj})
+            session.run(
+                prepared_statement,
+                {"subj": subj, "obj": obj, "timestamp": timestamp},
+            )
 
     def _delete_rel(self, subj: str, obj: str, rel: str) -> None:
         r"""Deletes a specific relationship between two nodes in the Neo4j
@@ -721,3 +730,68 @@ class Neo4jGraph(BaseGraphStorage):
             return result[0] if result else {}
         except CypherSyntaxError as e:
             raise ValueError(f"Generated Cypher Statement is not valid\n{e}")
+
+    def get_triplet(
+        self,
+        subj: Optional[str] = None,
+        obj: Optional[str] = None,
+        rel: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        r"""
+        Query triplet information. If subj, obj, or rel is
+        not specified, returns all matching triplets.
+
+        Args:
+            subj (Optional[str]): The ID of the subject node.
+                        If None, matches any subject node.
+            obj (Optional[str]): The ID of the object node.
+                        If None, matches any object node.
+            rel (Optional[str]): The type of relationship.
+                        If None, matches any relationship type.
+
+        Returns:
+            List[Dict[str, Any]]: A list of matching triplets,
+                    each containing subj, obj, rel, and timestamp.
+        """
+        import logging
+
+        logging.basicConfig(level=logging.DEBUG)
+        logger = logging.getLogger(__name__)
+
+        # Construct the query
+        query = """
+                MATCH (n1:Entity)-[r]->(n2:Entity)
+                WHERE ($subj IS NULL OR n1.id = $subj)
+                AND ($obj IS NULL OR n2.id = $obj)
+                AND ($rel IS NULL OR type(r) = $rel)
+                RETURN n1.id AS subj, n2.id AS obj, 
+                type(r) AS rel, r.timestamp AS timestamp
+            """
+
+        # Construct the query parameters
+        params = {
+            "subj": subj
+            if subj is not None
+            else None,  # If subj is None, match any subject node
+            "obj": obj
+            if obj is not None
+            else None,  # If obj is None, match any object node
+            "rel": rel
+            if rel is not None
+            else None,  # If rel is None, match any relationship type
+        }
+
+        logger.debug(f"Executing query: {query}")
+        logger.debug(f"Query parameters: {params}")
+
+        with self.driver.session(database=self.database) as session:
+            try:
+                result = session.run(query, params)
+                records = [record.data() for record in result]
+                logger.debug(
+                    f"Query returned {len(records)} records: {records}"
+                )
+                return records
+            except Exception as e:
+                logger.error(f"Error executing query: {e}")
+                return []

camel/toolkits/__init__.py

@@ -58,6 +58,7 @@ from .mcp_toolkit import MCPToolkit
 from .web_toolkit import WebToolkit
 from .file_write_toolkit import FileWriteToolkit
 from .terminal_toolkit import TerminalToolkit
+from .pubmed_toolkit import PubMedToolkit
 
 
 __all__ = [
@@ -104,4 +105,5 @@ __all__ = [
     'WebToolkit',
     'FileWriteToolkit',
     'TerminalToolkit',
+    'PubMedToolkit',
 ]