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

camel/datagen/evol_instruct/templates.py

@@ -0,0 +1,268 @@
+# ========= 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 abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Dict, List, Union
+
+
+# flake8: noqa
+@dataclass(frozen=True)
+class BaseEvolInstructTemplates(ABC):
+    r"""Abstract base class for evolution instruction templates.
+
+    This class defines a required structure for prompt transformation templates
+    - `EVOL_METHODS`: A dictionary mapping method keys to their descriptions.
+    - `STRATEGY`: A dictionary defining strategies and associated methods.
+
+    Subclasses should define concrete templates for specific domains.
+    """
+
+    @property
+    @abstractmethod
+    def EVOL_METHODS(self) -> Dict[str, str]:
+        r"""A dictionary mapping evolution method keys to their descriptions."""
+        pass
+
+    @property
+    @abstractmethod
+    def STRATEGY(self) -> Dict[str, Dict[str, Union[str, List[str]]]]:
+        r"""A dictionary defining strategies and their corresponding methods."""
+        pass
+
+
+# flake8: noqa
+@dataclass(frozen=True)
+class EvolInstructTemplates(BaseEvolInstructTemplates):
+    r"""Contains templates for EvolInstruct prompt transformations.
+
+    References:
+      - WizardLM: Empowering Large Language Models to Follow Complex
+        Instructions
+        https://arxiv.org/pdf/2304.12244
+      - eva: Evolving Alignment via Asymmetric Self-Play
+        https://arxiv.org/abs/2411.00062
+    """
+
+    # High-level instructions on in-depth/in-breadth evolving
+    INST_IN_DEPTH = (
+        "Please act as an expert Prompt Creator.\n"
+        "Your objective is to rewrite a given prompt into a more complex "
+        "version to make those large language models (e.g., gemini) a bit "
+        "harder to handle.\n"
+        "But the rewritten prompt must be reasonable and must be understood "
+        "and responded by humans.\n"
+        "Your rewriting cannot omit the non-text parts such as the table and "
+        "code in #Given Prompt#, if there is any."
+        "You should try your best not to make the #Rewritten Prompt# become "
+        "verbose, "
+        "The #Rewritten Prompt# should be roughly the similar length or a "
+        "little bit more than that of #Given Prompt#.\n"
+        "The #Rewritten Prompt# must sound like a real human user's prompt; "
+        "DON'T make it like sound machine-generated."
+        "Specifically, you SHOULD complicate the given prompt using the "
+        "following method: "
+        "\n{method}\n"
+        "The rewritten prompt should reflect meaningful changes across its "
+        "structure, ensuring the entire sentence feels sufficiently different "
+        "from the original. "
+        "Again, make sure the rewritten prompt is more CHALLENGING."
+        "Respond with your rewritten prompt directly. "
+        "#Given Prompt#:\n{prompt}\n"
+        "#Rewritten Prompt#:\n"
+    ).lstrip()
+
+    INST_IN_BREADTH = (
+        "Please act as an expert Prompt Creator.\n"
+        "Your objective is to generate a brand-new prompt based on the #Given "
+        "Prompt#. "
+        "The purpose of this task is to promote diversity and generality of "
+        "training prompts for language models, helping it practice with "
+        "varied challenges and perspectives.\n"
+        "The LENGTH and complexity of the #Created Prompt# should be similar "
+        "to that of the #Given Prompt#.\n"
+        "The #Created Prompt# must be reasonable, interpretable, and solvable "
+        "by humans.\n"
+        "The #Created Prompt# must sound like a real human user's prompt; "
+        "DON'T make it sound like machine-generated."
+        "Follow the method described below to guide your creation:\n"
+        "{method}\n"
+        "The created prompt should reflect meaningful changes across its "
+        "structure, ensuring the entire sentence feels sufficiently different "
+        "from the original. "
+        "Respond with your created prompt directly.\n"
+        "#Given Prompt#:\n{prompt}\n"
+        "#Created Prompt#:\n"
+    ).lstrip()
+
+    # Sub-method instructions (following the eva paper setting)
+    IN_BREADTH_KEYS = [
+        'persona',
+        'shift-in',
+        'shift-out',
+        'mix',
+        'abstract',
+    ]
+
+    IN_DEPTH_KEYS = [
+        'constraints',
+        'deepening',
+        'concretizing',
+        'reasoning',
+        'expansion',
+    ]
+
+    STRATEGY = {
+        "IN-DEPTH": {
+            'meta_instruction': INST_IN_DEPTH,
+            'methods': IN_DEPTH_KEYS,
+        },
+        "IN-BREADTH": {
+            'meta_instruction': INST_IN_BREADTH,
+            'methods': IN_BREADTH_KEYS,
+        },
+    }
+
+    EVOL_METHODS = {
+        "persona": (
+            "Reframe the #Given Prompt# as if written by a user with a "
+            "completely different persona, background, or expertise. Adjust "
+            "the tone, style, phrasing, or anything you feel proper to "
+            "reflect this change. The changes should make the prompt feel "
+            "like it was authored by someone entirely new."
+        ),
+        "shift-in": (
+            "Shift the high-level idea of the #Given Prompt# to explore a "
+            "different subdomain or context within the same domain. Ensure "
+            "the new topic still challenges the model to reason or provide "
+            "knowledge relevant to the domain."
+        ),
+        "shift-out": (
+            "Shift the high-level idea of the #Given Prompt# to a completely "
+            "different topic in a different setting. The new topic may "
+            "challenge the model with similar reasoning or contextual "
+            "understanding but in a novel way."
+        ),
+        "mix": (
+            "Combine the high-level concept of the #Given Prompt# with "
+            "elements from a different domain. Introduce novel scenarios or "
+            "contexts to create diversity while maintaining relevance to the "
+            "original idea."
+        ),
+        "abstract": (
+            "Turn the #Given Prompt# into a more abstract or generalized "
+            "version, removing specific details while preserving its intent. "
+            "Ensure the new prompt encourages broader, principle-driven "
+            "reasoning."
+        ),
+        "constraints": (
+            "Add one or more significant constraints or requirements into the "
+            "'#Given Prompt#'. The added constraints must meaningfully alter "
+            "how the model would respond. For example, specify additional "
+            "rules, contexts, or limitations that demand creative adjustments."
+        ),
+        "deepening": (
+            "If the #Given Prompt# contains inquiries about certain issues, "
+            "increase the depth and breadth of the inquiry. Make the question "
+            "require a more detailed, multi-layered, or comprehensive response"
+            ". For instance, break the problem into sub-problems or require "
+            "connections between unrelated concepts."
+        ),
+        "concretizing": (
+            "Replace general concepts in the #Given Prompt# with more specific"
+            " and detailed concepts. Ensure that the change makes the problem "
+            "more defined and concrete, leaving less room for ambiguity. For "
+            "example, replace 'a device' with 'a wearable fitness tracker "
+            "with GPS'."
+        ),
+        "reasoning": (
+            "Add one or more reasoning steps into the '#Given Prompt#'. "
+            "Explicitly rewrite it to demand multi-step reasoning or justify "
+            "intermediate steps in the solution. For instance, if the original"
+            " prompt is a simple query, make the response require a "
+            "step-by-step breakdown of logic or calculations."
+        ),
+        "expansion": (
+            "Expand the #Given Prompt# by including additional perspectives, "
+            "domains, or layers of complexity. For example, if the original "
+            "prompt focuses on a single scenario, add related scenarios or ask"
+            " the model to compare different situations."
+        ),
+    }
+
+
+# flake8: noqa
+@dataclass(frozen=True)
+class MathEvolInstructTemplates(BaseEvolInstructTemplates):
+    r"""Contains templates for MathEvolInstruct prompt transformations."""
+
+    # Meta-instructions for in-depth evolving
+    INST_IN_DEPTH = (
+        "Please act as a math expert. Your objective is to create a new math "
+        "problem that is more challenging yet concise than the given math "
+        "problem. Ensure that the mathematical content (including any "
+        "equations or figures) is preserved, and rephrase the problem to "
+        "increase its complexity and depth. The generated problem should be "
+        "clearly stated, strictly mathematical, and suitable for solving with "
+        "symbolic computation (e.g., using sympy). You will be given a method "
+        "to guide your creation. Make sure to follow the method strictly. "
+        "Consolidate any multiple parts into one integrated question that "
+        "ask for one definitive answer. Respond with your generated problem "
+        "directly. "
+        "#Original Problem#:\n{prompt}\n"
+        "#Generated Problem#:\n"
+    ).lstrip()
+
+    EVOL_METHODS = {
+        "constraints": (
+            "Add one or more significant constraints or requirements into the "
+            "'#Given Prompt#'. The added constraints must meaningfully alter "
+            "how the model would respond. For example, specify additional "
+            "rules, contexts, or limitations that demand creative adjustments."
+        ),
+        "deepening": (
+            "Increase the difficulty of the #Given Prompt# by integrating "
+            "additional layers of reasoning and rigor. Refine the problem so "
+            "that all added difficulty is consolidated into a single coherent "
+            "question requiring one final answer, avoiding fragmentation into "
+            "multiple sub-problems."
+        ),
+        "expansion": (
+            "Expand the #Given Prompt# by incorporating additional "
+            "perspectives or layers of complexity into the problem statement. "
+            "Ensure that the revised problem remains a single, unified "
+            "question with one final answer, rather than a series of separate "
+            "sub-questions."
+        ),
+        "condense": (
+            "Reformulate the given math problem into a well-structured and "
+            "formally stated mathematical question.\n"
+            "- Present the problem in a structured and rigorous mathematical "
+            "format.\n"
+            "- Removing unnecessary instructions, explanations, or hints.\n"
+            "- If the given problem contains several sub-questions, make "
+            "necessary changes to let the problem could be answered with one "
+            "number or expression by removing the sub-questions or combining "
+            "them into one."
+        ),
+    }
+
+    IN_DEPTH_KEYS = ['constraints', 'deepening', 'expansion']
+
+    STRATEGY = {
+        "IN-DEPTH": {
+            'meta_instruction': INST_IN_DEPTH,
+            'methods': IN_DEPTH_KEYS,
+        },
+    }

