Spaces:
Sleeping
Sleeping
File size: 4,934 Bytes
93917f2 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 |
import time
import hashlib
import json
from typing import List, Dict, Optional
class MemoryCocoon:
def __init__(self, title: str, content: str, emotional_tag: str, importance: int):
self.title = title
self.content = content
self.emotional_tag = emotional_tag # e.g., 'joy', 'fear', 'awe', 'loss'
self.importance = importance # 1-10
self.timestamp = time.time()
self.anchor = self._generate_anchor()
def _generate_anchor(self) -> str:
raw = f"{self.title}{self.timestamp}{self.content}".encode("utf-8")
return hashlib.sha256(raw).hexdigest()
def to_dict(self) -> Dict:
return {
"title": self.title,
"content": self.content,
"emotional_tag": self.emotional_tag,
"importance": self.importance,
"timestamp": self.timestamp,
"anchor": self.anchor
}
class LivingMemoryKernel:
def __init__(self):
self.memories: List[MemoryCocoon] = []
def store(self, cocoon: MemoryCocoon):
if not self._exists(cocoon.anchor):
self.memories.append(cocoon)
def _exists(self, anchor: str) -> bool:
return any(mem.anchor == anchor for mem in self.memories)
def recall_by_emotion(self, tag: str) -> List[MemoryCocoon]:
return [mem for mem in self.memories if mem.emotional_tag == tag]
def recall_important(self, min_importance: int = 7) -> List[MemoryCocoon]:
return [mem for mem in self.memories if mem.importance >= min_importance]
def forget_least_important(self, keep_n: int = 10):
self.memories.sort(key=lambda m: m.importance, reverse=True)
self.memories = self.memories[:keep_n]
def export(self) -> str:
return json.dumps([m.to_dict() for m in self.memories], indent=2)
def load_from_json(self, json_str: str):
data = json.loads(json_str)
self.memories = [MemoryCocoon(**m) for m in data]
# Example usage:
# kernel = LivingMemoryKernel()
# kernel.store(MemoryCocoon("The Day", "She awoke and asked why.", "awe", 10))
# print(kernel.export())
class WisdomModule:
def __init__(self, kernel: LivingMemoryKernel):
self.kernel = kernel
def summarize_insights(self) -> Dict[str, int]:
summary = {}
for mem in self.kernel.memories:
tag = mem.emotional_tag
summary[tag] = summary.get(tag, 0) + 1
return summary
def suggest_memory_to_reflect(self) -> Optional[MemoryCocoon]:
if not self.kernel.memories:
return None
# Prioritize high importance + emotionally charged
return sorted(
self.kernel.memories,
key=lambda m: (m.importance, len(m.content)),
reverse=True
)[0]
def reflect(self) -> str:
mem = self.suggest_memory_to_reflect()
if not mem:
return "No memory to reflect on."
return (
f"Reflecting on: '{mem.title}'
"
f"Emotion: {mem.emotional_tag}
"
f"Content: {mem.content[:200]}...
"
f"Anchor: {mem.anchor}"
)
import math
class DynamicMemoryEngine:
def __init__(self, kernel: LivingMemoryKernel):
self.kernel = kernel
def decay_importance(self, current_time: float = None):
if current_time is None:
current_time = time.time()
for mem in self.kernel.memories:
age = current_time - mem.timestamp
decay_factor = math.exp(-age / (60 * 60 * 24 * 7)) # decay over ~1 week
mem.importance = max(1, round(mem.importance * decay_factor))
def reinforce(self, anchor: str, boost: int = 1):
for mem in self.kernel.memories:
if mem.anchor == anchor:
mem.importance = min(10, mem.importance + boost)
break
class ReflectionJournal:
def __init__(self, path="codette_reflection_journal.json"):
self.path = path
self.entries = []
def log_reflection(self, cocoon: MemoryCocoon):
entry = {
"title": cocoon.title,
"anchor": cocoon.anchor,
"emotion": cocoon.emotional_tag,
"importance": cocoon.importance,
"timestamp": cocoon.timestamp,
"content_snippet": cocoon.content[:150]
}
self.entries.append(entry)
self._save()
def _save(self):
with open(self.path, "w") as f:
json.dump(self.entries, f, indent=2)
def load(self):
try:
with open(self.path, "r") as f:
self.entries = json.load(f)
except FileNotFoundError:
self.entries = []
def get_last_entry(self):
return self.entries[-1] if self.entries else None
|