feat: ruff

Introduces Ruff for formatting and linting and removes flake8, isort, and black.
Fixes the resulting linter errors.

Signed-off-by: Maxim Stykow <maxim.stykow@tngtech.com>

Author: mstykow

.flake8

@@ -35,14 +35,11 @@ jobs:
       - name: Install the project
         run: uv sync --locked
 
-      - name: Run isort
-        run: uv run isort src/ tests/ --check
+      - name: Run Ruff linter
+        run: uv run ruff check
 
-      - name: Run black
-        run: uv run black src/ tests/ --check
-
-      - name: Run flake8
-        run: uv run flake8 src/ tests/
+      - name: Run Ruff formatter
+        run: uv run ruff format --check
 
       - name: Run mypy
         run: uv run python -m mypy src/ tests/

.github/workflows/lint_and_run_tests.yml

@@ -8,6 +8,7 @@ __pycache__/
 .vscode/*
 
 .mypy_cache/
+.ruff_cache
 
 .venv/
 dist/

.gitignore

@@ -2,19 +2,11 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 repos:
-  - repo: https://github.com/pycqa/isort
-    rev: 5.12.0
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.6
     hooks:
-      - id: isort
-        name: isort (python)
-  - repo: https://github.com/psf/black
-    rev: 23.1.0
-    hooks:
-    -   id: black
-  - repo: https://github.com/pycqa/flake8
-    rev: 6.0.0
-    hooks:
-      - id: flake8
+      - id: ruff
+      - id: ruff-format
   - repo: https://github.com/pre-commit/mirrors-mypy
     rev: v1.4.1
     hooks:

.pre-commit-config.yaml

@@ -53,14 +53,8 @@ Options:
 To test your changes, run
 
 ```bash
-uv run pytest
+uv run ruff check
+uv run ruff format --check
 uv run python -m mypy src/ tests/
-```
-
-The package uses pre-commit hooks to check the code style of your changes.
-It also provides a script `(./scripts/linter_and_formatting.sh)` to make your changes compliant with the expected
-code style. To use this script under linux run
-
-```bash
-./scripts/linter_and_formatting.sh  # in the root of the repo
+uv run pytest
 ```

README.md

@@ -23,11 +23,9 @@ spdx2opossum = "opossum_lib.cli:spdx2opossum"
 [dependency-groups]
 test = ["pytest>=8.3.4,<9"]
 dev = [
-    "black>=24.8.0,<25",
-    "isort>=5.13.2,<6",
-    "flake8>=7.1.1,<8",
     "mypy>=1.14.1,<2",
     "pre-commit>=4.0.1,<5",
+    "ruff>=0.8.6",
 ]
 
 [tool.uv]
@@ -37,9 +35,6 @@ default-groups = [
 ]
 package = true
 
-[tool.isort]
-profile = "black"
-
 [tool.mypy]
 warn_return_any = true
 warn_unused_configs = true
@@ -54,3 +49,27 @@ ignore_missing_imports = true
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    # pycodestyle
+    "E",
+    # Pyflakes
+    "F",
+    # pyupgrade
+    "UP",
+    # flake8-bugbear
+    "B",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+]
+extend-select = ["E501"]
+
+[tool.ruff.format]
+quote-style = "double"
+docstring-code-format = true

pyproject.toml

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 from io import StringIO
-from typing import Optional
 
 from spdx_tools.spdx.model.document import CreationInfo
 from spdx_tools.spdx.model.file import File
@@ -22,7 +21,7 @@
 from opossum_lib.opossum_file import OpossumPackage, SourceInfo
 
 
-def _get_purl(package: Package) -> Optional[str]:
+def _get_purl(package: Package) -> str | None:
     for external_reference in package.external_references:
         if external_reference.reference_type == PURL:
             return external_reference.locator

scripts/linter_and_formatting.sh

@@ -5,7 +5,6 @@
 import uuid
 from dataclasses import fields
 from pathlib import Path
-from typing import Dict, List, Tuple, Union
 from zipfile import ZIP_DEFLATED, ZipFile
 
 from networkx import DiGraph, shortest_path
@@ -55,33 +54,29 @@ def write_dict_to_file(
 
 
 def to_dict(
-    element: Union[
-        Resource,
-        Metadata,
-        OpossumPackage,
-        OpossumInformation,
-        SourceInfo,
-        ExternalAttributionSource,
-        str,
-        int,
-        bool,
-        Dict[str, OpossumPackage],
-        Dict[str, List[str]],
-        List[str],
-        None,
-    ]
-) -> Union[Dict, str, List[str], bool, int, None]:
+    element: Resource
+    | Metadata
+    | OpossumPackage
+    | OpossumInformation
+    | SourceInfo
+    | ExternalAttributionSource
+    | str
+    | int
+    | bool
+    | dict[str, OpossumPackage]
+    | dict[str, list[str]]
+    | list[str]
+    | None,
+) -> dict | str | list[str] | bool | int | None:
     if isinstance(element, Resource):
         return element.to_dict()
     if isinstance(
         element,
-        (
-            Metadata,
-            OpossumPackage,
-            OpossumInformation,
-            SourceInfo,
-            ExternalAttributionSource,
-        ),
+        Metadata
+        | OpossumPackage
+        | OpossumInformation
+        | SourceInfo
+        | ExternalAttributionSource,
     ):
         result = []
         for f in fields(element):
@@ -97,8 +92,8 @@ def to_dict(
 def generate_json_file_from_tree(tree: DiGraph) -> OpossumInformation:
     metadata = create_metadata(tree)
     resources = Resource(type=ResourceType.TOP_LEVEL)
-    resources_to_attributions: Dict[str, List[str]] = dict()
-    external_attributions: Dict[str, OpossumPackage] = dict()
+    resources_to_attributions: dict[str, list[str]] = dict()
+    external_attributions: dict[str, OpossumPackage] = dict()
     attribution_breakpoints = []
     external_attribution_sources = {
         SPDX_FILE_IDENTIFIER: ExternalAttributionSource(SPDX_FILE_IDENTIFIER, 500),
@@ -117,8 +112,8 @@ def generate_json_file_from_tree(tree: DiGraph) -> OpossumInformation:
                 "A tree should always have a node without incoming edge."
             )
         for node in connected_subgraph.nodes():
-            path: List[str] = shortest_path(connected_subgraph, source, node)
-            path_with_labels: List[Tuple[str, ResourceType]] = (
+            path: list[str] = shortest_path(connected_subgraph, source, node)
+            path_with_labels: list[tuple[str, ResourceType]] = (
                 _replace_node_ids_with_labels_and_add_resource_type(
                     path, connected_subgraph
                 )
@@ -149,8 +144,8 @@ def generate_json_file_from_tree(tree: DiGraph) -> OpossumInformation:
 
 
 def create_attribution_and_link_with_resource(
-    external_attributions: Dict[OpossumPackageIdentifier, OpossumPackage],
-    resources_to_attributions: Dict[OpossumPackageIdentifier, List[str]],
+    external_attributions: dict[OpossumPackageIdentifier, OpossumPackage],
+    resources_to_attributions: dict[OpossumPackageIdentifier, list[str]],
     file_path: str,
     node: str,
     tree: DiGraph,

src/opossum.lib.py.egg-info/PKG-INFO

@@ -1,7 +1,6 @@
 # SPDX-FileCopyrightText: 2023 TNG Technology Consulting GmbH <https://www.tngtech.com>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Optional, Union
 
 from networkx import DiGraph, set_node_attributes
 from spdx_tools.spdx.graph_generation import generate_relationship_graph_from_spdx
@@ -21,9 +20,9 @@ def generate_graph_from_spdx(document: Document) -> DiGraph:
 
 def _create_label_for_node(graph: DiGraph, node: str) -> str:
     if _node_represents_a_spdx_element(graph, node):
-        element_node: Optional[Union[CreationInfo, File, Package, Snippet]] = (
-            graph.nodes[node]["element"]
-        )
+        element_node: CreationInfo | File | Package | Snippet | None = graph.nodes[
+            node
+        ]["element"]
         if element_node:
             return element_node.name or element_node.spdx_id
         else:

src/opossum.lib.py.egg-info/SOURCES.txt

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2023 TNG Technology Consulting GmbH <https://www.tngtech.com>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 from networkx import DiGraph, weakly_connected_components
 from spdx_tools.spdx.constants import DOCUMENT_SPDX_ID
@@ -10,15 +10,15 @@
 from opossum_lib.opossum_file import ResourceType
 
 
-def _get_source_for_graph_traversal(connected_subgraph: DiGraph) -> Optional[str]:
+def _get_source_for_graph_traversal(connected_subgraph: DiGraph) -> str | None:
     return (
         DOCUMENT_SPDX_ID
         if DOCUMENT_SPDX_ID in connected_subgraph.nodes
         else _get_node_without_incoming_edge(connected_subgraph)
     )
 
 
-def _get_node_without_incoming_edge(graph: DiGraph) -> Optional[str]:
+def _get_node_without_incoming_edge(graph: DiGraph) -> str | None:
     for node, degree in graph.in_degree():
         if degree == 0 and _node_represents_a_spdx_element(graph, node):
             return str(node)
@@ -31,7 +31,7 @@ def _node_represents_a_spdx_element(graph: DiGraph, node: str) -> bool:
     return "element" in graph.nodes[node]
 
 
-def _weakly_connected_component_sub_graphs(graph: DiGraph) -> List[DiGraph]:
+def _weakly_connected_component_sub_graphs(graph: DiGraph) -> list[DiGraph]:
     connected_sub_graphs = []
     for connected_set in weakly_connected_components(
         graph
@@ -41,7 +41,7 @@ def _weakly_connected_component_sub_graphs(graph: DiGraph) -> List[DiGraph]:
     return connected_sub_graphs
 
 
-def _create_file_path_from_graph_path(path: List[str], graph: DiGraph) -> str:
+def _create_file_path_from_graph_path(path: list[str], graph: DiGraph) -> str:
     base_path = "/" + "/".join(
         [_replace_prefix(graph.nodes[node]["label"]) for node in path]
     )
@@ -51,8 +51,8 @@ def _create_file_path_from_graph_path(path: List[str], graph: DiGraph) -> str:
 
 
 def _replace_node_ids_with_labels_and_add_resource_type(
-    path: List[str], graph: DiGraph
-) -> List[Tuple[str, ResourceType]]:
+    path: list[str], graph: DiGraph
+) -> list[tuple[str, ResourceType]]:
     resulting_path = []
     path_with_label_and_resource_type = [
         (
@@ -85,11 +85,11 @@ def _replace_prefix(label: str) -> str:
     return label
 
 
-def _get_resource_type(node_attributes: Dict[str, Any]) -> ResourceType:
-    element = node_attributes.get("element", None)
+def _get_resource_type(node_attributes: dict[str, Any]) -> ResourceType:
+    element = node_attributes.get("element")
     if isinstance(element, Package):
         return ResourceType.FOLDER
-    elif isinstance(element, (Snippet, File)):
+    elif isinstance(element, Snippet | File):
         return ResourceType.FILE
     else:
         return ResourceType.OTHER

src/opossum.lib.py.egg-info/dependency_links.txt

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2023 TNG Technology Consulting GmbH <https://www.tngtech.com>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any, Dict, List
+from typing import Any
 
 from opossum_lib.opossum_file import (
     OpossumInformation,
@@ -13,7 +13,7 @@
 
 
 def merge_opossum_information(
-    elements_to_merge: List[OpossumInformation],
+    elements_to_merge: list[OpossumInformation],
 ) -> OpossumInformation:
     expanded_opossum_information = [
         expand_opossum_package_identifier(opossum_information)
@@ -86,7 +86,7 @@ def expand_opossum_package_identifier(
     )
 
 
-def _merge_resources(resources: List[Resource]) -> Resource:
+def _merge_resources(resources: list[Resource]) -> Resource:
     merged_resource = Resource(ResourceType.TOP_LEVEL)
     for resource in resources:
         for path in resource.get_paths_of_all_leaf_nodes_with_types():
@@ -95,10 +95,10 @@ def _merge_resources(resources: List[Resource]) -> Resource:
 
 
 def _merge_resources_to_attributions(
-    resources_to_attributions: List[Dict[ResourcePath, List[OpossumPackageIdentifier]]]
-) -> Dict[ResourcePath, List[OpossumPackageIdentifier]]:
-    merged_resources_to_attributions: Dict[
-        ResourcePath, List[OpossumPackageIdentifier]
+    resources_to_attributions: list[dict[ResourcePath, list[OpossumPackageIdentifier]]],
+) -> dict[ResourcePath, list[OpossumPackageIdentifier]]:
+    merged_resources_to_attributions: dict[
+        ResourcePath, list[OpossumPackageIdentifier]
     ] = dict()
     for resource_to_attribution in resources_to_attributions:
         for resource_path, identifiers in resource_to_attribution.items():
@@ -112,8 +112,8 @@ def _merge_resources_to_attributions(
 
 
 def _merge_attribution_breakpoints(
-    attribution_breakpoints_to_merge: List[List[str]],
-) -> List[str]:
+    attribution_breakpoints_to_merge: list[list[str]],
+) -> list[str]:
     merged_attribution_breakpoints = []
     for attribution_breakpoints in attribution_breakpoints_to_merge:
         merged_attribution_breakpoints.extend(
@@ -126,8 +126,8 @@ def _merge_attribution_breakpoints(
     return merged_attribution_breakpoints
 
 
-def _merge_dicts_without_duplicates(dicts: List[Dict[str, Any]]) -> Dict[str, Any]:
-    merged_dict: Dict[str, Any] = dict()
+def _merge_dicts_without_duplicates(dicts: list[dict[str, Any]]) -> dict[str, Any]:
+    merged_dict: dict[str, Any] = dict()
     for single_dict in dicts:
         for key, value in single_dict.items():
             if key in merged_dict and merged_dict.get(key) != value:

src/opossum.lib.py.egg-info/entry_points.txt

@@ -6,7 +6,7 @@
 from copy import deepcopy
 from dataclasses import dataclass, field
 from enum import Enum, auto
-from typing import Dict, List, Literal, Optional, Tuple, Union
+from typing import Literal
 
 OpossumPackageIdentifier = str
 ResourcePath = str
@@ -16,50 +16,50 @@
 class OpossumInformation:
     metadata: Metadata
     resources: Resource
-    externalAttributions: Dict[OpossumPackageIdentifier, OpossumPackage]
-    resourcesToAttributions: Dict[ResourcePath, List[OpossumPackageIdentifier]]
-    attributionBreakpoints: List[str] = field(default_factory=list)
-    externalAttributionSources: Dict[str, ExternalAttributionSource] = field(
+    externalAttributions: dict[OpossumPackageIdentifier, OpossumPackage]
+    resourcesToAttributions: dict[ResourcePath, list[OpossumPackageIdentifier]]
+    attributionBreakpoints: list[str] = field(default_factory=list)
+    externalAttributionSources: dict[str, ExternalAttributionSource] = field(
         default_factory=dict
     )
 
 
 @dataclass(frozen=True)
 class SourceInfo:
     name: str
-    documentConfidence: Optional[int] = 0
+    documentConfidence: int | None = 0
 
 
 @dataclass(frozen=True)
 class OpossumPackage:
     source: SourceInfo
-    attributionConfidence: Optional[int] = None
-    comment: Optional[str] = None
-    packageName: Optional[str] = None
-    packageVersion: Optional[str] = None
-    packageNamespace: Optional[str] = None
-    packageType: Optional[str] = None
-    packagePURLAppendix: Optional[str] = None
-    copyright: Optional[str] = None
-    licenseName: Optional[str] = None
-    licenseText: Optional[str] = None
-    url: Optional[str] = None
-    firstParty: Optional[bool] = None
-    excludeFromNotice: Optional[bool] = None
-    preSelected: Optional[bool] = None
-    followUp: Optional[Literal["FOLLOW_UP"]] = None
-    originId: Optional[str] = None
-    criticality: Optional[Union[Literal["high"], Literal["medium"]]] = None
+    attributionConfidence: int | None = None
+    comment: str | None = None
+    packageName: str | None = None
+    packageVersion: str | None = None
+    packageNamespace: str | None = None
+    packageType: str | None = None
+    packagePURLAppendix: str | None = None
+    copyright: str | None = None
+    licenseName: str | None = None
+    licenseText: str | None = None
+    url: str | None = None
+    firstParty: bool | None = None
+    excludeFromNotice: bool | None = None
+    preSelected: bool | None = None
+    followUp: Literal["FOLLOW_UP"] | None = None
+    originId: str | None = None
+    criticality: Literal["high"] | Literal["medium"] | None = None
 
 
 @dataclass(frozen=True)
 class Metadata:
     projectId: str
     fileCreationDate: str
     projectTitle: str
-    projectVersion: Optional[str] = None
-    expectedReleaseDate: Optional[str] = None
-    buildDate: Optional[str] = None
+    projectVersion: str | None = None
+    expectedReleaseDate: str | None = None
+    buildDate: str | None = None
 
 
 class ResourceType(Enum):
@@ -72,10 +72,10 @@ class ResourceType(Enum):
 @dataclass(frozen=True)
 class Resource:
     type: ResourceType
-    children: Dict[str, Resource] = field(default_factory=dict)
+    children: dict[str, Resource] = field(default_factory=dict)
 
     def add_path(
-        self, path_with_resource_types: List[Tuple[str, ResourceType]]
+        self, path_with_resource_types: list[tuple[str, ResourceType]]
     ) -> Resource:
         resource = deepcopy(self)
         if len(path_with_resource_types) == 0:
@@ -103,7 +103,7 @@ def element_exists_but_resource_type_differs(
         return False
 
     def drop_element(
-        self, path_to_element_to_drop: List[Tuple[str, ResourceType]]
+        self, path_to_element_to_drop: list[tuple[str, ResourceType]]
     ) -> Resource:
         paths_in_resource = self.get_paths_of_all_leaf_nodes_with_types()
         if path_to_element_to_drop not in paths_in_resource:
@@ -121,7 +121,7 @@ def drop_element(
 
             return resource
 
-    def to_dict(self) -> Union[int, Dict]:
+    def to_dict(self) -> int | dict:
         if not self.has_children():
             if self.type == ResourceType.FOLDER:
                 return {}
@@ -134,7 +134,7 @@ def to_dict(self) -> Union[int, Dict]:
 
     def get_paths_of_all_leaf_nodes_with_types(
         self,
-    ) -> List[List[Tuple[str, ResourceType]]]:
+    ) -> list[list[tuple[str, ResourceType]]]:
         paths = []
         for name, resource in self.children.items():
             path = [(name, resource.type)]

src/opossum.lib.py.egg-info/requires.txt

@@ -1,7 +1,6 @@
 # SPDX-FileCopyrightText: 2023 TNG Technology Consulting GmbH <https://www.tngtech.com>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Dict, Optional, Tuple, Union
 
 from networkx import DiGraph, edge_bfs, is_weakly_connected
 from spdx_tools.spdx.constants import DOCUMENT_SPDX_ID
@@ -21,17 +20,14 @@ def generate_tree_from_graph(graph: DiGraph) -> DiGraph:
 
 def _generate_tree_from_graph_recursively(
     graph: DiGraph,
-    source: Optional[str] = DOCUMENT_SPDX_ID,
-    created_tree: Optional[DiGraph] = None,
+    source: str | None = DOCUMENT_SPDX_ID,
+    created_tree: DiGraph | None = None,
 ) -> DiGraph:
     if not graph.edges():
         return graph.copy()
 
     if is_weakly_connected(graph):
-        if created_tree:
-            created_tree = created_tree.copy()
-        else:
-            created_tree = DiGraph()
+        created_tree = created_tree.copy() if created_tree else DiGraph()
         edges_bfs = edge_bfs(graph, source)
 
         visited_edges = []
@@ -53,10 +49,7 @@ def _generate_tree_from_graph_recursively(
             created_tree.add_edges_from(tree_component.edges(data=True))
 
     else:  # get connected components
-        if created_tree:
-            created_tree = created_tree.copy()
-        else:
-            created_tree = DiGraph()
+        created_tree = created_tree.copy() if created_tree else DiGraph()
         for connected_subgraph in _weakly_connected_component_sub_graphs(graph):
             # if the documents node is not in the subgraph we choose
             # any elements node without incoming edge
@@ -71,14 +64,14 @@ def _generate_tree_from_graph_recursively(
 
 
 def _add_edge_and_associated_nodes_to_tree(
-    edge: Tuple[str, str], created_tree: DiGraph, graph: DiGraph
+    edge: tuple[str, str], created_tree: DiGraph, graph: DiGraph
 ) -> None:
     _add_source_node(edge, graph, created_tree)
     _add_target_node_and_edge(edge, graph, created_tree)
 
 
 def _add_target_node_and_edge(
-    edge: Tuple[str, str], graph: DiGraph, tree: DiGraph
+    edge: tuple[str, str], graph: DiGraph, tree: DiGraph
 ) -> None:
     if edge[1] not in tree:
         target_node_data = graph.nodes[edge[1]]
@@ -93,9 +86,9 @@ def _add_target_node_and_edge(
         tree.add_edge(edge[0], duplicated_node)
 
 
-def _add_source_node(edge: Tuple[str, str], graph: DiGraph, tree: DiGraph) -> None:
+def _add_source_node(edge: tuple[str, str], graph: DiGraph, tree: DiGraph) -> None:
     if edge[0] not in tree:
-        source_node_data: Dict[str, Union[CreationInfo, Package, File]] = graph.nodes[
+        source_node_data: dict[str, CreationInfo | Package | File] = graph.nodes[
             edge[0]
         ]
         tree.add_node(edge[0], **source_node_data)

src/opossum.lib.py.egg-info/top_level.txt

@@ -3,7 +3,6 @@
 # SPDX-License-Identifier: Apache-2.0
 import json
 from pathlib import Path
-from typing import Tuple
 from zipfile import ZipFile
 
 import pytest
@@ -16,7 +15,7 @@
 
 
 @pytest.mark.parametrize("options", [("--infile", "--outfile"), ("-i", "-o")])
-def test_cli_with_system_exit_code_0(tmp_path: Path, options: Tuple[str, str]) -> None:
+def test_cli_with_system_exit_code_0(tmp_path: Path, options: tuple[str, str]) -> None:
     runner = CliRunner()
 
     result = runner.invoke(
@@ -35,9 +34,11 @@ def test_cli_with_system_exit_code_0(tmp_path: Path, options: Tuple[str, str]) -
 
     assert result.exit_code == 0
 
-    with ZipFile(str(tmp_path / "output.opossum"), "r") as z:
-        with z.open("input.json") as file:
-            opossum_dict = json.load(file)
+    with (
+        ZipFile(str(tmp_path / "output.opossum"), "r") as z,
+        z.open("input.json") as file,
+    ):
+        opossum_dict = json.load(file)
     assert "metadata" in opossum_dict
     # we are using randomly generated UUIDs for the project-id, therefore
     # we need to exclude the "metadata" section from the comparison

src/opossum_lib/attribution_generation.py

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 from pathlib import Path
-from typing import List
 
 import pytest
 from networkx import get_node_attributes
@@ -30,7 +29,7 @@ def test_generate_graph_from_spdx(
     file_name: str,
     nodes_count: int,
     edges_count: int,
-    relationship_node_keys: List[str],
+    relationship_node_keys: list[str],
 ) -> None:
     document = parse_file(str(Path(__file__).resolve().parent / "data" / file_name))
     validation_messages = validate_full_spdx_document(document)

src/opossum_lib/file_generation.py

@@ -1,7 +1,6 @@
 # SPDX-FileCopyrightText: 2023 TNG Technology Consulting GmbH <https://www.tngtech.com>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Dict, List
 from unittest import mock
 
 import pytest
@@ -173,9 +172,9 @@ def test_merge_resources() -> None:
     ],
 )
 def test_merge_resources_to_attributions(
-    resources_to_attributions: List[Dict[ResourcePath, List[OpossumPackageIdentifier]]],
-    expected_resources_to_attributions: Dict[
-        ResourcePath, List[OpossumPackageIdentifier]
+    resources_to_attributions: list[dict[ResourcePath, list[OpossumPackageIdentifier]]],
+    expected_resources_to_attributions: dict[
+        ResourcePath, list[OpossumPackageIdentifier]
     ],
 ) -> None:
     merged_resources_to_attributions = _merge_resources_to_attributions(