Fix all typing issues

tagging/create_manifests.py

@@ -5,6 +5,7 @@ import argparse
 import datetime
 import logging
 import os
+from docker.models.containers import Container
 from .docker_runner import DockerRunner
 from .get_taggers_and_manifests import get_taggers_and_manifests
 from .git_helper import GitHelper
@@ -55,9 +56,9 @@ def create_manifest_file(
     owner: str,
     wiki_path: str,
     manifests: list[ManifestInterface],
-    container,
+    container: Container,
 ) -> None:
-    manifest_names = [manifest.__name__ for manifest in manifests]
+    manifest_names = [manifest.__class__.__name__ for manifest in manifests]
     LOGGER.info(f"Using manifests: {manifest_names}")
 
     commit_hash_tag = GitHelper.commit_hash_tag()

tagging/docker_runner.py

@@ -1,6 +1,7 @@
 # Copyright (c) Jupyter Development Team.
 # Distributed under the terms of the Modified BSD License.
 from typing import Optional
+from types import TracebackType
 import docker
 from docker.models.containers import Container
 import logging
@@ -13,7 +14,7 @@ class DockerRunner:
     def __init__(
         self,
         image_name: str,
-        docker_client=docker.from_env(),
+        docker_client: docker.DockerClient = docker.from_env(),
         command: str = "sleep infinity",
     ):
         self.container: Optional[Container] = None
@@ -31,7 +32,13 @@ class DockerRunner:
         LOGGER.info(f"Container {self.container.name} created")
         return self.container
 
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        assert self.container is not None
         LOGGER.info(f"Removing container {self.container.name} ...")
         if self.container:
             self.container.remove(force=True)
@@ -44,6 +51,7 @@ class DockerRunner:
         LOGGER.info(f"Running cmd: '{cmd}' on container: {container}")
         out = container.exec_run(cmd)
         result = out.output.decode("utf-8").rstrip()
+        assert isinstance(result, str)
         if print_result:
             LOGGER.info(f"Command result: {result}")
         assert out.exit_code == 0, f"Command: {cmd} failed"

tagging/get_taggers_and_manifests.py

@@ -1,20 +1,22 @@
 # Copyright (c) Jupyter Development Team.
 # Distributed under the terms of the Modified BSD License.
+from typing import Optional
 from .images_hierarchy import ALL_IMAGES
 from .manifests import ManifestInterface
 from .taggers import TaggerInterface
 
 
 def get_taggers_and_manifests(
-    short_image_name: str,
+    short_image_name: Optional[str],
 ) -> tuple[list[TaggerInterface], list[ManifestInterface]]:
-    taggers: list[TaggerInterface] = []
-    manifests: list[ManifestInterface] = []
-    while short_image_name is not None:
-        image_description = ALL_IMAGES[short_image_name]
+    if short_image_name is None:
+        return [[], []]  # type: ignore
 
-        taggers = image_description.taggers + taggers
-        manifests = image_description.manifests + manifests
-
-        short_image_name = image_description.parent_image
-    return taggers, manifests
+    image_description = ALL_IMAGES[short_image_name]
+    parent_taggers, parent_manifests = get_taggers_and_manifests(
+        image_description.parent_image
+    )
+    return (
+        parent_taggers + image_description.taggers,
+        parent_manifests + image_description.manifests,
+    )

tagging/git_helper.py

@@ -7,7 +7,7 @@ from plumbum.cmd import git
 class GitHelper:
     @staticmethod
     def commit_hash() -> str:
-        return git["rev-parse", "HEAD"]().strip()
+        return git["rev-parse", "HEAD"]().strip()  # type: ignore
 
     @staticmethod
     def commit_hash_tag() -> str:
@@ -15,7 +15,7 @@ class GitHelper:
 
     @staticmethod
     def commit_message() -> str:
-        return git["log", -1, "--pretty=%B"]().strip()
+        return git["log", -1, "--pretty=%B"]().strip()  # type: ignore
 
 
 if __name__ == "__main__":

tagging/github_set_env.py

@@ -3,7 +3,7 @@
 import os
 
 
-def github_set_env(env_name, env_value):
+def github_set_env(env_name: str, env_value: str) -> None:
     if not os.environ.get("GITHUB_ACTIONS") or not os.environ.get("GITHUB_ENV"):
         return
 

