Build issue resolve

Author: harshdesaii

multimind/memory/active_learning.py

@@ -47,7 +47,6 @@ def __init__(
         self.reinforcement: Dict[str, List[Dict[str, Any]]] = {}  # item_id -> reinforcement data
         self.last_analysis = datetime.now()
         self.last_optimization = datetime.now()
-        self.load()
 
     async def add_message(self, message: Dict[str, str]) -> None:
         """Add message and track feedback."""
@@ -210,7 +209,7 @@ async def _remove_item(self, item_id: str) -> None:
         if item_id in self.reinforcement:
             del self.reinforcement[item_id]
 
-    def get_messages(self) -> List[Dict[str, str]]:
+    async def get_messages(self) -> List[Dict[str, str]]:
         """Get all messages from all items."""
         messages = []
         for item in self.items:
@@ -241,7 +240,7 @@ async def save(self) -> None:
                     "last_optimization": self.last_optimization.isoformat()
                 }, f)
 
-    def load(self) -> None:
+    async def load(self) -> None:
         """Load items and feedback from persistent storage."""
         if self.storage_path and self.storage_path.exists():
             with open(self.storage_path, 'r') as f:

multimind/memory/associative.py

@@ -88,7 +88,6 @@ def __init__(
         self.last_cluster_update = datetime.now()
         self.last_analysis = datetime.now()
         self.last_evolution = datetime.now()
-        self.load()
 
     async def add_message(self, message: Dict[str, str]) -> None:
         """Add message as new association."""
@@ -407,7 +406,7 @@ async def _remove_association(self, association_id: str) -> None:
         if association_id in self.learning_history:
             del self.learning_history[association_id]
 
-    def get_messages(self) -> List[Dict[str, str]]:
+    async def get_messages(self) -> List[Dict[str, str]]:
         """Get all messages from all associations."""
         messages = []
         for association in self.associations:
@@ -448,7 +447,7 @@ async def save(self) -> None:
                     "last_evolution": self.last_evolution.isoformat()
                 }, f)
 
-    def load(self) -> None:
+    async def load(self) -> None:
         """Load associations from persistent storage."""
         if self.storage_path and self.storage_path.exists():
             with open(self.storage_path, 'r') as f:

multimind/memory/base.py

@@ -3,8 +3,7 @@
 """
 
 from abc import ABC, abstractmethod
-import inspect
-from typing import List, Dict, Any, Optional, Union
+from typing import List, Dict, Any
 from datetime import datetime
 
 class BaseMemory(ABC):
@@ -14,17 +13,6 @@ def __init__(self, memory_key: str = "chat_history"):
         self.memory_key = memory_key
         self.created_at = datetime.now()
 
-    def __init_subclass__(cls, **kwargs):
-        """Auto-wrap sync overrides so BaseMemory API stays async."""
-        super().__init_subclass__(**kwargs)
-        for method_name in ("add_message", "get_messages", "clear", "save", "load"):
-            method = cls.__dict__.get(method_name)
-            if method is None:
-                continue
-            if inspect.iscoroutinefunction(method):
-                continue
-            setattr(cls, method_name, BaseMemory._make_async_wrapper(method))
-
     @abstractmethod
     async def add_message(self, message: Dict[str, str]) -> None:
         """Add a message to memory."""
@@ -48,40 +36,4 @@ async def save(self) -> None:
     @abstractmethod
     async def load(self) -> None:
         """Load memory from persistent storage."""
-        pass 
-
-    @staticmethod
-    async def _maybe_await(value: Any) -> Any:
-        """Await value when needed; otherwise return directly."""
-        if inspect.isawaitable(value):
-            return await value
-        return value
-
-    @staticmethod
-    def _make_async_wrapper(sync_method):
-        """Wrap a synchronous method with an async callable."""
-        async def _wrapped(self, *args, **kwargs):
-            return sync_method(self, *args, **kwargs)
-        _wrapped.__name__ = sync_method.__name__
-        _wrapped.__doc__ = sync_method.__doc__
-        return _wrapped
-
-    async def add_message_async(self, message: Dict[str, str]) -> None:
-        """Backward-compatible alias for async add_message()."""
-        await self.add_message(message)
-
-    async def get_messages_async(self) -> List[Dict[str, str]]:
-        """Backward-compatible alias for async get_messages()."""
-        return await self.get_messages()
-
-    async def clear_async(self) -> None:
-        """Backward-compatible alias for async clear()."""
-        await self.clear()
-
-    async def save_async(self) -> None:
-        """Backward-compatible alias for async save()."""
-        await self.save()
-
-    async def load_async(self) -> None:
-        """Backward-compatible alias for async load()."""
-        await self.load()
+        pass 

multimind/memory/buffer.py

@@ -50,9 +50,7 @@ def __init__(
         self.last_backup = datetime.now()
         self.backup_history: List[Dict[str, Any]] = []
 
-        # Load if storage path exists
-        if self.storage_path and self.storage_path.exists():
-            self.load()
+        # Load explicitly via await memory.load() when needed.
 
     async def add_message(
         self,
@@ -94,7 +92,7 @@ async def add_message(
         if self.enable_backup and (datetime.now() - self.last_backup).total_seconds() >= self.backup_interval:
             await self._backup()
 
-    def get_messages(self) -> List[Dict[str, str]]:
+    async def get_messages(self) -> List[Dict[str, str]]:
         """Get all messages from the buffer."""
         return self.messages
 
@@ -108,7 +106,7 @@ def get_messages_with_metadata(self) -> List[Dict[str, Any]]:
             for i, msg in enumerate(self.messages)
         ]
 
-    def clear(self) -> None:
+    async def clear(self) -> None:
         """Clear all messages from the buffer."""
         self.messages = []
         self.message_tokens = []
@@ -117,7 +115,7 @@ def clear(self) -> None:
         if self.storage_path and self.storage_path.exists():
             self.storage_path.unlink()
 
-    def save(self) -> None:
+    async def save(self) -> None:
         """Save buffer to persistent storage."""
         if not self.storage_path:
             return
@@ -135,7 +133,7 @@ def save(self) -> None:
         with open(self.storage_path, "w") as f:
             json.dump(data, f)
 
-    def load(self) -> None:
+    async def load(self) -> None:
         """Load buffer from persistent storage."""
         if not self.storage_path or not self.storage_path.exists():
             return
@@ -152,7 +150,7 @@ def load(self) -> None:
             self.backup_history = data["backup_history"]
         except Exception as e:
             print(f"Error loading buffer: {e}")
-            self.clear()
+            await self.clear()
 
     def _remove_oldest(self) -> None:
         """Remove the oldest message based on strategy."""
@@ -263,7 +261,7 @@ async def _backup(self) -> None:
 
         # Save to disk if storage path exists
         if self.storage_path:
-            self.save()
+            await self.save()
 
     def get_stats(self) -> Dict[str, Any]:
         """Get buffer statistics."""

multimind/memory/cognitive_scratchpad.py

@@ -47,7 +47,6 @@ def __init__(
         self.reasoning_chains: Dict[str, List[Dict[str, Any]]] = {}  # chain_id -> chain data
         self.last_analysis = datetime.now()
         self.last_optimization = datetime.now()
-        self.load()
 
     async def add_message(self, message: Dict[str, str]) -> None:
         """Add message and track reasoning steps."""
@@ -206,7 +205,7 @@ async def _remove_item(self, item_id: str) -> None:
                 s for s in chain_data if s["item_id"] != item_id
             ]
 
-    def get_messages(self) -> List[Dict[str, str]]:
+    async def get_messages(self) -> List[Dict[str, str]]:
         """Get all messages from all items."""
         messages = []
         for item in self.items:
@@ -237,7 +236,7 @@ async def save(self) -> None:
                     "last_optimization": self.last_optimization.isoformat()
                 }, f)
 
-    def load(self) -> None:
+    async def load(self) -> None:
         """Load items and steps from persistent storage."""
         if self.storage_path and self.storage_path.exists():
             with open(self.storage_path, 'r') as f:

multimind/memory/combined.py

@@ -20,30 +20,30 @@ def __init__(
     async def add_message(self, message: Dict[str, str]) -> None:
         """Add message to all memory types."""
         for memory in self.memories:
-            await BaseMemory._maybe_await(memory.add_message(message))
+            await memory.add_message(message)
 
     async def get_messages(self) -> List[Dict[str, str]]:
         """Get messages from all memory types."""
         all_messages = []
         for memory in self.memories:
-            msgs = await BaseMemory._maybe_await(memory.get_messages())
+            msgs = await memory.get_messages()
             all_messages.extend(msgs)
         return all_messages
 
     async def clear(self) -> None:
         """Clear all memory types."""
         for memory in self.memories:
-            await BaseMemory._maybe_await(memory.clear())
+            await memory.clear()
 
     async def save(self) -> None:
         """Save all memory types."""
         for memory in self.memories:
-            await BaseMemory._maybe_await(memory.save())
+            await memory.save()
 
     async def load(self) -> None:
         """Load all memory types."""
         for memory in self.memories:
-            await BaseMemory._maybe_await(memory.load())
+            await memory.load()
 
     def get_memory(self, memory_type: type) -> Optional[BaseMemory]:
         """Get a specific memory type instance."""

multimind/memory/contextual.py

@@ -64,7 +64,6 @@ def __init__(
         self.context_summaries: Dict[str, str] = {}  # context_id -> summary
         self.context_evolution: Dict[str, List[Dict[str, Any]]] = {}  # context_id -> evolution history
         self.last_summarization = datetime.now()
-        self.load()
 
     async def add_message(self, message: Dict[str, str]) -> None:
         """Add message to the appropriate context."""
@@ -423,7 +422,7 @@ async def _remove_context(self, context_id: str) -> None:
         del self.context_metadata[context_id]
         del self.context_weights[context_id]
 
-    def get_messages(self) -> List[Dict[str, str]]:
+    async def get_messages(self) -> List[Dict[str, str]]:
         """Get all messages from all contexts."""
         messages = []
         for context in self.contexts:
@@ -465,7 +464,7 @@ async def save(self) -> None:
                     "last_summarization": self.last_summarization.isoformat()
                 }, f)
 
-    def load(self) -> None:
+    async def load(self) -> None:
         """Load contexts from persistent storage."""
         if self.storage_path and self.storage_path.exists():
             with open(self.storage_path, 'r') as f:
@@ -540,9 +539,10 @@ async def traverse(current_id: str, depth: int) -> None:
 
     async def get_context_stats(self) -> Dict[str, Any]:
         """Get statistics about contexts."""
+        messages = await self.get_messages()
         stats = {
             "total_contexts": len(self.contexts),
-            "total_messages": len(self.get_messages()),
+            "total_messages": len(messages),
             "relationship_types": {
                 rel_type: 0 for rel_type in self.relationship_types
             },

multimind/memory/declarative.py

@@ -130,7 +130,6 @@ def __init__(
         self.last_temporal = datetime.now()
         self.last_causal = datetime.now()
         self.last_graph_update = datetime.now()
-        self.load()
 
     async def add_message(self, message: Dict[str, str]) -> None:
         """Add message and analyze factual information."""
@@ -649,7 +648,7 @@ async def _remove_fact(self, fact_id: str) -> None:
         if fact_id in self.validation_history:
             del self.validation_history[fact_id]
 
-    def get_messages(self) -> List[Dict[str, str]]:
+    async def get_messages(self) -> List[Dict[str, str]]:
         """Get all messages from all facts."""
         messages = []
         for fact in self.facts:
@@ -706,7 +705,7 @@ async def save(self) -> None:
                     "last_graph_update": self.last_graph_update.isoformat()
                 }, f)
 
-    def load(self) -> None:
+    async def load(self) -> None:
         """Load facts from persistent storage."""
         if self.storage_path and self.storage_path.exists():
             with open(self.storage_path, 'r') as f:

multimind/memory/dnc.py

@@ -87,7 +87,6 @@ def __init__(
         self.last_optimization = datetime.now()
         self.last_analysis = datetime.now()
         self.last_backup = datetime.now()
-        self.load()
 
     async def add_message(self, message: Dict[str, str]) -> None:
         """Add message to DNC memory."""
@@ -368,7 +367,7 @@ async def _create_backup(self) -> None:
         except Exception as e:
             print(f"Error creating backup: {e}")
 
-    def get_messages(self) -> List[Dict[str, str]]:
+    async def get_messages(self) -> List[Dict[str, str]]:
         """Get all messages from memory."""
         messages = []
         for item in self.items:
@@ -426,7 +425,7 @@ async def save(self) -> None:
                     "last_backup": self.last_backup.isoformat()
                 }, f)
 
-    def load(self) -> None:
+    async def load(self) -> None:
         """Load memory from persistent storage."""
         if self.storage_path and self.storage_path.exists():
             with open(self.storage_path, 'r') as f: