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

camel/environments/single_step.py

@@ -19,6 +19,7 @@ from camel.datasets import BaseGenerator, DataPoint, StaticDataset
 from camel.logger import get_logger
 from camel.verifiers.base import (
     BaseVerifier,
+    VerificationOutcome,
     VerificationResult,
 )
 
@@ -51,7 +52,7 @@ class SingleStepEnv:
         question="Episode ended. This is just a placeholder."
     )
 
-    ACCURACY_REWARD = 10
+    ACCURACY_REWARD = 1
 
     def __init__(
         self,
@@ -126,6 +127,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 +159,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(
@@ -203,35 +207,66 @@ class SingleStepEnv:
             return observations[0] if batch_size == 1 else observations
 
         elif isinstance(self.dataset, BaseGenerator):
-            raise NotImplementedError(
-                "Reset not yet implemented for BaseGenerator datasets."
-            )
+            self._states = [
+                await self.dataset.async_sample() for _ in range(batch_size)
+            ]
+            self.current_batch_size = batch_size
+            self._states_done = [False] * batch_size
+
+            observations = [
+                Observation(question=sample.question, context={}, metadata={})
+                for sample in self._states
+            ]
+
+            return observations[0] if batch_size == 1 else observations
 
         else:
             raise TypeError(f"Unsupported dataset type: {type(self.dataset)}")
 
     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.
+        self, action: Union[Action, List[Action], str]
+    ) -> Union[
+        Tuple[Observation, float, bool, Dict[str, Any]],
+        List[Tuple[Observation, float, bool, Dict[str, Any]]],
+    ]:
+        r"""Execute one interaction step in the environment using the
+        proposed solution.
+
+        This method processes the agent's response(s) to the current
+        observation(s), verifies the correctness of the responses using
+        the verifier, computes rewards, and returns the resulting
+        state transition(s).
+
+        The environment is strictly single-step. Once an action is
+        submitted for a state, that state is marked as done, and
+        the observation will not change.
 
         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 (Union[Action, List[Action], str]):
+                The action(s) taken by the agent,
+                    which should contain the response(s)
+                to the observation(s). Can be:
+                - A single `Action` object (for batch size 1),
+                - A list of `Action` objects (for batched evaluation),
+                - A raw string (only allowed when batch size is 1).
 
         Returns:
-            Union[StepResult, List[StepResult]]: StepResult or list of
-                StepResults for the processed states.
+            Union[Tuple[Observation, float, bool, Dict[str, Any]], List[...]]:
+                A tuple or list of tuples containing:
+                - `Observation`: Placeholder indicating episode end.
+                - `float`: The reward for the response.
+                - `bool`: Whether the episode is done
+                    (always `True` in this case).
+                - `dict`: Additional info including the proposed solution,
+                          verification result, and original data point.
 
         Raises:
-            RuntimeError: If environment isn't set up or episode has ended.
-            ValueError: If indices are invalid, duplicate, or correspond to
-                finished states.
+            RuntimeError: If the environment has not been set up,
+                or if `reset()` has not been called.
+            ValueError: If invalid action format, duplicate indices,
+                or out-of-bounds indices are detected.
         """
+
         if not self._is_setup:
             raise RuntimeError("Environment not set up. Call setup() first.")
         if self._batch_done():
@@ -241,12 +276,10 @@ 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]
+        actions = self._normalize_actions(action)
+
+        indices = [a.index for a in actions]
 
-        if len(set(indices)) != len(indices):
-            raise ValueError("Duplicate state indices in actions.")
         for idx in indices:
             if idx < 0 or idx >= len(self._states):
                 raise ValueError(f"Invalid state index {idx}.")
@@ -254,7 +287,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,25 +294,34 @@ 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,
-            ground_truths=ground_truths,  # type: ignore [arg-type]
-            raise_on_error=True,
-        )
+        try:
+            verification_results = await self.verifier.verify_batch(
+                solutions=proposed_solutions,
+                reference_answers=ground_truths,  # type: ignore [arg-type]
+                raise_on_error=True,
+            )
+        except Exception as e:
+            logger.error(f"Verification failed: {e}")
+            # Return failed verification results with status=FAILURE
+            verification_results = [
+                VerificationResult(
+                    result="",
+                    status=VerificationOutcome.FAILURE,
+                    error_message=f"Verification error: {e}",
+                )
+                for _ in range(len(proposed_solutions))
+            ]
 
         total_rewards, rewards_dicts = await self._compute_reward_batch(
             proposed_solutions, verification_results
         )
-
-        step_results = []
-        # TODO: batch this
-        for i, action in enumerate(actions):
-            idx = action.index
-            step_result = StepResult(
+        # Create and return step results in batch
+        step_results = [
+            StepResult(
                 observation=self.PLACEHOLDER_OBS,
                 reward=total_rewards[i],
                 rewards_dict=rewards_dicts[i],
@@ -288,14 +329,96 @@ class SingleStepEnv:
                 info={
                     "proposed_solution": proposed_solutions[i],
                     "verification_result": verification_results[i],
-                    "state": self._states[idx],
+                    "state": self._states[indices[i]],
                 },
-            )
-            step_results.append(step_result)
+            ).as_tuple()
+            for i in range(len(actions))
+        ]
+        for _, idx in enumerate(indices):
             self._states_done[idx] = True
 
         return step_results[0] if len(step_results) == 1 else step_results
 
+    def _normalize_actions(
+        self, action: Union[Action, List[Action], str]
+    ) -> List[Action]:
+        r"""Normalize the user-provided action(s) into a validated list
+        of `Action` objects.
+
+        This method handles flexibility in input format by converting
+        raw strings (only allowed when batch size is 1) and ensuring
+        all necessary structure and integrity checks on actions
+        (e.g., index bounds, duplicates).
+
+        Args:
+            action (Union[Action, List[Action], str]):
+                The raw input action(s) provided by the agent. Can be:
+                - A single `Action` object.
+                - A list of `Action` objects.
+                - A raw string (if `batch_size == 1`), auto-wrapped
+                    in an `Action`.
+
+        Returns:
+            List[Action]: A list of validated `Action` instances
+                ready for evaluation.
+
+        Raises:
+            ValueError: If:
+                - Action indices are invalid or duplicated,
+                - Action list is empty,
+                - Index mismatches expected values
+                    (e.g., 0 for batch size 1),
+                - Wrong structure is used
+                    (e.g., string used with batch size > 1).
+            TypeError: If the action is of an unsupported type.
+        """
+
+        if isinstance(action, str):
+            if self.current_batch_size != 1:
+                raise ValueError(
+                    "String input for action is only allowed"
+                    " when batch_size == 1"
+                )
+            logger.warning("Auto-converting from str to Action", stacklevel=2)
+            action = Action(index=0, llm_response=action)
+
+        if isinstance(action, Action):
+            actions = [action]
+        elif isinstance(action, list):
+            if not action:
+                raise ValueError("Action list cannot be empty")
+            if not all(isinstance(a, Action) for a in action):
+                raise ValueError(
+                    "All elements in the list must be Action objects"
+                )
+            actions = action
+        else:
+            raise TypeError("Action must be a str, Action, or list of Actions")
+
+        if self.current_batch_size == 1 and len(actions) != 1:
+            raise ValueError(
+                "For batch_size=1, expect a single Action or a "
+                "list containing exactly one Action"
+            )
+
+        # Validate indices
+        for a in actions:
+            if not isinstance(a.index, int):
+                raise ValueError(
+                    f"Action index must be an integer, got {a.index}"
+                )
+            if self.current_batch_size == 1:
+                if a.index != 0:
+                    raise ValueError(
+                        "For batch_size=1, Action index must be 0"
+                    )
+
+        indices = [a.index for a in actions]
+        if len(set(indices)) != len(indices):
+            raise ValueError("Duplicate state indices in actions.")
+
+        return actions
+
     async def _compute_reward_batch(
         self,
         proposed_solutions: List[str],
@@ -315,6 +438,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 +484,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 the batch processing has started.
+
+        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

@@ -185,7 +185,7 @@ class DockerInterpreter(BaseInterpreter):
         code: str,
         code_type: str,
     ) -> str:
-        r"""Executes the given code in the conatiner attached to the
+        r"""Executes the given code in the container attached to the
         interpreter, and captures the stdout and stderr streams.
 
         Args:
@@ -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/internal_python_interpreter.py

@@ -421,7 +421,7 @@ class InternalPythonInterpreter(BaseInterpreter):
         result = None
         if not isinstance(if_statement.test, ast.Compare):
             raise InterpreterError(
-                "Only Campare expr supported in if statement, get"
+                "Only Compare expr supported in if statement, get"
                 f" {if_statement.test.__class__.__name__}"
             )
         if self._execute_condition(if_statement.test):

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',
 ]

camel/loaders/{panda_reader.py → pandas_reader.py}

@@ -11,13 +11,10 @@
 # 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
 from functools import wraps
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
 
-import pandas as pd
-
 if TYPE_CHECKING:
     from pandas import DataFrame
     from pandasai import SmartDataframe
@@ -50,25 +47,18 @@ def check_suffix(valid_suffixs: List[str]) -> Callable:
     return decorator
 
 
-class PandaReader:
+class PandasReader:
     def __init__(self, config: Optional[Dict[str, Any]] = None) -> None:
-        r"""Initializes the PandaReader class.
+        r"""Initializes the PandasReader class.
 
         Args:
             config (Optional[Dict[str, Any]], optional): The configuration
                 dictionary that can include LLM API settings for LLM-based
-                processing. If not provided, it will use OpenAI with the API
-                key from the OPENAI_API_KEY environment variable. You can
-                customize the LLM configuration by providing a 'llm' key in
-                the config dictionary. (default: :obj:`None`)
+                processing. If not provided, no LLM will be configured by
+                default. You can customize the LLM configuration by providing
+                a 'llm' key in the config dictionary. (default: :obj:`None`)
         """
-        from pandasai.llm import OpenAI  # type: ignore[import-untyped]
-
         self.config = config or {}
-        if "llm" not in self.config:
-            self.config["llm"] = OpenAI(
-                api_token=os.getenv("OPENAI_API_KEY"),
-            )
 
         self.__LOADER = {
             ".csv": self.read_csv,
@@ -91,8 +81,13 @@ class PandaReader:
         data: Union["DataFrame", str],
         *args: Any,
         **kwargs: Dict[str, Any],
-    ) -> "SmartDataframe":
-        r"""Loads a file or DataFrame and returns a SmartDataframe object.
+    ) -> Union["DataFrame", "SmartDataframe"]:
+        r"""Loads a file or DataFrame and returns a DataFrame or
+        SmartDataframe object.
+
+        If an LLM is configured in the config dictionary, a SmartDataframe
+        will be returned, otherwise a regular pandas DataFrame will be
+        returned.
 
         args:
             data (Union[DataFrame, str]): The data to load.
@@ -100,24 +95,32 @@ class PandaReader:
             **kwargs (Dict[str, Any]): Additional keyword arguments.
 
         Returns:
-            SmartDataframe: The SmartDataframe object.
+            Union[DataFrame, SmartDataframe]: The DataFrame or SmartDataframe
+                object.
         """
         from pandas import DataFrame
-        from pandasai import SmartDataframe
 
+        # Load the data into a pandas DataFrame
         if isinstance(data, DataFrame):
-            return SmartDataframe(data, config=self.config)
-        file_path = str(data)
-        path = Path(file_path)
-        if not file_path.startswith("http") and not path.exists():
-            raise FileNotFoundError(f"File {file_path} not found")
-        if path.suffix in self.__LOADER:
-            return SmartDataframe(
-                self.__LOADER[path.suffix](file_path, *args, **kwargs),  # type: ignore[operator]
-                config=self.config,
-            )
+            df = data
         else:
-            raise ValueError(f"Unsupported file format: {path.suffix}")
+            file_path = str(data)
+            path = Path(file_path)
+            if not file_path.startswith("http") and not path.exists():
+                raise FileNotFoundError(f"File {file_path} not found")
+            if path.suffix in self.__LOADER:
+                df = self.__LOADER[path.suffix](file_path, *args, **kwargs)  # type: ignore[operator]
+            else:
+                raise ValueError(f"Unsupported file format: {path.suffix}")
+
+        # If an LLM is configured, return a SmartDataframe, otherwise return a
+        # regular DataFrame
+        if "llm" in self.config:
+            from pandasai import SmartDataframe
+
+            return SmartDataframe(df, config=self.config)
+        else:
+            return df
 
     @check_suffix([".csv"])
     def read_csv(
@@ -133,6 +136,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_csv(file_path, *args, **kwargs)
 
     @check_suffix([".xlsx", ".xls"])
@@ -149,6 +154,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_excel(file_path, *args, **kwargs)
 
     @check_suffix([".json"])
@@ -165,6 +172,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_json(file_path, *args, **kwargs)
 
     @check_suffix([".parquet"])
@@ -181,6 +190,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_parquet(file_path, *args, **kwargs)
 
     def read_sql(self, *args: Any, **kwargs: Dict[str, Any]) -> "DataFrame":
@@ -193,6 +204,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_sql(*args, **kwargs)
 
     def read_table(
@@ -208,6 +221,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_table(file_path, *args, **kwargs)
 
     def read_clipboard(
@@ -222,6 +237,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_clipboard(*args, **kwargs)
 
     @check_suffix([".html"])
@@ -238,6 +255,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_html(file_path, *args, **kwargs)
 
     @check_suffix([".feather"])
@@ -254,6 +273,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_feather(file_path, *args, **kwargs)
 
     @check_suffix([".dta"])
@@ -270,6 +291,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_stata(file_path, *args, **kwargs)
 
     @check_suffix([".sas"])
@@ -286,6 +309,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_sas(file_path, *args, **kwargs)
 
     @check_suffix([".pkl"])
@@ -302,6 +327,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_pickle(file_path, *args, **kwargs)
 
     @check_suffix([".h5"])
@@ -318,6 +345,8 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_hdf(file_path, *args, **kwargs)
 
     @check_suffix([".orc"])
@@ -334,4 +363,6 @@ class PandaReader:
         Returns:
             DataFrame: The DataFrame object.
         """
+        import pandas as pd
+
         return pd.read_orc(file_path, *args, **kwargs)

camel/loaders/unstructured_io.py

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import traceback
 import uuid
 import warnings
 from typing import (
@@ -151,7 +152,7 @@ class UnstructuredIO:
                     elements = partition(file=f, **kwargs)
                     return elements
             except Exception:
-                warnings.warn(f"Failed to partition the file: {input_path}")
+                warnings.warn(traceback.format_exc())
                 return None
 
     @staticmethod

camel/memories/blocks/chat_history_block.py

@@ -38,7 +38,7 @@ class ChatHistoryBlock(MemoryBlock):
         keep_rate (float, optional): In historical messages, the score of the
             last message is 1.0, and with each step taken backward, the score
             of the message is multiplied by the `keep_rate`. Higher `keep_rate`
-            leads to high possiblity to keep history messages during context
+            leads to high possibility to keep history messages during context
             creation.
     """