camel-ai 0.2.35__py3-none-any.whl → 0.2.37__py3-none-any.whl

camel/verifiers/python_verifier.py

@@ -12,18 +12,21 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import ast
 import asyncio
 import os
 import shutil
 import subprocess
+import sys
 import tempfile
 import venv
-from typing import List, Optional
+from typing import List, Optional, Tuple
 
+from camel.extractors.base import BaseExtractor
 from camel.logger import get_logger
 from camel.verifiers import BaseVerifier
 
-from .models import VerificationOutcome, VerificationResult, VerifierInput
+from .models import VerificationOutcome, VerificationResult
 
 logger = get_logger(__name__)
 
@@ -45,12 +48,16 @@ class PythonVerifier(BaseVerifier):
 
     def __init__(
         self,
+        extractor: Optional[BaseExtractor] = None,
         timeout: Optional[float] = 30.0,
         required_packages: Optional[List[str]] = None,
+        **kwargs,
     ):
         r"""Initializes the PythonVerifier.
 
         Args:
+            extractor (Optional[BaseExtractor], optional): The extractor to use
+                for extracting code from the solution. (default: :obj:`None`)
             timeout (Optional[float], optional): The execution timeout in
                 seconds. (default: :obj:`30.0`)
             required_packages (Optional[List[str]], optional): A list of
@@ -58,7 +65,7 @@ class PythonVerifier(BaseVerifier):
                 (default: :obj:`None`)
         """
         # TODO: Use CAMEL's Interpreter to execute the code
-        super().__init__(timeout=timeout)
+        super().__init__(extractor=extractor, timeout=timeout, **kwargs)
         self.venv_path: Optional[str] = None
         self.required_packages = required_packages or []
 
@@ -67,25 +74,39 @@ class PythonVerifier(BaseVerifier):
         else:  # Unix-like systems
             self.bin_dir = 'bin'
 
-    async def _setup(self) -> None:
-        r"""Set up a virtual environment for execution
-        and install required packages.
-        """
+    async def _setup(self, **kwargs) -> None:
+        r"""Set up a virtual environment and install required packages."""
+        uv = kwargs.get('uv', False)
+        if uv or self._is_uv_environment():
+            logger.info("[UV] Detected uv environment. Using uv for setup.")
+            self._setup_with_uv()
+            return
+
         self.venv_path = tempfile.mkdtemp()
-        venv.create(self.venv_path, with_pip=True)
-        logger.info(f"Virtual environment created at {self.venv_path}")
+        try:
+            venv.create(self.venv_path, with_pip=True)
+            logger.info(f"Virtual environment created at {self.venv_path}")
+        except Exception as e:
+            logger.error(f"Failed to create virtual environment: {e}")
+            # Clean up resources before re-raising
+            if self.venv_path and os.path.exists(self.venv_path):
+                shutil.rmtree(self.venv_path)
+                self.venv_path = None
+            raise
 
         venv_pip = os.path.join(self.venv_path, self.bin_dir, "pip")
 
         if self.required_packages:
             try:
+                # Add timeout to subprocess call
                 subprocess.run(
                     [venv_pip, "install", *self.required_packages],
                     check=True,
                     capture_output=True,
+                    timeout=self._timeout,
                 )
                 logger.info(
-                    "Installed required packages:"
+                    "Installed required packages: "
                     f"{', '.join(self.required_packages)}"
                 )
             except subprocess.CalledProcessError as e:
@@ -93,6 +114,97 @@ class PythonVerifier(BaseVerifier):
                     "Failed to install required packages: "
                     f"{e.stderr.decode().strip()}"
                 )
