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

camel/configs/vllm_config.py

@@ -18,7 +18,6 @@ from typing import Optional, Sequence, Union
 from pydantic import Field
 
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 # flake8: noqa: E501
@@ -32,14 +31,14 @@ class VLLMConfig(BaseConfig):
         temperature (float, optional): Sampling temperature to use, between
             :obj:`0` and :obj:`2`. Higher values make the output more random,
             while lower values make it more focused and deterministic.
-            (default: :obj:`0.2`)
+            (default: :obj:`None`)
         top_p (float, optional): An alternative to sampling with temperature,
             called nucleus sampling, where the model considers the results of
             the tokens with top_p probability mass. So :obj:`0.1` means only
             the tokens comprising the top 10% probability mass are considered.
-            (default: :obj:`1.0`)
+            (default: :obj:`None`)
         n (int, optional): How many chat completion choices to generate for
-            each input message. (default: :obj:`1`)
+            each input message. (default: :obj:`None`)
         response_format (object, optional): An object specifying the format
             that the model must output. Compatible with GPT-4 Turbo and all
             GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
@@ -55,7 +54,7 @@ class VLLMConfig(BaseConfig):
             max context length.
         stream (bool, optional): If True, partial message deltas will be sent
             as data-only server-sent events as they become available.
-            (default: :obj:`False`)
+            (default: :obj:`None`)
         stop (str or list, optional): Up to :obj:`4` sequences where the API
             will stop generating further tokens. (default: :obj:`None`)
         max_tokens (int, optional): The maximum number of tokens to generate
@@ -66,12 +65,12 @@ class VLLMConfig(BaseConfig):
             :obj:`2.0`. Positive values penalize new tokens based on whether
             they appear in the text so far, increasing the model's likelihood
             to talk about new topics. See more information about frequency and
-            presence penalties. (default: :obj:`0.0`)
+            presence penalties. (default: :obj:`None`)
         frequency_penalty (float, optional): Number between :obj:`-2.0` and
             :obj:`2.0`. Positive values penalize new tokens based on their
             existing frequency in the text so far, decreasing the model's
             likelihood to repeat the same line verbatim. See more information
-            about frequency and presence penalties. (default: :obj:`0.0`)
+            about frequency and presence penalties. (default: :obj:`None`)
         logit_bias (dict, optional): Modify the likelihood of specified tokens
             appearing in the completion. Accepts a json object that maps tokens
             (specified by their token ID in the tokenizer) to an associated
@@ -80,10 +79,10 @@ class VLLMConfig(BaseConfig):
             The exact effect will vary per model, but values between:obj:` -1`
             and :obj:`1` should decrease or increase likelihood of selection;
             values like :obj:`-100` or :obj:`100` should result in a ban or
-            exclusive selection of the relevant token. (default: :obj:`{}`)
+            exclusive selection of the relevant token. (default: :obj:`None`)
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
-            (default: :obj:`""`)
+            (default: :obj:`None`)
         logprobs: Whether to return log probabilities of the output tokens or
             not. If true, returns the log probabilities of each output token
             returned in the `logits` of `message`. (default: :obj:`None`)
@@ -93,17 +92,17 @@ class VLLMConfig(BaseConfig):
             this parameter is used. (default: :obj:`None`)
     """
 
-    temperature: float = 0.2  # openai default: 1.0
-    top_p: float = 1.0
-    n: int = 1
-    stream: bool = False
-    stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN
-    max_tokens: Union[int, NotGiven] = NOT_GIVEN
-    presence_penalty: float = 0.0
-    response_format: Union[dict, NotGiven] = NOT_GIVEN
-    frequency_penalty: float = 0.0
+    temperature: Optional[float] = None  # openai default: 1.0
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stream: Optional[bool] = None
+    stop: Optional[Union[str, Sequence[str]]] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    response_format: Optional[dict] = None
+    frequency_penalty: Optional[float] = None
     logit_bias: dict = Field(default_factory=dict)
-    user: str = ""
+    user: Optional[str] = None
     logprobs: Optional[bool] = None
     top_logprobs: Optional[int] = None
 

camel/configs/yi_config.py

@@ -16,7 +16,6 @@ from __future__ import annotations
 from typing import Optional, Union
 
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 class YiConfig(BaseConfig):
@@ -37,22 +36,22 @@ class YiConfig(BaseConfig):
         max_tokens (int, optional): Specifies the maximum number of tokens
             the model can generate. This sets an upper limit, but does not
             guarantee that this number will always be reached.
-            (default: :obj:`5000`)
+            (default: :obj:`None`)
         top_p (float, optional): Controls the randomness of the generated
             results. Lower values lead to less randomness, while higher
-            values increase randomness. (default: :obj:`0.9`)
+            values increase randomness. (default: :obj:`None`)
         temperature (float, optional): Controls the diversity and focus of
             the generated results. Lower values make the output more focused,
             while higher values make it more diverse. (default: :obj:`0.3`)
         stream (bool, optional): If True, enables streaming output.
-            (default: :obj:`False`)
+            (default: :obj:`None`)
     """
 
     tool_choice: Optional[Union[dict[str, str], str]] = None
-    max_tokens: Union[int, NotGiven] = NOT_GIVEN
-    top_p: float = 0.9
-    temperature: float = 0.3
-    stream: bool = False
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = None
+    temperature: Optional[float] = None
+    stream: Optional[bool] = None
 
 
 YI_API_PARAMS = {param for param in YiConfig.model_fields.keys()}

camel/configs/zhipuai_config.py

