[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-test/jupyter_ai_test/debug_persona.py

@@ -1,6 +1,7 @@
 from jupyter_ai.personas.base_persona import BasePersona, PersonaDefaults
 from jupyterlab_chat.models import Message
 
+
 class DebugPersona(BasePersona):
     """
     The Jupyternaut persona, the main persona provided by Jupyter AI.
@@ -15,9 +16,9 @@ def defaults(self):
             name="DebugPersona",
             avatar_path="/api/ai/static/jupyternaut.svg",
             description="A mock persona used for debugging in local dev environments.",
-            system_prompt="..."
+            system_prompt="...",
         )
-    
+
     async def process_message(self, message: Message):
         self.log.info("HI IM DEBUGPERSONA AND IDK WHAT TO DO")
         return

packages/jupyter-ai/jupyter_ai/extension.py

@@ -1,10 +1,10 @@
-from asyncio import get_event_loop_policy
 import os
 import re
 import time
 import types
+from asyncio import get_event_loop_policy
 from functools import partial
-from typing import Dict, TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict
 
 import traitlets
 from dask.distributed import Client as DaskClient
@@ -253,13 +253,12 @@ def initialize(self):
         )
 
     @property
-    def event_loop(self) -> 'AbstractEventLoop':
+    def event_loop(self) -> "AbstractEventLoop":
         """
         Returns a reference to the asyncio event loop.
         """
         return get_event_loop_policy().get_event_loop()
 
-
     async def connect_chat(
         self, logger: EventLogger, schema_id: str, data: dict
     ) -> None:
@@ -326,7 +325,9 @@ def on_change(self, room_id: str, events: ArrayEvent) -> None:
             # message triggers 2 events, one with `raw_time` set to `True` and
             # another with `raw_time` set to `False` milliseconds later.
             # we should explore fixing this quirk in Jupyter Chat.
-            new_messages = [Message(**m) for m in change['insert'] if not m.get('raw_time', False)]
+            new_messages = [
+                Message(**m) for m in change["insert"] if not m.get("raw_time", False)
+            ]
             for new_message in new_messages:
                 persona_manager.route_message(new_message)
 
@@ -419,7 +420,9 @@ def initialize_settings(self):
         # requires the event loop to be running on init. So instead we schedule
         # this as a task that is run as soon as the loop starts, and pass
         # consumers a Future that resolves to the Dask client when awaited.
-        self.settings["dask_client_future"] = self.event_loop.create_task(self._get_dask_client())
+        self.settings["dask_client_future"] = self.event_loop.create_task(
+            self._get_dask_client()
+        )
 
         # Create empty context providers dict to be filled later.
         # This is created early to use as kwargs for chat handlers.

packages/jupyter-ai/jupyter_ai/history.py

@@ -45,7 +45,7 @@ def _convert_to_langchain_messages(self, jchat_messages: List[JChatMessage]):
         """
         messages: List[BaseMessage] = []
         for jchat_message in jchat_messages:
-            if jchat_message.sender.startswith('jupyter-ai-personas::'):
+            if jchat_message.sender.startswith("jupyter-ai-personas::"):
                 messages.append(AIMessage(content=jchat_message.body))
             else:
                 messages.append(HumanMessage(content=jchat_message.body))

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

@@ -1,2 +1,2 @@
 from .base_persona import BasePersona, PersonaDefaults
-from .persona_manager import PersonaManager
+from .persona_manager import PersonaManager

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

@@ -1,40 +1,45 @@
-from pydantic import BaseModel
-from dataclasses import asdict
-from typing import Any, Dict, Optional, Set, TYPE_CHECKING
 from abc import ABC, abstractmethod
-from time import time
+from dataclasses import asdict
 from logging import Logger
+from time import time
+from typing import TYPE_CHECKING, Any, Dict, Optional, Set
+
 from jupyter_ai.config_manager import ConfigManager
+from jupyterlab_chat.models import Message, NewMessage, User
 from jupyterlab_chat.ychat import YChat
-from jupyterlab_chat.models import User, Message, NewMessage
+from pydantic import BaseModel
+
 from .persona_awareness import PersonaAwareness
 
 # prevents a circular import
 # `PersonaManager` types have to be surrounded in single quotes
 if TYPE_CHECKING:
-    from .persona_manager import PersonaManager
     from collections.abc import AsyncIterator
 
+    from .persona_manager import PersonaManager
+
+
 class PersonaDefaults(BaseModel):
     """
     Data structure that represents the default settings of a persona. Each persona
     must define some basic default settings, like its name.
 
     Each of these settings can be overwritten through the settings UI.
     """
+
     ################################################
     # required fields
     ################################################
-    name: str # e.g. "Jupyternaut"
-    description: str # e.g. "..."
-    avatar_path: str # e.g. /avatars/jupyternaut.svg
-    system_prompt: str # e.g. "You are a language model named..."
+    name: str  # e.g. "Jupyternaut"
+    description: str  # e.g. "..."
+    avatar_path: str  # e.g. /avatars/jupyternaut.svg
+    system_prompt: str  # e.g. "You are a language model named..."
 
     ################################################
     # optional fields
     ################################################
-    slash_commands: Set[str] = set("*") # change this to enable/disable slash commands
-    model_uid: Optional[str] = None # e.g. "ollama:deepseek-coder-v2" 
+    slash_commands: Set[str] = set("*")  # change this to enable/disable slash commands
+    model_uid: Optional[str] = None  # e.g. "ollama:deepseek-coder-v2"
     # ^^^ set this to automatically default to a model after a fresh start, no config file
 
 
@@ -44,27 +49,32 @@ class BasePersona(ABC):
     """
 
     ychat: YChat
-    manager: 'PersonaManager'
+    manager: "PersonaManager"
     config: ConfigManager
     log: Logger
     awareness: PersonaAwareness
 
     ################################################
     # constructor
     ################################################
-    def __init__(self, *, ychat: YChat, manager: 'PersonaManager', config: ConfigManager, log: Logger):
+    def __init__(
+        self,
+        *,
+        ychat: YChat,
+        manager: "PersonaManager",
+        config: ConfigManager,
+        log: Logger,
+    ):
         self.ychat = ychat
         self.manager = manager
         self.config = config
         self.log = log
         self.awareness = PersonaAwareness(
-            ychat=self.ychat,
-            log=self.log,
-            user=self.as_user()
+            ychat=self.ychat, log=self.log, user=self.as_user()
         )
 
         self.ychat.set_user(self.as_user())
-        
+
     ################################################
     # abstract methods, required by subclasses.
     ################################################
@@ -86,7 +96,7 @@ async def process_message(self, message: Message) -> None:
         # support streaming
         # handle multiple processed messages concurrently (if model service allows it)
         pass
-    
+
     ################################################
     # base class methods, available to subclasses.
     ################################################
@@ -95,7 +105,7 @@ def id(self) -> str:
         """
         Return a unique ID for this persona, which sets its username in the
         `User` object shared with other collaborative extensions.
-        
+
         - This ID is guaranteed to be identical throughout this object's
         lifecycle.
 
@@ -106,40 +116,40 @@ def id(self) -> str:
 
             - For example, 'Jupyternaut' always has the ID
             `jupyter-ai-personas::jupyter-ai::JupyternautPersona`.
-        
+
         - The ID must be unique, so if a package provides multiple personas,
         their class names must be unique. Renaming the persona class changes the
         ID of that persona, so you should also avoid renaming it if possible.
         """
-        package_name = self.__module__.split('.')[0]
+        package_name = self.__module__.split(".")[0]
         class_name = self.__class__.__name__
-        return f'jupyter-ai-personas::{package_name}::{class_name}'
+        return f"jupyter-ai-personas::{package_name}::{class_name}"
 
     @property
     def name(self) -> str:
         return self.defaults.name
-    
+
     @property
     def avatar_path(self) -> str:
         return self.defaults.avatar_path
 
     @property
     def system_prompt(self) -> str:
         return self.defaults.system_prompt
-    
+
     def as_user(self) -> User:
         return User(
             username=self.id,
             name=self.name,
             display_name=self.name,
             avatar_url=self.avatar_path,
         )
-    
+
     def as_user_dict(self) -> Dict[str, Any]:
         user = self.as_user()
         return asdict(user)
-    
-    async def forward_reply_stream(self, reply_stream: 'AsyncIterator'):
+
+    async def forward_reply_stream(self, reply_stream: "AsyncIterator"):
         """
         Forwards an async iterator, dubbed the 'reply stream', to a new message
         by this persona in the YChat.
@@ -152,13 +162,13 @@ async def forward_reply_stream(self, reply_stream: 'AsyncIterator'):
         stream_id: Optional[str] = None
 
         try:
-            self.awareness.set_local_state_field('isWriting', True)
+            self.awareness.set_local_state_field("isWriting", True)
             async for chunk in reply_stream:
                 if not stream_id:
                     stream_id = self.ychat.add_message(
                         NewMessage(body="", sender=self.id)
                     )
-                
+
                 assert stream_id
                 self.ychat.update_message(
                     Message(
@@ -171,8 +181,9 @@ async def forward_reply_stream(self, reply_stream: 'AsyncIterator'):
                     append=True,
                 )
         except Exception as e:
-            self.log.error(f"Persona '{self.name}' encountered an exception printed below when attempting to stream output.")
+            self.log.error(
+                f"Persona '{self.name}' encountered an exception printed below when attempting to stream output."
+            )
             self.log.exception(e)
         finally:
-            self.awareness.set_local_state_field('isWriting', False)
-            
+            self.awareness.set_local_state_field("isWriting", False)

packages/jupyter-ai/jupyter_ai/personas/jupyternaut/__init__.py

@@ -1 +1 @@
-from .jupyternaut import JupyternautPersona
+from .jupyternaut import JupyternautPersona

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

@@ -1,12 +1,13 @@
 from typing import Any
 
+from jupyterlab_chat.models import Message
 from langchain_core.output_parsers import StrOutputParser
 from langchain_core.runnables.history import RunnableWithMessageHistory
 
+from ...history import YChatHistory
 from ..base_persona import BasePersona, PersonaDefaults
 from .prompt_template import JUPYTERNAUT_PROMPT_TEMPLATE, JupyternautVariables
-from ...history import YChatHistory
-from jupyterlab_chat.models import Message
+
 
 class JupyternautPersona(BasePersona):
     """
@@ -22,19 +23,19 @@ def defaults(self):
             name="Jupyternaut",
             avatar_path="/api/ai/static/jupyternaut.svg",
             description="The standard agent provided by JupyterLab. Currently has no tools.",
-            system_prompt="..."
+            system_prompt="...",
         )
-    
+
     async def process_message(self, message: Message):
         provider_name = self.config.lm_provider.name
-        model_id = self.config.lm_provider_params['model_id']
+        model_id = self.config.lm_provider_params["model_id"]
 
         runnable = self.build_runnable()
         variables = JupyternautVariables(
             input=message.body,
             model_id=model_id,
             provider_name=provider_name,
-            persona_name=self.name
+            persona_name=self.name,
         )
         variables_dict = variables.model_dump()
         reply_stream = runnable.astream(variables_dict)

packages/jupyter-ai/jupyter_ai/personas/jupyternaut/prompt_template.py

@@ -1,12 +1,12 @@
 from typing import Optional
 
-from pydantic import BaseModel
 from langchain.prompts import (
     ChatPromptTemplate,
     HumanMessagePromptTemplate,
     MessagesPlaceholder,
     SystemMessagePromptTemplate,
 )
+from pydantic import BaseModel
 
 _JUPYTERNAUT_SYSTEM_PROMPT_FORMAT = """
 <instructions>
@@ -48,23 +48,26 @@
 </context>
 """.strip()
 
-JUPYTERNAUT_PROMPT_TEMPLATE = ChatPromptTemplate.from_messages([
-    SystemMessagePromptTemplate.from_template(
-        _JUPYTERNAUT_SYSTEM_PROMPT_FORMAT,
-        template_format="jinja2"
-    ),
-    MessagesPlaceholder(variable_name="history"),
-    HumanMessagePromptTemplate.from_template("{input}")
-])
+JUPYTERNAUT_PROMPT_TEMPLATE = ChatPromptTemplate.from_messages(
+    [
+        SystemMessagePromptTemplate.from_template(
+            _JUPYTERNAUT_SYSTEM_PROMPT_FORMAT, template_format="jinja2"
+        ),
+        MessagesPlaceholder(variable_name="history"),
+        HumanMessagePromptTemplate.from_template("{input}"),
+    ]
+)
+
 
 class JupyternautVariables(BaseModel):
     """
     Variables expected by `JUPYTERNAUT_PROMPT_TEMPLATE`, defined as a Pydantic
-    data model for developer convenience. 
+    data model for developer convenience.
 
     Call the `.model_dump()` method on an instance to convert it to a Python
     dictionary.
     """
+
     input: str
     persona_name: str
     provider_name: str