wip

Author: spoorcc

dfetch/commands/report.py

@@ -6,7 +6,7 @@
 import argparse
 import glob
 import os
-from typing import List, Tuple
+from typing import List
 
 import dfetch.commands.command
 import dfetch.manifest.manifest
@@ -16,7 +16,7 @@
 from dfetch.project.metadata import Metadata
 from dfetch.project.vcs import VCS
 from dfetch.reporting import REPORTERS, ReportTypes
-from dfetch.util.license import guess_license_in_file
+from dfetch.util.license import License, guess_license_in_file
 
 logger = get_logger(__name__)
 
@@ -71,14 +71,14 @@ def __call__(self, args: argparse.Namespace) -> None:
                 determined_licenses = self._determine_licenses(project)
                 version = self._determine_version(project)
                 reporter.add_project(
-                    project=project, license_names=determined_licenses, version=version
+                    project=project, licenses=determined_licenses, version=version
                 )
 
             if reporter.dump_to_file(args.outfile):
                 logger.info(f"Generated {reporter.name} report: {args.outfile}")
 
     @staticmethod
-    def _determine_licenses(project: ProjectEntry) -> List[Tuple[str, float]]:
+    def _determine_licenses(project: ProjectEntry) -> List[License]:
         """Try to determine license of fetched project."""
         if not os.path.exists(project.destination):
             logger.print_warning_line(
@@ -91,10 +91,13 @@ def _determine_licenses(project: ProjectEntry) -> List[Tuple[str, float]]:
 
             for license_file in filter(VCS.is_license_file, glob.glob("*")):
                 logger.debug(f"Found license file {license_file} for {project.name}")
-                guessed_license, probability = guess_license_in_file(license_file)
+                guessed_license = guess_license_in_file(license_file)
 
-                if guessed_license:
-                    license_files.append((str(guessed_license.name), probability))
+                if (
+                    guessed_license
+                    and guessed_license.probability > LICENSE_PROBABILITY_THRESHOLD
+                ):
+                    license_files.append(guessed_license)
                 else:
                     logger.print_warning_line(
                         project.name, f"Could not determine license in {license_file}"

dfetch/reporting/reporter.py

@@ -1,9 +1,10 @@
 """Abstract reporting interface."""
 
 from abc import ABC, abstractmethod
-from typing import List, Tuple
+from typing import List
 
 from dfetch.manifest.project import ProjectEntry
+from dfetch.util.license import License
 
 
 class Reporter(ABC):
@@ -15,7 +16,7 @@ class Reporter(ABC):
     def add_project(
         self,
         project: ProjectEntry,
-        license_names: List[Tuple[str, float]],
+        licenses: List[License],
         version: str,
     ) -> None:
         """Add a project to the report."""

dfetch/reporting/sbom_reporter.py

@@ -15,7 +15,7 @@
         An fetched project generates an sbom
 """
 
-from typing import List, Tuple
+from typing import List
 
 from cyclonedx.builder.this import this_component as cdx_lib_component
 from cyclonedx.model import ExternalReference, ExternalReferenceType, XsUri
@@ -29,6 +29,7 @@
 import dfetch.util.purl
 from dfetch.manifest.project import ProjectEntry
 from dfetch.reporting.reporter import Reporter
+from dfetch.util.license import License
 
 # PyRight is pedantic with decorators see https://github.com/madpah/serializable/issues/8
 # It might be fixable with https://github.com/microsoft/pyright/discussions/4426, would prefer
@@ -52,7 +53,7 @@ def __init__(self) -> None:
     def add_project(
         self,
         project: ProjectEntry,
-        license_names: List[Tuple[str, float]],
+        licenses: List[License],
         version: str,
     ) -> None:
         """Add a project to the report."""
@@ -94,8 +95,8 @@ def add_project(
                     )
                 )
 
-        for name, _ in license_names:
-            component.licenses.add(LicenseExpression(name))
+        for lic in licenses:
+            component.licenses.add(LicenseExpression(lic.name))
         self._bom.components.add(component)
 
     def dump_to_file(self, outfile: str) -> bool:

dfetch/reporting/stdout_reporter.py

@@ -4,12 +4,13 @@
 from the manifest or the metadata (``.dfetch_data.yaml``).
 """
 
-from typing import List, Tuple
+from typing import List
 
 from dfetch.log import get_logger
 from dfetch.manifest.project import ProjectEntry
 from dfetch.project.metadata import Metadata
 from dfetch.reporting.reporter import Reporter
+from dfetch.util.license import License
 
 logger = get_logger(__name__)
 
@@ -22,7 +23,7 @@ class StdoutReporter(Reporter):
     def add_project(
         self,
         project: ProjectEntry,
-        license_names: List[Tuple[str, float]],
+        licenses: List[License],
         version: str,
     ) -> None:
         """Add a project to the report."""
@@ -38,7 +39,7 @@ def add_project(
             logger.print_info_field("    revision", metadata.revision)
             logger.print_info_field("    patch", metadata.patch)
             logger.print_info_field(
-                "    licenses", ",".join(license for license, _ in license_names)
+                "    licenses", ",".join(license.name for license in licenses)
             )
 
         except FileNotFoundError:

dfetch/util/license.py

@@ -1,17 +1,38 @@
 """*Dfetch* uses *Infer-License* to guess licenses from files."""
 
 import os
-from typing import Optional, Tuple, Union
+from dataclasses import dataclass
+from typing import Optional, Union
 
 import infer_license
-from infer_license.types import License
+from infer_license.types import License as InferredLicense
 
-LICENSE_PROBABILITY_THRESHOLD = 0.80
+
+@dataclass
+class License:
+    """Class to hold license information."""
+
+    name: str  # SPDX Full name
+    shortname: str  # SPDX Identifier
+    trove_classifier: Optional[str]
+    probability: float
+
+    @staticmethod
+    def from_inferred(
+        inferred_license: InferredLicense, probability: float
+    ) -> "License":
+        """Create License from an InferredLicense."""
+        return License(
+            name=inferred_license.name,
+            shortname=inferred_license.shortname,
+            trove_classifier=inferred_license.trove_classifier,
+            probability=probability,
+        )
 
 
 def guess_license_in_file(
     filename: Union[str, "os.PathLike[str]"],
-) -> Tuple[Optional[License], float]:
+) -> Optional[License]:
     """Guess license from file."""
     try:
         with open(filename, encoding="utf-8") as f:
@@ -21,7 +42,5 @@ def guess_license_in_file(
             license_text = f.read()
 
     probable_license = infer_license.api.probabilities(license_text)
-    if probable_license and probable_license[0][1] > LICENSE_PROBABILITY_THRESHOLD:
-        return probable_license[0]
 
-    return None, 0.0
+    return None if not probable_license else License.from_inferred(*probable_license[0])