LicensesManager and API/CLI (#161)

* spdx license string

* move handlers

* add licenses_url to config

* add licenses to extension app handlers

* handle more spdx-like output of builder

* linting

* don't cache federated extensions, as they may be interactively installed

* fix markdown mime, add download option

* fix extension

* add tests for licenses handler

* add some debugging to header disposition check

* add markdown mimetype if needed

* consume most of the license CLI, remove special cases for dev_mode, etc

* add CLI test for different formats

* clean up systemexit testing

* add top-level key for bundles

* add license route to OpenAPI

Author: bollwyvl

jupyterlab_server/__init__.py

@@ -2,6 +2,7 @@
 # Distributed under the terms of the Modified BSD License.
 
 from .app import LabServerApp
+from .licenses_app import LicensesApp
 from .handlers import add_handlers, LabHandler, LabConfig
 from .workspaces_handler import slugify, WORKSPACE_EXTENSION
 from ._version import __version__
@@ -23,4 +24,4 @@ def _jupyter_server_extension_points():
             'module': 'jupyterlab_server',
             'app': LabServerApp
         }
-    ]
+    ]

jupyterlab_server/config.py

@@ -233,6 +233,8 @@ class LabConfig(HasTraits):
 
     themes_url = Unicode(help='The theme url.').tag(config=True)
 
+    licenses_url = Unicode(help='The third-party licenses url.')
+
     themes_dir = Unicode('',
                          help=('The optional location of the themes '
                                'directory. If given, a handler will be added '
@@ -278,6 +280,10 @@ def _default_listings_url(self):
     def _default_themes_url(self):
         return ujoin(self.app_url, 'api', 'themes/')
 
+    @default('licenses_url')
+    def _default_licenses_url(self):
+        return ujoin(self.app_url, 'api', 'licenses/')
+
     @default('tree_url')
     def _default_tree_url(self):
         return ujoin(self.app_url, 'tree/')

jupyterlab_server/handlers.py

@@ -18,6 +18,7 @@
 from .themes_handler import ThemesHandler
 from .translations_handler import TranslationsHandler
 from .workspaces_handler import WorkspacesHandler
+from .licenses_handler import LicensesHandler, LicensesManager
 
 # -----------------------------------------------------------------------------
 # Module globals
@@ -257,6 +258,18 @@ def add_handlers(handlers, extension_app):
             }
         ))
 
+    # Handle licenses.
+    if extension_app.licenses_url:
+        licenses_url = extension_app.licenses_url
+        licenses_path = ujoin(licenses_url, '(.*)')
+        handlers.append((
+            licenses_path,
+            LicensesHandler,
+            {
+                'manager': LicensesManager(parent=extension_app)
+            }
+        ))
+
     # Handle translations.
     if extension_app.translations_api_url:
         # Handle requests for the list of language packs available.

jupyterlab_server/licenses_app.py

@@ -0,0 +1,98 @@
+"""A license reporting CLI
+
+Mostly ready-to-use, the downstream must provide the location of the application's
+static resources. Licenses from an app's federated_extensions will also be discovered
+as configured in `labextensions_path` and `extra_labextensions_path`.
+
+    from traitlets import default
+    from jupyterlab_server import LicensesApp
+
+    class MyLicensesApp(LicensesApp):
+        version = "0.1.0"
+
+        @default("static_dir")
+        def _default_static_dir(self):
+            return "my-static/"
+
+    class MyApp(JupyterApp, LabConfig):
+        ...
+        subcommands = dict(
+            licenses=(MyLicensesApp, MyLicensesApp.description.splitlines()[0])
+        )
+
+"""
+from traitlets import Bool, Unicode, Enum, Instance
+from jupyter_core.application import JupyterApp, base_aliases, base_flags
+
+from ._version import __version__
+from .config import LabConfig
+from .licenses_handler import LicensesManager
+
+
+class LicensesApp(JupyterApp, LabConfig):
+    version = __version__
+
+    description = """
+    Report frontend licenses
+    """
+
+    static_dir = Unicode(
+        "", config=True, help="The static directory from which to show licenses"
+    )
+
+    full_text = Bool(
+        False, config=True, help="Also print out full license text (if available)"
+    )
+
+    report_format = Enum(
+        ["markdown", "json", "csv"], "markdown", config=True, help="Reporter format"
+    )
+
+    bundles_pattern = Unicode(
+        ".*", config=True, help="A regular expression of bundles to print"
+    )
+
+    licenses_manager = Instance(LicensesManager)
+
+    aliases = {
+        **base_aliases,
+        "bundles": "LicensesApp.bundles_pattern",
+        "report-format": "LicensesApp.report_format",
+    }
+
+    flags = {
+        **base_flags,
+        "full-text": (
+            {"LicensesApp": {"full_text": True}},
+            "Print out full license text (if available)",
+        ),
+        "json": (
+            {"LicensesApp": {"report_format": "json"}},
+            "Print out report as JSON (implies --full-text)",
+        ),
+        "csv": (
+            {"LicensesApp": {"report_format": "csv"}},
+            "Print out report as CSV (implies --full-text)",
+        ),
+    }
+
+    def initialize(self, *args, **kwargs):
+        super().initialize(*args, **kwargs)
+        self.init_licenses_manager()
+
+    def init_licenses_manager(self):
+        self.licenses_manager = LicensesManager(
+            labextensions_path=sum(
+                [self.labextensions_path + self.extra_labextensions_path], []
+            ),
+            parent=self,
+        )
+
+    def start(self):
+        report = self.licenses_manager.report(
+            report_format=self.report_format,
+            full_text=self.full_text,
+            bundles_pattern=self.bundles_pattern,
+        )[0]
+        print(report)
+        self.exit(0)