Merge pull request #1 from Zsailer/shim

[WIP] Move over initial shim logic

Author: Zsailer

CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+<!-- <START NEW CHANGELOG ENTRY> -->
+
+
+<!-- <END NEW CHANGELOG ENTRY> -->

LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2022 Project Jupyter Contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

MANIFEST.in

@@ -0,0 +1,6 @@
+include LICENSE
+
+# added by check-manifest
+include *.md
+recursive-include docs *.md
+recursive-include notebook_shim *.py

README.md

@@ -1,2 +1,30 @@
-# notebook_shim
-A shim layer for notebook traits and config
+# Notebook Shim
+
+This project provides a way for JupyterLab and other frontends to switch to [Jupyter Server](https://github.com/jupyter/jupyter_server/) for their Python Web application backend.
+
+## Basic Usage
+
+Install from PyPI:
+```
+> pip install notebook_shim
+```
+This will automatically enable the extension in Jupyter Server.
+
+## Usage
+
+This project also includes an API for shimming traits that moved from `NotebookApp` in to `ServerApp` in Jupyter Server. This can be used by applications that subclassed `NotebookApp` to leverage the Python server backend of Jupyter Notebooks. Such extensions should *now* switch to `ExtensionApp` API in Jupyter Server and add `NotebookConfigShimMixin` in their inheritance list to properly handle moved traits.
+
+For example, an application class that previously looked like:
+```python
+from notebook.notebookapp import NotebookApp
+
+class MyApplication(NotebookApp):
+```
+should switch to look something like:
+```python
+from jupyter_server.extension.application import ExtensionApp
+from notebook_shim.shim import NotebookConfigShimMixin
+
+class MyApplication(NotebookConfigShimMixin, ExtensionApp):
+```
+

RELEASE.md

@@ -0,0 +1,15 @@
+To create a release, update the version number in `noetbook_shim/__version__.py`, then run the following:
+
+```
+git clean -dffx
+python setup.py sdist
+python setup.py bdist_wheel
+export script_version=`python setup.py --version 2>/dev/null`
+git commit -a -m "Release $script_version"
+git tag $script_version
+git push --all
+git push --tags
+pip install twine
+twine check dist/*
+twine upload dist/*
+```

jupyter_server_config.d/notebook_shim.json

@@ -0,0 +1,7 @@
+{
+    "ServerApp": {
+        "jpserver_extensions": {
+            "notebook_shim": true
+        }
+    }
+}

notebook_shim/__init__.py

@@ -0,0 +1,6 @@
+def _jupyter_server_extension_paths():
+    return [
+        {
+            'module': 'notebook_shim.nbserver',
+        }
+    ]

notebook_shim/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

notebook_shim/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ["jupyter_server.pytest_plugin"]

notebook_shim/nbserver.py

@@ -0,0 +1,126 @@
+"""
+This module contains a Jupyter Server extension that attempts to
+make classic server and notebook extensions work in the new server.
+
+Unfortunately, you'll notice that requires some major monkey-patching.
+The goal is that this extension will only be used as a temporary
+patch to transition extension authors from classic notebook server to jupyter_server.
+"""
+import os
+import types
+import inspect
+from functools import wraps
+from jupyter_core.paths import jupyter_config_path
+from traitlets.traitlets import is_trait
+
+
+from jupyter_server.services.config.manager import ConfigManager
+from .traits import NotebookAppTraits
+
+
+class ClassProxyError(Exception):
+    pass
+
+
+def proxy(obj1, obj2, name, overwrite=False):
+    """Redirects a method, property, or trait from object 1 to object 2."""
+    if hasattr(obj1, name) and overwrite is False:
+        raise ClassProxyError(
+            "Cannot proxy the attribute '{name}' from {cls2} because "
+            "{cls1} already has this attribute.".format(
+                name=name,
+                cls1=obj1.__class__,
+                cls2=obj2.__class__
+            )
+        )
+    attr = getattr(obj2, name)
+
+    # First check if this thing is a trait (see traitlets)
+    cls_attr = getattr(obj2.__class__, name)
+    if is_trait(cls_attr) or type(attr) == property:
+        thing = property(lambda self: getattr(obj2, name))
+
+    elif isinstance(attr, types.MethodType):
+        @wraps(attr)
+        def thing(self, *args, **kwargs):
+            return attr(*args, **kwargs)
+
+    # Anything else appended on the class is just an attribute of the class.
+    else:
+        thing = attr
+
+    setattr(obj1.__class__, name, thing)
+
+
+def public_members(obj):
+    members = inspect.getmembers(obj)
+    return [m for m, _ in members if not m.startswith('_')]
+
+
+def diff_members(obj1, obj2):
+    """Return all attribute names found in obj2 but not obj1"""
+    m1 = public_members(obj1)
+    m2 = public_members(obj2)
+    return set(m2).difference(m1)
+
+
+def get_nbserver_extensions(config_dirs):
+    cm = ConfigManager(read_config_path=config_dirs)
+    section = cm.get("jupyter_notebook_config")
+    extensions = section.get('NotebookApp', {}).get('nbserver_extensions', {})
+    return extensions
+
+
+def _link_jupyter_server_extension(serverapp):
+    # Get the extension manager from the server
+    manager = serverapp.extension_manager
+    logger = serverapp.log
+
+    # Hack that patches the enabled extensions list, prioritizing
+    # jupyter nbclassic. In the future, it would be much better
+    # to incorporate a dependency injection system in the
+    # Extension manager that allows extensions to list
+    # their dependency tree and sort that way.
+    def sorted_extensions(self):
+        """Dictionary with extension package names as keys
+        and an ExtensionPackage objects as values.
+        """
+        # Sort the keys and
+        keys = sorted(self.extensions.keys())
+        keys.remove("notebook_shim")
+        keys = ["notebook_shim"] + keys
+        return {key: self.extensions[key] for key in keys}
+
+    manager.__class__.sorted_extensions = property(sorted_extensions)
+
+    # Look to see if nbclassic is enabled. if so,
+    # link the nbclassic extension here to load
+    # its config. Then, port its config to the serverapp
+    # for backwards compatibility.
+    try:
+        pkg = manager.extensions["notebook_shim"]
+        pkg.link_point("notebook_shim", serverapp)
+        point = pkg.extension_points["notebook_shim"]
+        nbapp = point.app
+    except Exception:
+        nbapp = NotebookAppTraits()
+
+    # Proxy NotebookApp traits through serverapp to notebookapp.
+    members = diff_members(serverapp, nbapp)
+    for m in members:
+        proxy(serverapp, nbapp, m)
+
+    # Find jupyter server extensions listed as notebook server extensions.
+    jupyter_paths = jupyter_config_path()
+    config_dirs = jupyter_paths + [serverapp.config_dir]
+    nbserver_extensions = get_nbserver_extensions(config_dirs)
+
+
+def _load_jupyter_server_extension(serverapp):
+    # Patch the config service manager to find the
+    # proper path for old notebook frontend extensions
+    config_manager = serverapp.config_manager
+    read_config_path = config_manager.read_config_path
+    read_config_path += [os.path.join(p, 'nbconfig')
+                         for p in jupyter_config_path()]
+    config_manager.read_config_path = read_config_path