run lint

Author: blink1073

examples/simple/simple_ext1/handlers.py

@@ -42,7 +42,7 @@ def get(self):
 
 class TemplateHandler(BaseTemplateHandler):
     def get(self, path):
-        """ Optionaly, you can print(self.get_template('simple1.html'))"""
+        """Optionaly, you can print(self.get_template('simple1.html'))"""
         self.write(self.render_template("simple1.html", path=path))
 
 

examples/simple/simple_ext1/static/bundle.js

@@ -57,37 +57,35 @@
     /******/
   }; // create a fake namespace object // mode & 1: value is a module id, require it // mode & 2: merge all properties of value into the ns // mode & 4: return value when already ns object // mode & 8|1: behave like require
   /******/
-  /******/ /******/ /******/ /******/ /******/ /******/ __webpack_require__.t = function (
-    value,
-    mode
-  ) {
-    /******/ if (mode & 1) value = __webpack_require__(value);
-    /******/ if (mode & 8) return value;
-    /******/ if (
-      mode & 4 &&
-      typeof value === "object" &&
-      value &&
-      value.__esModule
-    )
-      return value;
-    /******/ var ns = Object.create(null);
-    /******/ __webpack_require__.r(ns);
-    /******/ Object.defineProperty(ns, "default", {
-      enumerable: true,
-      value: value,
-    });
-    /******/ if (mode & 2 && typeof value != "string")
-      for (var key in value)
-        __webpack_require__.d(
-          ns,
-          key,
-          function (key) {
-            return value[key];
-          }.bind(null, key)
-        );
-    /******/ return ns;
-    /******/
-  }; // getDefaultExport function for compatibility with non-harmony modules
+  /******/ /******/ /******/ /******/ /******/ /******/ __webpack_require__.t =
+    function (value, mode) {
+      /******/ if (mode & 1) value = __webpack_require__(value);
+      /******/ if (mode & 8) return value;
+      /******/ if (
+        mode & 4 &&
+        typeof value === "object" &&
+        value &&
+        value.__esModule
+      )
+        return value;
+      /******/ var ns = Object.create(null);
+      /******/ __webpack_require__.r(ns);
+      /******/ Object.defineProperty(ns, "default", {
+        enumerable: true,
+        value: value,
+      });
+      /******/ if (mode & 2 && typeof value != "string")
+        for (var key in value)
+          __webpack_require__.d(
+            ns,
+            key,
+            function (key) {
+              return value[key];
+            }.bind(null, key)
+          );
+      /******/ return ns;
+      /******/
+    }; // getDefaultExport function for compatibility with non-harmony modules
   /******/
   /******/ /******/ __webpack_require__.n = function (module) {
     /******/ var getter =

jupyter_server/_sysinfo.py

@@ -56,10 +56,10 @@ def pkg_commit_hash(pkg_path):
             if repo_commit:
                 return "repository", repo_commit.strip().decode("ascii")
             else:
-                return u"", u""
+                return "", ""
         par_path = p.dirname(par_path)
 
-    return u"", u""
+    return "", ""
 
 
 def pkg_info(pkg_path):

jupyter_server/auth/login.py

@@ -75,8 +75,8 @@ def passwd_check(self, a, b):
         return passwd_check(a, b)
 
     def post(self):
-        typed_password = self.get_argument("password", default=u"")
-        new_password = self.get_argument("new_password", default=u"")
+        typed_password = self.get_argument("password", default="")
+        new_password = self.get_argument("new_password", default="")
 
         if self.get_login_available(self.settings):
             if self.passwd_check(self.hashed_password, typed_password) and not new_password:
@@ -247,7 +247,7 @@ def password_from_settings(cls, settings):
 
         If there is no configured password, an empty string will be returned.
         """
-        return settings.get("password", u"")
+        return settings.get("password", "")
 
     @classmethod
     def get_login_available(cls, settings):

jupyter_server/base/handlers.py

@@ -548,13 +548,13 @@ def get_json_body(self):
         if not self.request.body:
             return None
         # Do we need to call body.decode('utf-8') here?
-        body = self.request.body.strip().decode(u"utf-8")
+        body = self.request.body.strip().decode("utf-8")
         try:
             model = json.loads(body)
         except Exception as e:
             self.log.debug("Bad JSON: %r", body)
             self.log.error("Couldn't parse JSON", exc_info=True)
-            raise web.HTTPError(400, u"Invalid JSON in body of request") from e
+            raise web.HTTPError(400, "Invalid JSON in body of request") from e
         return model
 
     def write_error(self, status_code, **kwargs):

jupyter_server/extension/application.py

@@ -211,7 +211,9 @@ def _default_log_level(self):
     @default("log_format")
     def _default_log_format(self):
         """override default log format to include date & time"""
-        return u"%(color)s[%(levelname)1.1s %(asctime)s.%(msecs).03d %(name)s]%(end_color)s %(message)s"
+        return (
+            "%(color)s[%(levelname)1.1s %(asctime)s.%(msecs).03d %(name)s]%(end_color)s %(message)s"
+        )
 
     static_url_prefix = Unicode(
         help="""Url where the static assets for the extension are served."""

jupyter_server/extension/serverextension.py

@@ -329,7 +329,7 @@ def list_server_extensions(self):
             for name, extension in ext_manager.extensions.items():
                 enabled = extension.enabled
                 # Attempt to get extension metadata
-                self.log.info(u"    {} {}".format(name, GREEN_ENABLED if enabled else RED_DISABLED))
+                self.log.info("    {} {}".format(name, GREEN_ENABLED if enabled else RED_DISABLED))
                 try:
                     self.log.info("    - Validating {}...".format(name))
                     if not extension.validate():

jupyter_server/gateway/gateway_client.py

@@ -397,7 +397,7 @@ def load_connection_args(self, **kwargs):
 
 
 async def gateway_request(endpoint, **kwargs):
-    """Make an async request to kernel gateway endpoint, returns a response """
+    """Make an async request to kernel gateway endpoint, returns a response"""
     client = AsyncHTTPClient()
     kwargs = GatewayClient.instance().load_connection_args(**kwargs)
     try:

jupyter_server/gateway/handlers.py

@@ -81,7 +81,7 @@ def send_ping(self):
         self.ping(b"")
 
     def open(self, kernel_id, *args, **kwargs):
-        """Handle web socket connection open to notebook server and delegate to gateway web socket handler """
+        """Handle web socket connection open to notebook server and delegate to gateway web socket handler"""
         self.ping_callback = PeriodicCallback(self.send_ping, GATEWAY_WS_PING_INTERVAL_SECS * 1000)
         self.ping_callback.start()
 
@@ -221,7 +221,7 @@ async def _read_messages(self, callback):
             jitter = random.randint(10, 100) * 0.01
             retry_interval = (
                 min(
-                    GatewayClient.instance().gateway_retry_interval * (2 ** self.retry),
+                    GatewayClient.instance().gateway_retry_interval * (2**self.retry),
                     GatewayClient.instance().gateway_retry_interval_max,
                 )
                 + jitter

jupyter_server/gateway/managers.py

@@ -54,7 +54,7 @@ def __init__(self, **kwargs):
         )
 
     def remove_kernel(self, kernel_id):
-        """Complete override since we want to be more tolerant of missing keys """
+        """Complete override since we want to be more tolerant of missing keys"""
         try:
             return self._kernels.pop(kernel_id)
         except KeyError:
@@ -178,7 +178,7 @@ async def shutdown_all(self, now=False):
             self.remove_kernel(kernel_id)
 
     async def cull_kernels(self):
-        """Override cull_kernels so we can be sure their state is current. """
+        """Override cull_kernels so we can be sure their state is current."""
         await self.list_kernels()
         await super().cull_kernels()
 
@@ -299,7 +299,7 @@ class GatewaySessionManager(SessionManager):
     kernel_manager = Instance("jupyter_server.gateway.managers.GatewayMappingKernelManager")
 
     async def kernel_culled(self, kernel_id):
-        """Checks if the kernel is still considered alive and returns true if its not found. """
+        """Checks if the kernel is still considered alive and returns true if its not found."""
         kernel = None
         try:
             km = self.kernel_manager.get_kernel(kernel_id)
@@ -313,7 +313,7 @@ async def kernel_culled(self, kernel_id):
 
 
 class GatewayKernelManager(AsyncKernelManager):
-    """Manages a single kernel remotely via a Gateway Server. """
+    """Manages a single kernel remotely via a Gateway Server."""
 
     kernel_id = None
     kernel = None
@@ -449,23 +449,23 @@ async def start_kernel(self, **kwargs):
         self.kernel_url = url_path_join(self.kernels_url, url_escape(str(self.kernel_id)))
 
     async def shutdown_kernel(self, now=False, restart=False):
-        """Attempts to stop the kernel process cleanly via HTTP. """
+        """Attempts to stop the kernel process cleanly via HTTP."""
 
         if self.has_kernel:
             self.log.debug("Request shutdown kernel at: %s", self.kernel_url)
             response = await gateway_request(self.kernel_url, method="DELETE")
             self.log.debug("Shutdown kernel response: %d %s", response.code, response.reason)
 
     async def restart_kernel(self, **kw):
-        """Restarts a kernel via HTTP.  """
+        """Restarts a kernel via HTTP."""
         if self.has_kernel:
             kernel_url = self.kernel_url + "/restart"
             self.log.debug("Request restart kernel at: %s", kernel_url)
             response = await gateway_request(kernel_url, method="POST", body=json_encode({}))
             self.log.debug("Restart kernel response: %d %s", response.code, response.reason)
 
     async def interrupt_kernel(self):
-        """Interrupts the kernel via an HTTP request. """
+        """Interrupts the kernel via an HTTP request."""
         if self.has_kernel:
             kernel_url = self.kernel_url + "/interrupt"
             self.log.debug("Request interrupt kernel at: %s", kernel_url)

jupyter_server/kernelspecs/handlers.py

@@ -16,7 +16,7 @@ def get(self, kernel_name, path, include_body=True):
         try:
             self.root = ksm.get_kernel_spec(kernel_name).resource_dir
         except KeyError as e:
-            raise web.HTTPError(404, u"Kernel spec %s not found" % kernel_name) from e
+            raise web.HTTPError(404, "Kernel spec %s not found" % kernel_name) from e
         self.log.debug("Serving kernel resource from: %s", self.root)
         return web.StaticFileHandler.get(self, path, include_body=include_body)
 

jupyter_server/nbconvert/handlers.py

@@ -67,7 +67,7 @@ def get_exporter(format, **kwargs):
         Exporter = get_exporter(format)
     except KeyError as e:
         # should this be 400?
-        raise web.HTTPError(404, u"No exporter for format: %s" % format) from e
+        raise web.HTTPError(404, "No exporter for format: %s" % format) from e
 
     try:
         return Exporter(**kwargs)

jupyter_server/pytest_plugin.py

@@ -109,7 +109,7 @@ def jp_environ(
     jp_env_jupyter_path,
     jp_env_config_path,
 ):
-    """Configures a temporary environment based on Jupyter-specific environment variables. """
+    """Configures a temporary environment based on Jupyter-specific environment variables."""
     monkeypatch.setenv("HOME", str(jp_home_dir))
     monkeypatch.setenv("PYTHONPATH", os.pathsep.join(sys.path))
     # monkeypatch.setenv("JUPYTER_NO_CONFIG", "1")
@@ -127,7 +127,7 @@ def jp_environ(
 
 @pytest.fixture
 def jp_server_config():
-    """Allows tests to setup their specific configuration values. """
+    """Allows tests to setup their specific configuration values."""
     return {}
 
 
@@ -145,7 +145,7 @@ def jp_template_dir(tmp_path):
 
 @pytest.fixture
 def jp_argv():
-    """Allows tests to setup specific argv values. """
+    """Allows tests to setup specific argv values."""
     return []
 
 
@@ -157,7 +157,7 @@ def jp_extension_environ(jp_env_config_path, monkeypatch):
 
 @pytest.fixture
 def jp_http_port(http_server_port):
-    """Returns the port value from the http_server_port fixture. """
+    """Returns the port value from the http_server_port fixture."""
     return http_server_port[-1]
 
 
@@ -406,7 +406,7 @@ def client_fetch(*parts, headers=None, params=None, **kwargs):
     return client_fetch
 
 
-some_resource = u"The very model of a modern major general"
+some_resource = "The very model of a modern major general"
 sample_kernel_json = {
     "argv": ["cat", "{connection_file}"],
     "display_name": "Test kernel",

jupyter_server/serverapp.py

@@ -537,7 +537,7 @@ class JupyterServerStopApp(JupyterApp):
         help="Port of the server to be killed. Default %s" % DEFAULT_JUPYTER_SERVER_PORT,
     )
 
-    sock = Unicode(u"", config=True, help="UNIX socket of the server to be killed.")
+    sock = Unicode("", config=True, help="UNIX socket of the server to be killed.")
 
     def parse_command_line(self, argv=None):
         super(JupyterServerStopApp, self).parse_command_line(argv)
@@ -768,7 +768,9 @@ def _default_log_level(self):
     @default("log_format")
     def _default_log_format(self):
         """override default log format to include date & time"""
-        return u"%(color)s[%(levelname)1.1s %(asctime)s.%(msecs).03d %(name)s]%(end_color)s %(message)s"
+        return (
+            "%(color)s[%(levelname)1.1s %(asctime)s.%(msecs).03d %(name)s]%(end_color)s %(message)s"
+        )
 
     # file to be opened in the Jupyter server
     file_to_run = Unicode("", help="Open the named file when the application is launched.").tag(
@@ -847,12 +849,12 @@ def _default_ip(self):
     @validate("ip")
     def _validate_ip(self, proposal):
         value = proposal["value"]
-        if value == u"*":
-            value = u""
+        if value == "*":
+            value = ""
         return value
 
     custom_display_url = Unicode(
-        u"",
+        "",
         config=True,
         help=_i18n(
             """Override URL shown to users.
@@ -894,7 +896,7 @@ def port_default(self):
     def port_retries_default(self):
         return int(os.getenv(self.port_retries_env, self.port_retries_default_value))
 
-    sock = Unicode(u"", config=True, help="The UNIX socket the Jupyter server will listen on.")
+    sock = Unicode("", config=True, help="The UNIX socket the Jupyter server will listen on.")
 
     sock_mode = Unicode(
         "0600", config=True, help="The permissions mode for UNIX socket creation (default: 0600)."
@@ -911,7 +913,7 @@ def _validate_sock_mode(self, proposal):
                     bool(converted_value & stat.S_IRUSR),
                     bool(converted_value & stat.S_IWUSR),
                     # And isn't out of bounds.
-                    converted_value <= 2 ** 12,
+                    converted_value <= 2**12,
                 )
             )
         except ValueError:
