Use updated pydantic models in license code

Author: ArBridgeman

exasol/toolbox/nox/_dependencies.py

@@ -4,46 +4,27 @@
 import json
 import subprocess
 import tempfile
-from dataclasses import dataclass
 from inspect import cleandoc
 from json import loads
 from pathlib import Path
 
 import nox
-import tomlkit
 from nox import Session
 
+from exasol.toolbox.util.dependencies.poetry_dependencies import (
+    Package,
+    PoetryDependencies,
+    PoetryDependency,
+    PoetryToml,
+)
 
-@dataclass(frozen=True)
-class Package:
-    name: str
+
+class PackageLicense(Package):
     package_link: str
-    version: str
     license: str
     license_link: str
 
 
-def _dependencies(toml_str: str) -> dict[str, list]:
-    toml = tomlkit.loads(toml_str)
-    poetry = toml.get("tool", {}).get("poetry", {})
-    dependencies: dict[str, list] = {}
-
-    packages = poetry.get("dependencies", {})
-    if packages:
-        dependencies["project"] = []
-    for package in packages:
-        dependencies["project"].append(package)
-
-    groups = poetry.get("group", {})
-    for group in groups:
-        packages = groups.get(group, {}).get("dependencies")
-        if packages and not dependencies.get(group, {}):
-            dependencies[group] = []
-        for package in packages:
-            dependencies[group].append(package)
-    return dependencies
-
-
 def _normalize(_license: str) -> str:
     def is_multi_license(l):
         return ";" in l
@@ -98,7 +79,7 @@ def select_most_restrictive(licenses: list) -> str:
     return mapping[_license]
 
 
-def _packages_from_json(json: str) -> list[Package]:
+def _packages_from_json(json: str) -> list[PackageLicense]:
     packages = loads(json)
     packages_list = []
     mapping = {
@@ -114,7 +95,7 @@ def _packages_from_json(json: str) -> list[Package]:
     for package in packages:
         package_license = _normalize(package["License"])
         packages_list.append(
-            Package(
+            PackageLicense(
                 name=package["Name"],
                 package_link="" if package["URL"] == "UNKNOWN" else package["URL"],
                 version=package["Version"],
@@ -127,7 +108,7 @@ def _packages_from_json(json: str) -> list[Package]:
     return packages_list
 
 
-def _licenses() -> list[Package]:
+def _licenses() -> list[PackageLicense]:
     with tempfile.NamedTemporaryFile() as file:
         subprocess.run(
             [
@@ -146,31 +127,31 @@ def _licenses() -> list[Package]:
 
 
 def _packages_to_markdown(
-    dependencies: dict[str, list], packages: list[Package]
+    dependencies: dict[str, list], packages: list[PackageLicense]
 ) -> str:
     def heading():
         text = "# Dependencies\n"
         return text
 
-    def dependency(group: str, group_packages: list, packages: list[Package]) -> str:
+    def dependency(
+        group: str,
+        group_packages: list[PoetryDependency],
+        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|Licence|\n"
             text += "|---|---|---|\n"
             return text
 
-        def _rows(_group_packages: list, _packages: list[Package]) -> str:
-            def _normalize_package_name(name: str) -> str:
-                _name = name.lower()
-                while "_" in _name:
-                    _name = _name.replace("_", "-")
-                return _name
-
+        def _rows(
+            _group_packages: list[PoetryDependency], _packages: list[PackageLicense]
+        ) -> str:
             text = ""
             for package in _group_packages:
                 consistent = filter(
-                    lambda elem: (_normalize_package_name(elem.name) == package),
+                    lambda elem: elem.normalized_name == package.normalized_name,
                     _packages,
                 )
                 for content in consistent:
@@ -276,8 +257,11 @@ def run(self, session: Session) -> None:
 @nox.session(name="dependency:licenses", python=False)
 def dependency_licenses(session: Session) -> None:
     """returns the packages and their licenses"""
-    toml = Path("pyproject.toml")
-    dependencies = _dependencies(toml.read_text())
+    working_directory = Path()
+    groups = PoetryToml(working_directory=working_directory).groups
+    dependencies = PoetryDependencies(
+        groups=groups, working_directory=working_directory
+    ).direct_dependencies
     package_infos = _licenses()
     print(_packages_to_markdown(dependencies=dependencies, packages=package_infos))
 

test/unit/dependencies_test.py

@@ -1,29 +1,22 @@
 import json
+from inspect import cleandoc
 
 import pytest
+from toolbox.util.dependencies.poetry_dependencies import (
+    PoetryDependency,
+    PoetryGroup,
+)
 
 from exasol.toolbox.nox._dependencies import (
     Audit,
-    Package,
-    _dependencies,
+    PackageLicense,
     _normalize,
     _packages_from_json,
     _packages_to_markdown,
 )
 
-
-def test_dependencies():
-    toml = """
-        [tool.poetry.dependencies]
-        pytest = ">=7.2.2,<9"
-        python = "^3.9"
-        
-        [tool.poetry.group.dev.dependencies]
-        autoimport = "^1.4.0"
-    """
-
-    actual = _dependencies(toml)
-    assert actual == {"project": ["pytest", "python"], "dev": ["autoimport"]}
+MAIN_GROUP = PoetryGroup(name="main", toml_section="project.dependencies")
+DEV_GROUP = PoetryGroup(name="dev", toml_section="tool.poetry.group.dev.dependencies")
 
 
 @pytest.mark.parametrize(
@@ -56,30 +49,30 @@ def test_normalize(licenses, expected):
     [
         (
             """
-[
-    {
-        "License": "license1",
-        "Name": "name1",
-        "URL": "link1",
-        "Version": "version1"
-    },
-    {
-        "License": "license2",
-        "Name": "name2",
-        "URL": "UNKNOWN",
-        "Version": "version2"
-    }
-]
-            """,
+        [
+            {
+                "License": "license1",
+                "Name": "name1",
+                "URL": "link1",
+                "Version": "version1"
+            },
+            {
+                "License": "license2",
+                "Name": "name2",
+                "URL": "UNKNOWN",
+                "Version": "version2"
+            }
+        ]
+                    """,
             [
-                Package(
+                PackageLicense(
                     name="name1",
                     version="version1",
                     package_link="link1",
                     license="license1",
                     license_link="",
                 ),
-                Package(
+                PackageLicense(
                     name="name2",
                     version="version2",
                     package_link="",
@@ -96,35 +89,56 @@ def test_packages_from_json(json, expected):
 
 
 @pytest.mark.parametrize(
-    "dependencies,packages,expected",
+    "dependencies,packages",
     [
         (
-            {"project": ["package1", "package3"], "dev": ["package2"]},
+            {
+                MAIN_GROUP.name: [
+                    PoetryDependency(
+                        name="package1", version="version1", group=MAIN_GROUP
+                    ),
+                    PoetryDependency(
+                        name="package3", version="version3", group=MAIN_GROUP
+                    ),
+                ],
+                DEV_GROUP.name: [
+                    PoetryDependency(
+                        name="package2", version="version2", group=DEV_GROUP
+                    )
+                ],
+            },
             [
-                Package(
+                PackageLicense(
                     name="package1",
                     package_link="package_link1",
                     version="version1",
                     license="license1",
                     license_link="license_link1",
                 ),
-                Package(
+                PackageLicense(
                     name="package2",
                     package_link="package_link2",
                     version="version2",
                     license="license2",
                     license_link="license_link2",
                 ),
-                Package(
+                PackageLicense(
                     name="package3",
                     package_link="package_link3",
                     version="version3",
                     license="license3",
                     license_link="",
                 ),
             ],
-            """# Dependencies
-## Project Dependencies
+        )
+    ],
+)
+def test_packages_to_markdown(dependencies, packages):
+    actual = _packages_to_markdown(dependencies, packages)
+    assert (
+        actual
+        == """# Dependencies
+## Main Dependencies
 |Package|version|Licence|
 |---|---|---|
 |[package1](package_link1)|version1|[license1](license_link1)|
@@ -135,13 +149,8 @@ def test_packages_from_json(json, expected):
 |---|---|---|
 |[package2](package_link2)|version2|[license2](license_link2)|
 
-""",
-        )
-    ],
-)
-def test_packages_to_markdown(dependencies, packages, expected):
-    actual = _packages_to_markdown(dependencies, packages)
-    assert actual == expected
+"""
+    )
 
 
 class TestFilterJsonForVulnerabilities: