scanoss 1.39.0__py3-none-any.whl → 1.40.1__py3-none-any.whl

scanoss/inspection/{raw → policy_check/scanoss}/undeclared_component.py

@@ -24,11 +24,11 @@ SPDX-License-Identifier: MIT
 
 import json
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import List
 
-from ..policy_check import PolicyStatus
-from ..utils.markdown_utils import generate_jira_table, generate_table
-from .raw_base import RawBase
+from ...policy_check.policy_check import PolicyCheck, PolicyOutput, PolicyStatus
+from ...utils.markdown_utils import generate_jira_table, generate_table
+from ...utils.scan_result_processor import ScanResultProcessor
 
 
 @dataclass
@@ -44,7 +44,7 @@ class Component:
     licenses: List[License]
     status: str
 
-class UndeclaredComponent(RawBase[Component]):
+class UndeclaredComponent(PolicyCheck[Component]):
     """
     SCANOSS UndeclaredComponent class
     Inspects for undeclared components
@@ -59,7 +59,7 @@ class UndeclaredComponent(RawBase[Component]):
         format_type: str = 'json',
         status: str = None,
         output: str = None,
-        sbom_format: str = 'settings',
+        sbom_format: str = 'settings'
     ):
         """
         Initialize the UndeclaredComponent class.
@@ -74,13 +74,14 @@ class UndeclaredComponent(RawBase[Component]):
         :param sbom_format: Sbom format for status output (default 'settings')
         """
         super().__init__(
-            debug, trace, quiet,format_type, filepath, output, status, name='Undeclared Components Policy'
+            debug, trace, quiet, format_type, status, name='Undeclared Components Policy', output=output
         )
         self.filepath = filepath
-        self.format = format
         self.output = output
         self.status = status
         self.sbom_format = sbom_format
+        self.results_processor = ScanResultProcessor(self.debug, self.trace, self.quiet, self.filepath)
+
 
     def _get_undeclared_components(self, components: list[Component]) -> list or None:
         """
@@ -163,7 +164,7 @@ class UndeclaredComponent(RawBase[Component]):
 
         return summary
 
-    def _json(self, components: list[Component]) -> Dict[str, Any]:
+    def _json(self, components: list[Component]) -> PolicyOutput:
         """
         Format the undeclared components as JSON.
 
@@ -171,16 +172,16 @@ class UndeclaredComponent(RawBase[Component]):
         :return: Dictionary with formatted JSON details and summary
         """
         # Use component grouped by licenses to generate the summary
-        component_licenses = self._group_components_by_license(components)
+        component_licenses = self.results_processor.group_components_by_license(components)
         details = {}
         if len(components) > 0:
             details = {'components': components}
-        return {
-            'details': f'{json.dumps(details, indent=2)}\n',
-            'summary': self._get_summary(component_licenses),
-        }
+        return PolicyOutput(
+            details=f'{json.dumps(details, indent=2)}\n',
+            summary=self._get_summary(component_licenses)
+        )
 
-    def _markdown(self, components: list[Component]) -> Dict[str, Any]:
+    def _markdown(self, components: list[Component]) -> PolicyOutput:
         """
         Format the undeclared components as Markdown.
 
@@ -190,15 +191,15 @@ class UndeclaredComponent(RawBase[Component]):
         headers = ['Component', 'License']
         rows = []
         # TODO look at using SpdxLite license name lookup method
-        component_licenses = self._group_components_by_license(components)
+        component_licenses = self.results_processor.group_components_by_license(components)
         for component in component_licenses:
             rows.append([component.get('purl'), component.get('spdxid')])
-        return {
-            'details': f'### Undeclared components\n{generate_table(headers, rows)}\n',
-            'summary': self._get_summary(component_licenses),
-        }
+        return PolicyOutput(
+            details= f'### Undeclared components\n{generate_table(headers, rows)}\n',
+            summary= self._get_summary(component_licenses),
+        )
 
-    def _jira_markdown(self, components: list) -> Dict[str, Any]:
+    def _jira_markdown(self, components: list) -> PolicyOutput:
         """
         Format the undeclared components as Markdown.
 
@@ -208,13 +209,13 @@ class UndeclaredComponent(RawBase[Component]):
         headers = ['Component', 'License']
         rows = []
         # TODO look at using SpdxLite license name lookup method