+                # Clean up resources before re-raising
+                if self.venv_path and os.path.exists(self.venv_path):
+                    shutil.rmtree(self.venv_path)
+                    self.venv_path = None
+                raise
+            except subprocess.TimeoutExpired:
+                logger.error(
+                    f"Package installation timed out "
+                    f"after {self._timeout} seconds"
+                )
+                if self.venv_path and os.path.exists(self.venv_path):
+                    shutil.rmtree(self.venv_path)
+                    self.venv_path = None
+                raise
+
+    def _is_uv_environment(self) -> bool:
+        r"""Detect whether the current Python runtime is managed by uv."""
+        return "UV_CACHE_DIR" in os.environ or "uv" in sys.executable
+
+    def _setup_with_uv(self) -> None:
+        r"""Create virtual environment and install packages using uv."""
+        self.venv_path = tempfile.mkdtemp()
+        try:
+            subprocess.run(
+                ["uv", "venv", self.venv_path],
+                check=True,
+                capture_output=True,
+                timeout=self._timeout,
+            )
+            logger.info(
+                f"[UV] Virtual environment created at {self.venv_path}"
+            )
+        except subprocess.CalledProcessError as e:
+            logger.error(
+                "[UV] Failed to create virtual environment:\n"
+                f"{e.stderr.decode().strip()}"
+            )
+            # Clean up resources before re-raising
+            if self.venv_path and os.path.exists(self.venv_path):
+                shutil.rmtree(self.venv_path)
+                self.venv_path = None
+            raise
+        except subprocess.TimeoutExpired:
+            logger.error(
+                f"[UV] Virtual environment creation timed "
+                f"out after {self._timeout} seconds"
+            )
+            if self.venv_path and os.path.exists(self.venv_path):
+                shutil.rmtree(self.venv_path)
+                self.venv_path = None
+            raise
+
+        if self.required_packages:
+            venv_python = os.path.join(self.venv_path, self.bin_dir, "python")
+            try:
+                subprocess.run(
+                    [
+                        "uv",
+                        "pip",
+                        "install",
+                        "--python",
+                        venv_python,
+                        *self.required_packages,
+                    ],
+                    check=True,
+                    capture_output=True,
+                    timeout=self._timeout,
+                )
+                logger.info(
+                    "[UV] Installed required packages via uv: "
+                    f"{', '.join(self.required_packages)}"
+                )
+            except subprocess.CalledProcessError as e:
+                logger.error(
+                    "[UV] Failed to install required packages via uv:\n"
+                    f"{e.stderr.decode().strip()}"
+                )
+                # Clean up resources before re-raising
+                if self.venv_path and os.path.exists(self.venv_path):
+                    shutil.rmtree(self.venv_path)
+                    self.venv_path = None
+                raise
+            except subprocess.TimeoutExpired:
+                logger.error(
+                    f"[UV] Package installation timed "
+                    f"out after {self._timeout} seconds"
+                )
+                if self.venv_path and os.path.exists(self.venv_path):
+                    shutil.rmtree(self.venv_path)
+                    self.venv_path = None
+                raise
 
     async def _cleanup(self) -> None:
         r"""Clean up the virtual environment."""
@@ -102,25 +214,29 @@ class PythonVerifier(BaseVerifier):
             self.venv_path = None
 
     async def _verify_implementation(
-        self, result: VerifierInput
+        self, solution: str, ground_truth: Optional[str]
     ) -> VerificationResult:
-        r"""Executes the LLM-generated response in a Python virtual
-        environment.
+        r"""Executes the provided Python solution in an isolated environment
+        and verifies its output against an expected ground truth expression.
+
+        This method runs the solution in a subprocess inside a virtual
+        environment. The ground truth is assumed to be a pure Python
+        expression and is evaluated directly in the verifier process.
+
+        If both executions are successful, the actual output is compared
+        against the evaluated ground truth using semantic equality. If
+        evaluation fails, string comparison is used as a fallback.
 
         Args:
-            result (VerifierInput): Contains the LLM-generated Python code to
-                execute and optional ground truth for comparison.
+            solution (str): The Python code or expression to execute and
+                verify.
+            ground_truth (Optional[str]): The expected value as a Python
+             expression. If None, only execution success is verified.
 
         Returns:
