camel-ai 0.2.38__py3-none-any.whl → 0.2.39__py3-none-any.whl

camel/verifiers/math_verifier.py

@@ -0,0 +1,182 @@
+# ========= 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
+
+from camel.extractors.base import BaseExtractor
+from camel.logger import get_logger
+from camel.verifiers import BaseVerifier
+from camel.verifiers.models import VerificationOutcome, VerificationResult
+
+logger = get_logger(__name__)
+
+
+class MathVerifier(BaseVerifier):
+    r"""Verifier for mathematical expressions using Math-Verify.
+
+    Features:
+    - Supports LaTeX and plain mathematical expressions
+    - Handles complex numbers, matrices, and sets
+    - Configurable precision for floating-point comparisons
+    - Optional LaTeX wrapping to ensure proper parsing and rendering
+    - Comprehensive error handling and logging
+    """
+
+    def __init__(
+        self,
+        extractor: Optional[BaseExtractor] = None,
+        timeout: Optional[float] = 30.0,
+        float_rounding: int = 6,
+        numeric_precision: int = 15,
+        enable_wrapping: Optional[bool] = False,
+        **kwargs,
+    ):
+        r"""Initializes the MathVerifier.
+
+        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`)
+            float_rounding (int, optional): The number of decimal places to
+                round floating-point numbers. (default: :obj:`6`)
+            numeric_precision (int, optional): The numeric precision for
+                floating-point comparisons. (default: :obj:`15`)
+            enable_wrapping (Optional[bool], optional): Whether to wrap LaTeX
+                expressions in math mode delimiters. (default: :obj:`False`)
+        """
+        super().__init__(extractor=extractor, timeout=timeout, **kwargs)
+        self.float_rounding = float_rounding
+        self.numeric_precision = numeric_precision
+        self.enable_wrapping = enable_wrapping
+
+    @staticmethod
+    def _latex_wrapping(s: str) -> str:
+        r"""Wrap a LaTeX expression in math mode delimiters.
+
+        This function checks whether the input string is already in a LaTeX
+        math environment (e.g., $, \[, \begin{}, etc.). If not, it wraps the
+        expression in $$...$$ to ensure proper parsing and rendering as a
+        mathematical expression.
+
+        Args:
+            s (str): The input LaTeX string.
+
+        Returns:
+            str: The LaTeX string wrapped in math mode if necessary.
+        """
+        s_stripped = s.strip()
+        if (
+            not any(
+                s_stripped.startswith(prefix)
+                for prefix in ("$", "\\(", "\\[", "\\begin")
+            )
+            and "\\boxed" not in s_stripped
+        ):
+            s = f"$$ {s_stripped} $$"
+        return s
+
+    async def _setup(self, **kwargs) -> None:
+        r"""No special setup needed for math verification."""
+        pass
+
+    async def _cleanup(self) -> None:
+        r"""No cleanup needed for math verification."""
+        pass
+
+    async def _verify_implementation(
+        self, solution: str, reference_answer: Optional[str]
+    ) -> VerificationResult:
+        r"""Verify mathematical expressions using Math-Verify.
+
+        Args:
+            solution: The solution to verify
+            reference_answer: The expected answer to compare against
+
+        Returns:
+            VerificationResult containing the verification status and details
+        """
+        from math_verify import parse, verify
+        from math_verify.parser import (
+            ExprExtractionConfig,
+            LatexExtractionConfig,
+        )
+
+        if reference_answer is None:
+            return VerificationResult(
+                status=VerificationOutcome.ERROR,
+                result="",
+                error_message=(
+                    "Ground truth is required for " "mathematical verification"
+                ),
+            )
+
+        try:
+            # Apply LaTeX wrapping if enabled
+            if self.enable_wrapping:
+                solution = self._latex_wrapping(solution)
+                reference_answer = self._latex_wrapping(reference_answer)
+                logger.debug("Applied LaTeX wrapping")
+
+            # Parse both expressions with LaTeX and plain expression support
+            parsed_reference_answer = parse(
+                reference_answer,
+                extraction_config=[
+                    LatexExtractionConfig(boxed_match_priority=0),
+                    ExprExtractionConfig(),
+                ],
+            )
+            parsed_solution = parse(
+                solution,
+                extraction_config=[
+                    LatexExtractionConfig(),
+                    ExprExtractionConfig(),
+                ],
+            )
+
+            if not parsed_reference_answer or not parsed_solution:
+                return VerificationResult(
+                    status=VerificationOutcome.ERROR,
+                    result="",
+                    error_message="Failed to parse expressions",
+                )
+
+            # Order matters! reference_answer must be first argument
+            is_correct = verify(
+                parsed_reference_answer,
+                parsed_solution,
+                float_rounding=self.float_rounding,
+                numeric_precision=self.numeric_precision,
+            )
+
+            if is_correct:
+                logger.debug("Mathematical verification succeeded")
+                return VerificationResult(
+                    status=VerificationOutcome.SUCCESS, result=solution
+                )
+            else:
+                logger.debug("Mathematical verification failed")
+                return VerificationResult(
+                    status=VerificationOutcome.FAILURE,
+                    result=solution,
+                    error_message="Solution does not match ground truth",
+                )
+
+        except Exception as error:
+            logger.error(f"Mathematical verification error: {error!s}")
+            return VerificationResult(
+                status=VerificationOutcome.ERROR,
+                result="",
+                error_message=f"Mathematical verification error: {error!s}",
+            )

