Update licenses to work with dictionary and have shared special string type for better readability

* Switch to class for cleaner look than function in function

Author: ArBridgeman

exasol/toolbox/nox/_dependencies.py

@@ -9,8 +9,8 @@
 from nox import Session
 
 from exasol.toolbox.util.dependencies.licenses import (
-    licenses,
-    packages_to_markdown,
+    PackageLicenseReport,
+    get_licenses,
 )
 from exasol.toolbox.util.dependencies.poetry_dependencies import get_dependencies
 
@@ -85,8 +85,11 @@ def run(self, session: Session) -> None:
 def dependency_licenses(session: Session) -> None:
     """Return the packages with their licenses"""
     dependencies = get_dependencies(working_directory=Path())
-    package_infos = licenses()
-    print(packages_to_markdown(dependencies=dependencies, packages=package_infos))
+    licenses = get_licenses()
+    license_markdown = PackageLicenseReport(
+        dependencies=dependencies, licenses=licenses
+    )
+    print(license_markdown.to_markdown())
 
 
 @nox.session(name="dependency:audit", python=False)

exasol/toolbox/util/dependencies/licenses.py

@@ -2,13 +2,18 @@
 
 import subprocess
 import tempfile
+from dataclasses import dataclass
 from inspect import cleandoc
 from json import loads
 from typing import Optional
 
 from pydantic import field_validator
 