camel/environments/models.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
 from datetime import datetime, timezone
-from typing import Any, Dict, Optional, Protocol
+from typing import Any, Dict, Optional, Protocol, Tuple
 
 from pydantic import BaseModel, Field
 
@@ -33,9 +33,8 @@ class Action(BaseModel):
             generated (UTC).
     """
 
-    index: int = Field(
-        ..., description="Index of the state this action is performed upon"
-    )
+    index: Optional[int] = Field(default=None, description="...")
+
     llm_response: str = Field(description="Generated response from the LLM")
     metadata: Dict[str, Any] = Field(
         default_factory=dict,
@@ -87,6 +86,13 @@ class StepResult(BaseModel):
         description="Additional information about the step",
     )
 
+    def as_tuple(
+        self,
+    ) -> Tuple[Observation, float, bool, Dict[str, Any]]:
+        r"""Returns all fields of the model as a tuple, in declaration order"""
+        self.info["rewards_dict"] = self.rewards_dict
+        return (self.observation, self.reward, self.done, self.info)
+
 
 class Environment(Protocol):
     async def reset(self) -> Observation:

camel/environments/single_step.py

@@ -126,6 +126,7 @@ class SingleStepEnv:
             await self.verifier.cleanup()
             self._states = []
             self._states_done = []
+            self.current_batch_size = 0
             logger.info('Environment closed successfully')
         except Exception as e:
             logger.error(f'Failed to close environment: {e}')
@@ -157,6 +158,8 @@ class SingleStepEnv:
             ValueError: If batch size exceeds dataset size.
             TypeError: If the dataset is of an unsupported type.
         """