-            VerificationResult: Contains verification status (SUCCESS/FAILURE/
-                ERROR), execution output, error messages if any, and execution
-                duration.
-
-        Raises:
-            asyncio.TimeoutError: If execution exceeds the configured timeout.
-            Exception: Any unexpected errors during execution are caught and
-                converted to an ERROR verification result.
+            VerificationResult: Result of the verification process.
         """
+        # Check for virtual environment setup
         if not self.venv_path:
             return VerificationResult(
                 status=VerificationOutcome.ERROR,
@@ -128,9 +244,47 @@ class PythonVerifier(BaseVerifier):
                 error_message="Virtual environment is not set up.",
             )
 
-        script = result.llm_response.strip()
-        venv_python = os.path.join(self.venv_path, self.bin_dir, "python")
+        # If the solution is an expression, evaluate it directly
+        if self._is_expression(solution):
+            try:
+                sol_val = ast.literal_eval(solution)
+            except Exception as e:
+                return VerificationResult(
+                    status=VerificationOutcome.ERROR,
+                    result="",
+                    error_message=f"Expression evaluation error: {e}",
+                )
 
+            if ground_truth is not None:
+                try:
+                    gt_val = ast.literal_eval(ground_truth)
+                except Exception as e:
+                    return VerificationResult(
+                        status=VerificationOutcome.ERROR,
+                        result="",
+                        error_message=f"Ground truth evaluation error: {e}",
+                    )
+                if sol_val == gt_val:
+                    return VerificationResult(
+                        status=VerificationOutcome.SUCCESS,
+                        result=str(sol_val),
+                    )
+                else:
+                    return VerificationResult(
+                        status=VerificationOutcome.FAILURE,
+                        result=str(sol_val),
+                        error_message="Output mismatch: "
+                        f"{sol_val} != {gt_val}",
+                    )
+            else:
+                return VerificationResult(
+                    status=VerificationOutcome.SUCCESS,
+                    result=str(sol_val),
+                )
+
+        # Otherwise, run the code block,
+        # which should already include a print(...) in the end
+        venv_python = os.path.join(self.venv_path, self.bin_dir, "python")
         if not os.path.exists(venv_python):
             return VerificationResult(
                 status=VerificationOutcome.ERROR,
@@ -139,64 +293,166 @@ class PythonVerifier(BaseVerifier):
             )
 
         try:
-            process = await asyncio.create_subprocess_exec(
-                venv_python,
-                "-c",
-                script,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-            )
-
-            stdout, stderr = await asyncio.wait_for(
-                process.communicate(), timeout=self._timeout
+            sol_out, sol_err, sol_code = await self._run_code_block(
+                solution, venv_python
             )
+            if sol_code != 0:
+                return VerificationResult(
+                    status=VerificationOutcome.ERROR,
+                    result=sol_out,
+                    error_message=f"Solution code error:\n{sol_err}",
+                )
 
-            output_result = stdout.decode().strip()
-            error_output = stderr.decode().strip()
-
-            if process.returncode == 0:
-                # If ground truth is provided, compare it with the result
-                if result.ground_truth is not None:
-                    # Normalize both strings by removing extra whitespace
-                    normalized_output = ' '.join(output_result.strip().split())
-                    normalized_truth = ' '.join(
-                        str(result.ground_truth).strip().split()
+            if ground_truth is not None:
+                try:
+                    # First, try to evaluate the output as-is.
+                    sol_val = ast.literal_eval(sol_out)
+                except Exception as e:
+                    logger.warning(
+                        f"Direct eval failed: {e}. Trying repr on output."
                     )
+                    try:
+                        # Try to convert sol_out to a literal
+                        # by wrapping it with repr.
+                        # FIXME: may be unnecessary
+                        sol_val = ast.literal_eval(repr(sol_out))
+                    except Exception as e2:
+                        logger.warning(
+                            f"repr eval also failed: {e2}."
+                            "Falling back to string comparison."
+                        )
+                        sol_val = None
 
-                    if normalized_output == normalized_truth:
+                if sol_val is not None:
+                    try:
+                        gt_val = ast.literal_eval(ground_truth)
+                    except Exception as e:
+                        return VerificationResult(
+                            status=VerificationOutcome.ERROR,
+                            result="",
+                            error_message="Ground truth evaluation error:"
+                            f"{e}",
+                        )
+                    if sol_val == gt_val:
                         return VerificationResult(
                             status=VerificationOutcome.SUCCESS,
-                            result=output_result,
+                            result=sol_out,
                         )
                     else:
                         return VerificationResult(
                             status=VerificationOutcome.FAILURE,
-                            error_message="Output doesn't match ground truth",
-                            result=output_result,
+                            result=sol_out,
+                            error_message="Output mismatch: "
+                            f"{sol_val} != {gt_val}",
                         )
                 else:
-                    return VerificationResult(
-                        status=VerificationOutcome.SUCCESS,
-                        result=output_result,
-                    )
-
+                    # Fallback: string comparison
+                    if sol_out.strip() == ground_truth.strip():
+                        return VerificationResult(
+                            status=VerificationOutcome.SUCCESS,
+                            result=sol_out,
+                        )
+                    else:
+                        return VerificationResult(
+                            status=VerificationOutcome.FAILURE,
+                            result=sol_out,
+                            error_message="Fallback string mismatch: "
+                            f"'{sol_out}' != '{ground_truth}'",
+                        )
             else:
                 return VerificationResult(
-                    status=VerificationOutcome.ERROR,
-                    error_message=error_output,
-                    result=output_result,
+                    status=VerificationOutcome.SUCCESS,
+                    result=sol_out,
                 )
-
         except asyncio.TimeoutError:
             return VerificationResult(
                 status=VerificationOutcome.TIMEOUT,
                 result="",
                 error_message="Execution timed out.",
             )
-
         except Exception as e:
             return VerificationResult(
                 status=VerificationOutcome.ERROR,
                 result="",
-                error_message=f"Execution error: {e}",
+                error_message=f"Unexpected error: {e}",
             )
+
+    async def _run_code_block(
+        self, code: str, venv_path: str
+    ) -> Tuple[str, str, int]:
+        r"""Executes a block of Python code in the virtual environment.
+
+        The code is written to a temporary file, executed using the Python
+        interpreter from the specified virtual environment, and
+        its output and error streams are captured.
+
+        Args:
+            code (str): The Python code to execute.
+            venv_path (str): The path to the virtual environment's Python
+                binary.
+
+        Returns:
+            Tuple[str, str, int]: A tuple containing the stdout output,
+            stderr output, and return code from the executed script.
+        """
+        # No longer checking for expressions since they're handled separately
+        with tempfile.NamedTemporaryFile(
+            "w+", suffix=".py", delete=False
+        ) as tmp:
+            tmp.write(code)
+            tmp_path = tmp.name
+
+        proc = await asyncio.create_subprocess_exec(
+            venv_path,
+            tmp_path,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await asyncio.wait_for(
+            proc.communicate(), timeout=self._timeout
+        )
+        os.remove(tmp_path)
+        return (
+            stdout.decode().strip(),
+            stderr.decode().strip(),
+            proc.returncode if proc.returncode is not None else -1,
+        )
+
+    def _is_expression(self, code: str) -> bool:
+        r"""Determines whether a given string of code is a single expression.
+
+        This utility uses Python's AST module to parse the code and checks if
+        it consists of a single expression node.
+
+        Args:
+            code (str): The Python code to analyze.
+
+        Returns:
+            bool: True if the code is a single expression, False otherwise.
+        """
+        # Skip empty or whitespace-only strings
+        if not code or code.isspace():
+            return False
+
+        try:
+            # First try parsing as an expression - this is more reliable than
+            # starting with literal_eval
+            tree = ast.parse(code.strip(), mode='eval')
+            # Check if it's a function call (like print()) - these should not
+            # be treated as expressions
+            if isinstance(tree.body, ast.Call):
+                return False
+            # If parsing succeeds in 'eval' mode and it's not a function call,
+            # it's a valid expression
+            return True
+        except SyntaxError:
+            # If parsing as expression fails, it's not a valid expression
+            return False
+        except Exception:
+            # For any other parsing errors, try literal_eval as fallback for
+            # simple literals
+            try:
+                ast.literal_eval(code)
+                return True
+            except Exception:
+                return False

{camel_ai-0.2.35.dist-info → camel_ai-0.2.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.35
+Version: 0.2.37
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -58,6 +58,7 @@ Requires-Dist: jupyter-client<9,>=8.6.2; extra == 'all'
 Requires-Dist: linkup-sdk<0.3,>=0.2.1; extra == 'all'
 Requires-Dist: litellm<2,>=1.38.1; extra == 'all'
 Requires-Dist: mcp>=1.3.0; extra == 'all'
+Requires-Dist: mem0ai>=0.1.67; extra == 'all'
 Requires-Dist: mistralai<2,>=1.1.0; extra == 'all'
 Requires-Dist: mock<6,>=5; extra == 'all'
 Requires-Dist: mypy<2,>=1.5.1; extra == 'all'
@@ -78,7 +79,7 @@ Requires-Dist: prance<24,>=23.6.21.0; extra == 'all'
 Requires-Dist: praw<8,>=7.7.1; extra == 'all'
 Requires-Dist: pre-commit<4,>=3; extra == 'all'
 Requires-Dist: pydub<0.26,>=0.25.1; extra == 'all'
-Requires-Dist: pygithub<3,>=2.3.0; extra == 'all'
+Requires-Dist: pygithub<3,>=2.6.0; extra == 'all'
 Requires-Dist: pymilvus<3,>=2.4.0; extra == 'all'
 Requires-Dist: pymupdf<2,>=1.22.5; extra == 'all'
 Requires-Dist: pyowm<4,>=3.3.0; extra == 'all'
@@ -124,7 +125,7 @@ Provides-Extra: communication-tools
 Requires-Dist: discord-py<3,>=2.3.2; extra == 'communication-tools'
 Requires-Dist: notion-client<3,>=2.2.1; extra == 'communication-tools'
 Requires-Dist: praw<8,>=7.7.1; extra == 'communication-tools'
-Requires-Dist: pygithub<3,>=2.3.0; extra == 'communication-tools'
+Requires-Dist: pygithub<3,>=2.6.0; extra == 'communication-tools'
 Requires-Dist: pytelegrambotapi<5,>=4.18.0; extra == 'communication-tools'
 Requires-Dist: slack-bolt<2,>=1.20.1; extra == 'communication-tools'
 Requires-Dist: slack-sdk<4,>=3.27.2; extra == 'communication-tools'
@@ -225,6 +226,7 @@ Provides-Extra: storage
 Requires-Dist: azure-storage-blob<13,>=12.21.0; extra == 'storage'
 Requires-Dist: botocore<2,>=1.35.3; extra == 'storage'
 Requires-Dist: google-cloud-storage<3,>=2.18.0; extra == 'storage'
+Requires-Dist: mem0ai>=0.1.73; extra == 'storage'
 Requires-Dist: nebula3-python==3.8.2; extra == 'storage'
 Requires-Dist: neo4j<6,>=5.18.0; extra == 'storage'
 Requires-Dist: pymilvus<3,>=2.4.0; extra == 'storage'
@@ -443,9 +445,56 @@ Installing CAMEL is a breeze thanks to its availability on PyPI. Simply open you
 pip install camel-ai
 ```
 
+### Starting with ChatAgent
+
+This example demonstrates how to create a `ChatAgent` using the CAMEL framework and perform a search query using DuckDuckGo.
+
+1. **Install the tools package:**
+
+  ```bash
+  pip install 'camel-ai[web_tools]'
+  ```
+
+2. **Set up your OpenAI API key:**
+
+  ```bash
+  export OPENAI_API_KEY='your_openai_api_key'
+  ```
+
+3. **Run the following Python code:**
+
+  ```python
+  from camel.models import ModelFactory
+  from camel.types import ModelPlatformType, ModelType
+  from camel.agents import ChatAgent
+  from camel.toolkits import SearchToolkit
+
+  model = ModelFactory.create(
+    model_platform=ModelPlatformType.OPENAI,
+    model_type=ModelType.GPT_4O,
+    model_config_dict={"temperature": 0.0},
+  )
+
+  search_tool = SearchToolkit().search_duckduckgo
+
+  agent = ChatAgent(model=model, tools=[search_tool])
+
+  response_1 = agent.step("What is CAMEL-AI?")
+  print(response_1.msgs[0].content)
+  # CAMEL-AI is the first LLM (Large Language Model) multi-agent framework
+  # and an open-source community focused on finding the scaling laws of agents.
+  # ...
+
+  response_2 = agent.step("What is the Github link to CAMEL framework?")
+  print(response_2.msgs[0].content)
+  # The GitHub link to the CAMEL framework is
+  # [https://github.com/camel-ai/camel](https://github.com/camel-ai/camel).
+  ```
+
+
 For more detailed instructions and additional configuration options, check out the [installation section](https://github.com/camel-ai/camel/blob/master/docs/get_started/installation.md).
 
-After running, you can explore our CAMEL Tech Stack and Cookbooks at [www.docs.camel-ai.org](https://docs.camel-ai.org) to build powerful multi-agent systems.
+After running, you can explore our CAMEL Tech Stack and Cookbooks at [docs.camel-ai.org](https://docs.camel-ai.org) to build powerful multi-agent systems.
 
 We provide a [![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1AzP33O8rnMW__7ocWJhVBXjKziJXPtim?usp=sharing) demo showcasing a conversation between two ChatGPT agents playing roles as a python programmer and a stock trader collaborating on developing a trading bot for stock market.
 
@@ -503,7 +552,7 @@ We believe that studying these agents on a large scale offers valuable insights
 </div>
 
 <div align="center">
-  <a href="https://www.agent-trust.camel-ai.org/">
+  <a href="https://agent-trust.camel-ai.org/">
     <img src="docs/images/agent_trust.png" alt="Agent Trust">
   </a>
 </div>