tagging/images_hierarchy.py

@@ -39,39 +39,39 @@ ALL_IMAGES = {
     "base-notebook": ImageDescription(
         parent_image=None,
         taggers=[
-            SHATagger,
-            DateTagger,
-            UbuntuVersionTagger,
-            PythonVersionTagger,
-            JupyterNotebookVersionTagger,
-            JupyterLabVersionTagger,
-            JupyterHubVersionTagger,
+            SHATagger(),
+            DateTagger(),
+            UbuntuVersionTagger(),
+            PythonVersionTagger(),
+            JupyterNotebookVersionTagger(),
+            JupyterLabVersionTagger(),
+            JupyterHubVersionTagger(),
         ],
-        manifests=[CondaEnvironmentManifest, AptPackagesManifest],
+        manifests=[CondaEnvironmentManifest(), AptPackagesManifest()],
     ),
     "minimal-notebook": ImageDescription(parent_image="base-notebook"),
     "scipy-notebook": ImageDescription(parent_image="minimal-notebook"),
     "r-notebook": ImageDescription(
         parent_image="minimal-notebook",
-        taggers=[RVersionTagger],
-        manifests=[RPackagesManifest],
+        taggers=[RVersionTagger()],
+        manifests=[RPackagesManifest()],
     ),
     "tensorflow-notebook": ImageDescription(
-        parent_image="scipy-notebook", taggers=[TensorflowVersionTagger]
+        parent_image="scipy-notebook", taggers=[TensorflowVersionTagger()]
     ),
     "datascience-notebook": ImageDescription(
         parent_image="scipy-notebook",
-        taggers=[RVersionTagger, JuliaVersionTagger],
-        manifests=[RPackagesManifest, JuliaPackagesManifest],
+        taggers=[RVersionTagger(), JuliaVersionTagger()],
+        manifests=[RPackagesManifest(), JuliaPackagesManifest()],
     ),
     "pyspark-notebook": ImageDescription(
         parent_image="scipy-notebook",
-        taggers=[SparkVersionTagger, HadoopVersionTagger, JavaVersionTagger],
-        manifests=[SparkInfoManifest],
+        taggers=[SparkVersionTagger(), HadoopVersionTagger(), JavaVersionTagger()],
+        manifests=[SparkInfoManifest()],
     ),
     "all-spark-notebook": ImageDescription(
         parent_image="pyspark-notebook",
-        taggers=[RVersionTagger],
-        manifests=[RPackagesManifest],
+        taggers=[RVersionTagger()],
+        manifests=[RPackagesManifest()],
     ),
 }

tagging/manifests.py

@@ -1,11 +1,12 @@
 # Copyright (c) Jupyter Development Team.
 # Distributed under the terms of the Modified BSD License.
 from plumbum.cmd import docker
+from docker.models.containers import Container
 from .docker_runner import DockerRunner
 from .git_helper import GitHelper
 
 
-def quoted_output(container, cmd: str) -> str:
+def quoted_output(container: Container, cmd: str) -> str:
     return "\n".join(
         [
             "```",
@@ -50,13 +51,13 @@ class ManifestInterface:
     """Common interface for all manifests"""
 
     @staticmethod
-    def markdown_piece(container) -> str:
+    def markdown_piece(container: Container) -> str:
         raise NotImplementedError
 
 
 class CondaEnvironmentManifest(ManifestInterface):
     @staticmethod
-    def markdown_piece(container) -> str:
+    def markdown_piece(container: Container) -> str:
         return "\n".join(
             [
                 "## Python Packages",
@@ -72,7 +73,7 @@ class CondaEnvironmentManifest(ManifestInterface):
 
 class AptPackagesManifest(ManifestInterface):
     @staticmethod
-    def markdown_piece(container) -> str:
+    def markdown_piece(container: Container) -> str:
         return "\n".join(
             [
                 "## Apt Packages",
@@ -84,7 +85,7 @@ class AptPackagesManifest(ManifestInterface):
 
 class RPackagesManifest(ManifestInterface):
     @staticmethod
-    def markdown_piece(container) -> str:
+    def markdown_piece(container: Container) -> str:
         return "\n".join(
             [
                 "## R Packages",
@@ -101,7 +102,7 @@ class RPackagesManifest(ManifestInterface):
 
 class JuliaPackagesManifest(ManifestInterface):
     @staticmethod
-    def markdown_piece(container) -> str:
+    def markdown_piece(container: Container) -> str:
         return "\n".join(
             [
                 "## Julia Packages",
@@ -118,7 +119,7 @@ class JuliaPackagesManifest(ManifestInterface):
 
 class SparkInfoManifest(ManifestInterface):
     @staticmethod
-    def markdown_piece(container) -> str:
+    def markdown_piece(container: Container) -> str:
         return "\n".join(
             [
                 "## Apache Spark",

tagging/tag_image.py

@@ -28,11 +28,11 @@ def tag_image(short_image_name: str, owner: str) -> None:
     with DockerRunner(image) as container:
         tags = []
         for tagger in taggers:
-            tagger_name = tagger.__name__
+            tagger_name = tagger.__class__.__name__
             tag_value = tagger.tag_value(container)
             tags.append(tag_value)
             LOGGER.info(
-                f"Applying tag tagger_name: {tagger_name} tag_value: {tag_value}"
+                f"Applying tag, tagger_name: {tagger_name} tag_value: {tag_value}"
             )
             docker["tag", image, f"{owner}/{short_image_name}:{tag_value}"]()
 

tagging/taggers.py

@@ -1,15 +1,16 @@
 # Copyright (c) Jupyter Development Team.
 # Distributed under the terms of the Modified BSD License.
 from datetime import datetime
+from docker.models.containers import Container
 from .git_helper import GitHelper
 from .docker_runner import DockerRunner
 
 
-def _get_program_version(container, program: str) -> str:
+def _get_program_version(container: Container, program: str) -> str:
     return DockerRunner.run_simple_command(container, cmd=f"{program} --version")
 
 
-def _get_env_variable(container, variable: str) -> str:
+def _get_env_variable(container: Container, variable: str) -> str:
     env = DockerRunner.run_simple_command(
         container,
         cmd="env",
@@ -21,7 +22,7 @@ def _get_env_variable(container, variable: str) -> str:
     raise KeyError(variable)
 
 
-def _get_pip_package_version(container, package: str) -> str:
+def _get_pip_package_version(container: Container, package: str) -> str:
     VERSION_PREFIX = "Version: "
     package_info = DockerRunner.run_simple_command(
         container,
@@ -37,25 +38,25 @@ class TaggerInterface:
     """Common interface for all taggers"""
 
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         raise NotImplementedError
 
 
 class SHATagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return GitHelper.commit_hash_tag()
 
 
 class DateTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return datetime.utcnow().strftime("%Y-%m-%d")
 
 
 class UbuntuVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         os_release = DockerRunner.run_simple_command(
             container,
             "cat /etc/os-release",
@@ -63,63 +64,64 @@ class UbuntuVersionTagger(TaggerInterface):
         for line in os_release:
             if line.startswith("VERSION_ID"):
                 return "ubuntu-" + line.split("=")[1].strip('"')
+        raise RuntimeError(f"did not find ubuntu version in: {os_release}")
 
 
 class PythonVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return "python-" + _get_program_version(container, "python").split()[1]
 
 
 class JupyterNotebookVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return "notebook-" + _get_program_version(container, "jupyter-notebook")
 
 
 class JupyterLabVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return "lab-" + _get_program_version(container, "jupyter-lab")
 
 
 class JupyterHubVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return "hub-" + _get_program_version(container, "jupyterhub")
 
 
 class RVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return "r-" + _get_program_version(container, "R").split()[2]
 
 
 class TensorflowVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return "tensorflow-" + _get_pip_package_version(container, "tensorflow")
 
 
 class JuliaVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return "julia-" + _get_program_version(container, "julia").split()[2]
 
 
 class SparkVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return "spark-" + _get_env_variable(container, "APACHE_SPARK_VERSION")
 
 
 class HadoopVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return "hadoop-" + _get_env_variable(container, "HADOOP_VERSION")
 
 
 class JavaVersionTagger(TaggerInterface):
     @staticmethod
-    def tag_value(container) -> str:
+    def tag_value(container: Container) -> str:
         return "java-" + _get_program_version(container, "java").split()[1]