@@ -16,7 +16,6 @@ from __future__ import annotations
 from typing import Optional, Sequence, Union
 
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 class ZhipuAIConfig(BaseConfig):
@@ -29,15 +28,15 @@ class ZhipuAIConfig(BaseConfig):
         temperature (float, optional): Sampling temperature to use, between
             :obj:`0` and :obj:`2`. Higher values make the output more random,
             while lower values make it more focused and deterministic.
-            (default: :obj:`0.2`)
+            (default: :obj:`None`)
         top_p (float, optional): An alternative to sampling with temperature,
             called nucleus sampling, where the model considers the results of
             the tokens with top_p probability mass. So :obj:`0.1` means only
             the tokens comprising the top 10% probability mass are considered.
-            (default: :obj:`0.6`)
+            (default: :obj:`None`)
         stream (bool, optional): If True, partial message deltas will be sent
             as data-only server-sent events as they become available.
-            (default: :obj:`False`)
+            (default: :obj:`None`)
         stop (str or list, optional): Up to :obj:`4` sequences where the API
             will stop generating further tokens. (default: :obj:`None`)
         max_tokens (int, optional): The maximum number of tokens to generate
@@ -60,11 +59,11 @@ class ZhipuAIConfig(BaseConfig):
             are present.
     """
 
-    temperature: float = 0.2
-    top_p: float = 0.6
-    stream: bool = False
-    stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN
-    max_tokens: Union[int, NotGiven] = NOT_GIVEN
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    stream: Optional[bool] = None
+    stop: Optional[Union[str, Sequence[str]]] = None
+    max_tokens: Optional[int] = None
     tool_choice: Optional[Union[dict[str, str], str]] = None
 
 

camel/datasets/few_shot_generator.py

@@ -22,7 +22,6 @@ from camel.agents import ChatAgent
 from camel.logger import get_logger
 from camel.models.base_model import BaseModelBackend
 from camel.verifiers import BaseVerifier
-from camel.verifiers.models import VerifierInput
 
 from .base_generator import BaseGenerator
 from .models import DataPoint
@@ -203,10 +202,8 @@ class FewShotGenerator(BaseGenerator):
 
                 try:
                     verifier_response = await self.verifier.verify(
-                        VerifierInput(
-                            llm_response=rationale,
-                            ground_truth=None,
-                        )
+                        solution=rationale,
+                        ground_truth=None,
                     )
                     if not verifier_response or not verifier_response.result:
                         raise ValueError(

camel/datasets/static_dataset.py

@@ -153,17 +153,6 @@ class StaticDataset(Dataset):
                     return None
 
             rationale = item.get('rationale')
-            if not isinstance(rationale, str):
-                if self._strict:
-                    raise ValueError(
-                        f"Sample at index {idx} has invalid 'rationale': "
-                        f"expected str, got {type(rationale)}"
-                    )
-                else:
-                    logger.warning(
-                        f"Skipping sample at index {idx}: invalid 'rationale'"
-                    )
-                    return None
 
             final_answer = item.get('final_answer')
             if not isinstance(final_answer, str):
@@ -207,25 +196,33 @@ class StaticDataset(Dataset):
         r"""Return the size of the dataset."""
         return self._length
 
-    def __getitem__(self, idx: int) -> DataPoint:
-        r"""Retrieve a datapoint by index.
+    def __getitem__(
+        self, idx: Union[int, slice]
+    ) -> Union[DataPoint, List[DataPoint]]:
+        r"""Retrieve a datapoint or a batch of datapoints by index or slice.
 
         Args:
-            idx (int): Index of the datapoint.
+            idx (Union[int, slice]): Index or slice of the datapoint(s).
 
         Returns:
-            DataPoint: The datapoint corresponding to the given index.
+            List[DataPoint]: A list of `DataPoint` objects.
 
         Raises:
-            IndexError: If :obj:`idx` is out of bounds (negative or greater
-                than dataset length - 1).
+            IndexError: If an integer `idx` is out of bounds.
         """
+        if isinstance(idx, int):
+            if idx < 0 or idx >= self._length:
+                raise IndexError(
+                    f"Index {idx} out of bounds for dataset "
+                    f"of size {self._length}"
+                )
+            return self.data[idx]
 
-        if idx < 0 or idx >= self._length:
-            raise IndexError(
-                f"Index {idx} out of bounds for dataset of size {self._length}"
-            )
-        return self.data[idx]
+        elif isinstance(idx, slice):
+            return self.data[idx.start : idx.stop : idx.step]
+
+        else:
+            raise TypeError(f"Indexing type {type(idx)} not supported.")
 
     def sample(self) -> DataPoint:
         r"""Sample a random datapoint from the dataset.
@@ -240,7 +237,12 @@ class StaticDataset(Dataset):
         if self._length == 0:
             raise RuntimeError("Dataset is empty, cannot sample.")
         idx = self._rng.randint(0, self._length - 1)
-        return self[idx]
+        sample = self[idx]
+        if not isinstance(sample, DataPoint):
+            raise TypeError(
+                f"Expected DataPoint instance, got {type(sample).__name__}"
+            )
+        return sample
 
     @property
     def metadata(self) -> Dict[str, Any]:

camel/environments/models.py

@@ -33,6 +33,9 @@ class Action(BaseModel):
             generated (UTC).
     """
 
+    index: int = Field(
+        ..., description="Index of the state this action is performed upon"
+    )
     llm_response: str = Field(description="Generated response from the LLM")
     metadata: Dict[str, Any] = Field(
         default_factory=dict,