start implementation on new architecture

sia/working_memory.py

@@ -0,0 +1,116 @@
+from typing import List, Optional
+import xml.etree.ElementTree as ET
+
+from .entry import Entry
+
+class WorkingMemory:
+    """
+    Manages a collection of entries that represent the current state of the system.
+    
+    The working memory stores different types of entries (scripts, reasoning, errors, etc.)
+    and provides methods to add, remove, and update them. It also generates XML context
+    representing the current state.
+    """
+    
+    def __init__(self):
+        """Initialize an empty working memory."""
+        self._entries: List[Entry] = []
+        
+    def add_entry(self, entry: Entry) -> None:
+        """
+        Add a new entry to working memory.
+        
+        Args:
+            entry: Entry object to add
+        """
+        if not isinstance(entry, Entry):
+            raise TypeError("Entry must be an instance of Entry class")
+        self._entries.append(entry)
+        
+    def remove_entry(self, id: str) -> None:
+        """
+        Remove an entry from working memory by its ID.
+        Ensures cleanup is performed before removal.
+        
+        Args:
+            id: Unique identifier of entry to remove
+        """
+        entry = self.get_entry(id)
+        if entry is not None:
+            entry.cleanup()
+            self._entries = [e for e in self._entries if e.id != id]
+            
+    def clear(self) -> None:
+        """
+        Remove all entries from working memory.
+        Ensures cleanup is performed on all entries.
+        """
+        for entry in self._entries:
+            entry.cleanup()
+        self._entries.clear()
+        
+    def __del__(self):
+        """
+        Clean up all entries when memory is deleted.
+        """
+        if hasattr(self, '_entries'):  # Check in case of partial initialization
+            self.clear()
+            
+    def get_entry(self, id: str) -> Optional[Entry]:
+        """
+        Get an entry by its ID.
+        
+        Args:
+            id: Unique identifier of entry to retrieve
+            
+        Returns:
+            Entry if found, None otherwise
+        """
+        for entry in self._entries:
+            if entry.id == id:
+                return entry
+        return None
+
+    def get_entries(self) -> List[Entry]:
+        """
+        Get all entries in working memory.
+        
+        Returns:
+            List[Entry]: List of all entries
+        """
+        return self._entries.copy()  # Return a copy to prevent external modification
+            
+    def get_entries_count(self) -> int:
+        """
+        Get the total number of entries.
+        
+        Returns:
+            int: Number of entries in working memory
+        """
+        return len(self._entries)
+    
+    def get_entries_by_type(self, entry_type: type) -> List[Entry]:
+        """
+        Get all entries of a specific type.
+        
+        Args:
+            entry_type: Type of entries to retrieve
+            
+        Returns:
+            List[Entry]: List of entries matching the specified type
+        """
+        return [e for e in self._entries if isinstance(e, entry_type)]
+        
+    def update(self) -> None:
+        """Update all entries in working memory."""
+        for entry in self._entries:
+            entry.update()
+            
+    def generate_context(self) -> List[ET.Element]:
+        """
+        Generate XML Elements representing all entries.
+        
+        Returns:
+            List[ET.Element]: List of XML elements for each entry
+        """
+        return [entry.generate_context() for entry in self._entries]