@@ -923,17 +925,17 @@ def _validate_sock_mode(self, proposal):
         return value
 
     certfile = Unicode(
-        u"", config=True, help=_i18n("""The full path to an SSL/TLS certificate file.""")
+        "", config=True, help=_i18n("""The full path to an SSL/TLS certificate file.""")
     )
 
     keyfile = Unicode(
-        u"",
+        "",
         config=True,
         help=_i18n("""The full path to a private key file for usage with SSL/TLS."""),
     )
 
     client_ca = Unicode(
-        u"",
+        "",
         config=True,
         help=_i18n(
             """The full path to a certificate authority certificate for SSL/TLS client authentication."""
@@ -1013,7 +1015,7 @@ def _token_default(self):
         if self.password:
             # no token if password is enabled
             self._token_generated = False
-            return u""
+            return ""
         else:
             self._token_generated = True
             return binascii.hexlify(os.urandom(24)).decode("ascii")
@@ -1074,7 +1076,7 @@ def _token_changed(self, change):
         self._token_generated = False
 
     password = Unicode(
-        u"",
+        "",
         config=True,
         help="""Hashed password to use for web authentication.
 
@@ -1219,7 +1221,7 @@ def _default_allow_remote(self):
     )
 
     browser = Unicode(
-        u"",
+        "",
         config=True,
         help="""Specify what command to use to invoke a web
                       browser when starting the server. If not specified, the