-from exasol.toolbox.util.dependencies.shared_models import Package
+from exasol.toolbox.util.dependencies.shared_models import (
+    NormalizedPackageStr,
+    Package,
+    normalize_package_name,
+)
 
 LICENSE_MAPPING_TO_ABBREVIATION = {
     "BSD License": "BSD",
@@ -88,20 +93,20 @@ def select_most_restrictive(licenses: list[str]) -> str:
     return LICENSE_MAPPING_TO_ABBREVIATION.get(_license, _license)
 
 
-def _packages_from_json(json: str) -> list[PackageLicense]:
+def _packages_from_json(json: str) -> dict[NormalizedPackageStr, PackageLicense]:
     packages = loads(json)
-    return [
-        PackageLicense(
+    return {
+        normalize_package_name(package["Name"]): PackageLicense(
             name=package["Name"],
             package_link=package["URL"],
             version=package["Version"],
             license=package["License"],
         )
         for package in packages
-    ]
+    }
 
 
-def licenses() -> list[PackageLicense]:
+def get_licenses() -> dict[NormalizedPackageStr, PackageLicense]:
     with tempfile.NamedTemporaryFile() as file:
         subprocess.run(
             [
@@ -117,62 +122,56 @@ def licenses() -> list[PackageLicense]:
         return _packages_from_json(file.read().decode())
 
 
-def packages_to_markdown(
-    dependencies: dict[str, list], packages: list[PackageLicense]
-) -> str:
-    def heading():
-        return "# Dependencies\n"
-
-    def dependency(
-        group: str,
-        group_packages: list[Package],
-        packages: list[PackageLicense],
-    ) -> str:
-        def _header(_group: str):
-            _group = "".join([word.capitalize() for word in _group.strip().split()])
-            text = f"## {_group} Dependencies\n"
-            text += "|Package|Version|License|\n"
-            text += "|---|---|---|\n"
-            return text
-
-        def _rows(
-            _group_packages: list[Package], _packages: list[PackageLicense]
-        ) -> str:
-            text = ""
-            for package in _group_packages:
-                consistent = filter(
-                    lambda elem: elem.normalized_name == package.normalized_name,
-                    _packages,
-                )
-                for content in consistent:
-                    if content.package_link:
-                        text += f"|[{content.name}]({content.package_link})"
-                    else:
-                        text += f"|{content.name}"
-                    text += f"|{content.version}"
-                    if content.license_link:
-                        text += f"|[{content.license}]({content.license_link})|\n"
-                    else:
-                        text += f"|{content.license}|\n"
-            text += "\n"
-            return text
-
-        _template = cleandoc(
-            """
-            {header}{rows}
-        """
-        )
-        return _template.format(
-            header=_header(group), rows=_rows(group_packages, packages)
-        )
-
-    template = cleandoc(
-        """
-        {heading}{rows}
-    """
-    )
-
-    rows = ""
-    for group in dependencies:
-        rows += dependency(group, dependencies[group], packages)
-    return template.format(heading=heading(), rows=rows)
+@dataclass(frozen=True)
+class PackageLicenseReport:
+    dependencies: dict[str, dict[NormalizedPackageStr, Package]]
+    licenses: dict[NormalizedPackageStr, PackageLicense]
+
+    @staticmethod
+    def _format_group_table_header(group: str):
+        _group = "".join([word.capitalize() for word in group.strip().split()])
+        text = f"## `{group}` Dependencies\n"
+        text += "|Package|Version|License|\n"
+        text += "|---|---|---|\n"
+        return text
+
+    def _format_group_table(
+        self, group: str, group_package_names: set[NormalizedPackageStr]
+    ):
+        group_header = self._format_group_table_header(group=group)
+
+        rows_text = ""
+        for package_name in group_package_names:
+            if license_info := self.licenses.get(package_name):
+                rows_text += self._format_table_row(license_info=license_info)
+
+        return f"""{group_header}{rows_text}\n"""
+
+    @staticmethod
+    def _format_table_row(license_info: PackageLicense) -> str:
+        text = ""
+        # column: package
+        if license_info.package_link:
+            text += f"|[{license_info.name}]({license_info.package_link})"
+        else:
+            text += f"|{license_info.name}"
+
+        # column: version
+        text += f"|{license_info.version}"
+
+        # column: license
+        if license_info.license_link:
+            text += f"|[{license_info.license}]({license_info.license_link})|"
+        else:
+            text += f"|{license_info.license}|"
+
+        return text + "\n"
+
+    def to_markdown(self) -> str:
+        rows = ""
+        for group in self.dependencies:
+            group_package_names = set(self.dependencies[group].keys())
+            rows += self._format_group_table(
+                group=group, group_package_names=group_package_names
+            )
+        return cleandoc(f"""# Dependencies\n\n{rows}""")

exasol/toolbox/util/dependencies/poetry_dependencies.py

@@ -12,7 +12,10 @@
 )
 from tomlkit import TOMLDocument
 
-from exasol.toolbox.util.dependencies.shared_models import Package
+from exasol.toolbox.util.dependencies.shared_models import (
+    NormalizedPackageStr,
+    Package,
+)
 from exasol.toolbox.util.git import Git
 
 
@@ -92,15 +95,17 @@ def _extract_from_line(line: str) -> Optional[Package]:
             return None
         return Package(name=split_line[0], version=split_line[1])
 
-    def _extract_from_poetry_show(self, output_text: str) -> dict[str, Package]:
+    def _extract_from_poetry_show(
+        self, output_text: str
+    ) -> dict[NormalizedPackageStr, Package]:
         return {
-            package.name: package
+            package.normalized_name: package
             for line in output_text.splitlines()
             if (package := self._extract_from_line(line))
         }
 
     @property
-    def direct_dependencies(self) -> dict[str, dict[str, Package]]:
+    def direct_dependencies(self) -> dict[str, dict[NormalizedPackageStr, Package]]:
         dependencies = {}
         for group in self.groups:
             command = (
@@ -122,7 +127,7 @@ def direct_dependencies(self) -> dict[str, dict[str, Package]]:
         return dependencies
 
     @property
-    def all_dependencies(self) -> dict[str, dict[str, Package]]:
+    def all_dependencies(self) -> dict[str, dict[NormalizedPackageStr, Package]]:
         command = ("poetry", "show", "--no-truncate")
         output = subprocess.run(
             command,
@@ -143,19 +148,23 @@ def all_dependencies(self) -> dict[str, dict[str, Package]]:
         for line in output.stdout.splitlines():
             dep = self._extract_from_line(line=line)
             if dep and dep.name not in names_direct_dependencies:
-                transitive_dependencies[dep.name] = dep
+                transitive_dependencies[dep.normalized_name] = dep
 
         return direct_dependencies | {TRANSITIVE_GROUP.name: transitive_dependencies}
 
 
-def get_dependencies(working_directory: Path) -> dict[str, list[Package]]:
+def get_dependencies(
+    working_directory: Path,
+) -> dict[str, dict[NormalizedPackageStr, Package]]:
     poetry_dep = PoetryToml.load_from_toml(working_directory=working_directory)
     return PoetryDependencies(
         groups=poetry_dep.groups, working_directory=working_directory
     ).direct_dependencies
 
 
-def get_dependencies_from_latest_tag() -> dict[str, list[Package]]:
+def get_dependencies_from_latest_tag() -> (
+    dict[str, dict[NormalizedPackageStr, Package]]
+):
     latest_tag = Git.get_latest_tag()
     with tempfile.TemporaryDirectory() as path:
         tmpdir = Path(path)

exasol/toolbox/util/dependencies/shared_models.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
-from typing import Annotated
+from typing import (
+    Annotated,
+    NewType,
+)
 
 from packaging.version import Version
 from pydantic import (
@@ -9,15 +12,21 @@
     ConfigDict,
 )
 
+NormalizedPackageStr = NewType("NormalizedPackageStr", str)
+
 VERSION_TYPE = Annotated[str, AfterValidator(lambda v: Version(v))]
 
 
+def normalize_package_name(package_name: str) -> NormalizedPackageStr:
+    return NormalizedPackageStr(package_name.lower().replace("_", "-"))
+
+
 class Package(BaseModel):
     model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)
 
     name: str
     version: VERSION_TYPE
 
     @property
-    def normalized_name(self) -> str:
-        return self.name.lower().replace("_", "-")
+    def normalized_name(self) -> NormalizedPackageStr:
+        return normalize_package_name(self.name)