camel/verifiers/python_verifier.py

@@ -76,15 +76,19 @@ class PythonVerifier(BaseVerifier):
 
     async def _setup(self, **kwargs) -> None:
         r"""Set up a virtual environment and install required packages."""
-        uv = kwargs.get('uv', True)
-        if uv and self._is_uv_environment():
+        # Check if we're in a uv environment and use uv if available
+        if kwargs.get("uv", False) 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()
         try:
-            venv.create(self.venv_path, with_pip=True)
+            # Use system=True to ensure that the virtual environment uses the
+            # system Python libraries
+            venv.create(
+                self.venv_path, with_pip=True, system_site_packages=True
+            )
             logger.info(f"Virtual environment created at {self.venv_path}")
         except Exception as e:
             logger.error(f"Failed to create virtual environment: {e}")
@@ -138,7 +142,7 @@ class PythonVerifier(BaseVerifier):
         self.venv_path = tempfile.mkdtemp()
         try:
             subprocess.run(
-                ["uv", "venv", self.venv_path],
+                ["uv", "venv", "--python", sys.executable, self.venv_path],
                 check=True,
                 capture_output=True,
                 timeout=self._timeout,
@@ -218,7 +222,7 @@ class PythonVerifier(BaseVerifier):
             self.venv_path = None
 
     async def _verify_implementation(
-        self, solution: str, ground_truth: Optional[str]
+        self, solution: str, reference_answer: Optional[str]
     ) -> VerificationResult:
         r"""Executes the provided Python solution in an isolated environment
         and verifies its output against an expected ground truth expression.
@@ -234,7 +238,7 @@ class PythonVerifier(BaseVerifier):
         Args:
             solution (str): The Python code or expression to execute and
                 verify.
-            ground_truth (Optional[str]): The expected value as a Python
+            reference_answer (Optional[str]): The expected value as a Python
              expression. If None, only execution success is verified.
 
         Returns:
@@ -259,9 +263,9 @@ class PythonVerifier(BaseVerifier):
                     error_message=f"Expression evaluation error: {e}",
                 )
 
-            if ground_truth is not None:
+            if reference_answer is not None:
                 try:
-                    gt_val = ast.literal_eval(ground_truth)
+                    gt_val = ast.literal_eval(reference_answer)
                 except Exception as e:
                     return VerificationResult(
                         status=VerificationOutcome.ERROR,
@@ -311,29 +315,17 @@ class PythonVerifier(BaseVerifier):
                     error_message=f"Solution code error:\n{sol_err}",
                 )
 
-            if ground_truth is not None:
+            if reference_answer 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
+                    logger.warning(f"Direct eval failed: {e}.")
+                    sol_val = None
 
                 if sol_val is not None:
                     try:
-                        gt_val = ast.literal_eval(ground_truth)
+                        gt_val = ast.literal_eval(reference_answer)
                     except Exception as e:
                         return VerificationResult(
                             status=VerificationOutcome.ERROR,
@@ -355,7 +347,7 @@ class PythonVerifier(BaseVerifier):
                         )
                 else:
                     # Fallback: string comparison
-                    if sol_out.strip() == ground_truth.strip():
+                    if sol_out.strip() == reference_answer.strip():
                         return VerificationResult(
                             status=VerificationOutcome.SUCCESS,
                             result=sol_out,
@@ -365,7 +357,7 @@ class PythonVerifier(BaseVerifier):
                             status=VerificationOutcome.FAILURE,
                             result=sol_out,
                             error_message="Fallback string mismatch: "
-                            f"'{sol_out}' != '{ground_truth}'",
+                            f"'{sol_out}' != '{reference_answer}'",
                         )
             else:
                 return VerificationResult(

{camel_ai-0.2.38.dist-info → camel_ai-0.2.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.38
+Version: 0.2.39
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -55,6 +55,7 @@ Requires-Dist: ipykernel<7,>=6.0.0; extra == 'all'
 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: math-verify<0.8,>=0.7.0; 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'
@@ -133,6 +134,7 @@ Provides-Extra: data-tools
 Requires-Dist: aiosqlite<0.21,>=0.20.0; extra == 'data-tools'
 Requires-Dist: datacommons-pandas<0.0.4,>=0.0.3; extra == 'data-tools'
 Requires-Dist: datacommons<2,>=1.4.3; extra == 'data-tools'
+Requires-Dist: math-verify<0.8,>=0.7.0; extra == 'data-tools'
 Requires-Dist: networkx<4,>=3.4.2; extra == 'data-tools'
 Requires-Dist: numpy~=1.26; extra == 'data-tools'
 Requires-Dist: pandas<2,>=1.5.3; extra == 'data-tools'