Merge branch 'jupyterlab:main' into copilot

Author: hideyukikodama

docs/source/_static/openrouter-model-setup-2.png

@@ -24,6 +24,13 @@ Jupyter AI's settings page with the OpenRouter provider selected is shown below:
 
 Type in the model name and the API base URL corresponding to the model you wish to use. For Deepseek, you should use `https://api.deepseek.com` as the API base URL, and use `deepseek-chat` as the local model ID.
 
+If you have an OpenRouter account and wish to use their API and URL, it is also possible using the OpenRouter provider in Jupyter AI, as shown here:
+
+<img src="../_static/openrouter-model-setup-2.png"
+    width="75%"
+    alt='Screenshot of the tab in Jupyter AI where OpenRouter model access is selected with its own API and URL.'
+    class="screenshot" />
+
 If you are using OpenRouter for the first time it will also require entering the `OPENROUTER_API_KEY`. If you have used OpenRouter before with a different model provider, you will need to update the API key. After doing this, click "Save Changes" at the bottom to save your settings.
 
 You should now be able to use Deepseek! An example of usage is shown next:

docs/source/users/openrouter.md

@@ -48,6 +48,12 @@ class ChatOpenAIProvider(BaseProvider, ChatOpenAI):
         "gpt-4o-2024-11-20",
         "gpt-4o-mini",
         "chatgpt-4o-latest",
+        "gpt-4.1",
+        "gpt-4.1-mini",
+        "gpt-4.1-nano",
+        "o1",
+        "o3-mini",
+        "o4-mini",
     ]
     model_id_key = "model_name"
     pypi_package_deps = ["langchain_openai"]

packages/jupyter-ai-magics/jupyter_ai_magics/partner_providers/openai.py

@@ -0,0 +1,39 @@
+import asyncio
+import getpass
+
+from jupyter_server.auth.identity import IdentityProvider, User
+
+
+def create_initials(username):
+    """Creates initials combining first 2 consonants"""
+
+    username = username.lower()
+
+    # Default: return first two unique consonants
+    consonants = [c for c in username if c in "bcdfghjklmnpqrstvwxyz"]
+    if len(consonants) >= 2:
+        return (consonants[0] + consonants[1]).upper()
+
+    # Fallback: first two characters
+    return username[:2].upper()
+
+
+class LocalIdentityProvider(IdentityProvider):
+    """IdentityProvider that determines username from system user."""
+
+    def get_user(self, handler):
+        try:
+            username = getpass.getuser()
+            user = User(
+                username=username,
+                name=username,
+                initials=create_initials(username),
+                color=None,
+            )
+            return user
+        except OSError as e:
+            self.log.debug(
+                "Could not determine username from system. Falling back to anonymous"
+                f"user."
+            )
+            return self._get_user(handler)

packages/jupyter-ai/jupyter_ai/auth/identity.py

@@ -1,12 +1,11 @@
 import json
 import logging
 import os
-import shutil
 import time
 from copy import deepcopy
 from typing import List, Optional, Type, Union
 
-from deepmerge import always_merger as Merger
+from deepmerge import Merger, always_merger
 from jsonschema import Draft202012Validator as Validator
 from jupyter_ai.models import DescribeConfigResponse, GlobalConfig, UpdateConfigRequest
 from jupyter_ai_magics import JupyternautPersona, Persona
@@ -178,11 +177,23 @@ def _init_config_schema(self):
         with open(OUR_SCHEMA_PATH, encoding="utf-8") as f:
             default_schema = json.load(f)
 
+        # Create a custom `deepmerge.Merger` object to merge lists using the
+        # 'append_unique' strategy.
+        #
+        # This stops type union declarations like `["string", "null"]` from
+        # growing into `["string", "null", "string", "null"]` on restart.
+        # This fixes issue #1320.
+        merger = Merger(
+            [(list, ["append_unique"]), (dict, ["merge"]), (set, ["union"])],
+            ["override"],
+            ["override"],
+        )
+
         # merge existing_schema into default_schema
         # specifying existing_schema as the second argument ensures that
         # existing_schema always overrides existing keys in default_schema, i.e.
         # this call only adds new keys in default_schema.
-        schema = Merger.merge(default_schema, existing_schema)
+        schema = merger.merge(default_schema, existing_schema)
         with open(self.schema_path, encoding="utf-8", mode="w") as f:
             json.dump(schema, f, indent=self.indentation_depth)
 
