camel-ai 0.2.73a2__tar.gz → 0.2.73a3__tar.gz

{camel_ai-0.2.73a2 → camel_ai-0.2.73a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.73a2
+Version: 0.2.73a3
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel

{camel_ai-0.2.73a2 → camel_ai-0.2.73a3}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.73a2'
+__version__ = '0.2.73a3'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.73a2 → camel_ai-0.2.73a3}/camel/toolkits/excel_toolkit.py

@@ -14,6 +14,7 @@
 
 # Enables postponed evaluation of annotations (for string-based type hints)
 import os
+from pathlib import Path
 from typing import TYPE_CHECKING, List, Optional, Union
 
 from camel.logger import get_logger
@@ -41,7 +42,7 @@ class ExcelToolkit(BaseToolkit):
     def __init__(
         self,
         timeout: Optional[float] = None,
-        file_path: Optional[str] = None,
+        working_directory: Optional[str] = None,
     ):
         r"""Initializes a new instance of the ExcelToolkit class.
 
@@ -49,16 +50,28 @@ class ExcelToolkit(BaseToolkit):
             timeout (Optional[float]): The timeout value for API requests
                 in seconds. If None, no timeout is applied.
                 (default: :obj:`None`)
-            file_path (Optional[str]): Path to an existing Excel file to load.
-                (default: :obj:`None`)
+            working_directory (str, optional): The default directory for
+                output files. If not provided, it will be determined by the
+                `CAMEL_WORKDIR` environment variable (if set). If the
+                environment variable is not set, it defaults to
+                `camel_working_dir`.
         """
         super().__init__(timeout=timeout)
-        self.file_path = file_path
         self.wb = None
-        if file_path and os.path.exists(file_path):
-            from openpyxl import load_workbook
+        if working_directory:
+            self.working_directory = Path(working_directory).resolve()
+        else:
+            camel_workdir = os.environ.get("CAMEL_WORKDIR")
+            if camel_workdir:
+                self.working_directory = Path(camel_workdir).resolve()
+            else:
+                self.working_directory = Path("./camel_working_dir").resolve()
 
-            self.wb = load_workbook(file_path)
+        self.working_directory.mkdir(parents=True, exist_ok=True)
+        logger.info(
+            f"ExcelToolkit initialized with output directory: "
+            f"{self.working_directory}"
+        )
 
     def _validate_file_path(self, file_path: str) -> bool:
         r"""Validate file path for security.
@@ -232,12 +245,11 @@ class ExcelToolkit(BaseToolkit):
             logger.error(f"Failed to process Excel file {document_path}: {e}")
             return f"Failed to process Excel file {document_path}: {e}"
 
-    def _save_workbook(self, file_path: Optional[str] = None) -> str:
+    def _save_workbook(self, file_path: str) -> str:
         r"""Save the current workbook to file.
 
         Args:
-            file_path (Optional[str]): The path to save the workbook.
-                If None, uses self.file_path.
+            file_path (str): The path to save the workbook.
 
         Returns:
             str: Success or error message.
@@ -245,23 +257,46 @@ class ExcelToolkit(BaseToolkit):
         if not self.wb:
             return "Error: No workbook loaded to save."
 
-        save_path = file_path or self.file_path
-        if not save_path:
-            return "Error: No file path specified for saving."
-
-        if not self._validate_file_path(save_path):
+        if not self._validate_file_path(file_path):
             return "Error: Invalid file path for saving."
 
         try:
-            self.wb.save(save_path)
-            return f"Workbook saved successfully to {save_path}"
+            self.wb.save(file_path)
+            return f"Workbook saved successfully to {file_path}"
         except Exception as e:
             logger.error(f"Failed to save workbook: {e}")
             return f"Error: Failed to save workbook: {e}"
 
