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

camel/extractors/__init__.py

@@ -12,5 +12,20 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from .base import BaseExtractor, BaseExtractorStrategy
+from .python_strategies import (
+    BoxedStrategy,
+    PythonDictStrategy,
+    PythonListStrategy,
+    PythonSetStrategy,
+    PythonTupleStrategy,
+)
 
-__all__ = ["BaseExtractor", "BaseExtractorStrategy"]
+__all__ = [
+    "BaseExtractor",
+    "BaseExtractorStrategy",
+    "BoxedStrategy",
+    "PythonListStrategy",
+    "PythonDictStrategy",
+    "PythonSetStrategy",
+    "PythonTupleStrategy",
+]

camel/toolkits/__init__.py

@@ -60,6 +60,7 @@ from .browser_toolkit import BrowserToolkit
 from .file_write_toolkit import FileWriteToolkit
 from .terminal_toolkit import TerminalToolkit
 from .pubmed_toolkit import PubMedToolkit
+from .thinking_toolkit import ThinkingToolkit
 
 __all__ = [
     'BaseToolkit',
@@ -108,4 +109,5 @@ __all__ = [
     'FileWriteToolkit',
     'TerminalToolkit',
     'PubMedToolkit',
+    'ThinkingToolkit',
 ]

camel/toolkits/thinking_toolkit.py

@@ -0,0 +1,74 @@
+# ========= 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 List, Optional
+
+from camel.logger import get_logger
+from camel.toolkits import FunctionTool
+from camel.toolkits.base import BaseToolkit
+
+logger = get_logger(__name__)
+
+
+class ThinkingToolkit(BaseToolkit):
+    r"""A toolkit for recording thoughts during reasoning processes.
+
+    Attributes:
+        thoughts (List[str]): A list to store the recorded thoughts.
+    """
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        r"""Initialize the ThinkingToolkit.
+
+        Args:
+            timeout (Optional[float]): The timeout for the toolkit.
+                (default: :obj: `None`)
+        """
+        super().__init__(timeout=timeout)
+        self.thoughts: List[str] = []
+
+    def think(self, thought: str) -> str:
+        r"""Use the tool to think about something.
+        It will not obtain new information or change the database, but just
+        append the thought to the log. Use it when complex reasoning or some
+        cache memory is needed.
+
+        Args:
+            thought (str): A thought to think about.
+
+        Returns:
+            str: The full log of thoughts including the new thought.
+        """
+        try:
+            logger.debug(f"Thought: {thought}")
+            self.thoughts.append(thought)
+
+            thoughts = "\n".join([f"- {t}" for t in self.thoughts])
+            return f"Thoughts:\n{thoughts}"
+
+        except Exception as e:
+            error_msg = f"Error recording thought: {e}"
+            logger.error(error_msg)
+            return error_msg
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Get all tools in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of tools.
+        """
+        return [FunctionTool(self.think)]

camel/types/enums.py

@@ -123,6 +123,7 @@ class ModelType(UnifiedModelType, Enum):
     NVIDIA_LLAMA3_3_70B_INSTRUCT = "meta/llama-3.3-70b-instruct"
 
     # Gemini models
+    GEMINI_2_5_PRO_EXP = "gemini-2.5-pro-exp-03-25"
     GEMINI_2_0_FLASH = "gemini-2.0-flash-exp"
     GEMINI_2_0_FLASH_THINKING = "gemini-2.0-flash-thinking-exp"
     GEMINI_2_0_PRO_EXP = "gemini-2.0-pro-exp-02-05"
@@ -420,6 +421,7 @@ class ModelType(UnifiedModelType, Enum):
             bool: Whether this type of models is gemini.
         """
         return self in {
+            ModelType.GEMINI_2_5_PRO_EXP,
             ModelType.GEMINI_2_0_FLASH,
             ModelType.GEMINI_1_5_FLASH,
             ModelType.GEMINI_1_5_PRO,
@@ -724,6 +726,7 @@ class ModelType(UnifiedModelType, Enum):
         }:
             return 256_000
         elif self in {
+            ModelType.GEMINI_2_5_PRO_EXP,
             ModelType.GEMINI_2_0_FLASH,
             ModelType.GEMINI_1_5_FLASH,
             ModelType.GEMINI_1_5_PRO,

camel/utils/chunker/code_chunker.py

@@ -16,9 +16,7 @@ from typing import List, Optional
 
 from unstructured.documents.elements import Element, ElementMetadata
 
-from camel.messages import OpenAIUserMessage
-from camel.types import ModelType
-from camel.utils import BaseTokenCounter, OpenAITokenCounter
+from camel.utils import get_model_encoding
 
 from .base import BaseChunker
 
@@ -38,20 +36,18 @@ class CodeChunker(BaseChunker):
             token counting, if `None`, OpenAITokenCounter will be used.
             (default: :obj:`None`)
         remove_image: (bool, optional): If the chunker should skip the images.
+        model_name (str, optional): The tokenizer model name used
+            for token counting. (default: :obj:`"cl100k_base"`)
     """
 
     def __init__(
         self,
         chunk_size: int = 8192,
-        token_counter: Optional[BaseTokenCounter] = None,
+        model_name: str = "cl100k_base",
         remove_image: Optional[bool] = True,
     ):
         self.chunk_size = chunk_size
-        self.token_counter = (
-            token_counter
-            if token_counter
-            else OpenAITokenCounter(model=ModelType.GPT_4O_MINI)
-        )
+        self.tokenizer = get_model_encoding(model_name)
         self.remove_image = remove_image
         self.struct_pattern = re.compile(
             r'^\s*(?:(def|class|function)\s+\w+|'
@@ -72,9 +68,7 @@ class CodeChunker(BaseChunker):
         Returns:
             int: The number of tokens in the input text.
         """
-        return self.token_counter.count_tokens_from_messages(
-            [OpenAIUserMessage(role="user", name="user", content=text)]
-        )
+        return len(self.tokenizer.encode(text, disallowed_special=()))
 
     def _split_oversized(self, line: str) -> List[str]:
         r"""Splits an oversized line into multiple chunks based on token limits
@@ -86,7 +80,7 @@ class CodeChunker(BaseChunker):
             List[str]: A list of smaller chunks after splitting the
                 oversized line.
         """
-        tokens = self.token_counter.encode(line)
+        tokens = self.tokenizer.encode(line, disallowed_special=())
         chunks = []
         buffer = []
         current_count = 0
@@ -96,12 +90,12 @@ class CodeChunker(BaseChunker):
             current_count += 1
 
             if current_count >= self.chunk_size:
-                chunks.append(self.token_counter.decode(buffer).strip())
+                chunks.append(self.tokenizer.decode(buffer).strip())
                 buffer = []
                 current_count = 0
 
         if buffer:
-            chunks.append(self.token_counter.decode(buffer))
+            chunks.append(self.tokenizer.decode(buffer))
         return chunks
 
     def chunk(self, content: List[str]) -> List[Element]:

camel/verifiers/base.py

@@ -16,6 +16,7 @@ import time
 from abc import ABC, abstractmethod
 from typing import List, Optional
 
+from camel.extractors.base import BaseExtractor
 from camel.logger import get_logger
 from camel.utils import BatchProcessor
 
@@ -44,6 +45,7 @@ class BaseVerifier(ABC):
 
     def __init__(
         self,
+        extractor: Optional[BaseExtractor] = None,
         max_parallel: Optional[int] = None,
         timeout: Optional[float] = None,
         max_retries: int = 3,
@@ -72,6 +74,9 @@ class BaseVerifier(ABC):
                 down. (default: :obj:`85.0`)
             **kwargs: Additional verifier parameters.
         """
+
+        self.extractor = extractor
+
         self._is_setup: bool = False
         self._max_parallel: Optional[int] = max_parallel
         self._timeout: Optional[float] = timeout
@@ -82,7 +87,7 @@ class BaseVerifier(ABC):
         self._memory_threshold: float = memory_threshold
         self._batch_processor: BatchProcessor = BatchProcessor()
 
-    async def setup(self) -> None:
+    async def setup(self, **kwargs) -> None:
         r"""Set up the verifier with necessary resources.
 
         Initializes:
@@ -97,6 +102,8 @@ class BaseVerifier(ABC):
             return
 
         try:
+            if self.extractor:
+                await self.extractor.setup()
             batch_size = max(1, self._initial_batch_size or 10)
             max_parallel = max(1, self._max_parallel or 1)
             self._batch_processor = BatchProcessor()
@@ -106,7 +113,7 @@ class BaseVerifier(ABC):
                 f"batch_size={batch_size}, max_parallel={max_parallel}"
             )
 
-            await self._setup()
+            await self._setup(**kwargs)
             self._is_setup = True
 
         except Exception as e:
@@ -118,7 +125,7 @@ class BaseVerifier(ABC):
             raise RuntimeError(error_msg) from e
 
     @abstractmethod
-    async def _setup(self) -> None:
+    async def _setup(self, **kwargs) -> None:
         r"""Implement verifier-specific setup logic."""
         pass
 
@@ -136,6 +143,8 @@ class BaseVerifier(ABC):
             return
 
         try:
+            if self.extractor:
+                await self.extractor.cleanup()
             self._batch_processor = BatchProcessor()
             await self._cleanup()
             logger.info(f"{self.__class__.__name__} cleaned up successfully")
@@ -191,15 +200,28 @@ class BaseVerifier(ABC):
         start_time = time.time()
 
         while attempt < self._max_retries:
+            # Extract verifiable part of the proposed solution,
+            # if verifier has been initialized with extractor.
+            verifiable_solution = (
+                await self.extractor.extract(solution)
+                if self.extractor
+                else solution
+            )
+
+            if not verifiable_solution:
+                continue
+
             try:
                 verification_result = (
                     await asyncio.wait_for(
-                        self._verify_implementation(solution, ground_truth),
+                        self._verify_implementation(
+                            verifiable_solution, ground_truth
+                        ),
                         timeout=self._timeout,
                     )
                     if self._timeout
                     else await self._verify_implementation(
-                        solution, ground_truth
+                        verifiable_solution, ground_truth
                     )
                 )
 
@@ -267,6 +289,7 @@ class BaseVerifier(ABC):
             "Subclasses must implement _verify_implementation()"
         )
 
+    # TODO: check again
     async def verify_batch(
         self,
         solutions: List[str],