camel-ai 0.2.73a6__tar.gz → 0.2.73a9__tar.gz

{camel_ai-0.2.73a6 → camel_ai-0.2.73a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.73a6
+Version: 0.2.73a9
 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.73a6 → camel_ai-0.2.73a9}/camel/__init__.py

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

{camel_ai-0.2.73a6 → camel_ai-0.2.73a9}/camel/societies/__init__.py

@@ -13,8 +13,10 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from .babyagi_playing import BabyAGI
 from .role_playing import RolePlaying
+from .workforce import Workforce
 
 __all__ = [
     'RolePlaying',
     'BabyAGI',
+    'Workforce',
 ]

{camel_ai-0.2.73a6 → camel_ai-0.2.73a9}/camel/storages/key_value_storages/mem0_cloud.py

@@ -103,34 +103,6 @@ class Mem0Storage(BaseKeyValueStorage):
         }
         return {k: v for k, v in options.items() if v is not None}
 
-    def _prepare_filters(
-        self,
-        agent_id: Optional[str] = None,
-        user_id: Optional[str] = None,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        r"""Helper method to prepare filters for Mem0 API calls.
-
-        Args:
-            agent_id (Optional[str], optional): Agent ID to filter by
-                (default: :obj:`None`).
-            user_id (Optional[str], optional): User ID to filter by (default:
-                :obj:`None`).
-            filters (Optional[Dict[str, Any]], optional): Additional filters
-                (default: :obj:`None`).
-
-        Returns:
-            Dict[str, Any]: Prepared filters dictionary for API calls.
-        """
-        base_filters: Dict[str, Any] = {"AND": []}
-        if filters:
-            base_filters["AND"].append(filters)
-        if agent_id or self.agent_id:
-            base_filters["AND"].append({"agent_id": agent_id or self.agent_id})
-        if user_id or self.user_id:
-            base_filters["AND"].append({"user_id": user_id or self.user_id})
-        return base_filters if base_filters["AND"] else {}
-
     def _prepare_messages(
         self,
         records: List[Dict[str, Any]],
@@ -168,7 +140,6 @@ class Mem0Storage(BaseKeyValueStorage):
             self.client.add(messages, **options)
         except Exception as e:
             logger.error(f"Error adding memory: {e}")
-            logger.error(f"Error: {e}")
 
     def load(self) -> List[Dict[str, Any]]:
         r"""Loads all stored records from the Mem0 storage system.
@@ -178,11 +149,18 @@ class Mem0Storage(BaseKeyValueStorage):
                 represents a stored record.
         """
         try:
-            filters = self._prepare_filters(
-                agent_id=self.agent_id,
-                user_id=self.user_id,
-            )
-            results = self.client.get_all(version="v2", **filters)
+            # Build kwargs for get_all
+            kwargs = {}
+            if self.agent_id:
+                kwargs['agent_id'] = self.agent_id
+            if self.user_id:
+                kwargs['user_id'] = self.user_id
+
+            # If no filters available, return empty list
+            if not kwargs:
+                return []
+
+            results = self.client.get_all(**kwargs)
 
             # Transform results into MemoryRecord objects
             transformed_results = []
@@ -190,35 +168,58 @@ class Mem0Storage(BaseKeyValueStorage):
                 memory_record = MemoryRecord(
                     uuid=UUID(result["id"]),
                     message=BaseMessage(
-                        role_name="user",
+                        role_name="memory",
                         role_type=RoleType.USER,
-                        meta_dict={},
+                        meta_dict=result.get("metadata", {}),
                         content=result["memory"],
                     ),
                     role_at_backend=OpenAIBackendRole.USER,
                     extra_info=result.get("metadata", {}),
                     timestamp=datetime.fromisoformat(
-                        result["created_at"]
+                        result["created_at"].replace('Z', '+00:00')
                     ).timestamp(),
-                    agent_id=result.get("agent_id", ""),
+                    agent_id=result.get("agent_id", self.agent_id or ""),
                 )
                 transformed_results.append(memory_record.to_dict())
 
             return transformed_results
         except Exception as e:
-            logger.error(f"Error searching memories: {e}")
+            logger.error(f"Error loading memories: {e}")
             return []
 
     def clear(
         self,
+        agent_id: Optional[str] = None,
+        user_id: Optional[str] = None,
     ) -> None:
-        r"""Removes all records from the Mem0 storage system."""
+        r"""Removes all records from the Mem0 storage system.
+
+        Args:
+            agent_id (Optional[str]): Specific agent ID to clear memories for.
+            user_id (Optional[str]): Specific user ID to clear memories for.
+        """
         try:
-            filters = self._prepare_filters(
-                agent_id=self.agent_id,
-                user_id=self.user_id,
-            )
-            self.client.delete_users(**filters)
+            # Use provided IDs or fall back to instance defaults
+            target_user_id = user_id or self.user_id
+            target_agent_id = agent_id or self.agent_id
+
+            # Build kwargs for delete_users method
+            kwargs = {}
+            if target_user_id:
+                kwargs['user_id'] = target_user_id
+            if target_agent_id:
+                kwargs['agent_id'] = target_agent_id
+
+            if kwargs:
+                # Use delete_users (plural) - this is the correct method name
+                self.client.delete_users(**kwargs)
+                logger.info(
+                    f"Successfully cleared memories with filters: {kwargs}"
+                )
+            else:
+                logger.warning(
+                    "No user_id or agent_id available for clearing memories"
+                )
+
         except Exception as e:
             logger.error(f"Error deleting memories: {e}")
-            logger.error(f"Error: {e}")

{camel_ai-0.2.73a6 → camel_ai-0.2.73a9}/camel/toolkits/file_write_toolkit.py

@@ -840,6 +840,69 @@ class FileWriteToolkit(BaseToolkit):
 
         return text
 
+    def _ensure_html_utf8_meta(self, content: str) -> str:
+        r"""Ensure HTML content has UTF-8 meta tag.
+
+        Args:
+            content (str): The HTML content.
+
+        Returns:
+            str: HTML content with UTF-8 meta tag.
+        """
+        # Check if content already has a charset meta tag
+        has_charset = re.search(
+            r'<meta[^>]*charset[^>]*>', content, re.IGNORECASE
+        )
+
+        # UTF-8 meta tag
+        utf8_meta = '<meta charset="utf-8">'
+
+        if has_charset:
+            # Replace existing charset with UTF-8
+            content = re.sub(
+                r'<meta[^>]*charset[^>]*>',
+                utf8_meta,
+                content,
+                flags=re.IGNORECASE,
+            )
+        else:
+            # Add UTF-8 meta tag
+            # Try to find <head> tag
+            head_match = re.search(r'<head[^>]*>', content, re.IGNORECASE)
+            if head_match:
+                # Insert after <head> tag
+                insert_pos = head_match.end()
+                content = (
+                    content[:insert_pos]
+                    + '\n    '
+                    + utf8_meta
+                    + content[insert_pos:]
+                )
+            else:
+                # No <head> tag found, check if there's <html> tag
+                html_match = re.search(r'<html[^>]*>', content, re.IGNORECASE)
+                if html_match:
+                    # Insert <head> with meta tag after <html>
+                    insert_pos = html_match.end()
+                    content = (
+                        content[:insert_pos]
+                        + '\n<head>\n    '
+                        + utf8_meta
+                        + '\n</head>'
+                        + content[insert_pos:]
+                    )
+                else:
+                    # No proper HTML structure, wrap content
+                    content = (
+                        '<!DOCTYPE html>\n<html>\n<head>\n    '
+                        + utf8_meta
+                        + '\n</head>\n<body>\n'
+                        + content
+                        + '\n</body>\n</html>'
+                    )
+
+        return content
+
     def _write_csv_file(
         self,
         file_path: Path,
@@ -901,6 +964,10 @@ class FileWriteToolkit(BaseToolkit):
             content (str): The content to write.
             encoding (str): Character encoding to use. (default: :obj:`utf-8`)
         """
+        # For HTML files, ensure UTF-8 meta tag is present
+        if file_path.suffix.lower() in ['.html', '.htm']:
+            content = self._ensure_html_utf8_meta(content)
+
         with file_path.open("w", encoding=encoding) as f:
             f.write(content)