Add spell check and ensure docstrings (#1226)

* add spelling and docstring enforcement
* lint

Author: blink1073

.github/workflows/build.yml

@@ -76,7 +76,7 @@ jobs:
           ignore_links: "http://my-gateway-server.com:8888"
 
   build_docs:
-    runs-on: ubuntu-latest
+    runs-on: windows-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v3

.pre-commit-config.yaml

@@ -5,17 +5,18 @@ repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v4.4.0
     hooks:
-      - id: end-of-file-fixer
       - id: check-case-conflict
+      - id: check-ast
+      - id: check-docstring-first
       - id: check-executables-have-shebangs
-      - id: requirements-txt-fixer
       - id: check-added-large-files
       - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: check-json
       - id: check-toml
       - id: check-yaml
         exclude: etc/kubernetes/.*.yaml
-      - id: debug-statements
-      - id: forbid-new-submodules
+      - id: end-of-file-fixer
       - id: trailing-whitespace
 
   - repo: https://github.com/python-jsonschema/check-jsonschema

Makefile

@@ -71,6 +71,7 @@ lint: ## Check code style
 	black --check --diff --color .
 	mdformat --check *.md
 	pipx run 'validate-pyproject[all]' pyproject.toml
+	pipx run interrogate -v .
 
 run-dev: test-install-wheel ## Make a server in jupyter_websocket mode
 	python enterprise_gateway

docs/doc-requirements.txt

@@ -8,5 +8,6 @@ sphinx_book_theme
 sphinxcontrib-mermaid
 sphinxcontrib-openapi
 sphinxcontrib_github_alt
+sphinxcontrib_spelling
 sphinxemoji
 tornado

docs/source/conf.py

@@ -36,6 +36,13 @@
     "sphinxemoji.sphinxemoji",
 ]
 
+try:
+    import enchant  # noqa
+
+    extensions += ["sphinxcontrib.spelling"]
+except ImportError:
+    pass
+
 myst_enable_extensions = ["html_image"]
 myst_heading_anchors = 4  # Needs to be 4 or higher
 

enterprise_gateway/__init__.py

@@ -1,9 +1,8 @@
+"""Lazy-loading entrypoint for the enterprise gateway package."""
 # Copyright (c) Jupyter Development Team.
 # Distributed under the terms of the Modified BSD License.
 from ._version import __version__  # noqa
 
-"""Lazy-loading entrypoint for the enterprise gateway package."""
-
 
 def launch_instance(*args, **kwargs):
     from enterprise_gateway.enterprisegatewayapp import launch_instance

enterprise_gateway/base/handlers.py

@@ -1,6 +1,7 @@
+"""Tornado handlers for the base of the API."""
 # Copyright (c) Jupyter Development Team.
 # Distributed under the terms of the Modified BSD License.
-"""Tornado handlers for the base of the API."""
+
 
 import json
 from typing import List
@@ -20,6 +21,7 @@ class APIVersionHandler(TokenAuthorizationMixin, CORSMixin, JSONErrorsMixin, API
     """
 
     def get(self):
+        """Get the API version."""
         # not authenticated, so give as few info as possible
         # to be backwards compatibile, use only 'version' for the jupyter_server version
         # and be more specific for gateway_version
@@ -41,6 +43,7 @@ class NotFoundHandler(JSONErrorsMixin, web.RequestHandler):
     """
 
     def prepare(self):
+        """Prepare the response."""
         raise web.HTTPError(404)
 
 

enterprise_gateway/client/gateway_client.py

@@ -1,3 +1,4 @@
+"""An Enterprise Gateway client."""
 import logging
 import os
 import queue as queue
@@ -29,12 +30,14 @@ class GatewayClient:
     KERNEL_LAUNCH_TIMEOUT = os.getenv("KERNEL_LAUNCH_TIMEOUT", "40")
 
     def __init__(self, host=DEFAULT_GATEWAY_HOST):
+        """Initialize the client."""
         self.http_api_endpoint = f"http://{host}/api/kernels"
         self.ws_api_endpoint = f"ws://{host}/api/kernels"
         self.log = logging.getLogger("GatewayClient")
         self.log.setLevel(log_level)
 
     def start_kernel(self, kernelspec_name, username=DEFAULT_USERNAME, timeout=REQUEST_TIMEOUT):
+        """Start a kernel."""
         self.log.info(f"Starting a {kernelspec_name} kernel ....")
 
         json_data = {
@@ -66,6 +69,7 @@ def start_kernel(self, kernelspec_name, username=DEFAULT_USERNAME, timeout=REQUE
         )
 
     def shutdown_kernel(self, kernel):
+        """Shut down a kernel."""
         self.log.info(f"Shutting down kernel : {kernel.kernel_id} ....")
 
         if not kernel:
@@ -83,6 +87,7 @@ def shutdown_kernel(self, kernel):
 
 
 class KernelClient:
+    """A kernel client class."""
 
     DEAD_MSG_ID = "deadbeefdeadbeefdeadbeefdeadbeef"
     POST_IDLE_TIMEOUT = 0.5
@@ -91,6 +96,7 @@ class KernelClient:
     def __init__(
         self, http_api_endpoint, ws_api_endpoint, kernel_id, timeout=REQUEST_TIMEOUT, logger=None
     ):
+        """Initialize the client."""
         self.shutting_down = False
         self.restarting = False
         self.http_api_endpoint = http_api_endpoint
@@ -113,6 +119,7 @@ def __init__(
         self.interrupt_thread = None
 
     def shutdown(self):
+        """Shut down the client."""
         # Terminate thread, close socket and clear queues.
         self.shutting_down = True
 
@@ -204,6 +211,7 @@ def execute(self, code, timeout=REQUEST_TIMEOUT):
         return "".join(response)
 
     def interrupt(self):
+        """Interrupt the kernel."""
         url = "{}/{}".format(self.kernel_http_api_endpoint, "interrupt")
         response = requests.post(url)
         if response.status_code == 204:
@@ -217,6 +225,7 @@ def interrupt(self):
             )
 
     def restart(self, timeout=REQUEST_TIMEOUT):
+        """Restart the kernel."""
         self.restarting = True
         self.kernel_socket.close()
         self.kernel_socket = None
@@ -238,6 +247,7 @@ def restart(self, timeout=REQUEST_TIMEOUT):
             )
 
     def get_state(self):
+        """Get the state of the client."""
         url = f"{self.kernel_http_api_endpoint}"
         response = requests.get(url)
         if response.status_code == 200:
@@ -252,14 +262,17 @@ def get_state(self):
             )
 
     def start_interrupt_thread(self, wait_time=DEFAULT_INTERRUPT_WAIT):
+        """Start the interrupt thread."""
         self.interrupt_thread = Thread(target=self.perform_interrupt, args=(wait_time,))
         self.interrupt_thread.start()
 
     def perform_interrupt(self, wait_time):
+        """Perform an interrupt on the client."""
         time.sleep(wait_time)  # Allow parent to start executing cell to interrupt
         self.interrupt()
 
     def terminate_interrupt_thread(self):
+        """Terminate the interrupt thread."""
         if self.interrupt_thread:
             self.interrupt_thread.join()
             self.interrupt_thread = None