refactor: convert more camelCase to snake_case

Author: abraemer

src/opossum_lib/scancode/convert_scancode_to_opossum.py

@@ -12,7 +12,7 @@
     Metadata,
     OpossumInformation,
 )
-from opossum_lib.scancode.model import ScanCodeData
+from opossum_lib.scancode.model import Header, ScanCodeData
 from opossum_lib.scancode.resource_tree import (
     convert_to_opossum_resources,
     create_attribution_mapping,
@@ -24,17 +24,25 @@ def convert_scancode_to_opossum(filename: str) -> OpossumInformation:
     logging.info(f"Converting scancode to opossum {filename}")
 
     scancode_data = load_scancode_json(filename)
-    validate_scancode_json(scancode_data, filename)
 
     filetree = scancode_to_file_tree(scancode_data)
     resources = convert_to_opossum_resources(filetree)
-    externalAttributions, resourcesToAttributions = create_attribution_mapping(filetree)
+    external_attributions, resources_to_attributions = create_attribution_mapping(
+        filetree
+    )
+
+    scancode_header = extract_scancode_header(scancode_data, filename)
+    metadata = {
+        "projectId": str(uuid.uuid4()),
+        "fileCreationDate": scancode_header.end_timestamp,
+        "projectTitle": "ScanCode file",
+    }
 
     return OpossumInformation(
-        metadata=create_opossum_metadata(scancode_data),
+        metadata=Metadata(**metadata),
         resources=resources,
-        externalAttributions=externalAttributions,
-        resourcesToAttributions=resourcesToAttributions,
+        externalAttributions=external_attributions,
+        resourcesToAttributions=resources_to_attributions,
         attributionBreakpoints=[],
         externalAttributionSources={},
     )
@@ -56,19 +64,8 @@ def load_scancode_json(filename: str) -> ScanCodeData:
     return scancode_data
 
 
-def validate_scancode_json(scancode_data: ScanCodeData, filename: str) -> None:
+def extract_scancode_header(scancode_data: ScanCodeData, filename: str) -> Header:
     if len(scancode_data.headers) != 1:
         logging.error(f"Headers of ScanCode file are invalid. File: {filename}")
         sys.exit(1)
-
-
-def create_opossum_metadata(scancode_data: ScanCodeData) -> Metadata:
-    scancode_header = scancode_data.headers[0]
-
-    metadata = {
-        "projectId": str(uuid.uuid4()),
-        "fileCreationDate": scancode_header.end_timestamp,
-        "projectTitle": "ScanCode file",
-    }
-
-    return Metadata.model_validate(metadata)
+    return scancode_data.headers[0]

src/opossum_lib/scancode/resource_tree.py

@@ -51,37 +51,37 @@ def scancode_to_file_tree(scancode_data: ScanCodeData) -> ScanCodeFileTree:
     return root
 
 
-def convert_to_opossum_resources(rootnode: ScanCodeFileTree) -> ResourceInFile:
+def convert_to_opossum_resources(root_node: ScanCodeFileTree) -> ResourceInFile:
     def process_node(node: ScanCodeFileTree) -> ResourceInFile:
         if node.file.type == FileType.FILE:
             return 1
         else:
-            rootpath = node.file.path
+            root_path = node.file.path
             children = {
-                relpath(n.file.path, rootpath): process_node(n)
+                relpath(n.file.path, root_path): process_node(n)
                 for n in node.children.values()
             }
             return children
 
-    return {rootnode.file.path: process_node(rootnode)}
+    return {root_node.file.path: process_node(root_node)}
 
 
 def get_attribution_info(file: File) -> list[OpossumPackage]:
     if file.type == FileType.DIRECTORY:
         return []
-    copyright = "\n".join([c.copyright for c in file.copyrights])
+    copyright = "\n".join(c.copyright for c in file.copyrights)
     source_info = SourceInfo(SCANCODE_SOURCE_NAME)
 
     attribution_infos = []
     for license_detection in file.license_detections:
-        licenseName = license_detection.license_expression_spdx
-        maxscore = max([m.score for m in license_detection.matches])
-        attributionConfidence = int(maxscore)
+        license_name = license_detection.license_expression_spdx
+        max_score = max(m.score for m in license_detection.matches)
+        attribution_confidence = int(max_score)
 
         package = OpossumPackage(
             source_info,
-            licenseName=licenseName,
-            attributionConfidence=attributionConfidence,
+            licenseName=license_name,
+            attributionConfidence=attribution_confidence,
             copyright=copyright,
         )
         attribution_infos.append(package)
@@ -94,29 +94,29 @@ def get_attribution_key(attribution: OpossumPackage) -> OpossumPackageIdentifier
 
 
 def create_attribution_mapping(
-    rootnode: ScanCodeFileTree,
+    root_node: ScanCodeFileTree,
 ) -> tuple[
     dict[OpossumPackageIdentifier, OpossumPackage],
     dict[ResourcePath, list[OpossumPackageIdentifier]],
 ]:
-    externalAttributions: dict[OpossumPackageIdentifier, OpossumPackage] = {}
-    resourcesToAttributions: dict[ResourcePath, list[OpossumPackageIdentifier]] = {}
+    external_attributions: dict[OpossumPackageIdentifier, OpossumPackage] = {}
+    resources_to_attributions: dict[ResourcePath, list[OpossumPackageIdentifier]] = {}
 
     def process_node(node: ScanCodeFileTree) -> None:
         # the / is required by OpossumUI
         path = "/" + node.file.path
         attributions = get_attribution_info(node.file)
 
         new_attributions_with_id = {get_attribution_key(a): a for a in attributions}
-        externalAttributions.update(new_attributions_with_id)
+        external_attributions.update(new_attributions_with_id)
 
         if len(new_attributions_with_id) > 0:
-            resourcesToAttributions[path] = list(new_attributions_with_id.keys())
+            resources_to_attributions[path] = list(new_attributions_with_id.keys())
 
         for child in node.children.values():
             process_node(child)
 
-    for child in rootnode.children.values():
+    for child in root_node.children.values():
         process_node(child)
 
-    return externalAttributions, resourcesToAttributions
+    return external_attributions, resources_to_attributions

tests/test_scancode/test_convert_scancode_to_opossum.py

@@ -4,51 +4,40 @@
 
 import json
 from pathlib import Path
-from unittest import mock
 
 import pytest
 from _pytest.logging import LogCaptureFixture
 
-from opossum_lib.opossum.opossum_file import Metadata
 from opossum_lib.scancode.convert_scancode_to_opossum import (
-    create_opossum_metadata,
-    validate_scancode_json,
+    extract_scancode_header,
 )
 from opossum_lib.scancode.model import ScanCodeData
 
 TEST_SCANCODE_FILE = str(Path(__file__).parent.parent / "data/scancode_input.json")
 
 
-def test_create_opossum_metadata() -> None:
+def test_extract_scancode_header() -> None:
     scancode_data = _create_valid_scancode_data()
-    with mock.patch("uuid.uuid4", return_value="1234-12345-12345"):
-        metadata = create_opossum_metadata(scancode_data)
+    extracted_header = extract_scancode_header(scancode_data, "test/path/scancode.json")
+    assert extracted_header == scancode_data.headers[0]
 
-    expected_metadata = Metadata(
-        projectId="1234-12345-12345",
-        fileCreationDate="2025-01-10T102700.397143",
-        projectTitle="ScanCode file",
-    )
 
-    assert metadata == expected_metadata
-
-
-def test_load_scancode_json_missing_header(caplog: LogCaptureFixture) -> None:
+def test_extract_scancode_header_missing_header(caplog: LogCaptureFixture) -> None:
     scancode_data = _create_valid_scancode_data()
     scancode_data.headers = []
 
     with pytest.raises(SystemExit):
-        validate_scancode_json(scancode_data, "test/path/scancode.json")
+        extract_scancode_header(scancode_data, "test/path/scancode.json")
 
     assert "header" in caplog.messages[0].lower()
 
 
-def test_validate_scancode_json_multiple_headers(caplog: LogCaptureFixture) -> None:
+def test_extract_scancode_header_multiple_headers(caplog: LogCaptureFixture) -> None:
     scancode_data = _create_valid_scancode_data()
     scancode_data.headers.append(scancode_data.headers[0])
 
     with pytest.raises(SystemExit):
-        validate_scancode_json(scancode_data, "test/path/scancode.json")
+        extract_scancode_header(scancode_data, "test/path/scancode.json")
 
     assert "header" in caplog.messages[0].lower()
 

tests/test_scancode/test_resource_tree.py

@@ -110,10 +110,10 @@ def test_create_attribution_mapping_paths_have_root_prefix(_: Any) -> None:
     rootnode = _create_reference_Node_structure()
     # rootnode.children["file1"].file.license_detections = [ld1]
     # rootnode.children["B"].children["file3"].file.license_detections = [ld2]
-    _, resourcesToAttributions = create_attribution_mapping(rootnode)
-    assert "/A/file1" in resourcesToAttributions
-    assert "/A/file2.txt" in resourcesToAttributions
-    assert "/A/B/file3" in resourcesToAttributions
+    _, resources_to_attributions = create_attribution_mapping(rootnode)
+    assert "/A/file1" in resources_to_attributions
+    assert "/A/file2.txt" in resources_to_attributions
+    assert "/A/B/file3" in resources_to_attributions
 
 
 def test_create_attribution_mapping() -> None:
@@ -132,22 +132,22 @@ def get_attribution_info_mock(file: File) -> list[OpossumPackage]:
         else:
             return []
 
-    rootnode = _create_reference_Node_structure()
+    root_node = _create_reference_Node_structure()
 
     with mock.patch(
         "opossum_lib.scancode.resource_tree.get_attribution_info",
         new=get_attribution_info_mock,
     ):
-        externalAttributions, resourcesToAttributions = create_attribution_mapping(
-            rootnode
+        external_attributions, resources_to_attributions = create_attribution_mapping(
+            root_node
         )
-    assert len(externalAttributions) == 3  # deduplication worked
+    assert len(external_attributions) == 3  # deduplication worked
 
-    reverseMapping = {v: k for (k, v) in externalAttributions.items()}
-    id1, id2, id3 = reverseMapping[pkg1], reverseMapping[pkg2], reverseMapping[pkg3]
-    assert len(resourcesToAttributions) == 2  # only files with attributions
-    assert set(resourcesToAttributions["/" + file1.path]) == {id1, id2}
-    assert set(resourcesToAttributions["/" + file2.path]) == {id1, id2, id3}
+    reverse_mapping = {v: k for (k, v) in external_attributions.items()}
+    id1, id2, id3 = reverse_mapping[pkg1], reverse_mapping[pkg2], reverse_mapping[pkg3]
+    assert len(resources_to_attributions) == 2  # only files with attributions
+    assert set(resources_to_attributions["/" + file1.path]) == {id1, id2}
+    assert set(resources_to_attributions["/" + file2.path]) == {id1, id2, id3}
 
 
 def test_get_attribution_info_directory() -> None:
@@ -257,7 +257,7 @@ def _create_reference_Node_structure() -> ScanCodeFileTree:
 
 
 def _create_file(path: str, type: FileType, **kwargs: Any) -> File:
-    defaultproperties = {
+    default_properties = {
         "path": path,
         "type": type,
         "name": Path(path).name,
@@ -295,4 +295,4 @@ def _create_file(path: str, type: FileType, **kwargs: Any) -> File:
         "scan_errors": [],
         **kwargs,
     }
-    return File.model_validate(defaultproperties)
+    return File.model_validate(default_properties)