+        if batch_size <= 0:
+            raise ValueError("Batch size must be positive")
 
         if not self._is_setup:
             logger.warning(
@@ -212,16 +215,18 @@ class SingleStepEnv:
 
     async def step(
         self, action: Union[Action, List[Action]]
-    ) -> Union[StepResult, List[StepResult]]:
-        r"""Process actions for a subset of states and update their
-        finished status.
+    ) -> Union[
+        Tuple[Observation, float, bool, Dict[str, Any]],
+        List[Tuple[Observation, float, bool, Dict[str, Any]]],
+    ]:
+        r"""Process actions for a subset of states and update their finished
+        status.
 
         Args:
-            action: Single action or list of actions, where each action
-                contains an index indicating which state it corresponds to.
-                The index must be a valid position in the internal _states list
-                that was populated during the reset() call.
-
+            action: Single action (for batch_size=1 or micro-batch of size 1)
+                or list of actions (for batch_size>=2 with multiple actions).
+                Each action must have an index for batch_size>=2, indicating
+                which state it corresponds to.
 
         Returns:
             Union[StepResult, List[StepResult]]: StepResult or list of
@@ -241,10 +246,62 @@ class SingleStepEnv:
         if not self._states:
             raise RuntimeError("No current observation. Call reset() first.")
 
-        # Normalize everything to list
-        actions = [action] if isinstance(action, Action) else action
-        indices = [act.index for act in actions]
+        # Normalize actions into a list for uniform processing
+        if self.current_batch_size == 1:
+            if isinstance(action, list):
+                if len(action) != 1 or not isinstance(action[0], Action):
+                    raise ValueError(
+                        "For batch_size=1, expect a single Action or a "
+                        "list containing exactly one Action"
+                    )
+            elif not isinstance(action, Action):
+                raise ValueError(
+                    "For batch_size=1, expect a single Action or a "
+                    "list containing exactly one Action"
+                )
+            if isinstance(action, Action):
+                actions = [action]
+            else:
+                actions = action
+            if actions[0].index is None:
+                actions[0].index = 0
+            if actions[0].index != 0:
+                raise ValueError("For batch_size=1, index must be None or 0")
+
+        else:  # batch_size >= 2
+            if isinstance(action, Action):
+                if action.index is None:
+                    raise ValueError(
+                        "For batch_size>=2, each Action must have an index"
+                    )
+                if not isinstance(action.index, int):
+                    raise ValueError("Index must be an integer")
+                actions = [action]
+            elif isinstance(action, list):
+                if not action:  # Empty list
+                    raise ValueError("Action list cannot be empty")
+                actions = action
+                for act in actions:
+                    if not isinstance(act, Action):
+                        raise ValueError(
+                            "All elements in list must be Action objects"
+                        )
+                    if act.index is None:
+                        raise ValueError(
+                            "For batch_size>=2, each Action must have an index"
+                        )
+                    if not isinstance(act.index, int):
+                        raise ValueError("Index must be an integer")
+            else:
+                raise ValueError(
+                    "For batch_size>=2, expect an Action or list of Actions"
+                )
 
+        # Validate indices
+        indices: List[int] = []
+        for act in actions:
+            assert act.index is not None
+            indices.append(act.index)
         if len(set(indices)) != len(indices):
             raise ValueError("Duplicate state indices in actions.")
         for idx in indices:
@@ -254,7 +311,6 @@ class SingleStepEnv:
                 raise ValueError(f"State at index {idx} is already finished.")
 
         num_actions = len(actions)
-
         if self.current_batch_size % num_actions != 0:
             logger.warning(
                 f"Number of actions ({num_actions}) is not a divisor of "
@@ -262,9 +318,9 @@ class SingleStepEnv:
             )
 
         proposed_solutions = [act.llm_response for act in actions]
-        ground_truths: List[str] = [
-            self._states[idx].final_answer for idx in indices
-        ]
+        ground_truths: List[str] = []
+        for idx in indices:
+            ground_truths.append(self._states[idx].final_answer)
 
         verification_results = await self.verifier.verify_batch(
             solutions=proposed_solutions,
@@ -276,9 +332,10 @@ class SingleStepEnv:
             proposed_solutions, verification_results
         )
 
+        # TODO Batch this
         step_results = []
-        # TODO: batch this
         for i, action in enumerate(actions):
+            assert action.index is not None
             idx = action.index
             step_result = StepResult(
                 observation=self.PLACEHOLDER_OBS,
@@ -291,7 +348,7 @@ class SingleStepEnv:
                     "state": self._states[idx],
                 },
             )
-            step_results.append(step_result)
+            step_results.append(step_result.as_tuple())
             self._states_done[idx] = True
 
         return step_results[0] if len(step_results) == 1 else step_results
@@ -315,6 +372,12 @@ class SingleStepEnv:
                 - List of total rewards for each solution.
                 - List of reward component dictionaries for each solution.
         """
+        if len(proposed_solutions) != len(verification_results):
+            raise ValueError(
+                f"Length mismatch: {len(proposed_solutions)} solutions vs "
+                f"{len(verification_results)} verification results"
+            )
+
         total_rewards = []
         rewards_dicts = []
 
@@ -355,9 +418,20 @@ class SingleStepEnv:
         return {}
 
     def _batch_done(self) -> bool:
+        r"""Check if all states in the current batch are done.
+
+        Returns:
+            bool: True if all states are marked as done, False otherwise.
+        """
         return all(self._states_done)
 
     def _batch_started(self) -> bool:
+        r"""Check if any state in the current batch is done.
+
+        Returns:
+            bool: True if at least one state is marked as done, False
+                otherwise.
+        """
         return any(self._states_done)
 
     @property

camel/interpreters/docker_interpreter.py

@@ -210,7 +210,7 @@ class DockerInterpreter(BaseInterpreter):
         if self.require_confirm:
             logger.info(
                 f"The following {code_type} code will run on your "
-                "computer: {code}"
+                f"computer: {code}"
             )
             while True:
                 choice = input("Running code? [Y/n]:").lower()

camel/interpreters/e2b_interpreter.py

@@ -99,7 +99,7 @@ class E2BInterpreter(BaseInterpreter):
         if self.require_confirm:
             logger.info(
                 f"The following {code_type} code will run on your "
-                "e2b sandbox: {code}"
+                f"e2b sandbox: {code}"
             )
             while True:
                 choice = input("Running code? [Y/n]:").lower()

camel/interpreters/subprocess_interpreter.py

@@ -292,7 +292,7 @@ class SubprocessInterpreter(BaseInterpreter):
         if self.require_confirm:
             logger.info(
                 f"The following {code_type} code will run on your "
-                "computer: {code}"
+                f"computer: {code}"
             )
             while True:
                 choice = input("Running code? [Y/n]:").lower().strip()

camel/loaders/__init__.py

@@ -18,7 +18,7 @@ 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 .pandas_reader import PandasReader
 from .unstructured_io import UnstructuredIO
 
 __all__ = [
@@ -30,6 +30,6 @@ __all__ = [
     'Firecrawl',
     'Apify',
     'ChunkrReader',
-    'PandaReader',
+    'PandasReader',
     'MinerU',
 ]