+    def save_workbook(self, filename: str) -> str:
+        r"""Save the current in-memory workbook to a file.
+
+        Args:
+            filename (str): The filename to save the workbook. Must end with
+                .xlsx extension. The file will be saved in self.
+                working_directory.
+
+        Returns:
+            str: Success message or error details.
+        """
+        if not self.wb:
+            return "Error: No workbook is currently loaded in memory."
+
+        # Validate filename
+        if not filename:
+            return "Error: Filename is required."
+
+        if not filename.endswith('.xlsx'):
+            return "Error: Filename must end with .xlsx extension."
+
+        # Create full path in working directory
+        file_path = self.working_directory / filename
+        resolved_file_path = str(file_path.resolve())
+
+        return self._save_workbook(resolved_file_path)
+
     def create_workbook(
         self,
-        file_path: str,
+        filename: Optional[str] = None,
         sheet_name: Optional[str] = None,
         data: Optional[List[List[Union[str, int, float, None]]]] = None,
     ) -> str:
@@ -271,8 +306,9 @@ class ExcelToolkit(BaseToolkit):
         toolkit to work with the new file and optionally adds initial data.
 
         Args:
-            file_path (str): Where to save the new Excel file. Must end with .
-                xlsx.
+            filename (Optional[str]): The filename for the workbook. Must end
+                with .xlsx extension. The file will be saved in
+                self.working_directory. (default: :obj:`None`)
             sheet_name (Optional[str]): Name for the first sheet. If None,
                 creates "Sheet1". (default: :obj:`None`)
             data (Optional[List[List[Union[str, int, float, None]]]]): Initial
@@ -284,14 +320,31 @@ class ExcelToolkit(BaseToolkit):
         """
         from openpyxl import Workbook
 
-        if not self._validate_file_path(file_path):
+        # Validate filename
+        if filename is None:
+            return "Error: Filename is required."
+
+        if not filename.endswith('.xlsx'):
+            return "Error: Filename must end with .xlsx extension."
+
+        # Create full path in working directory
+        file_path = self.working_directory / filename
+        resolved_file_path = str(file_path.resolve())
+
+        if not self._validate_file_path(resolved_file_path):
             return "Error: Invalid file path."
 
+        # Check if file already exists
+        if os.path.exists(resolved_file_path):
+            return (
+                f"Error: File {filename} already exists in "
+                f"{self.working_directory}."
+            )
+
         try:
             # Create a new workbook
             wb = Workbook()
             self.wb = wb
-            self.file_path = file_path
 
             # Handle sheet creation safely
             if sheet_name:
@@ -312,42 +365,55 @@ class ExcelToolkit(BaseToolkit):
                     ws.append(row)
 
             # Save the workbook to the specified file path
-            wb.save(file_path)
+            wb.save(resolved_file_path)
 
-            return f"Workbook created successfully at {file_path}"
+            return f"Workbook created successfully at {resolved_file_path}"
         except Exception as e:
             logger.error(f"Failed to create workbook: {e}")
             return f"Error: Failed to create workbook: {e}"
 
-    def delete_workbook(self, file_path: Optional[str] = None) -> str:
-        r"""Delete a spreadsheet file.
+    def delete_workbook(self, filename: str) -> str:
+        r"""Delete a spreadsheet file from the working directory.
 
         Args:
-            file_path (Optional[str]): The path of the file to delete.
-                If None, uses self.file_path.
+            filename (str): The filename to delete. Must end with .xlsx
+                extension. The file will be deleted from self.
+                working_directory.
 
         Returns:
-            str: Success message.
+            str: Success message or error details.
         """
-        target_path = file_path or self.file_path
-        if not target_path:
-            return "Error: No file path specified for deletion."
+        # Validate filename
+        if not filename:
+            return "Error: Filename is required."
+
+        if not filename.endswith('.xlsx'):
+            return "Error: Filename must end with .xlsx extension."
+
+        # Create full path in working directory
+        file_path = self.working_directory / filename
+        target_path = str(file_path.resolve())
 
         if not self._validate_file_path(target_path):
             return "Error: Invalid file path."
 
         if not os.path.exists(target_path):
