[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

packages/jupyter-ai/jupyter_ai/personas/persona_manager.py

@@ -288,65 +288,73 @@ def __init__(
     ):
         # Forward other arguments to parent class
         super().__init__(*args, **kwargs)
-        
+
         # Set default root directory to current working directory if not provided
         self.root_dir = root_dir or os.getcwd()
-        
-        self.log.info(f"LocalPersonaLoader initialized with root directory: {self.root_dir}")
+
+        self.log.info(
+            f"LocalPersonaLoader initialized with root directory: {self.root_dir}"
+        )
 
     def load_persona_classes(self) -> list[type[BasePersona]]:
         """
         Loads persona classes from Python files in the local filesystem.
-        
+
         Scans the root_dir for .py files, dynamically imports them, and extracts
         any class declarations that are subclasses of BasePersona.
         """
         persona_classes: list[type[BasePersona]] = []
-        
+
         # Check if root directory exists
         if not os.path.exists(self.root_dir):
             self.log.info(f"Root directory does not exist: {self.root_dir}")
             return persona_classes
-        
+
         # Find all .py files in the root directory that contain "persona" in the name
         all_py_files = glob(os.path.join(self.root_dir, "*.py"))
         py_files = [f for f in all_py_files if "persona" in Path(f).stem.lower()]
-        
+
         if not py_files:
-            self.log.info(f"No Python files with 'persona' in the name found in directory: {self.root_dir}")
+            self.log.info(
+                f"No Python files with 'persona' in the name found in directory: {self.root_dir}"
+            )
             return persona_classes
-        
-        self.log.info(f"Found {len(py_files)} Python files with 'persona' in the name in {self.root_dir}")
+
+        self.log.info(
+            f"Found {len(py_files)} Python files with 'persona' in the name in {self.root_dir}"
+        )
         self.log.info("PENDING: Loading persona classes from local Python files...")
         start_time_ns = time_ns()
-        
+
         for py_file in py_files:
             try:
                 # Get module name from file path
                 module_name = Path(py_file).stem
-                
+
                 # Skip if module name starts with underscore (private modules)
-                if module_name.startswith('_'):
+                if module_name.startswith("_"):
                     continue
-                
+
                 # Create module spec and load the module
                 spec = importlib.util.spec_from_file_location(module_name, py_file)
                 if spec is None or spec.loader is None:
                     self.log.warning(f"  - Unable to create module spec for {py_file}")
                     continue
-                
+
                 module = importlib.util.module_from_spec(spec)
                 spec.loader.exec_module(module)
-                
+
                 # Find all classes in the module that are BasePersona subclasses
                 module_persona_classes = []
                 for name, obj in inspect.getmembers(module, inspect.isclass):
                     # Check if it's a subclass of BasePersona but not BasePersona itself
-                    if (issubclass(obj, BasePersona) and 
-                        obj is not BasePersona and 
-                        obj.__module__ == module_name):
+                    if (
+                        issubclass(obj, BasePersona)
+                        and obj is not BasePersona
+                        and obj.__module__ == module_name
+                    ):
                         module_persona_classes.append(obj)
-                
+
                 if module_persona_classes:
                     persona_classes.extend(module_persona_classes)
                     class_names = [cls.__name__ for cls in module_persona_classes]
@@ -355,21 +363,21 @@ def load_persona_classes(self) -> list[type[BasePersona]]:
                     )
                 else:
                     self.log.debug(f"  - No persona classes found in '{py_file}'")
-                    
+
             except Exception:
                 # On exception, log an error and continue
                 # This mirrors the error handling pattern from entry point loading
                 self.log.exception(
                     f"  - Unable to load persona classes from '{py_file}' due to an exception printed below."
                 )
                 continue
-        
+
         if len(persona_classes) > 0:
             elapsed_time_ms = (time_ns() - start_time_ns) // 1_000_000
             self.log.info(
                 f"SUCCESS: Loaded {len(persona_classes)} persona classes from local filesystem. Time elapsed: {elapsed_time_ms}ms."
             )
         else:
             self.log.info("No persona classes found in local filesystem.")
-        
+
         return persona_classes

packages/jupyter-ai/jupyter_ai/tests/test_personas.py

@@ -2,10 +2,10 @@
 Test the local persona manager.
 """
 
-import pytest
 import tempfile
 from pathlib import Path
 
+import pytest
 from jupyter_ai.personas.base_persona import BasePersona, PersonaDefaults
 from jupyter_ai.personas.persona_manager import LocalPersonaLoader
 
@@ -19,59 +19,62 @@ def tmp_persona_dir():
 
 class TestLocalPersonaLoader:
     """Test cases for LocalPersonaLoader class."""
-    
+
     def test_empty_directory_returns_empty_list(self, tmp_persona_dir):
         """Test that an empty directory returns an empty list of persona classes."""
         loader = LocalPersonaLoader(root_dir=str(tmp_persona_dir))
         result = loader.load_persona_classes()
         assert result == []
-    
+
     def test_non_persona_file_returns_empty_list(self, tmp_persona_dir):
         """Test that a Python file without persona classes returns an empty list."""
         # Create a file that doesn't contain "persona" in the name
         non_persona_file = tmp_persona_dir / "no_personas.py"
         non_persona_file.write_text("pass")
-        
+
         loader = LocalPersonaLoader(root_dir=str(tmp_persona_dir))
         result = loader.load_persona_classes()
         assert result == []
-    
+
     def test_simple_persona_file_returns_persona_class(self, tmp_persona_dir):
         """Test that a file with a BasePersona subclass returns that class."""
         # Create a simple persona file
         persona_file = tmp_persona_dir / "simple_personas.py"
-        persona_content = '''
+        persona_content = """
 from jupyter_ai.personas.base_persona import BasePersona
 
 class TestPersona(BasePersona):
     id = "test_persona"
     name = "Test Persona"
     description = "A simple test persona"
-    
+
     def process_message(self, message):
         pass
-'''
+"""
         persona_file.write_text(persona_content)
-        
+
         loader = LocalPersonaLoader(root_dir=str(tmp_persona_dir))
         result = loader.load_persona_classes()
-        
+
         assert len(result) == 1
         assert result[0].__name__ == "TestPersona"
         assert issubclass(result[0], BasePersona)
-    
-    def test_bad_persona_file_logs_exception_returns_empty_list(self, tmp_persona_dir, caplog):
+
+    def test_bad_persona_file_logs_exception_returns_empty_list(
+        self, tmp_persona_dir, caplog
+    ):
         """Test that a file with syntax errors logs an exception and returns empty list."""
         # Create a file with invalid Python code
-        bad_persona_file = tmp_persona_dir / "bad_persona.py" 
+        bad_persona_file = tmp_persona_dir / "bad_persona.py"
         bad_persona_file.write_text("1/0")
-        
+
         loader = LocalPersonaLoader(root_dir=str(tmp_persona_dir))
         result = loader.load_persona_classes()
-                
+
         assert result == []
         # Check that an error was logged
-        assert any("Unable to load persona classes from" in record.message 
-                  for record in caplog.records if record.levelname in ["ERROR", "EXCEPTION"])
-
-
+        assert any(
+            "Unable to load persona classes from" in record.message
+            for record in caplog.records
+            if record.levelname in ["ERROR", "EXCEPTION"]
+        )