camel-ai 0.2.21__py3-none-any.whl → 0.2.22__py3-none-any.whl

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.21'
+__version__ = '0.2.22'
 
 __all__ = [
     '__version__',

camel/datagen/self_instruct/self_instruct.py

@@ -361,7 +361,7 @@ class SelfInstructPipeline:
         in JSON format.
         """
         with open(self.data_output_path, 'w') as f:
-            json.dump(self.machine_tasks, f, indent=4)
+            json.dump(self.machine_tasks, f, indent=4, ensure_ascii=False)
 
     def generate(self):
         r"""Execute the entire pipeline to generate machine instructions

camel/embeddings/openai_embedding.py

@@ -30,6 +30,8 @@ class OpenAIEmbedding(BaseEmbedding[str]):
         model_type (EmbeddingModelType, optional): The model type to be
             used for text embeddings.
             (default: :obj:`TEXT_EMBEDDING_3_SMALL`)
+        url (Optional[str], optional): The url to the OpenAI service.
+            (default: :obj:`None`)
         api_key (str, optional): The API key for authenticating with the
             OpenAI service. (default: :obj:`None`)
         dimensions (int, optional): The text embedding output dimensions.
@@ -49,6 +51,7 @@ class OpenAIEmbedding(BaseEmbedding[str]):
         model_type: EmbeddingModelType = (
             EmbeddingModelType.TEXT_EMBEDDING_3_SMALL
         ),
+        url: str | None = None,
         api_key: str | None = None,
         dimensions: int | NotGiven = NOT_GIVEN,
     ) -> None:
@@ -61,7 +64,13 @@ class OpenAIEmbedding(BaseEmbedding[str]):
             assert isinstance(dimensions, int)
             self.output_dim = dimensions
         self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
-        self.client = OpenAI(timeout=180, max_retries=3, api_key=self._api_key)
+        self._url = url or os.environ.get("OPENAI_API_BASE_URL")
+        self.client = OpenAI(
+            timeout=180,
+            max_retries=3,
+            base_url=self._url,
+            api_key=self._api_key,
+        )
 
     def embed_list(
         self,

camel/interpreters/docker/Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.9-slim
+
+# Install R and required dependencies
+RUN apt-get update && apt-get install -y \
+    r-base \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /workspace
+
+# Keep container running
+CMD ["tail", "-f", "/dev/null"]

camel/interpreters/docker_interpreter.py

@@ -52,11 +52,13 @@ class DockerInterpreter(BaseInterpreter):
     _CODE_EXECUTE_CMD_MAPPING: ClassVar[Dict[str, str]] = {
         "python": "python {file_name}",
         "bash": "bash {file_name}",
+        "r": "Rscript {file_name}",
     }
 
     _CODE_EXTENSION_MAPPING: ClassVar[Dict[str, str]] = {
         "python": "py",
         "bash": "sh",
+        "r": "R",
     }
 
     _CODE_TYPE_MAPPING: ClassVar[Dict[str, str]] = {
@@ -67,6 +69,8 @@ class DockerInterpreter(BaseInterpreter):
         "shell": "bash",
         "bash": "bash",
         "sh": "bash",
+        "r": "r",
+        "R": "r",
     }
 
     def __init__(
@@ -104,8 +108,22 @@ class DockerInterpreter(BaseInterpreter):
         import docker
 
         client = docker.from_env()
+
+        # Build custom image with Python and R
+        dockerfile_path = Path(__file__).parent / "docker"
+        image_tag = "camel-interpreter:latest"
+        try:
+            client.images.get(image_tag)
+        except docker.errors.ImageNotFound:
+            logger.info("Building custom interpreter image...")
+            client.images.build(
+                path=str(dockerfile_path),
+                tag=image_tag,
+                rm=True,
+            )
+
         self._container = client.containers.run(
-            "python:3.10",
+            image_tag,
             detach=True,
             name=f"camel-interpreter-{uuid.uuid4()}",
             command="tail -f /dev/null",

camel/interpreters/subprocess_interpreter.py

@@ -48,11 +48,13 @@ class SubprocessInterpreter(BaseInterpreter):
     _CODE_EXECUTE_CMD_MAPPING: ClassVar[Dict[str, str]] = {
         "python": "python {file_name}",
         "bash": "bash {file_name}",
+        "r": "Rscript {file_name}",
     }
 
     _CODE_EXTENSION_MAPPING: ClassVar[Dict[str, str]] = {
         "python": "py",
         "bash": "sh",
+        "r": "R",
     }
 
     _CODE_TYPE_MAPPING: ClassVar[Dict[str, str]] = {
@@ -63,6 +65,8 @@ class SubprocessInterpreter(BaseInterpreter):
         "shell": "bash",
         "bash": "bash",
         "sh": "bash",
+        "r": "r",
+        "R": "r",
     }
 
     def __init__(
@@ -98,7 +102,7 @@ class SubprocessInterpreter(BaseInterpreter):
         if not file.is_file():
             raise RuntimeError(f"{file} is not a file.")
         code_type = self._check_code_type(code_type)
-        if code_type == "python":
+        if self._CODE_TYPE_MAPPING[code_type] == "python":
             # For Python code, use ast to analyze and modify the code
             import ast
 
@@ -113,23 +117,41 @@ class SubprocessInterpreter(BaseInterpreter):
                 # Get the last node
                 if tree.body:
                     last_node = tree.body[-1]
-                    # If it's an expression, wrap it in a print
+                    # Handle expressions that would normally not produce output
+                    # For example: In a REPL, typing '1 + 2' should show '3'
+
                     if isinstance(last_node, ast.Expr):
-                        tree.body[-1] = ast.Expr(
-                            value=ast.Call(
-                                func=ast.Name(id='print', ctx=ast.Load()),
-                                args=[
-                                    ast.Call(
-                                        func=ast.Name(
-                                            id='repr', ctx=ast.Load()
-                                        ),
-                                        args=[last_node.value],
-                                        keywords=[],
-                                    )
-                                ],
-                                keywords=[],
+                        # Only wrap in print(repr()) if it's not already a
+                        # print call
+                        if not (
+                            isinstance(last_node.value, ast.Call)
+                            and isinstance(last_node.value.func, ast.Name)
+                            and last_node.value.func.id == 'print'
+                        ):
+                            # Transform the AST to wrap the expression in print
+                            # (repr())
+                            # Example transformation:
+                            #   Before: x + y
+                            #   After:  print(repr(x + y))
+                            tree.body[-1] = ast.Expr(
+                                value=ast.Call(
+                                    # Create print() function call
+                                    func=ast.Name(id='print', ctx=ast.Load()),
+                                    args=[
+                                        ast.Call(
+                                            # Create repr() function call
+                                            func=ast.Name(
+                                                id='repr', ctx=ast.Load()
+                                            ),
+                                            # Pass the original expression as
+                                            # argument to repr()
+                                            args=[last_node.value],
+                                            keywords=[],
+                                        )
+                                    ],
+                                    keywords=[],
+                                )
                             )
-                        )
                     # Fix missing source locations
                     ast.fix_missing_locations(tree)
                     # Convert back to source
@@ -159,7 +181,10 @@ class SubprocessInterpreter(BaseInterpreter):
         return_code = proc.returncode
 
         # Clean up temporary file if it was created
-        if code_type == "python" and 'temp_file' in locals():
+        if (
+            self._CODE_TYPE_MAPPING[code_type] == "python"
+            and 'temp_file' in locals()
+        ):
             temp_file.unlink()
 
         if self.print_stdout and stdout:

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 .mineru_extractor import MinerU
 from .panda_reader import PandaReader
 from .unstructured_io import UnstructuredIO
 
@@ -30,4 +31,5 @@ __all__ = [
     'Apify',
     'ChunkrReader',
     'PandaReader',
+    'MinerU',
 ]

camel/loaders/mineru_extractor.py

@@ -0,0 +1,250 @@
+# ========= 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
+import time
+from typing import Dict, List, Optional, Union
+
+import requests
+
+from camel.utils import api_keys_required
+
+
+class MinerU:
+    r"""Document extraction service supporting OCR, formula recognition
+        and tables.
+
+    Args:
+        api_key (str, optional): Authentication key for MinerU API service.
+            If not provided, will use MINERU_API_KEY environment variable.
+            (default: :obj:`None`)
+        api_url (str, optional): Base URL endpoint for the MinerU API service.
+            (default: :obj:`"https://mineru.net/api/v4"`)
+
+    Note:
+        - Single file size limit: 200MB
+        - Page limit per file: 600 pages
+        - Daily high-priority parsing quota: 2000 pages
+        - Some URLs (GitHub, AWS) may timeout due to network restrictions
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", "MINERU_API_KEY"),
+        ]
+    )
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_url: Optional[str] = "https://mineru.net/api/v4",
+        is_ocr: bool = False,
+        enable_formula: bool = False,
+        enable_table: bool = True,
+        layout_model: str = "doclayout_yolo",
+        language: str = "en",
+    ) -> None:
+        r"""Initialize MinerU extractor.
+
+        Args:
+            api_key (str, optional): Authentication key for MinerU API service.
+                If not provided, will use MINERU_API_KEY environment variable.
+            api_url (str, optional): Base URL endpoint for MinerU API service.
+                (default: "https://mineru.net/api/v4")
+            is_ocr (bool, optional): Enable optical character recognition.
+                (default: :obj:`False`)
+            enable_formula (bool, optional): Enable formula recognition.
+                (default: :obj:`False`)
+            enable_table (bool, optional): Enable table detection, extraction.
+                (default: :obj:`True`)
+            layout_model (str, optional): Model for document layout detection.
+                Options are 'doclayout_yolo' or 'layoutlmv3'.
+                (default: :obj:`"doclayout_yolo"`)
+            language (str, optional): Primary language of the document.
+                (default: :obj:`"en"`)
+        """
+        self._api_key = api_key or os.environ.get("MINERU_API_KEY")
+        self._api_url = api_url
+        self._headers = {
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+            "Accept": "*/*",
+        }
+        self.is_ocr = is_ocr
+        self.enable_formula = enable_formula
+        self.enable_table = enable_table
+        self.layout_model = layout_model
+        self.language = language
+
+    def extract_url(self, url: str) -> Dict:
+        r"""Extract content from a URL document.
+
+        Args:
+            url (str): Document URL to extract content from.
+
+        Returns:
+            Dict: Task identifier for tracking extraction progress.
+        """
+        endpoint = f"{self._api_url}/extract/task"
+        payload = {"url": url}
+
+        try:
+            response = requests.post(
+                endpoint,
+                headers=self._headers,
+                json=payload,
+            )
+            response.raise_for_status()
+            return response.json()["data"]
+        except Exception as e:
+            raise RuntimeError(f"Failed to extract URL: {e}")
+
+    def batch_extract_urls(
+        self,
+        files: List[Dict[str, Union[str, bool]]],
+    ) -> str:
+        r"""Extract content from multiple document URLs in batch.
+
+        Args:
+            files (List[Dict[str, Union[str, bool]]]): List of document
+                configurations. Each document requires 'url' and optionally
+                'is_ocr' and 'data_id' parameters.
+
+        Returns:
+            str: Batch identifier for tracking extraction progress.
+        """
+        endpoint = f"{self._api_url}/extract/task/batch"
+        payload = {"files": files}
+
+        try:
+            response = requests.post(
+                endpoint,
+                headers=self._headers,
+                json=payload,
+            )
+            response.raise_for_status()
+            return response.json()["data"]["batch_id"]
+        except Exception as e:
+            raise RuntimeError(f"Failed to batch extract URLs: {e}")
+
+    def get_task_status(self, task_id: str) -> Dict:
+        r"""Retrieve status of a single extraction task.
+
+        Args:
+            task_id (str): Unique identifier of the extraction task.
+
+        Returns:
+            Dict: Current task status and results if completed.
+        """
+        endpoint = f"{self._api_url}/extract/task/{task_id}"
+
+        try:
+            response = requests.get(endpoint, headers=self._headers)
+            response.raise_for_status()
+            return response.json()["data"]
+        except Exception as e:
+            raise RuntimeError(f"Failed to get task status: {e}")
+
+    def get_batch_status(self, batch_id: str) -> Dict:
+        r"""Retrieve status of a batch extraction task.
+
+        Args:
+            batch_id (str): Unique identifier of the batch extraction task.
+
+        Returns:
+            Dict: Current status and results for all documents in the batch.
+        """
+        endpoint = f"{self._api_url}/extract-results/batch/{batch_id}"
+
+        try:
+            response = requests.get(endpoint, headers=self._headers)
+            response.raise_for_status()
+            return response.json()["data"]
+        except Exception as e:
+            raise RuntimeError(f"Failed to get batch status: {e}")
+
+    def wait_for_completion(
+        self,
+        task_id: str,
+        is_batch: bool = False,
+        timeout: float = 100,
+        check_interval: float = 5,
+    ) -> Dict:
+        r"""Monitor task until completion or timeout.
+
+        Args:
+            task_id (str): Unique identifier of the task or batch.
+            is_batch (bool, optional): Indicates if task is a batch operation.
+                (default: :obj:`False`)
+            timeout (float, optional): Maximum wait time in seconds.
+                (default: :obj:`100`)
+            check_interval (float, optional): Time between status checks in
+                seconds. (default: :obj:`5`)
+
+        Returns:
+            Dict: Final task status and extraction results.
+
+        Raises:
+            TimeoutError: If task exceeds specified timeout duration.
+            RuntimeError: If task fails or encounters processing error.
+        """
+        start_time = time.time()
+        while True:
+            if time.time() - start_time > timeout:
+                raise TimeoutError(
+                    f"Task {task_id} timed out after {timeout}s"
+                )
+
+            try:
+                status = (
+                    self.get_batch_status(task_id)
+                    if is_batch
+                    else self.get_task_status(task_id)
+                )
+
+                if is_batch:
+                    # Check batch status
+                    all_done = True
+                    failed_tasks = []
+                    for result in status.get('extract_result', []):
+                        if result.get('state') == 'failed':
+                            failed_tasks.append(
+                                f"{result.get('data_id')}:"
+                                f" {result.get('err_msg')}"
+                            )
+                        elif result.get('state') != 'done':
+                            all_done = False
+                            break
+
+                    if failed_tasks:
+                        raise RuntimeError(
+                            f"Batch tasks failed: {'; '.join(failed_tasks)}"
+                        )
+                    if all_done:
+                        return status
+                else:
+                    # Check single task status
+                    state = status.get('state')
+                    if state == 'failed':
+                        raise RuntimeError(
+                            f"Task failed: {status.get('err_msg')}"
+                        )
+                    elif state == 'done':
+                        return status
+
+            except Exception as e:
+                if not isinstance(e, RuntimeError):
+                    raise RuntimeError(f"Error checking status: {e}")
+                raise
+
+            time.sleep(check_interval)

camel/models/base_model.py

@@ -11,6 +11,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import abc
+import re
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Union
 
@@ -27,7 +29,30 @@ from camel.types import (
 from camel.utils import BaseTokenCounter
 
 
-class BaseModelBackend(ABC):
+class ModelBackendMeta(abc.ABCMeta):
+    r"""Metaclass that automatically preprocesses messages in run method.
+
+    Automatically wraps the run method of any class inheriting from
+    BaseModelBackend to preprocess messages (remove <think> tags) before they
+    are sent to the model.
+    """
+
+    def __new__(mcs, name, bases, namespace):
+        r"""Wraps run method with preprocessing if it exists in the class."""
+        if 'run' in namespace:
+            original_run = namespace['run']
+
+            def wrapped_run(
+                self, messages: List[OpenAIMessage], *args, **kwargs
+            ):
+                messages = self.preprocess_messages(messages)
+                return original_run(self, messages, *args, **kwargs)
+
+            namespace['run'] = wrapped_run
+        return super().__new__(mcs, name, bases, namespace)
+
+
+class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
     r"""Base class for different model backends.
     It may be OpenAI API, a local LLM, a stub for unit tests, etc.
 
@@ -73,6 +98,34 @@ class BaseModelBackend(ABC):
         """
         pass
 
+    def preprocess_messages(
+        self, messages: List[OpenAIMessage]
+    ) -> List[OpenAIMessage]:
+        r"""Preprocess messages before sending to model API.
+        Removes thinking content and other model-specific preprocessing.
+
+        Args:
+            messages (List[OpenAIMessage]): Original messages
+
+        Returns:
+            List[OpenAIMessage]: Preprocessed messages
+        """
+        # Remove thinking content from messages before sending to API
+        # This ensures only the final response is sent, excluding
+        # intermediate thought processes
+        return [
+            {  # type: ignore[misc]
+                **msg,
+                'content': re.sub(
+                    r'<think>.*?</think>',
+                    '',
+                    msg['content'],  # type: ignore[arg-type]
+                    flags=re.DOTALL,
+                ).strip(),
+            }
+            for msg in messages
+        ]
+
     @abstractmethod
     def run(
         self,

camel/models/deepseek_model.py

@@ -118,8 +118,6 @@ class DeepSeekModel(BaseModelBackend):
         if self.model_type in [
             ModelType.DEEPSEEK_REASONER,
         ]:
-            import re
-
             logger.warning(
                 "You are using a DeepSeek Reasoner model, "
                 "which has certain limitations, reference: "
@@ -141,22 +139,6 @@ class DeepSeekModel(BaseModelBackend):
                 if key in self.model_config_dict:
                     del self.model_config_dict[key]
 
-            # Remove thinking content from messages before sending to API
-            # This ensures only the final response is sent, excluding
-            # intermediate thought processes
-            messages = [
-                {  # type: ignore[misc]
-                    **msg,
-                    'content': re.sub(
-                        r'<think>.*?</think>',
-                        '',
-                        msg['content'],  # type: ignore[arg-type]
-                        flags=re.DOTALL,
-                    ).strip(),
-                }
-                for msg in messages
-            ]
-
         response = self._client.chat.completions.create(
             messages=messages,
             model=self.model_type,

camel/toolkits/__init__.py

@@ -45,8 +45,10 @@ from .human_toolkit import HumanToolkit
 from .stripe_toolkit import StripeToolkit
 from .video_toolkit import VideoDownloaderToolkit
 from .dappier_toolkit import DappierToolkit
-from .sympy_toolkit import SymPyToolkit
 from .semantic_scholar_toolkit import SemanticScholarToolkit
+from .sympy_toolkit import SymPyToolkit
+from .mineru_toolkit import MinerUToolkit
+
 
 __all__ = [
     'BaseToolkit',
@@ -79,6 +81,7 @@ __all__ = [
     'MeshyToolkit',
     'OpenBBToolkit',
     'DappierToolkit',
-    'SymPyToolkit',
     'SemanticScholarToolkit',
+    'SymPyToolkit',
+    'MinerUToolkit',
 ]

camel/toolkits/mineru_toolkit.py

@@ -0,0 +1,178 @@
+# ========= 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 Dict, List, Optional
+
+from camel.loaders.mineru_extractor import MinerU
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import api_keys_required
+
+
+class MinerUToolkit(BaseToolkit):
+    r"""Toolkit for extracting and processing document content
+        using MinerU API.
+
+    Provides comprehensive document processing capabilities including content
+    extraction from URLs and files, with support for OCR, formula recognition,
+    and table detection through the MinerU API service.
+
+    Note:
+        - Maximum file size: 200MB per file
+        - Maximum pages: 600 pages per file
+        - Daily quota: 2000 pages for high-priority parsing
+        - Network restrictions may affect certain URLs (e.g., GitHub, AWS)
+    """
+
+    @api_keys_required(
+        [
+            (None, "MINERU_API_KEY"),
+        ]
+    )
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_url: Optional[str] = "https://mineru.net/api/v4",
+        is_ocr: bool = False,
+        enable_formula: bool = False,
+        enable_table: bool = True,
+        layout_model: str = "doclayout_yolo",
+        language: str = "en",
+        wait: bool = True,
+        timeout: float = 300,
+    ) -> None:
+        r"""Initialize the MinerU document processing toolkit.
+
+        Args:
+            api_key (Optional[str]): Authentication key for MinerU API access.
+                If not provided, uses MINERU_API_KEY environment variable.
+                (default: :obj:`None`)
+            api_url (Optional[str]): Base endpoint URL for MinerU API service.
+                (default: :obj:`"https://mineru.net/api/v4"`)
+            is_ocr (bool): Enable Optical Character Recognition for image-based
+                text extraction. (default: :obj:`False`)
+            enable_formula (bool): Enable mathematical formula detection and
+                recognition. (default: :obj:`False`)
+            enable_table (bool): Enable table structure detection and
+                extraction. (default: :obj:`True`)
+            layout_model (str): Document layout analysis model selection.
+                Available options: 'doclayout_yolo', 'layoutlmv3'.
+                (default: :obj:`"doclayout_yolo"`)
+            language (str): Primary language of the document for processing.
+                (default: :obj:`"en"`)
+            wait (bool): Block execution until processing completion.
+                (default: :obj:`True`)
+            timeout (float): Maximum duration in seconds to wait for task
+                completion. (default: :obj:`300`)
+        """
+        self.client = MinerU(
+            api_key=api_key,
+            api_url=api_url,
+            is_ocr=is_ocr,
+            enable_formula=enable_formula,
+            enable_table=enable_table,
+            layout_model=layout_model,
+            language=language,
+        )
+        self.wait = wait
+        self.timeout = timeout
+
+    def extract_from_urls(
+        self,
+        urls: str | List[str],
+    ) -> Dict:
+        r"""Process and extract content from one or multiple URLs.
+
+        Args:
+            urls (str | List[str]): Target URL or list of URLs for content
+                extraction. Supports both single URL string and multiple URLs
+                in a list.
+
+        Returns:
+            Dict: Response containing either completed task results when wait
+                is True, or task/batch identifiers for status tracking when
+                wait is False.
+        """
+        if isinstance(urls, str):
+            # Single URL case
+            response = self.client.extract_url(url=urls)
+
+            if self.wait:
+                return self.client.wait_for_completion(
+                    response['task_id'],
+                    timeout=self.timeout,
+                )
+            return response
+        else:
+            # Multiple URLs case
+            files: List[Dict[str, str | bool]] = [
+                {"url": str(url)} for url in urls
+            ]
+            batch_id = self.client.batch_extract_urls(files=files)
+
+            if self.wait:
+                return self.client.wait_for_completion(
+                    batch_id,
+                    is_batch=True,
+                    timeout=self.timeout if self.timeout > 300 else 600,
+                )
+            return {"batch_id": batch_id}
+
+    def get_task_status(self, task_id: str) -> Dict:
+        r"""Retrieve current status of an individual extraction task.
+
+        Args:
+            task_id (str): Unique identifier for the extraction task to check.
+
+        Returns:
+            Dict: Status information and results (if task is completed) for
+                the specified task.
+
+        Note:
+            This is a low-level status checking method. For most use cases,
+            prefer using extract_from_url with wait=True for automatic
+            completion handling.
+        """
+        return self.client.get_task_status(task_id)
+
+    def get_batch_status(self, batch_id: str) -> Dict:
+        r"""Retrieve current status of a batch extraction task.
+
+        Args:
+            batch_id (str): Unique identifier for the batch extraction task
+                to check.
+
+        Returns:
+            Dict: Comprehensive status information and results for all files
+                in the batch task.
+
+        Note:
+            This is a low-level status checking method. For most use cases,
+            prefer using batch_extract_from_urls with wait=True for automatic
+            completion handling.
+        """
+        return self.client.get_batch_status(batch_id)
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Retrieve available toolkit functions as FunctionTool objects.
+
+        Returns:
+            List[FunctionTool]: Collection of FunctionTool objects representing
+                the available document processing functions in this toolkit.
+        """
+        return [
+            FunctionTool(self.extract_from_urls),
+            FunctionTool(self.get_task_status),
+            FunctionTool(self.get_batch_status),
+        ]

camel/toolkits/sympy_toolkit.py

@@ -721,6 +721,43 @@ class SymPyToolkit(BaseToolkit):
         except Exception as e:
             return self.handle_exception("compute_rank", e)
 
+    def compute_inner_product(
+        self, vector1: List[float], vector2: List[float]
+    ) -> str:
+        r"""Computes the inner (dot) product of two vectors.
+
+        Args:
+            vector1 (List[float]): The first vector as a list of floats.
+            vector2 (List[float]): The second vector as a list of floats.
+
+        Returns:
+            str: JSON string containing the inner product in the `"result"`
+                field. If an error occurs, the JSON string will include an
+                `"error"` field with the corresponding error message.
+
+        Raises:
+            ValueError: If the vectors have different dimensions.
+        """
+        import sympy as sp
+
+        try:
+            # Convert the lists into sympy Matrix objects (column vectors)
+            v1 = sp.Matrix(vector1)
+            v2 = sp.Matrix(vector2)
+
+            # Check that the vectors have the same dimensions.
+            if v1.shape != v2.shape:
+                raise ValueError(
+                    "Vectors must have the same dimensions to compute "
+                    "the inner product."
+                )
+
+            # Compute the dot (inner) product.
+            inner_product = v1.dot(v2)
+            return json.dumps({"result": str(inner_product)})
+        except Exception as e:
+            return self.handle_exception("compute_inner_product", e)
+
     def handle_exception(self, func_name: str, error: Exception) -> str:
         r"""Handles exceptions by logging and returning error details.
 
@@ -775,4 +812,5 @@ class SymPyToolkit(BaseToolkit):
             FunctionTool(self.compute_eigenvectors),
             FunctionTool(self.compute_nullspace),
             FunctionTool(self.compute_rank),
+            FunctionTool(self.compute_inner_product),
         ]

{camel_ai-0.2.21.dist-info → camel_ai-0.2.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: camel-ai
-Version: 0.2.21
+Version: 0.2.22
 Summary: Communicative Agents for AI Society Study
 License: Apache-2.0
 Keywords: communicative-ai,ai-societies,artificial-intelligence,deep-learning,multi-agent-systems,cooperative-ai,natural-language-processing,large-language-models
@@ -91,7 +91,6 @@ Requires-Dist: pymilvus (>=2.4.0,<3.0.0) ; extra == "rag" or extra == "storage"
 Requires-Dist: pyowm (>=3.3.0,<4.0.0) ; extra == "web-tools" or extra == "all"
 Requires-Dist: pytest (>=7,<8) ; extra == "test"
 Requires-Dist: pytest-asyncio (>=0.23.0,<0.24.0) ; extra == "test"
-Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: qdrant-client (>=1.9.0,<2.0.0) ; extra == "rag" or extra == "storage" or extra == "all"
 Requires-Dist: rank-bm25 (>=0.2.2,<0.3.0) ; extra == "rag" or extra == "all"
 Requires-Dist: redis (>=5.0.6,<6.0.0) ; extra == "storage" or extra == "all"

{camel_ai-0.2.21.dist-info → camel_ai-0.2.22.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=4nBZIePKPm_k6qsVFgcn22lxAVt4o_XkMGV4coE5Yyc,912
+camel/__init__.py,sha256=zMzBK9_6Ke7uNJPWsQiOL7N99FVfyYbf6eEIFJfZqp4,912
 camel/agents/__init__.py,sha256=LcS4m8s97-yADfznvcaAdUe9W0E9h3m6zrSc9H6m9so,1545
 camel/agents/base.py,sha256=c4bJYL3G3Z41SaFdMPMn8ZjLdFiFaVOFO6EQIfuCVR8,1124
 camel/agents/chat_agent.py,sha256=mnJNJbklukwGVsDPpPwzd1z8gMeKv3_TG55rbS28NPo,56492
@@ -66,7 +66,7 @@ camel/datagen/self_instruct/filter/__init__.py,sha256=UiGBfDRYO-3Z3dhaxAFVh4F8PF
 camel/datagen/self_instruct/filter/filter_function.py,sha256=-voPwP83c_bkZrSAhwludBCtfsKDFG_jlDHcNUOLV7o,6691
 camel/datagen/self_instruct/filter/filter_registry.py,sha256=5M_aNIopBeBj7U4fUsrAQpXQ2cZT6o6GaIIo0briFw0,2125
 camel/datagen/self_instruct/filter/instruction_filter.py,sha256=la_7P5bVdrk2qffnYFI2Ie3cjCEEHBxe4HB8PZ5jMq0,3426
-camel/datagen/self_instruct/self_instruct.py,sha256=W_0LSSnTBcqZD1dtdWIgXeTcgFEVqjLyTZojj6lYC-0,14076
+camel/datagen/self_instruct/self_instruct.py,sha256=zcq5006W6rsVLS4uIhv0xPpLCYhknLzoVJ5Jw_O0LLQ,14096
 camel/datagen/self_instruct/templates.py,sha256=7YMOUcIig6vLjqSwkWCq8XeRCjWq0Mfyzptn7DOmeAo,19480
 camel/datagen/source2synth/__init__.py,sha256=Kd6BBgIPRBm_VPAbJb-V_QKYyRDcX3fTQTm2Bl0Vkpc,1056
 camel/datagen/source2synth/data_processor.py,sha256=2_E1sS4BZNiAUMuB4ItomhU2oIFI6PwQKqDVlSv5ILc,17783
@@ -81,25 +81,27 @@ camel/embeddings/base.py,sha256=mxqFkWh2AfbxuVKPOqVx16fCznmuSh9QXGjaEeZHvoY,2190
 camel/embeddings/jina_embedding.py,sha256=6aakojtsJ6KLp3nqYLhEOtoFm2shoXlRzxb1YYN_uwo,6623
 camel/embeddings/mistral_embedding.py,sha256=JaHjcHrc4U216QfGA4NxOSLrgYB9lM19VR2mIMAkuvk,3287
 camel/embeddings/openai_compatible_embedding.py,sha256=48T1fNUkgifoPiVHPJ7HJERekP1sENy3t07S1ENiwWk,3158
-camel/embeddings/openai_embedding.py,sha256=DZh5OuXzBo1fMXifgyStUMm_BFaK1vQYrKdFtXqLKdg,3655
+camel/embeddings/openai_embedding.py,sha256=9kJBKUWkjEyxtn50V4MDjuOT2syIwWEnZeEHkbqIocg,3936
 camel/embeddings/sentence_transformers_embeddings.py,sha256=E7a8lN50CtDBsFO-NOFQ6qfCnbH41O0_kTTg7dG3sOo,2724
 camel/embeddings/vlm_embedding.py,sha256=HZFdcz1YzkFPzMj45_jaCVmDQJyccoXN561aLWlrYmo,5497
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=9X09UmxI2JqQnhrFfnZ3B9EzFmVfdSWQcjLWTIXKXe0,4962
 camel/interpreters/__init__.py,sha256=NOQUsg7gR84zO8nBXu4JGUatsxSDJqZS6otltjXfop4,1265
 camel/interpreters/base.py,sha256=F026f2ZnvHwikSMbk6APYNvB9qP4Ye5quSkTbFKV3O0,1898
-camel/interpreters/docker_interpreter.py,sha256=Uo5r2jcJGjC6rn5Yzx9qLzlXTsA5RH7AnFe7I0rxo10,8700
+camel/interpreters/docker/Dockerfile,sha256=6_k33dlpxgf8V9vfywWmjLuOgHmT2s-a8Lb8VbFRv4s,253
+camel/interpreters/docker_interpreter.py,sha256=K4J49oc-GnMtEKbvn3wNokWgWU97-vRgSfWSNadO9LU,9249
 camel/interpreters/e2b_interpreter.py,sha256=UC0en39x705cnnMCX4GxN7Tx0gCpu5yuWOFSBl_TagE,4815
 camel/interpreters/internal_python_interpreter.py,sha256=9psFm8mkN5-5WdTW__VBjDoh_u-PCifJMQYeo0DEoZo,22464
 camel/interpreters/interpreter_error.py,sha256=uEhcmHmmcajt5C9PLeHs21h1fE6cmyt23tCAGie1kTA,880
 camel/interpreters/ipython_interpreter.py,sha256=-erOR6imuh5pUtpbUYky3zoLDr30Y5E7lm59BwwxzNs,5976
-camel/interpreters/subprocess_interpreter.py,sha256=doWDS79Ks6po5bc6fOSBg8GChX2H79cq7y-AAYDEbuI,9497
-camel/loaders/__init__.py,sha256=k-N8rJgDaINKiu3ao1PntNZ-zuV31g1bAHe86f-N4js,1199
+camel/interpreters/subprocess_interpreter.py,sha256=v-JU5KstsxhgSa_cKKYiEq5jZx6fTcbfyZ013uAChts,10769
+camel/loaders/__init__.py,sha256=AJnrCWXkD0he3uJDxs7arMGf8nFqNYz3SK0JagMEO7A,1250
 camel/loaders/apify_reader.py,sha256=oaVjKyNhJhG-hTuIwrpZ2hsB4XTL0M-kUksgSL2R0ck,7952
 camel/loaders/base_io.py,sha256=SAJInsmIYin45lXMSAhzWEFl7FjQ4WswqRU0D7sihRs,10170
 camel/loaders/chunkr_reader.py,sha256=OhoJoXOjuI-XvJ4GOmiN_wB2NRQRHO4qk5PG4MHGMG0,6120
 camel/loaders/firecrawl_reader.py,sha256=wCPHEWbfLv_q2x9MdTiSvJ_LDqUPO88lzPf0mmOBsME,5667
 camel/loaders/jina_url_reader.py,sha256=dL9J5JlsFKEhi4gU_vYIxKvvf_RJ4LY9gG6i8P8JpcA,3601
+camel/loaders/mineru_extractor.py,sha256=nKa5n7f3ergv1TURcbXZJP5mQpnSCIFdlWrxWn4hBz8,9070
 camel/loaders/panda_reader.py,sha256=7z9mA869LTEI48VhPQc0t2fnIUZc4MGngIXCh6lff18,11361
 camel/loaders/unstructured_io.py,sha256=Dh-MB02nrhVXFyQCUrYt4DATd12zi5bNWE47cPC5yBs,17429
 camel/logger.py,sha256=j6mPsLJyKOn16o6Um57882mHsURQ8h-jia6Jd_34wRA,4239
@@ -126,9 +128,9 @@ camel/models/__init__.py,sha256=np8pj6JClpO5HzL_EQb_tkX5-SFTwozy2QUmMQuO7lU,2570
 camel/models/aiml_model.py,sha256=ItiTNq3IhvnGclT9Lwm_3NFzK-yIK2wIhevLfyn5oeU,5222
 camel/models/anthropic_model.py,sha256=BOj4vEtYVWbgy3DmBBlFh6LPXHbi1-LCPWzIxFuw9u4,5829
 camel/models/azure_openai_model.py,sha256=ptL4YK8KkAbOA6XDxIhcEqxPOVGrYmzXqBzdsZAyHss,6083
-camel/models/base_model.py,sha256=rxRZc31cKone4OGuvXi14FI_O9TC1aBvIy8WFSlVeSI,5727
+camel/models/base_model.py,sha256=RUUHAD85MCIiPP2uxrGm7s0SRfAJpYcX16Sq21tA2BY,7557
 camel/models/cohere_model.py,sha256=4Sm-YvQnSquz8L4EN9qGn0qz6WTz4cm_BQtP7_NZOHQ,10731
-camel/models/deepseek_model.py,sha256=WBZE63hB61XE4b_DLunlTX54sw74k-ImAVTyE9CDrSo,8140
+camel/models/deepseek_model.py,sha256=8KODWkub8wNW_63q2xn-Kh_Otvf4CghAlHrihrM9DQE,7515
 camel/models/fish_audio_model.py,sha256=mid-wdV_hkxHay-vgnF3zshwdXLyO4eM31139_0BXzo,5586
 camel/models/gemini_model.py,sha256=mS3_91vlLifsIolDR3TYRFzpV67iAnFiIRAZ8F5O7Qc,5462
 camel/models/groq_model.py,sha256=gDLv1_gOIioNmTh7I_efM5FMEsELqeQGAtY7ipd85TU,4922
@@ -240,7 +242,7 @@ camel/terminators/__init__.py,sha256=t8uqrkUnXEOYMXQDgaBkMFJ0EXFKI0kmx4cUimli3Ls
 camel/terminators/base.py,sha256=xmJzERX7GdSXcxZjAHHODa0rOxRChMSRboDCNHWSscs,1511
 camel/terminators/response_terminator.py,sha256=n3G5KP6Oj7-7WlRN0yFcrtLpqAJKaKS0bmhrWlFfCgQ,4982
 camel/terminators/token_limit_terminator.py,sha256=YWv6ZR8R9yI2Qnf_3xES5bEE_O5bb2CxQ0EUXfMh34c,2118
-camel/toolkits/__init__.py,sha256=QXU7wR4wpveIP_t2AcaWvOS-ANMygUGCfQXGl59aAyg,2854
+camel/toolkits/__init__.py,sha256=moyiULPxdXNOpbRBc-sHMV_dewyd_cGks21YRYbM7lY,2918
 camel/toolkits/arxiv_toolkit.py,sha256=I9WEUturZhbL5gQIgX_8bKttuJUlMKHcvUfhcidFVhs,6204
 camel/toolkits/ask_news_toolkit.py,sha256=PIFGGVHpSOXs2lg-zA6qhlHF17f1CyCjGbpud90yG8I,23158
 camel/toolkits/base.py,sha256=XnERVclg201dG7BrawwbuSeSlkz1ngIfatES1ingpkA,1264
@@ -256,6 +258,7 @@ camel/toolkits/human_toolkit.py,sha256=4YsZrCSFaMceM1MpGa-tg5gkmbdcZrm0qe3j2JRgf
 camel/toolkits/linkedin_toolkit.py,sha256=r1q8Ds95chC9vxtsaUYUDEitM8tDjUw_MrkpWpM4W8s,7911
 camel/toolkits/math_toolkit.py,sha256=5yVF0bKuwkZIV01uICd3TOfktXlTERjKt4DrFyz_oaE,3639
 camel/toolkits/meshy_toolkit.py,sha256=8989arDOaD8KQuaHsRu3bfYoqEoZdvcpiWDXcQ_iN0Q,6378
+camel/toolkits/mineru_toolkit.py,sha256=24XmZ1s8Wc1_Qsx2OLakMQi3sCSJYoN-vwxZdBreQLU,6807
 camel/toolkits/notion_toolkit.py,sha256=JZSQaM2V0hxPga4Qk-HR5kcQLeHR3gEriovd48Vy43o,9507
 camel/toolkits/open_api_specs/biztoc/__init__.py,sha256=OKCZrQCDwaWtXIN_2rA9FSqEvgpQRieRoHh7Ek6N16A,702
 camel/toolkits/open_api_specs/biztoc/ai-plugin.json,sha256=IJinQbLv5MFPGFwdN7PbOhwArFVExSEZdJspe-mOBIo,866
@@ -290,7 +293,7 @@ camel/toolkits/search_toolkit.py,sha256=4yTYkook3E3Yb-EOaio2O6FBcvzIXlVVC4WOvNSa
 camel/toolkits/semantic_scholar_toolkit.py,sha256=z7xF3lPtBVXbpYMBDX9eVeHKpTZAg5rKiDnB1bCkhvU,11472
 camel/toolkits/slack_toolkit.py,sha256=n8cn3kZIc27B-2KMTRK6Nsdan37SwMqBiBi1PMtuUvQ,10744
 camel/toolkits/stripe_toolkit.py,sha256=cQJlzu7qXSiClazgr-D3xRAcI_PK_csTT-xcwaTrHYc,9623
-camel/toolkits/sympy_toolkit.py,sha256=1z9nSkEKVHZUJ2CTSnWRQ-8qeXVusaG6nVHsP9J5P0M,31237
+camel/toolkits/sympy_toolkit.py,sha256=RCwgMTJxFnMpzexl-aDpeT6104HOyfyHxqRRijRGx5g,32654
 camel/toolkits/twitter_toolkit.py,sha256=a2OLSJSW2wY7pOwOApb1qchZPXzH22Rbgm9Yd7-7vrA,15826
 camel/toolkits/video_toolkit.py,sha256=n1P7F_cjdnC2jfUQQiJnhueRYA83GIjUF7HWIrES5xs,7089
 camel/toolkits/weather_toolkit.py,sha256=qHAMD56zqd5GWnEWiaA_0aBDwvgacdx0pAHScinY4GY,6965
@@ -306,7 +309,7 @@ camel/utils/constants.py,sha256=MQD3bgLIq_NATp0D1iFkrwfkCwVX-PAOSXheTkkEdkY,1410
 camel/utils/deduplication.py,sha256=UHikAtOW1TTDunf2t_wa2kFbmkrXWf7HfOKwLvwCxzo,8958
 camel/utils/response_format.py,sha256=9KrbwtOM9cA3LSjTgLiK7oKy-53_uMh1cvpyNwwJpng,2419
 camel/utils/token_counting.py,sha256=n5JsWuG6fiuMUgpsKUPMF1NKQJLle9ad1I88_aS4cMM,14018
-camel_ai-0.2.21.dist-info/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.21.dist-info/METADATA,sha256=4gpVS9RX6pp5-gkERC5BRNgMxqZUWWkQaHZi6B5n2r0,36460
-camel_ai-0.2.21.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-camel_ai-0.2.21.dist-info/RECORD,,
+camel_ai-0.2.22.dist-info/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.22.dist-info/METADATA,sha256=356SEI4dv3R-Te3OL1Q6GndV89WHugGhhROb-nz27RI,36421
+camel_ai-0.2.22.dist-info/WHEEL,sha256=7dDg4QLnNKTvwIDR9Ac8jJaAmBC_owJrckbC0jjThyA,88
+camel_ai-0.2.22.dist-info/RECORD,,

{camel_ai-0.2.21.dist-info → camel_ai-0.2.22.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: poetry-core 2.1.0
 Root-Is-Purelib: true
 Tag: py3-none-any