change extension name back to name

Author: Zsailer

jupyter_server/extension/application.py

@@ -96,7 +96,7 @@ def _prepare_templates(self):
         # Add templates to web app settings if extension has templates.
         if len(self.template_paths) > 0:
             self.settings.update({
-                "{}_template_paths".format(self.extension_name): self.template_paths
+                "{}_template_paths".format(self.name): self.template_paths
             })
 
         # Create a jinja environment for logging html templates.
@@ -111,7 +111,7 @@ def _prepare_templates(self):
         # Add the jinja2 environment for this extension to the tornado settings.
         self.settings.update(
             {
-                "{}_jinja2_env".format(self.extension_name): self.jinja2_env
+                "{}_jinja2_env".format(self.name): self.jinja2_env
             }
         )
 
@@ -144,32 +144,11 @@ class method. This method can be set as a entry_point in
     # side-by-side when launched directly.
     load_other_extensions = True
 
-    # Name of the extension
-    extension_name = Unicode(
-        help="Name of extension."
-    )
-
-    @default('extension_name')
-    def _extension_name_default(self):
-        try:
-            return self.name
-        except AttributeError:
-            raise ValueError("The extension must be given a `name`.")
-
-    INVALID_EXTENSION_NAME_CHARS = [' ', '.', '+', '/']
-
-    @validate('extension_name')
-    def _validate_extension_name(self, proposal):
-        value = proposal['value']
-        if isinstance(value, str):
-            # Validate that extension_name doesn't contain any invalid characters.
-            for c in ExtensionApp.INVALID_EXTENSION_NAME_CHARS:
-                if c in value:
-                    raise ValueError("Extension name '{name}' cannot contain any of the following characters: "
-                                     "{invalid_chars}.".
-                                     format(name=value, invalid_chars=ExtensionApp.INVALID_EXTENSION_NAME_CHARS))
-            return value
-        raise ValueError("Extension name must be a string, found {type}.".format(type=type(value)))
+    # The extension name used to name the jupyter config
+    # file, jupyter_{name}_config.
+    # This should also match the jupyter subcommand used to launch
+    # this extension from the CLI, e.g. `jupyter {name}`.
+    name = None
 
     # Extension URL sets the default landing page for this extension.
     extension_url = "/"
@@ -181,8 +160,8 @@ def _validate_extension_name(self, proposal):
 
     @property
     def static_url_prefix(self):