-        component_licenses = self._group_components_by_license(components)
+        component_licenses = self.results_processor.group_components_by_license(components)
         for component in component_licenses:
             rows.append([component.get('purl'), component.get('spdxid')])
-        return {
-            'details': f'{generate_jira_table(headers, rows)}',
-            'summary': self._get_jira_summary(component_licenses),
-        }
+        return PolicyOutput(
+            details= f'{generate_jira_table(headers, rows)}',
+            summary= self._get_jira_summary(component_licenses),
+        )
 
     def _get_unique_components(self, components: list) -> list:
         """
@@ -272,13 +273,13 @@ class UndeclaredComponent(RawBase[Component]):
 
         :return: A list of processed components with their licenses, or `None` if `self.results` is not set.
         """
-        if self.results is None:
+        if self.results_processor.get_results() is None:
             return None
         components: dict = {}
         # Extract file and snippet components
-        components = self._get_components_data(self.results, components)
+        components = self.results_processor.get_components_data(components)
         # Convert to list and process licenses
-        return self._convert_components_to_list(components)
+        return self.results_processor.convert_components_to_list(components)
 
     def run(self):
         """

scanoss/inspection/{raw → summary}/component_summary.py

@@ -24,11 +24,36 @@ SPDX-License-Identifier: MIT
 import json
 from typing import Any
 
-from ..policy_check import T
-from .raw_base import RawBase
+from ...scanossbase import ScanossBase
+from ..policy_check.policy_check import T
+from ..utils.scan_result_processor import ScanResultProcessor
+
+
+class ComponentSummary(ScanossBase):
+
+    def __init__( # noqa: PLR0913
+        self,
+        debug: bool = False,
+        trace: bool = False,
+        quiet: bool = False,
+        filepath: str = None,
+        format_type: str = 'json',
+        output: str = None,
+    ):
+        """
+        Initialize the ComponentSummary class.
 
+        :param debug: Enable debug mode
+        :param trace: Enable trace mode
+        :param quiet: Enable quiet mode
+        :param filepath: Path to the file containing component data
+        :param format_type: Output format ('json' or 'md')
+        """
+        super().__init__(debug, trace, quiet)
+        self.filepath = filepath
+        self.output = output
+        self.results_processor = ScanResultProcessor(debug, trace, quiet, filepath)
 
-class ComponentSummary(RawBase):
 
     def _json(self, data: dict[str,Any]) -> dict[str,Any]:
         """
@@ -77,11 +102,11 @@ class ComponentSummary(RawBase):
         """
         Get a component summary from detected components.
 
-        :param components: List of all components
+        :param scan_components: List of all components
         :return: Dict with license summary information
         """
         # A component is considered unique by its combination of PURL (Package URL) and license
-        component_licenses = self._group_components_by_license(scan_components)
+        component_licenses = self.results_processor.group_components_by_license(scan_components)
         total_components = len(component_licenses)
         # Get undeclared components
         undeclared_components = len([c for c in component_licenses if c['status'] == 'pending'])
@@ -121,13 +146,13 @@ class ComponentSummary(RawBase):
 
         :return: A list of processed components with license data, or `None` if `self.results` is not set.
         """
-        if self.results is None:
-            raise ValueError(f'Error: No results found in ${self.filepath}')
+        if self.results_processor.get_results() is None:
+            raise ValueError(f'Error: No results found in {self.filepath}')
 
         components: dict = {}
         # Extract component and license data from file and dependency results. Both helpers mutate `components`
-        self._get_components_data(self.results, components)
-        return self._convert_components_to_list(components)
+        self.results_processor.get_components_data(components)
+        return self.results_processor.convert_components_to_list(components)
 
     def _format(self, component_summary) -> str:
         # TODO: Implement formatter to support dynamic outputs

scanoss/inspection/{raw → summary}/license_summary.py

@@ -25,11 +25,12 @@ SPDX-License-Identifier: MIT
 import json
 from typing import Any
 
-from ..policy_check import T
-from .raw_base import RawBase
+from ...scanossbase import ScanossBase
+from ..policy_check.policy_check import T
+from ..utils.scan_result_processor import ScanResultProcessor
 
 
-class LicenseSummary(RawBase):
+class LicenseSummary(ScanossBase):
     """
        SCANOSS LicenseSummary class
        Inspects results and generates comprehensive license summaries from detected components.