@@ -194,15 +205,17 @@ def _init_validator(self) -> None:
 
     def _init_config(self):
         default_config = self._init_defaults()
-        if os.path.exists(self.config_path):
+        if os.path.exists(self.config_path) and os.stat(self.config_path).st_size != 0:
             self._process_existing_config(default_config)
         else:
             self._create_default_config(default_config)
 
     def _process_existing_config(self, default_config):
         with open(self.config_path, encoding="utf-8") as f:
             existing_config = json.loads(f.read())
-            merged_config = Merger.merge(
+            if "embeddings_fields" not in existing_config:
+                existing_config["embeddings_fields"] = {}
+            merged_config = always_merger.merge(
                 default_config,
                 {k: v for k, v in existing_config.items() if v is not None},
             )
@@ -305,6 +318,8 @@ def _read_config(self) -> GlobalConfig:
         with open(self.config_path, encoding="utf-8") as f:
             self._last_read = time.time_ns()
             raw_config = json.loads(f.read())
+            if "embeddings_fields" not in raw_config:
+                raw_config["embeddings_fields"] = {}
             config = GlobalConfig(**raw_config)
             self._validate_config(config)
             return config
@@ -481,7 +496,7 @@ def update_config(self, config_update: UpdateConfigRequest):  # type:ignore
                     raise KeyEmptyError("API key value cannot be empty.")
 
         config_dict = self._read_config().model_dump()
-        Merger.merge(config_dict, config_update.model_dump(exclude_unset=True))
+        always_merger.merge(config_dict, config_update.model_dump(exclude_unset=True))
         self._write_config(GlobalConfig(**config_dict))
 
     # this cannot be a property, as the parent Configurable already defines the

packages/jupyter-ai/jupyter_ai/config_manager.py

@@ -1,6 +1,7 @@
 import json
 import logging
 import os
+from pathlib import Path
 from unittest.mock import mock_open, patch
 
 import pytest
@@ -513,8 +514,8 @@ def test_config_manager_does_not_write_to_defaults(
 def test_config_manager_updates_schema(jp_data_dir, common_cm_kwargs):
     """
     Asserts that the ConfigManager adds new keys to the user's config schema
-    which are present in Jupyter AI's schema on init. Asserts that #1291 does
-    not occur again in the future.
+    which are present in Jupyter AI's schema on init. Asserts that the main
+    issue reported in #1291 does not occur again in the future.
     """
     schema_path = str(jp_data_dir / "config_schema.json")
     with open(schema_path, "w") as file:
@@ -547,3 +548,17 @@ def test_config_manager_updates_schema(jp_data_dir, common_cm_kwargs):
         assert "fields" in new_schema["properties"]
         assert "embeddings_fields" in new_schema["properties"]
         assert "completions_fields" in new_schema["properties"]
+
+
+def test_config_manager_handles_empty_touched_file(common_cm_kwargs):
+    """
+    Asserts that ConfigManager does not fail at runtime if `config.json` is a
+    "touched file", a completely empty file with 0 bytes. This may happen if a
+    user / build system runs `touch config.json` by accident.
+
+    Asserts that the second issue reported in #1291 does not occur again in the
+    future.
+    """
+    config_path = common_cm_kwargs["config_path"]
+    Path(config_path).touch()
+    ConfigManager(**common_cm_kwargs)

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

@@ -0,0 +1,68 @@
+import logging
+from unittest.mock import Mock, patch
+
+import pytest
+from jupyter_ai.auth.identity import LocalIdentityProvider, create_initials
+from jupyter_server.auth.identity import User
+
+
+@pytest.fixture
+def log():
+    log = logging.getLogger()
+    log.addHandler(logging.NullHandler())
+    return log
+
+
+@pytest.fixture
+def handler():
+    return Mock()
+
+
+@patch("getpass.getuser")
+def test_get_user_successful(getuser, log, handler):
+
+    getuser.return_value = "localuser"
+    provider = LocalIdentityProvider(log=log)
+
+    user = provider.get_user(handler)
+
+    assert isinstance(user, User)
+    assert user.username == "localuser"
+    assert user.name == "localuser"
+    assert user.initials == "LC"
+    assert user.color is None
+
+
+@patch("getpass.getuser")
+@pytest.mark.asyncio
+async def test_get_user_with_error(getuser, log, handler):
+
+    getuser.return_value = "localuser"
+    getuser.side_effect = OSError("Could not get username")
+    handler._jupyter_current_user = User(username="jupyteruser")
+
+    provider = LocalIdentityProvider(log=log)
+
+    user = provider.get_user(handler)
+    user = await user
+
+    assert isinstance(user, User)
+    assert user.username == "jupyteruser"
+
+
+@pytest.mark.parametrize(
+    "username,expected_initials",
+    [
+        ("johndoe", "JH"),
+        ("alice", "LC"),
+        ("xy", "XY"),
+        ("a", "A"),
+        ("SARAH", "SR"),
+        ("john-smith", "JH"),
+        ("john123", "JH"),
+        ("", ""),
+    ],
+)
+def test_create_initials(username, expected_initials):
+    """Test various initials generation scenarios."""
+    assert create_initials(username) == expected_initials.upper()

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

@@ -61,6 +61,7 @@
   "dependencies": {
     "@emotion/react": "^11.10.5",
     "@emotion/styled": "^11.10.5",
+    "@jupyter-notebook/application": "^7.2.0",
     "@jupyter/chat": "^0.8.1",
     "@jupyterlab/application": "^4.2.0",
     "@jupyterlab/apputils": "^4.2.0",
@@ -75,6 +76,7 @@
     "@jupyterlab/services": "^7.2.0",
     "@jupyterlab/settingregistry": "^4.2.0",
     "@jupyterlab/ui-components": "^4.2.0",
+    "@lumino/widgets": "^2.3.2",
     "@mui/icons-material": "^5.11.0",
     "@mui/material": "^5.11.0",
     "react": "^18.2.0",

packages/jupyter-ai/package.json

@@ -1,3 +1,4 @@
+import { INotebookShell } from '@jupyter-notebook/application';
 import {
   JupyterFrontEnd,
   JupyterFrontEndPlugin
@@ -11,6 +12,7 @@ import {
 } from '@jupyterlab/apputils';
 import { IDocumentWidget } from '@jupyterlab/docregistry';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { SingletonLayout, Widget } from '@lumino/widgets';
 
 import { chatCommandPlugins } from './chat-commands';
 import { completionPlugin } from './completions';
@@ -35,13 +37,19 @@ const plugin: JupyterFrontEndPlugin<void> = {
   id: '@jupyter-ai/core:plugin',
   autoStart: true,
   requires: [IRenderMimeRegistry],
-  optional: [ICommandPalette, IThemeManager, IJaiCompletionProvider],
+  optional: [
+    ICommandPalette,
+    IThemeManager,
+    IJaiCompletionProvider,
+    INotebookShell
+  ],
   activate: async (
     app: JupyterFrontEnd,
     rmRegistry: IRenderMimeRegistry,
     palette: ICommandPalette | null,
     themeManager: IThemeManager | null,
-    completionProvider: IJaiCompletionProvider | null
+    completionProvider: IJaiCompletionProvider | null,
+    notebookShell: INotebookShell | null
   ) => {
     const openInlineCompleterSettings = () => {
       app.commands.execute('settingeditor:open', {
@@ -50,7 +58,7 @@ const plugin: JupyterFrontEndPlugin<void> = {
     };
 
     // Create a AI settings widget.
-    let aiSettings: MainAreaWidget<ReactWidget>;
+    let aiSettings: Widget;
     let settingsWidget: ReactWidget;
     try {
       settingsWidget = buildAiSettings(
@@ -67,13 +75,20 @@ const plugin: JupyterFrontEndPlugin<void> = {
     app.commands.addCommand(CommandIDs.openAiSettings, {
       execute: () => {
         if (!aiSettings || aiSettings.isDisposed) {
-          aiSettings = new MainAreaWidget({ content: settingsWidget });
+          if (notebookShell) {
+            aiSettings = new Widget();
+            const layout = new SingletonLayout();
+            aiSettings.layout = layout;
+            layout.widget = settingsWidget;
+          } else {
+            aiSettings = new MainAreaWidget({ content: settingsWidget });
+          }
           aiSettings.id = 'jupyter-ai-settings';
           aiSettings.title.label = 'AI settings';
           aiSettings.title.closable = true;
         }
         if (!aiSettings.isAttached) {
-          app?.shell.add(aiSettings, 'main');
+          app?.shell.add(aiSettings, notebookShell ? 'left' : 'main');
         }
         app.shell.activateById(aiSettings.id);
       },