-        return "/static/{extension_name}/".format(
-            extension_name=self.extension_name)
+        return "/static/{name}/".format(
+            name=self.name)
 
     static_paths = List(Unicode(),
         help="""paths to search for serving static files.
@@ -216,10 +195,9 @@ def static_url_prefix(self):
 
     def _config_file_name_default(self):
         """The default config file name."""
-        if not self.extension_name:
+        if not self.name:
             return ''
-        return 'jupyter_{}_config'.format(self.extension_name.replace('-','_'))
-
+        return 'jupyter_{}_config'.format(self.name.replace('-','_'))
 
     def initialize_settings(self):
         """Override this method to add handling of settings."""
@@ -235,11 +213,11 @@ def initialize_templates(self):
 
     def _prepare_config(self):
         """Builds a Config object from the extension's traits and passes
-        the object to the webapp's settings as `<extension_name>_config`.
+        the object to the webapp's settings as `<name>_config`.
         """
         traits = self.class_own_traits().keys()
         self.extension_config = Config({t: getattr(self, t) for t in traits})
-        self.settings['{}_config'.format(self.extension_name)] = self.extension_config
+        self.settings['{}_config'.format(self.name)] = self.extension_config
 
     def _prepare_settings(self):
         # Make webapp settings accessible to initialize_settings method
@@ -248,8 +226,8 @@ def _prepare_settings(self):
 
         # Add static and template paths to settings.
         self.settings.update({
-            "{}_static_paths".format(self.extension_name): self.static_paths,
-            "{}".format(self.extension_name): self
+            "{}_static_paths".format(self.name): self.static_paths,
+            "{}".format(self.name): self
         })
 
         # Get setting defined by subclass using initialize_settings method.
@@ -274,7 +252,8 @@ def _prepare_handlers(self):
             # Get handler kwargs, if given
             kwargs = {}
             if issubclass(handler, ExtensionHandlerMixin):
-                kwargs['extension_name'] = self.extension_name
+                kwargs['name'] = self.name
+
             try:
                 kwargs.update(handler_items[2])
             except IndexError:
@@ -302,7 +281,7 @@ def _prepare_templates(self):
         # Add templates to web app settings if extension has templates.
         if len(self.template_paths) > 0:
             self.settings.update({
-                "{}_template_paths".format(self.extension_name): self.template_paths
+                "{}_template_paths".format(self.name): self.template_paths
             })
         self.initialize_templates()
 
@@ -319,7 +298,7 @@ def initialize_server(cls, argv=[], load_other_extensions=True, **kwargs):
         # initializes it.
         config = Config({
             "ServerApp": {
-                "jpserver_extensions": {cls.extension_name: True},
+                "jpserver_extensions": {cls.name: True},
                 "open_browser": cls.open_browser,
                 "default_url": cls.extension_url
             }
@@ -402,7 +381,7 @@ def _load_jupyter_server_extension(cls, serverapp):
         """
         try:
             # Get loaded extension from serverapp.
-            extension = serverapp._enabled_extensions[cls.extension_name]
+            extension = serverapp._enabled_extensions[cls.name]
         except KeyError:
             extension = cls()
             extension.link_to_serverapp(serverapp)
@@ -438,6 +417,6 @@ def launch_instance(cls, argv=None, **kwargs):
             if not cls.load_other_extensions:
                 serverapp.log.info(
                     "{ext_name} is running without loading "
-                    "other extensions.".format(ext_name=cls.extension_name)
+                    "other extensions.".format(ext_name=cls.name)
                 )
             serverapp.start()

jupyter_server/extension/handler.py

@@ -8,26 +8,26 @@ class ExtensionHandlerJinjaMixin:
     """
     def get_template(self, name):
         """Return the jinja template object for a given name"""
-        env = '{}_jinja2_env'.format(self.extension_name)
+        env = '{}_jinja2_env'.format(self.name)
         return self.settings[env].get_template(name)
 
 
 class ExtensionHandlerMixin:
     """Base class for Jupyter server extension handlers.
 
     Subclasses can serve static files behind a namespaced
-    endpoint: "/static/<extension_name>/"
+    endpoint: "/static/<name>/"
 
     This allows multiple extensions to serve static files under
     their own namespace and avoid intercepting requests for
     other extensions.
     """
-    def initialize(self, extension_name):
-        self.extension_name = extension_name
+    def initialize(self, name):
+        self.name = name
 
     @property
     def extensionapp(self):
-        return self.settings[self.extension_name]
+        return self.settings[self.name]
 
     @property
     def serverapp(self):
@@ -36,24 +36,23 @@ def serverapp(self):
 
     @property
     def config(self):
-        return self.settings["{}_config".format(self.extension_name)]
+        return self.settings["{}_config".format(self.name)]
 
     @property
     def server_config(self):
         return self.settings["config"]
 
     @property
     def static_url_prefix(self):
-        return "/static/{extension_name}/".format(
-            extension_name=self.extension_name)
+        return "/static/{name}/".format(name=self.name)
 
     @property
     def static_path(self):
-        return self.settings['{}_static_paths'.format(self.extension_name)]
+        return self.settings['{}_static_paths'.format(self.name)]
 
     def static_url(self, path, include_host=None, **kwargs):
         """Returns a static URL for the given relative static file path.
-        This method requires you set the ``{extension_name}_static_path``
+        This method requires you set the ``{name}_static_path``
         setting in your extension (which specifies the root directory
         of your static files).
         This method returns a versioned url (by default appending
@@ -68,7 +67,7 @@ def static_url(self, path, include_host=None, **kwargs):
         that value will be used as the default for all `static_url`
         calls that do not pass ``include_host`` as a keyword argument.
         """
-        key = "{}_static_paths".format(self.extension_name)
+        key = "{}_static_paths".format(self.name)
         try:
             self.require_setting(key, "static_url")
         except Exception as e:

jupyter_server/extension/serverextension.py

@@ -154,7 +154,7 @@ def _get_load_jupyter_server_extension(obj):
     return func
 
 
-def validate_server_extension(extension_name):
+def validate_server_extension(name):
     """Validates that you can import the extension module,
     gather all extension metadata, and find `load_jupyter_server_extension`
     functions for each extension.
@@ -176,10 +176,10 @@ def validate_server_extension(extension_name):
     """
     # If the extension does not exist, raise an exception
     try:
-        mod, metadata = _get_server_extension_metadata(extension_name)
+        mod, metadata = _get_server_extension_metadata(name)
         version = getattr(mod, '__version__', '')
     except ImportError:
-        raise ExtensionValidationError('{} is not importable.'.format(extension_name))
+        raise ExtensionValidationError('{} is not importable.'.format(name))
 
     try:
         for item in metadata:
@@ -194,7 +194,7 @@ def validate_server_extension(extension_name):
                 raise AttributeError
     # If the extension does not have a `load_jupyter_server_extension` function, raise exception.
     except AttributeError:
-        raise ExtensionValidationError('Found "{}" module but cannot load it.'.format(extension_name))
+        raise ExtensionValidationError('Found "{}" module but cannot load it.'.format(name))
     return version
 
 

jupyter_server/serverapp.py

@@ -1571,7 +1571,7 @@ def init_server_extensions(self):
                         app = extapp()
                         app.link_to_serverapp(self)
                         # Build a new list where we
-                        self._enabled_extensions[app.extension_name] = app
+                        self._enabled_extensions[app.name] = app
                     elif extloc:
                         extmod = importlib.import_module(extloc)
                         func = _get_load_jupyter_server_extension(extmod)
@@ -1603,8 +1603,8 @@ def load_server_extensions(self):
                 )
             else:
                 log_msg = (
-                    "Extension {extension_name} enabled and "
-                    "loaded".format(extension_name=extension.extension_name)
+                    "Extension {name} enabled and "
+                    "loaded".format(name=extension.name)
                 )
             # Find the extension loading function.
             func = None

tests/extension/mockextensions/app.py

@@ -18,18 +18,18 @@ def get(self):
 
 
 class MockExtensionTemplateHandler(
-        ExtensionHandlerJinjaMixin,
-        ExtensionHandlerMixin,
-        JupyterHandler
-    ):
+    ExtensionHandlerJinjaMixin,
+    ExtensionHandlerMixin,
+    JupyterHandler
+):
 
     def get(self):
         self.write(self.render_template("index.html"))
 
 
 class MockExtensionApp(ExtensionAppJinjaMixin, ExtensionApp):
 
-    extension_name = 'mockextension'
+    name = 'mockextension'
     template_paths = List().tag(config=True)
     mock_trait = Unicode('mock trait', config=True)
     loaded = False