@@ -38,6 +39,42 @@ class LicenseSummary(RawBase):
        information, providing detailed summaries including copyleft analysis and license statistics.
        """
 
+    # Define required license fields as class constants
+    REQUIRED_LICENSE_FIELDS = ['spdxid', 'url', 'copyleft', 'source']
+
+    def __init__( # noqa: PLR0913
+        self,
+        debug: bool = False,
+        trace: bool = False,
+        quiet: bool = False,
+        filepath: str = None,
+        status: str = None,
+        output: str = None,
+        include: str = None,
+        exclude: str = None,
+        explicit: str = None,
+    ):
+        """
+        Initialize the LicenseSummary class.
+
+        :param debug: Enable debug mode
+        :param trace: Enable trace mode
+        :param quiet: Enable quiet mode
+        :param filepath: Path to the file containing component data
+        :param output: Path to save detailed output
+        :param include: Licenses to include in the analysis
+        :param exclude: Licenses to exclude from the analysis
+        :param explicit: Explicitly defined licenses
+        """
+        super().__init__(debug=debug, trace=trace, quiet=quiet)
+        self.results_processor = ScanResultProcessor(debug, trace, quiet, filepath, include, exclude, explicit)
+        self.filepath = filepath
+        self.output = output
+        self.status = status
+        self.include = include
+        self.exclude = exclude
+        self.explicit = explicit
+
     def _json(self, data: dict[str,Any]) -> dict[str, Any]:
         """
         Format license summary data as JSON.
@@ -78,41 +115,6 @@ class LicenseSummary(RawBase):
         """
         pass
 
-    # Define required license fields as class constants
-    REQUIRED_LICENSE_FIELDS = ['spdxid', 'url', 'copyleft', 'source']
-
-    def __init__( # noqa: PLR0913
-        self,
-        debug: bool = False,
-        trace: bool = False,
-        quiet: bool = False,
-        filepath: str = None,
-        status: str = None,
-        output: str = None,
-        include: str = None,
-        exclude: str = None,
-        explicit: str = None,
-    ):
-        """
-        Initialize the LicenseSummary class.
-
-        :param debug: Enable debug mode
-        :param trace: Enable trace mode (default True)
-        :param quiet: Enable quiet mode
-        :param filepath: Path to the file containing component data
-        :param output: Path to save detailed output
-        :param include: Licenses to include in the analysis
-        :param exclude: Licenses to exclude from the analysis
-        :param explicit: Explicitly defined licenses
-        """
-        super().__init__(debug, trace, quiet, filepath = filepath, output=output)
-        self.license_util.init(include, exclude, explicit)
-        self.filepath = filepath
-        self.output = output
-        self.status = status
-        self.include = include
-        self.exclude = exclude
-        self.explicit = explicit
 
     def _get_licenses_summary_from_components(self, components: list)-> dict:
         """
@@ -122,7 +124,7 @@ class LicenseSummary(RawBase):
         :return: Dict with license summary information
         """
         # A component is considered unique by its combination of PURL (Package URL) and license
-        component_licenses = self._group_components_by_license(components)
+        component_licenses = self.results_processor.group_components_by_license(components)
         license_component_count = {}
         # Count license per component
         for lic in component_licenses:
@@ -164,14 +166,14 @@ class LicenseSummary(RawBase):
 
         :return: A list of processed components with license data, or `None` if `self.results` is not set.
         """
-        if self.results is None:
-            raise ValueError(f'Error: No results found in ${self.filepath}')
+        if self.results_processor.get_results() is None:
+            raise ValueError(f'Error: No results found in {self.filepath}')
 
         components: dict = {}
         # Extract component and license data from file and dependency results. Both helpers mutate `components`
-        self._get_components_data(self.results, components)
-        self._get_dependencies_data(self.results, components)
-        return self._convert_components_to_list(components)
+        self.results_processor.get_components_data(components)
+        self.results_processor.get_dependencies_data(components)
+        return self.results_processor.convert_components_to_list(components)
 
     def _format(self, license_summary) -> str:
         # TODO: Implement formatter to support dynamic outputs

