style: format code with black

- Run black formatter on all Python files
- Fix code formatting to pass CI lint checks
- 12 files reformatted to comply with Black style guide

Author: zyhe16

personaflow/__init__.py

@@ -2,10 +2,4 @@
 from .core.memory import Memory, MemoryManager, MemoryConfig
 from .core.system import PersonaSystem
 
-__all__ = [
-    'Character',
-    'Memory',
-    'MemoryManager',
-    'MemoryConfig',
-    'PersonaSystem'
-]
+__all__ = ["Character", "Memory", "MemoryManager", "MemoryConfig", "PersonaSystem"]

personaflow/core/__init__.py

@@ -2,10 +2,4 @@
 from .memory import Memory, MemoryConfig, MemoryManager
 from .system import PersonaSystem
 
-__all__ = [
-    'Character',
-    'Memory',
-    'MemoryConfig',
-    'MemoryManager',
-    'PersonaSystem'
-]
+__all__ = ["Character", "Memory", "MemoryConfig", "MemoryManager", "PersonaSystem"]

personaflow/core/character.py

@@ -15,7 +15,7 @@ def __init__(
             raise ValueError("Character name cannot be empty")
         if not prompt:
             raise ValueError("Character prompt cannot be empty")
-        
+
         self.name = name
         self.prompt = prompt
         self.background = background or {}
@@ -64,9 +64,9 @@ def to_dict(self) -> Dict[str, Any]:
     def from_dict(cls, data: Dict[str, Any]) -> "Character":
         """Create character from dictionary"""
         character = cls(
-            name=data["name"], 
-            prompt=data["prompt"], 
-            background=data.get("background", {})
+            name=data["name"],
+            prompt=data["prompt"],
+            background=data.get("background", {}),
         )
         # Restore memory_manager from dict if present
         if "memory_manager" in data:

personaflow/core/memory.py

@@ -2,40 +2,41 @@
 from datetime import datetime
 from dataclasses import dataclass, asdict
 
+
 @dataclass
 class Memory:
     """Structure for storing individual memory entries"""
+
     timestamp: str
     type: str  # 'interaction', 'event', 'system', etc.
     content: Dict[str, Any]
     metadata: Optional[Dict[str, Any]] = None
     character_name: str = ""
 
+
 @dataclass
 class MemoryConfig:
     """Configuration for memory management"""
+
     max_memories: int = 1000
     summary_threshold: int = 10
     auto_summarize: bool = True
 
+
 class MemoryManager:
-    def __init__(
-        self,
-        character_name: str,
-        config: Optional[Dict[str, Any]] = None
-    ):
+    def __init__(self, character_name: str, config: Optional[Dict[str, Any]] = None):
         if not character_name or not character_name.strip():
             raise ValueError("Character name cannot be empty")
-        
+
         self.character_name = character_name
         self.config = MemoryConfig(**config) if config else MemoryConfig()
-        
+
         # Validate config values
         if self.config.max_memories <= 0:
             raise ValueError("max_memories must be greater than 0")
         if self.config.summary_threshold <= 0:
             raise ValueError("summary_threshold must be greater than 0")
-        
+
         self.memories: List[Memory] = []
         self.summarized_memories: List[Memory] = []
         self._last_accessed = datetime.now()
@@ -44,28 +45,26 @@ def add_memory(
         self,
         content: Dict[str, Any],
         memory_type: str = "interaction",
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
     ):
         memory = Memory(
             timestamp=datetime.now().isoformat(),
             type=memory_type,
             content=content,
             metadata=metadata or {},
-            character_name=self.character_name
+            character_name=self.character_name,
         )
 
         self.memories.append(memory)
         self._manage_memory_size()
 
     def get_memories(
-        self,
-        limit: Optional[int] = None,
-        memory_types: Optional[List[str]] = None
+        self, limit: Optional[int] = None, memory_types: Optional[List[str]] = None
     ) -> List[Memory]:
         """Get relevant memories based on configuration"""
         if limit is not None and limit < 0:
             raise ValueError("Memory limit cannot be negative")
-        
+
         memories = self.memories
 
         if memory_types:
@@ -83,26 +82,26 @@ def _manage_memory_size(self):
                 self._summarize_old_memories()
             else:
                 # Keep most recent memories
-                self.memories = self.memories[-self.config.max_memories:]
+                self.memories = self.memories[-self.config.max_memories :]
 
     def _summarize_old_memories(self):
         """Summarize old memories to maintain important information"""
-        memories_to_summarize = self.memories[:-self.config.max_memories]
-        
+        memories_to_summarize = self.memories[: -self.config.max_memories]
+
         # Only create summary if there are memories to summarize
         if memories_to_summarize:
             summary = Memory(
                 timestamp=datetime.now().isoformat(),
                 type="summary",
                 content={
                     "period": f"{memories_to_summarize[0].timestamp} to {memories_to_summarize[-1].timestamp}",
-                    "summary": f"Summary of {len(memories_to_summarize)} memories"
+                    "summary": f"Summary of {len(memories_to_summarize)} memories",
                 },
-                character_name=self.character_name
+                character_name=self.character_name,
             )
             self.summarized_memories.append(summary)
-        
-        self.memories = self.memories[-self.config.max_memories:]
+
+        self.memories = self.memories[-self.config.max_memories :]
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert memory manager to dictionary"""
@@ -111,16 +110,13 @@ def to_dict(self) -> Dict[str, Any]:
             "config": asdict(self.config),
             "memories": [asdict(m) for m in self.memories],
             "summarized_memories": [asdict(m) for m in self.summarized_memories],
-            "last_accessed": self._last_accessed.isoformat()
+            "last_accessed": self._last_accessed.isoformat(),
         }
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'MemoryManager':
+    def from_dict(cls, data: Dict[str, Any]) -> "MemoryManager":
         """Create memory manager from dictionary"""
-        manager = cls(
-            character_name=data["character_name"],
-            config=data["config"]
-        )
+        manager = cls(character_name=data["character_name"], config=data["config"])
         manager.memories = [Memory(**m) for m in data["memories"]]
         manager.summarized_memories = [Memory(**m) for m in data["summarized_memories"]]
         manager._last_accessed = datetime.fromisoformat(data["last_accessed"])

personaflow/core/system.py

@@ -45,7 +45,7 @@ def add_interaction(
         """Add interaction to character's memory"""
         if character_name not in self.characters:
             raise KeyError(f"Character {character_name} not found")
-        
+
         character = self.characters[character_name]
         character.add_memory(
             content=content, memory_type=memory_type, metadata=metadata

personaflow/utils/__init__.py

@@ -1,14 +1,18 @@
 from .prompt_manager import PromptTemplate, PromptManager
-from .validators import validate_memory_content, validate_prompt_template, validate_memory_config
+from .validators import (
+    validate_memory_content,
+    validate_prompt_template,
+    validate_memory_config,
+)
 from .serializer import Serializer
 from .logger import Logger
 
 __all__ = [
-    'PromptTemplate',
-    'PromptManager',
-    'validate_memory_content',
-    'validate_prompt_template',
-    'validate_memory_config',
-    'Serializer',
-    'Logger'
+    "PromptTemplate",
+    "PromptManager",
+    "validate_memory_content",
+    "validate_prompt_template",
+    "validate_memory_config",
+    "Serializer",
+    "Logger",
 ]

personaflow/utils/logger.py

@@ -1,12 +1,10 @@
 import logging
 from typing import Optional
 
+
 class Logger:
     def __init__(
-        self,
-        name: str,
-        level: int = logging.INFO,
-        log_file: Optional[str] = None
+        self, name: str, level: int = logging.INFO, log_file: Optional[str] = None
     ):
         self.logger = logging.getLogger(name)
         self.logger.setLevel(level)
@@ -16,7 +14,7 @@ def __init__(
             # Console handler
             console_handler = logging.StreamHandler()
             formatter = logging.Formatter(
-                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
             )
             console_handler.setFormatter(formatter)
             self.logger.addHandler(console_handler)

personaflow/utils/serializer.py

@@ -2,12 +2,13 @@
 from typing import Dict, Any
 from datetime import datetime
 
+
 class Serializer:
     @staticmethod
     def to_json(data: Dict[str, Any], file_path: str):
         """Serialize data to JSON file"""
         try:
-            with open(file_path, 'w') as f:
+            with open(file_path, "w") as f:
                 json.dump(data, f, indent=2)
         except (IOError, TypeError) as e:
             raise IOError(f"Failed to serialize data to {file_path}: {str(e)}")
@@ -16,7 +17,7 @@ def to_json(data: Dict[str, Any], file_path: str):
     def from_json(file_path: str) -> Dict[str, Any]:
         """Deserialize data from JSON file"""
         try:
-            with open(file_path, 'r') as f:
+            with open(file_path, "r") as f:
                 return json.load(f)
         except (IOError, json.JSONDecodeError) as e:
             raise IOError(f"Failed to deserialize data from {file_path}: {str(e)}")

personaflow/utils/validators.py

@@ -2,6 +2,7 @@
 from string import Template
 import json
 
+
 def validate_prompt_template(template: str) -> bool:
     """Validate prompt template syntax"""
     try:
@@ -10,25 +11,27 @@ def validate_prompt_template(template: str) -> bool:
     except ValueError:
         return False
 
+
 def validate_memory_content(content: Dict[str, Any]) -> bool:
     """Validate memory content structure and types"""
     if not isinstance(content, dict):
         return False
-    
+
     # Memory content just needs to be a non-empty dictionary
     # Different memory types can have different structures
     return len(content) > 0
 
+
 def validate_memory_config(config: Dict[str, Any]) -> bool:
     """Validate memory configuration structure and types"""
     if not isinstance(config, dict):
         return False
 
     # Define valid fields and their types
     valid_fields = {
-        'max_memories': int,
-        'summary_threshold': int,
-        'auto_summarize': bool
+        "max_memories": int,
+        "summary_threshold": int,
+        "auto_summarize": bool,
     }
 
     # Check that all provided fields are valid and have correct types
@@ -37,5 +40,5 @@ def validate_memory_config(config: Dict[str, Any]) -> bool:
             return False
         if not isinstance(value, valid_fields[field]):
             return False
-    
+
     return True

tests/test_character.py

@@ -1,13 +1,14 @@
 import pytest
 from personaflow.core.character import Character
 
+
 class TestCharacter:
     @pytest.fixture
     def character(self):
         return Character(
             name="test_char",
             prompt="You are a test character",
-            background={"role": "test"}
+            background={"role": "test"},
         )
 
     def test_character_creation(self, character):