-            return f"File {target_path} does not exist."
+            return (
+                f"Error: File {filename} does not exist in "
+                f"{self.working_directory}."
+            )
 
         try:
             os.remove(target_path)
-            if target_path == self.file_path:
-                self.wb = None
-                self.file_path = None
-            return f"Workbook {target_path} deleted successfully."
+            # Clean up workbook if one is loaded
+            self.wb = None
+            return (
+                f"Workbook {filename} deleted successfully from "
+                f"{self.working_directory}."
+            )
         except Exception as e:
             logger.error(f"Failed to delete workbook: {e}")
-            return f"Failed to delete workbook {target_path}: {e}"
+            return f"Error: Failed to delete workbook {filename}: {e}"
 
     def create_sheet(
         self,
@@ -379,9 +445,6 @@ class ExcelToolkit(BaseToolkit):
                 for row in data:
                     ws.append(row)
 
-            save_result = self._save_workbook()
-            if save_result.startswith("Error"):
-                return save_result
             return f"Sheet {sheet_name} created successfully."
         except Exception as e:
             logger.error(f"Failed to create sheet: {e}")
@@ -408,9 +471,6 @@ class ExcelToolkit(BaseToolkit):
         try:
             ws = self.wb[sheet_name]
             self.wb.remove(ws)
-            save_result = self._save_workbook()
-            if save_result.startswith("Error"):
-                return save_result
             return f"Sheet {sheet_name} deleted successfully."
         except Exception as e:
             logger.error(f"Failed to delete sheet: {e}")
@@ -439,9 +499,6 @@ class ExcelToolkit(BaseToolkit):
                 for cell in row:
                     cell.value = None
 
-            save_result = self._save_workbook()
-            if save_result.startswith("Error"):
-                return save_result
             return f"Sheet {sheet_name} cleared successfully."
         except Exception as e:
             logger.error(f"Failed to clear sheet: {e}")
@@ -479,7 +536,6 @@ class ExcelToolkit(BaseToolkit):
         num_rows = end_row - start_row + 1
         ws.delete_rows(start_row, num_rows)
 
-        self._save_workbook()
         return (
             f"Deleted rows {start_row} to {end_row} from sheet "
             f"{sheet_name} successfully."
@@ -518,7 +574,6 @@ class ExcelToolkit(BaseToolkit):
         num_cols = end_col - start_col + 1
         ws.delete_cols(start_col, num_cols)
 
-        self._save_workbook()
         return (
             f"Deleted columns {start_col} to {end_col} from sheet "
             f"{sheet_name} successfully."
@@ -585,9 +640,6 @@ class ExcelToolkit(BaseToolkit):
                 ws[cell_reference].value = None
             else:
                 ws[cell_reference] = value
-            save_result = self._save_workbook()
-            if save_result.startswith("Error"):
-                return save_result
             return (
                 f"Cell {cell_reference} updated successfully in sheet "
                 f"{sheet_name}."
@@ -765,10 +817,9 @@ class ExcelToolkit(BaseToolkit):
                     if col_idx < len(values[row_idx]):
                         cell.value = values[row_idx][col_idx]
 
-        self._save_workbook()
         return f"Values set for range {cell_range} in sheet {sheet_name}."
 
-    def export_sheet_to_csv(self, sheet_name: str, csv_path: str) -> str:
+    def export_sheet_to_csv(self, sheet_name: str, csv_filename: str) -> str:
         r"""Export a specific sheet to CSV format.
 
         Use this to convert Excel sheets to CSV files for compatibility or
@@ -776,24 +827,63 @@ class ExcelToolkit(BaseToolkit):
 
         Args:
             sheet_name (str): Name of the sheet to export.
-            csv_path (str): File path where CSV will be saved.
+            csv_filename (str): Filename for the CSV file. Must end with .csv
+                extension. The file will be saved in self.working_directory.
 
         Returns:
             str: Success confirmation message or error details.
         """
         if not self.wb:
-            return "Error: Workbook not initialized."
+            return (
+                "Error: No workbook is currently loaded. Use "
+                "extract_excel_content to load a workbook first."
+            )
 
         if sheet_name not in self.wb.sheetnames:
-            return f"Error: Sheet {sheet_name} does not exist."
+            return (
+                f"Error: Sheet {sheet_name} does not exist in the current "
+                "workbook."
+            )
 
-        import pandas as pd
+        # Validate filename
+        if not csv_filename:
+            return "Error: CSV filename is required."
 
-        # Read the specific sheet
-        df = pd.read_excel(self.file_path, sheet_name=sheet_name)
-        df.to_csv(csv_path, index=False)
+        if not csv_filename.endswith('.csv'):
+            return "Error: CSV filename must end with .csv extension."
 
-        return f"Sheet {sheet_name} exported to CSV: {csv_path}"
+        # Create full path in working directory
+        csv_path = self.working_directory / csv_filename
+        resolved_csv_path = str(csv_path.resolve())
+
+        if not self._validate_file_path(resolved_csv_path):
+            return "Error: Invalid file path."
+
+        try:
+            # Get the worksheet
+            ws = self.wb[sheet_name]
+
+            # Convert worksheet to list of lists
+            data = []
+            for row in ws.iter_rows(values_only=True):
+                data.append(list(row))
+
+            # Write to CSV
+            import csv
+
+            with open(
+                resolved_csv_path, 'w', newline='', encoding='utf-8'
+            ) as csvfile:
+                writer = csv.writer(csvfile)
+                writer.writerows(data)
+
+            return (
+                f"Sheet {sheet_name} exported to {csv_filename} "
+                f"in {self.working_directory}."
+            )
+        except Exception as e:
+            logger.error(f"Failed to export sheet to CSV: {e}")
+            return f"Error: Failed to export sheet {sheet_name} to CSV: {e}"
 
     def get_rows(
         self,
@@ -862,7 +952,6 @@ class ExcelToolkit(BaseToolkit):
             return f"Error: Sheet {sheet_name} does not exist."
         ws = self.wb[sheet_name]
         ws.append(row_data)
-        self._save_workbook()
         return f"Row appended to sheet {sheet_name} successfully."
 
     def update_row(
@@ -901,7 +990,6 @@ class ExcelToolkit(BaseToolkit):
         for col_idx, value in enumerate(row_data, 1):
             ws.cell(row=row_number, column=col_idx).value = value
 
-        self._save_workbook()
         return f"Row {row_number} updated in sheet {sheet_name} successfully."
 
     def get_tools(self) -> List[FunctionTool]:
@@ -916,6 +1004,7 @@ class ExcelToolkit(BaseToolkit):
             # File operations
             FunctionTool(self.extract_excel_content),
             FunctionTool(self.create_workbook),
+            FunctionTool(self.save_workbook),
             FunctionTool(self.delete_workbook),
             FunctionTool(self.export_sheet_to_csv),
             # Sheet operations

{camel_ai-0.2.73a2 → camel_ai-0.2.73a3}/camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py

@@ -110,6 +110,11 @@ class WebSocketBrowserWrapper:
         self.process: Optional[subprocess.Popen] = None
         self.websocket = None
         self.server_port = None
+        self._send_lock = asyncio.Lock()  # Lock for sending messages
+        self._receive_task = None  # Background task for receiving messages
+        self._pending_responses: Dict[
+            str, asyncio.Future[Dict[str, Any]]
+        ] = {}  # Message ID -> Future
 
         # Logging configuration
         self.browser_log_to_file = (config or {}).get(
@@ -251,11 +256,22 @@ class WebSocketBrowserWrapper:
                 f"Failed to connect to WebSocket server: {e}"
             ) from e
 
+        # Start the background receiver task
+        self._receive_task = asyncio.create_task(self._receive_loop())
+
         # Initialize the browser toolkit
         await self._send_command('init', self.config)
 
     async def stop(self):
         """Stop the WebSocket connection and server."""
+        # Cancel the receiver task
+        if self._receive_task and not self._receive_task.done():
+            self._receive_task.cancel()
+            try:
+                await self._receive_task
+            except asyncio.CancelledError:
+                pass
+
         if self.websocket:
             try:
                 await self._send_command('shutdown', {})
@@ -327,6 +343,39 @@ class WebSocketBrowserWrapper:
         except Exception as e:
             logger.error(f"Failed to write to log file: {e}")
 
+    async def _receive_loop(self):
+        r"""Background task to receive messages from WebSocket."""
+        try:
+            while self.websocket:
+                try:
+                    response_data = await self.websocket.recv()
+                    response = json.loads(response_data)
+
+                    message_id = response.get('id')
+                    if message_id and message_id in self._pending_responses:
+                        # Set the result for the waiting coroutine
+                        future = self._pending_responses.pop(message_id)
+                        if not future.done():
+                            future.set_result(response)
+                    else:
+                        # Log unexpected messages
+                        logger.warning(
+                            f"Received unexpected message: {response}"
+                        )
+
+                except asyncio.CancelledError:
+                    break
+                except Exception as e:
+                    logger.error(f"Error in receive loop: {e}")
+                    # Notify all pending futures of the error
+                    for future in self._pending_responses.values():
+                        if not future.done():
+                            future.set_exception(e)
+                    self._pending_responses.clear()
+                    break
+        finally:
+            logger.debug("Receive loop terminated")
+
     async def _ensure_connection(self) -> None:
         """Ensure WebSocket connection is alive."""
         if not self.websocket:
@@ -350,39 +399,39 @@ class WebSocketBrowserWrapper:
         message_id = str(uuid.uuid4())
         message = {'id': message_id, 'command': command, 'params': params}
 
-        try:
-            # Send command
-            if self.websocket is None:
-                raise RuntimeError("WebSocket connection not established")
-            await self.websocket.send(json.dumps(message))
+        # Create a future for this message
+        future: asyncio.Future[Dict[str, Any]] = asyncio.Future()
+        self._pending_responses[message_id] = future
 
-            # Wait for response with matching ID
-            while True:
-                try:
-                    if self.websocket is None:
-                        raise RuntimeError("WebSocket connection lost")
-                    response_data = await asyncio.wait_for(
-                        self.websocket.recv(), timeout=60.0
-                    )
-                    response = json.loads(response_data)
-
-                    # Check if this is the response we're waiting for
-                    if response.get('id') == message_id:
-                        if not response.get('success'):
-                            raise RuntimeError(
-                                f"Command failed: {response.get('error')}"
-                            )
-                        return response['result']
+        try:
+            # Use lock only for sending to prevent interleaved messages
+            async with self._send_lock:
+                if self.websocket is None:
+                    raise RuntimeError("WebSocket connection not established")
+                await self.websocket.send(json.dumps(message))
+
+            # Wait for response (no lock needed, handled by background
+            # receiver)
+            try:
+                response = await asyncio.wait_for(future, timeout=60.0)
 
-                except asyncio.TimeoutError:
+                if not response.get('success'):
                     raise RuntimeError(
-                        f"Timeout waiting for response to command: {command}"
+                        f"Command failed: {response.get('error')}"
                     )
-                except json.JSONDecodeError as e:
-                    logger.warning(f"Failed to decode WebSocket response: {e}")
-                    continue
+                return response['result']
+
+            except asyncio.TimeoutError:
+                # Remove from pending if timeout
+                self._pending_responses.pop(message_id, None)
+                raise RuntimeError(
+                    f"Timeout waiting for response to command: {command}"
+                )
 
         except Exception as e:
+            # Clean up the pending response
+            self._pending_responses.pop(message_id, None)
+
             # Check if it's a connection closed error
             if (
                 "close frame" in str(e)