scanoss/inspection/{raw → summary}/match_summary.py

@@ -94,6 +94,7 @@ class MatchSummary(ScanossBase):
         self.scanoss_results_path = scanoss_results_path
         self.line_range_prefix = line_range_prefix
         self.output = output
+        self.print_debug("Initializing MatchSummary class")
 
 
     def _get_match_summary_item(self, file_name: str, result: dict) -> MatchSummaryItem:
@@ -108,11 +109,16 @@ class MatchSummary(ScanossBase):
         :param result: SCANOSS scan result dictionary containing match details
         :return: Populated match summary item with all relevant information
         """
+        self.print_trace(f"Creating match summary item for file: {file_name}, id: {result.get('id')}")
+
         if result.get('id') == "snippet":
             # Snippet match: create URL with line range anchor
             lines = scanoss_scan_results_utils.get_lines(result.get('lines'))
             end_line = lines[len(lines) - 1] if len(lines) > 1 else lines[0]
             file_url = f"{self.line_range_prefix}/{file_name}#L{lines[0]}-L{end_line}"
+
+            self.print_trace(f"Snippet match: lines {lines[0]}-{end_line}, purl: {result.get('purl')[0]}")
+
             return MatchSummaryItem(
                 file_url=file_url,
                 file=file_name,
@@ -124,6 +130,8 @@ class MatchSummary(ScanossBase):
                 lines=f"{lines[0]}-{lines[len(lines) - 1] if len(lines) > 1 else lines[0]}"
             )
         # File match: create URL without line range
+        self.print_trace(f"File match: {file_name}, purl: {result.get('purl')[0]}, version: {result.get('version')}")
+
         return MatchSummaryItem(
             file=file_name,
             file_url=f"{self.line_range_prefix}/{file_name}",
@@ -176,12 +184,19 @@ class MatchSummary(ScanossBase):
         required fields and categorizing matches into file matches and snippet matches.
         Skips invalid or incomplete results with debug messages.
         """
+        self.print_debug(f"Loading scan results from: {self.scanoss_results_path}")
+
         # Load scan results from JSON file
         scan_results = load_json_file(self.scanoss_results_path)
         gitlab_matches_summary = ComponentMatchSummary(files=[], snippet=[])
 
+        self.print_debug(f"Processing {len(scan_results)} files from scan results")
+        self.print_trace(f"Line range prefix set to: {self.line_range_prefix}")
+
         # Process each file and its results
         for file_name, results in scan_results.items():
+            self.print_trace(f"Processing file: {file_name} with {len(results)} results")
+
             for result in results:
                 # Skip non-matches
                 if result.get('id') == "none":
@@ -196,8 +211,15 @@ class MatchSummary(ScanossBase):
                 summary_item = self._get_match_summary_item(file_name, result)
                 if result.get('id') == "snippet":
                     gitlab_matches_summary.snippet.append(summary_item)
+                    self.print_trace(f"Added snippet match for {file_name}")
                 else:
                     gitlab_matches_summary.files.append(summary_item)
+                    self.print_trace(f"Added file match for {file_name}")
+
+        self.print_debug(
+            f"Match summary complete: {len(gitlab_matches_summary.files)} file matches, "
+            f"{len(gitlab_matches_summary.snippet)} snippet matches"
+        )
 
         return gitlab_matches_summary
 
@@ -212,14 +234,23 @@ class MatchSummary(ScanossBase):
         :param gitlab_matches_summary: Container with categorized file and snippet matches to format
         :return: Complete Markdown document with formatted match tables
         """
+        self.print_debug("Generating Markdown from match summaries")
 
         if len(gitlab_matches_summary.files) == 0 and len(gitlab_matches_summary.snippet) == 0:
+            self.print_debug("No matches to format - returning empty string")
             return ""
 
+        self.print_trace(
+            f"Formatting {len(gitlab_matches_summary.files)} file matches and "
+            f"{len(gitlab_matches_summary.snippet)} snippet matches"
+        )
+
         # Define table headers
         file_match_headers = ['File', 'License', 'Similarity', 'PURL', 'Version']
         snippet_match_headers = ['File', 'License', 'Similarity', 'PURL', 'Version', 'Lines']
+
         # Build file matches table
+        self.print_trace("Building file matches table")
         file_match_rows = []
         for file_match in gitlab_matches_summary.files:
             row = [
@@ -233,6 +264,7 @@ class MatchSummary(ScanossBase):
         file_match_table = generate_table(file_match_headers, file_match_rows)
 
         # Build snippet matches table
+        self.print_trace("Building snippet matches table")
         snippet_match_rows = []
         for snippet_match in gitlab_matches_summary.snippet:
             row = [
@@ -262,6 +294,8 @@ class MatchSummary(ScanossBase):
         markdown += snippet_match_table
         markdown += "\n</details>\n"
 
+        self.print_trace(f"Markdown generation complete (length: {len(markdown)} characters)")
+        self.print_debug("Match summary Markdown generation complete")
         return markdown
 
     def run(self):
@@ -275,16 +309,33 @@ class MatchSummary(ScanossBase):
         3. Generates Markdown report
         4. Outputs to file or stdout
         """
+        self.print_debug("Starting match summary generation process")
+        self.print_trace(
+            f"Configuration - Results path: {self.scanoss_results_path}, Output: {self.output}, "
+            f"Line range prefix: {self.line_range_prefix}"
+        )
+
         # Load and process scan results into categorized matches
+        self.print_trace("Loading and processing scan results")
         matches = self._get_matches_summary()
 
         # Format matches as GitLab-compatible Markdown
+        self.print_trace("Generating Markdown output")
         matches_md = self._markdown(matches)
         if matches_md == "":
+            self.print_debug("No matches found - exiting")
             self.print_stdout("No matches found.")
             return
+
         # Output to file or stdout
+        self.print_trace("Writing output")
+        if self.output:
+            self.print_debug(f"Writing match summary to file: {self.output}")
+        else:
+            self.print_debug("Writing match summary to 'stdout'")
+
         self.print_to_file_or_stdout(matches_md, self.output)
+        self.print_debug("Match summary generation complete")
 
 
 

scanoss/inspection/{raw/raw_base.py → utils/scan_result_processor.py}

@@ -22,11 +22,10 @@ SPDX-License-Identifier: MIT
   THE SOFTWARE.
 """
 
-from abc import abstractmethod
 from enum import Enum
 from typing import Any, Dict, TypeVar
 
-from ..policy_check import PolicyCheck
+from ...scanossbase import ScanossBase
 from ..utils.file_utils import load_json_file
 from ..utils.license_utils import LicenseUtil
 
@@ -51,12 +50,13 @@ class ComponentID(Enum):
 #
 
 T = TypeVar('T')
-class RawBase(PolicyCheck[T]):
+class ScanResultProcessor(ScanossBase):
     """
-    A base class to perform inspections over scan results.
+    A utility class for processing and transforming scan results.
 
-    This class provides a basic for scan results inspection, including methods for
-    processing scan results components and licenses.
+    This class provides functionality for processing scan results, including methods for
+    loading, parsing, extracting, and aggregating component and license data from scan results.
+    It serves as a shared data processing layer used by both policy checks and summary generators.
 
     Inherits from:
         ScanossBase: A base class providing common functionality for SCANOSS-related operations.
@@ -67,40 +67,19 @@ class RawBase(PolicyCheck[T]):
         debug: bool = False,
         trace: bool = False,
         quiet: bool = False,
-        format_type: str = None,
-        filepath: str = None,
-        output: str = None,
-        status: str = None,
-        name: str = None,
+        result_file_path: str = None,
+        include: str = None,
+        exclude: str = None,
+        explicit: str = None,
     ):
-        super().__init__(debug, trace, quiet, format_type,status, name, output)
+        super().__init__(debug, trace, quiet)
+        self.result_file_path = result_file_path
         self.license_util = LicenseUtil()
-        self.filepath = filepath
-        self.output = output
+        self.license_util.init(include, exclude, explicit)
         self.results = self._load_input_file()
 
-    @abstractmethod
-    def _get_components(self):
-        """
-        Retrieve and process components from the preloaded results.
-
-        This method performs the following steps:
-        1. Checks if the results have been previously loaded (self.results).
-        2. Extracts and processes components from the loaded results.
-
-        :return: A list of processed components, or None if an error occurred during any step.
-
-        Possible reasons for returning None include:
-        - Results not loaded (self.results is None)
-        - Failure to extract components from the results
-
-        Note:
-        - This method assumes that the results have been previously loaded and stored in self.results.
-        - Implementations must extract components (e.g. via `_get_components_data`,
-          `_get_dependencies_data`, or other helpers).
-        - If `self.results` is `None`, simply return `None`.
-        """
-    pass
+    def get_results(self) -> Dict[str, Any]:
+        return self.results
 
     def _append_component(self, components: Dict[str, Any], new_component: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -213,7 +192,7 @@ class RawBase(PolicyCheck[T]):
         else:
             component['undeclared'] += 1
 
-    def _get_components_data(self, results: Dict[str, Any], components: Dict[str, Any]) -> Dict[str, Any]:
+    def get_components_data(self, components: Dict[str, Any]) -> Dict[str, Any]:
         """
            Extract and process file and snippet components from results.
 
@@ -230,11 +209,11 @@ class RawBase(PolicyCheck[T]):
              which tracks the number of occurrences of each license
 
            Args:
-               results: A dictionary containing the raw results of a component scan
+               components: A dictionary containing the raw results of a component scan
            Returns:
                Updated components dictionary with file and snippet data
            """
-        for component in results.values():
+        for component in self.results.values():
             for c in component:
                 component_id = c.get('id')
                 if not component_id:
@@ -266,15 +245,13 @@ class RawBase(PolicyCheck[T]):
         # End components loop
         return components
 
-    def _get_dependencies_data(self, results: Dict[str, Any], components: Dict[str, Any]) -> Dict[str, Any]:
+    def get_dependencies_data(self,components: Dict[str, Any]) -> Dict[str, Any]:
         """
         Extract and process dependency components from results.
-
-        :param results: A dictionary containing the raw results of a component scan
         :param components: Existing components dictionary to update
         :return: Updated components dictionary with dependency data
         """
-        for component in results.values():
+        for component in self.results.values():
             for c in component:
                 component_id = c.get('id')
                 if not component_id:
@@ -313,12 +290,12 @@ class RawBase(PolicyCheck[T]):
               Dict[str, Any]: The parsed JSON data
         """
         try:
-            return load_json_file(self.filepath)
+            return load_json_file(self.result_file_path)
         except Exception as e:
                 self.print_stderr(f'ERROR: Problem parsing input JSON: {e}')
                 return None
 
-    def _convert_components_to_list(self, components: dict):
+    def convert_components_to_list(self, components: dict):
         if components is None:
             self.print_debug(f'WARNING: Components is empty {self.results}')
             return None
@@ -372,7 +349,7 @@ class RawBase(PolicyCheck[T]):
         self.print_debug("No priority sources found, returning all licenses as list")
         return licenses_data
 
-    def _group_components_by_license(self,components):
+    def group_components_by_license(self,components):
         """
         Groups components by their unique component-license pairs.
 
@@ -425,5 +402,5 @@ class RawBase(PolicyCheck[T]):
 
 
 #
-# End of PolicyCheck Class
-#
+# End of ScanResultProcessor Class
+#

scanoss/scanners/scanner_hfh.py

@@ -63,6 +63,7 @@ class ScannerHFH:
         depth: int = DEFAULT_HFH_DEPTH,
         recursive_threshold: float = DEFAULT_HFH_RECURSIVE_THRESHOLD,
         min_accepted_score: float = DEFAULT_HFH_MIN_ACCEPTED_SCORE,
+        use_grpc: bool = False,
     ):
         """
         Initialize the ScannerHFH.
@@ -107,6 +108,7 @@ class ScannerHFH:
         self.rank_threshold = rank_threshold
         self.recursive_threshold = recursive_threshold
         self.min_accepted_score = min_accepted_score
+        self.use_grpc = use_grpc
 
     def scan(self) -> Optional[Dict]:
         """
@@ -134,7 +136,7 @@ class ScannerHFH:
         spinner_thread.start()
 
         try:
-            response = self.client.folder_hash_scan(hfh_request)
+            response = self.client.folder_hash_scan(hfh_request, self.use_grpc)
             if response:
                 self.scan_results = response
         finally: