scanoss 1.14.0__py3-none-any.whl → 1.16.0__py3-none-any.whl

scanoss/scanoss_settings.py

@@ -0,0 +1,189 @@
+"""
+ SPDX-License-Identifier: MIT
+
+   Copyright (c) 2024, SCANOSS
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the 'Software'), to deal
+   in the Software without restriction, including without limitation the rights
+   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+   THE SOFTWARE.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, List, TypedDict
+
+from .scanossbase import ScanossBase
+
+
+class BomEntry(TypedDict, total=False):
+    purl: str
+    path: str
+
+
+class ScanossSettings(ScanossBase):
+    """Handles the loading and parsing of the SCANOSS settings file"""
+
+    def __init__(
+        self,
+        debug: bool = False,
+        trace: bool = False,
+        quiet: bool = False,
+        filepath: str = None,
+    ):
+        """
+        Args:
+            debug (bool, optional): Debug. Defaults to False.
+            trace (bool, optional): Trace. Defaults to False.
+            quiet (bool, optional): Quiet. Defaults to False.
+            filepath (str, optional): Path to settings file. Defaults to None.
+        """
+
+        super().__init__(debug, trace, quiet)
+        self.data = {}
+        self.settings_file_type = None
+        self.scan_type = None
+
+        if filepath:
+            self.load_json_file(filepath)
+
+    def load_json_file(self, filepath: str):
+        """Load the scan settings file
+
+        Args:
+            filepath (str): Path to the SCANOSS settings file
+        """
+        json_file = Path(filepath).resolve()
+
+        if not json_file.exists():
+            self.print_stderr(f"Scan settings file not found: {filepath}")
+            self.data = {}
+
+        with open(json_file, "r") as jsonfile:
+            self.print_debug(f"Loading scan settings from: {filepath}")
+            try:
+                self.data = json.load(jsonfile)
+            except Exception as e:
+                self.print_stderr(f"ERROR: Problem parsing input JSON: {e}")
+        return self
+
+    def set_file_type(self, file_type: str):
+        """Set the file type in order to support both legacy SBOM.json and new scanoss.json files
+
+        Args:
+            file_type (str): 'legacy' or 'new'
+
+        Raises:
+            Exception: Invalid scan settings file, missing "components" or "bom"
+        """
+        self.settings_file_type = file_type
+        if not self._is_valid_sbom_file:
+            raise Exception(
+                'Invalid scan settings file, missing "components" or "bom")'
+            )
+        return self
+
+    def set_scan_type(self, scan_type: str):
+        """Set the scan type to support legacy SBOM.json files
+
+        Args:
+            scan_type (str): 'identify' or 'exclude'
+        """
+        self.scan_type = scan_type
+        return self
+
+    def _is_valid_sbom_file(self):
+        """Check if the scan settings file is valid
+
+        Returns:
+            bool: True if the file is valid, False otherwise
+        """
+        if not self.data.get("components") or not self.data.get("bom"):
+            return False
+        return True
+
+    def _get_bom(self):
+        """Get the Billing of Materials from the settings file
+
+        Returns:
+            dict: If using scanoss.json
+            list: If using SBOM.json
+        """
+        if self.settings_file_type == "legacy":
+            return self.data.get("components", [])
+        return self.data.get("bom", {})
+
+    def get_bom_include(self) -> List[BomEntry]:
+        """Get the list of components to include in the scan
+
+        Returns:
+            list: List of components to include in the scan
+        """
+        if self.settings_file_type == "legacy":
+            return self._get_bom()
+        return self._get_bom().get("include", [])
+
+    def get_bom_remove(self) -> List[BomEntry]:
+        """Get the list of components to remove from the scan
+
+        Returns:
+            list: List of components to remove from the scan
+        """
+        if self.settings_file_type == "legacy":
+            return self._get_bom()
+        return self._get_bom().get("remove", [])
+
+    def get_sbom(self):
+        """Get the SBOM to be sent to the SCANOSS API
+
+        Returns:
+            dict: SBOM
+        """
+        if not self.data:
+            return None
+        return {
+            "scan_type": self.scan_type,
+            "assets": json.dumps(self._get_sbom_assets()),
+        }
+
+    def _get_sbom_assets(self):
+        """Get the SBOM assets
+
+        Returns:
+            List: List of SBOM assets
+        """
+        if self.scan_type == "identify":
+            return self.normalize_bom_entries(self.get_bom_include())
+        return self.normalize_bom_entries(self.get_bom_remove())
+
+    @staticmethod
+    def normalize_bom_entries(bom_entries) -> List[BomEntry]:
+        """Normalize the BOM entries
+
+        Args:
+            bom_entries (List[Dict]): List of BOM entries
+
+        Returns:
+            List: Normalized BOM entries
+        """
+        normalized_bom_entries = []
+        for entry in bom_entries:
+            normalized_bom_entries.append(
+                {
+                    "purl": entry.get("purl", ""),
+                }
+            )
+        return normalized_bom_entries

scanoss/scanossapi.py

@@ -34,6 +34,7 @@ import urllib3
 from pypac import PACSession
 from pypac.parser import PACFile
 from urllib3.exceptions import InsecureRequestWarning
+
 from .scanossbase import ScanossBase
 from . import __version__
 
@@ -50,14 +51,12 @@ class ScanossApi(ScanossBase):
     Currently support posting scan requests to the SCANOSS streaming API
     """
 
-    def __init__(self, scan_type: str = None, sbom_path: str = None, scan_format: str = None, flags: str = None,
+    def __init__(self, scan_format: str = None, flags: str = None,
                  url: str = None, api_key: str = None, debug: bool = False, trace: bool = False, quiet: bool = False,
                  timeout: int = 180, ver_details: str = None, ignore_cert_errors: bool = False,
                  proxy: str = None, ca_cert: str = None, pac: PACFile = None, retry: int = 5):
         """
         Initialise the SCANOSS API
-        :param scan_type: Scan type (default identify)
-        :param sbom_path: Input SBOM file to match scan type (default None)
         :param scan_format: Scan format (default plain)
         :param flags: Scanning flags (default None)
         :param url: API URL (default https://api.osskb.org/scan/direct)
@@ -77,9 +76,8 @@ class ScanossApi(ScanossBase):
         self.api_key = api_key if api_key else SCANOSS_API_KEY
         if self.api_key and not url and not os.environ.get("SCANOSS_SCAN_URL"):
             self.url = DEFAULT_URL2  # API key specific and no alternative URL, so use the default premium
-        self.scan_type = scan_type
+        self.sbom = None
         self.scan_format = scan_format if scan_format else 'plain'
-        self.sbom_path = sbom_path
         self.flags = flags
         self.timeout = timeout if timeout > 5 else 180
         self.retry_limit = retry if retry >= 0 else 5
@@ -92,8 +90,6 @@ class ScanossApi(ScanossBase):
             self.headers['x-api-key'] = self.api_key
         self.headers['User-Agent'] = f'scanoss-py/{__version__}'
         self.headers['user-agent'] = f'scanoss-py/{__version__}'
-        self.sbom = None
-        self.load_sbom()  # Load an input SBOM if one is specified
         if self.trace:
             logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
             http_client.HTTPConnection.debuglevel = 1
@@ -115,17 +111,6 @@ class ScanossApi(ScanossBase):
         if self. proxies:
             self.session.proxies = self.proxies
 
-    def load_sbom(self):
-        """
-        Load the input SBOM if one exists
-        """
-        if self.sbom_path:
-            if not self.scan_type:
-                self.scan_type = 'identify'  # Default to identify SBOM type if it's not set
-            self.print_debug(f'Loading {self.scan_type} SBOM {self.sbom_path}...')
-            with open(self.sbom_path) as f:
-                self.sbom = f.read()
-
     def scan(self, wfp: str, context: str = None, scan_id: int = None):
         """
         Scan the specified WFP and return the JSON object
@@ -137,14 +122,15 @@ class ScanossApi(ScanossBase):
         request_id = str(uuid.uuid4())
         form_data = {}
         if self.sbom:
-            form_data['type'] = self.scan_type
-            form_data['assets'] = self.sbom
+            form_data['type'] = self.sbom.get("scan_type")
+            form_data['assets'] = self.sbom.get("assets")
         if self.scan_format:
             form_data['format'] = self.scan_format
         if self.flags:
             form_data['flags'] = self.flags
         if context:
             form_data['context'] = context
+        
         scan_files = {'file': ("%s.wfp" % request_id, wfp)}
         headers = self.headers
         headers['x-request-id'] = request_id  # send a unique request id for each post
@@ -242,6 +228,10 @@ class ScanossApi(ScanossBase):
         except Exception as ee:
             self.print_stderr(f'Warning: Issue writing bad request file - {bad_req_file} ({ee.__class__.__name__}):'
                               f' {ee}')
+    
+    def set_sbom(self, sbom):
+        self.sbom = sbom
+        return self
 
 #
 # End of ScanossApi Class

scanoss/scanossbase.py

@@ -68,3 +68,24 @@ class ScanossBase:
         """
         if self.trace:
             self.print_stderr(*args, **kwargs)
+
+    @staticmethod
+    def print_stdout(*args, **kwargs):
+        """
+        Print message to STDOUT
+        """
+        print(
+            *args,
+            file=sys.stdout,
+            **kwargs,
+        )
+
+    def print_to_file_or_stdout(self, msg: str, file: str = None):
+        """
+        Print message to file if provided or stdout
+        """
+        if file:
+            with open(file, "w") as f:
+                f.write(msg)
+        else:
+            self.print_stdout(msg)

scanoss/scanpostprocessor.py

@@ -0,0 +1,159 @@
+"""
+ SPDX-License-Identifier: MIT
+
+   Copyright (c) 2024, SCANOSS
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to deal
+   in the Software without restriction, including without limitation the rights
+   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+   THE SOFTWARE.
+"""
+
+from typing import List
+
+from .scanoss_settings import BomEntry, ScanossSettings
+from .scanossbase import ScanossBase
+
+
+class ScanPostProcessor(ScanossBase):
+    """Handles post-processing of the scan results"""
+
+    def __init__(
+        self,
+        scan_settings: ScanossSettings,
+        debug: bool = False,
+        trace: bool = False,
+        quiet: bool = False,
+        results: dict = None,
+    ):
+        """
+        Args:
+            scan_settings (ScanossSettings): Scan settings object
+            debug (bool, optional): Debug mode. Defaults to False.
+            trace (bool, optional): Traces. Defaults to False.
+            quiet (bool, optional): Quiet mode. Defaults to False.
+            results (dict | str, optional): Results to be processed. Defaults to None.
+        """
+        super().__init__(debug, trace, quiet)
+        self.scan_settings = scan_settings
+        self.results = results
+
+    def load_results(self, raw_results: dict):
+        """Load the raw results
+
+        Args:
+            raw_results (dict): Raw scan results
+        """
+        self.results = raw_results
+        return self
+
+    def post_process(self):
+        """Post-process the scan results
+
+        Returns:
+            dict: Processed results
+        """
+        self.remove_dismissed_files()
+        return self.results
+
+    def remove_dismissed_files(self):
+        """Remove entries from the results based on files and/or purls specified in the SCANOSS settings file"""
+
+        to_remove_entries = self.scan_settings.get_bom_remove()
+
+        if not to_remove_entries:
+            return
+
+        self.results = {
+            result_path: result
+            for result_path, result in self.results.items()
+            if not self._should_remove_result(result_path, result, to_remove_entries)
+        }
+
+    def _should_remove_result(
+        self, result_path: str, result: dict, to_remove_entries: List[BomEntry]
+    ) -> bool:
+        """Check if a result should be removed based on the SCANOSS settings"""
+        result = result[0] if isinstance(result, list) else result
+        result_purls = result.get("purl", [])
+
+        for to_remove_entry in to_remove_entries:
+            to_remove_path = to_remove_entry.get("path")
+            to_remove_purl = to_remove_entry.get("purl")
+
+            if not to_remove_path and not to_remove_purl:
+                continue
+
+            # Bom entry has both path and purl
+            if self._is_full_match(result_path, result_purls, to_remove_entry):
+                self._print_removal_message(result_path, result_purls, to_remove_entry)
+                return True
+
+            # Bom entry has only purl
+            if not to_remove_path and to_remove_purl in result_purls:
+                self._print_removal_message(result_path, result_purls, to_remove_entry)
+                return True
+
+            # Bom entry has only path
+            if not to_remove_purl and to_remove_path == result_path:
+                self._print_removal_message(result_path, result_purls, to_remove_entry)
+                return True
+
+        return False
+
+    def _print_removal_message(
+        self, result_path: str, result_purls: List[str], to_remove_entry: BomEntry
+    ) -> None:
+        """Print a message about removing a result"""
+        if to_remove_entry.get("path") and to_remove_entry.get("purl"):
+            message = f"Removing '{result_path}' from the results. Full match found."
+        elif to_remove_entry.get("purl"):
+            message = f"Removing '{result_path}' from the results. Found PURL match."
+        else:
+            message = f"Removing '{result_path}' from the results. Found path match."
+
+        self.print_msg(
+            f"{message}\n"
+            f"Details:\n"
+            f"  - PURLs: {', '.join(result_purls)}\n"
+            f"  - Path: '{result_path}'\n"
+        )
+
+    def _is_full_match(
+        self,
+        result_path: str,
+        result_purls: List[str],
+        bom_entry: BomEntry,
+    ) -> bool:
+        """Check if path and purl matches fully with the bom entry
+
+        Args:
+            result_path (str): Scan result path
+            result_purls (List[str]): Scan result purls
+            bom_entry (BomEntry): BOM entry to compare with
+
+        Returns:
+            bool: True if the path and purl match, False otherwise
+        """
+
+        if not result_purls:
+            return False
+
+        return bool(
+            (bom_entry.get("purl") and bom_entry.get("path"))
+            and (bom_entry.get("path") == result_path)
+            and (bom_entry.get("purl") in result_purls)
+        )

scanoss/threadeddependencies.py

@@ -24,7 +24,9 @@
 
 import threading
 import queue
-from typing import Dict
+import json
+from enum import Enum
+from typing import Dict, Optional, Set
 from dataclasses import dataclass
 
 from .scancodedeps import ScancodeDeps
@@ -33,6 +35,14 @@ from .scanossgrpc import ScanossGrpc
 
 DEP_FILE_PREFIX = "file="  # Default prefix to signify an existing parsed dependency file
 
+DEV_DEPENDENCIES = { "dev", "test", "development", "provided", "runtime", "devDependencies", "dev-dependencies", "testImplementation", "testCompile", "Test", "require-dev" }
+
+
+# Define an enum class
+class SCOPE(Enum):
+    PRODUCTION = 'prod'
+    DEVELOPMENT = 'dev'
+
 
 @dataclass
 class ThreadedDependencies(ScanossBase):
@@ -66,9 +76,13 @@ class ThreadedDependencies(ScanossBase):
                 return resp
         return None
 
-    def run(self, what_to_scan: str = None, deps_file: str = None, wait: bool = True) -> bool:
+    def run(self, what_to_scan: str = None, deps_file: str = None, wait: bool = True, dep_scope: SCOPE =  None,
+            dep_scope_include: str = None, dep_scope_exclude: str = None) -> bool:
         """
         Initiate a background scan for the specified file/dir
+        :param dep_scope_exclude: comma separated list of dependency scopes to exclude
+        :param dep_scope_include: comma separated list of dependency scopes to include
+        :param dep_scope: Enum dependency scope to use
         :param what_to_scan: file/folder to scan
         :param deps_file: file to decorate instead of scan (overrides what_to_scan option)
         :param wait: wait for completion
@@ -82,8 +96,9 @@ class ThreadedDependencies(ScanossBase):
                 self.inputs.put(f'{DEP_FILE_PREFIX}{deps_file}')           # Add to queue and have parent wait on it
             else:                                                          # Search for dependencies to decorate
                 self.print_msg(f'Searching {what_to_scan} for dependencies...')
-                self.inputs.put(what_to_scan)                              # Add to queue and have parent wait on it
-            self._thread = threading.Thread(target=self.scan_dependencies, daemon=True)
+                self.inputs.put(what_to_scan)
+                # Add to queue and have parent wait on it
+            self._thread = threading.Thread(target=self.scan_dependencies(dep_scope, dep_scope_include, dep_scope_exclude), daemon=True)
             self._thread.start()
         except Exception as e:
             self.print_stderr(f'ERROR: Problem running threaded dependencies: {e}')
@@ -92,7 +107,54 @@ class ThreadedDependencies(ScanossBase):
             self.complete()
         return False if self._errors else True
 
-    def scan_dependencies(self) -> None:
+    def filter_dependencies(self,deps ,filter_dep)-> json:
+        files = deps.get('files', [])
+        # Iterate over files and their purls
+        for file in files:
+            if 'purls' in file:
+                # Filter purls with scope 'dependencies' and remove the scope field
+                file['purls'] = [
+                    {key: value for key, value in purl.items() if key != 'scope'}
+                    for purl in file['purls']
+                    if filter_dep(purl.get('scope'))
+                ]
+        # End of for loop
+
+        return {
+            'files': [
+                file for file in deps.get('files', [])
+                if file.get('purls')
+            ]
+        }
+
+    def filter_dependencies_by_scopes(self,deps: json, dep_scope: SCOPE = None, dep_scope_include: str = None,
+                                      dep_scope_exclude: str = None) -> json:
+        # Predefined set of scopes to filter
+
+        # Include all scopes
+        include_all = (dep_scope is None or dep_scope == "") and dep_scope_include is None and dep_scope_exclude is None
+        ## All dependencies, remove scope key
+        if include_all:
+            return self.filter_dependencies(deps, lambda purl:True)
+
+        # Use default list of scopes if a custom list is not set
+        if (dep_scope is not None and dep_scope != "") and dep_scope_include is None and dep_scope_exclude is None:
+            return self.filter_dependencies(deps, lambda purl: (dep_scope == SCOPE.PRODUCTION and purl not in DEV_DEPENDENCIES) or
+            dep_scope == SCOPE.DEVELOPMENT and purl in DEV_DEPENDENCIES)
+
+        if ((dep_scope_include is not None and dep_scope_include != "")
+                or  dep_scope_exclude is not None and dep_scope_exclude != ""):
+            # Create sets from comma-separated strings, if provided
+            exclude = set(dep_scope_exclude.split(',')) if dep_scope_exclude else set()
+            include = set(dep_scope_include.split(',')) if dep_scope_include else set()
+
+            # Define a lambda function that checks the inclusion/exclusion logic
+            return self.filter_dependencies(
+                deps,
+                lambda purl: (exclude and purl not in exclude) or (not exclude and purl in include)
+            )
+
+    def scan_dependencies(self, dep_scope: SCOPE = None, dep_scope_include: str = None, dep_scope_exclude: str = None) -> None:
         """
         Scan for dependencies from the given file/dir or from an input file (from the input queue).
         """
@@ -108,6 +170,14 @@ class ThreadedDependencies(ScanossBase):
                     self._errors = True
                 else:
                     deps = self.sc_deps.produce_from_file()
+                    if dep_scope is not None:
+                        self.print_debug(f'Filtering {dep_scope.name} dependencies')
+                    if dep_scope_include is not None:
+                        self.print_debug(f"Including dependencies with '{dep_scope_include.split(',')}' scopes")
+                    if dep_scope_exclude is not None:
+                        self.print_debug(f"Excluding dependencies with '{dep_scope_exclude.split(',')}' scopes")
+                    deps = self.filter_dependencies_by_scopes(deps, dep_scope,dep_scope_include, dep_scope_exclude)
+
             if not self._errors:
                 if deps is None:
                     self.print_stderr(f'Problem searching for dependencies for: {what_to_scan}')

{scanoss-1.14.0.dist-info → scanoss-1.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scanoss
-Version: 1.14.0
+Version: 1.16.0
 Summary: Simple Python library to leverage the SCANOSS APIs
 Home-page: https://scanoss.com
 Author: SCANOSS

{scanoss-1.14.0.dist-info → scanoss-1.16.0.dist-info}/RECORD

@@ -4,20 +4,23 @@ protoc_gen_swagger/options/annotations_pb2.py,sha256=b25EDD6gssUWnFby9gxgcpLIROT
 protoc_gen_swagger/options/annotations_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159
 protoc_gen_swagger/options/openapiv2_pb2.py,sha256=vYElGp8E1vGHszvWqX97zNG9GFJ7u2QcdK9ouq0XdyI,14939
 protoc_gen_swagger/options/openapiv2_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159
-scanoss/__init__.py,sha256=PYRQO5k_j5mM7XuvgMnHH8E6yu_q0uICKeUgA6to0Mk,1163
-scanoss/cli.py,sha256=rsLtipYmDjAQxEIKwQuf9Y5XAcl0p5hZs6ZQ_TcJ-eA,42812
+scanoss/__init__.py,sha256=0h0EuhMJeA8cpYqOnCxwfM-gtnXaB0BFmm8FwkEwnKI,1163
+scanoss/cli.py,sha256=k7RJVh36CwxUwDqOVHkXdArWp4QpzJVCSQ0haJWenKA,46686
 scanoss/components.py,sha256=ZHZ1KA69shxOASZK7USD9yPTITpAc_RXL5q5zpDK23o,12590
 scanoss/csvoutput.py,sha256=hBwr_Fc6mBdOdXgyQcdFrockYH-PJ0jblowlExJ6OPg,9925
-scanoss/cyclonedx.py,sha256=G6HxI8z3NJsOjBRuQJ8ApHQaUOP9-lO8PIBjcJMHchg,12167
+scanoss/cyclonedx.py,sha256=JVBYeR3D-i4yP9cVSyWvm0_7Y8Kr2MC5GxMgRGAf8R0,12585
 scanoss/filecount.py,sha256=o7xb6m387ucnsU4H1OXGzf_AdWsudhAHe49T8uX4Ieo,6660
-scanoss/scancodedeps.py,sha256=dPJsv9BmEsaM1IEzceJCnwLyu6Z0JwPposxdY4q0DAg,10775
-scanoss/scanner.py,sha256=VqLjJh7igR59gTA0jFHvueS6hh8JSs3QgEK7rzPuBbA,51210
-scanoss/scanossapi.py,sha256=5OwRQZ23rdPOL4bA5fXI7xdKnJOgRYaL60HuzZPdu-I,12562
-scanoss/scanossbase.py,sha256=WxYlWl6WxRArho4VKGFxEla8qYnjOXtF6EnwsHTrKm4,2319
+scanoss/results.py,sha256=8AJgXeZRc7Ugf4iM_NvFD8zPD2Y4NLePwNzZKUmmFi4,9885
+scanoss/scancodedeps.py,sha256=_9d7MAV20-FrET7mF7gW-BZiz2eHrtwudgrEcSX0oZQ,11321
+scanoss/scanner.py,sha256=Boxk0A-AuS0DMB4UYArU0PWZ0yJlK4v1YgdeVnKmJck,52023
+scanoss/scanoss_settings.py,sha256=NpNZ2aCpRG2EqfJc9_BK6SnODqkOwVBEq3u-9s0KxPI,5986
+scanoss/scanossapi.py,sha256=TJxPctr-0DTn_26LfM__OAMfntaXzvheFTbdmU-5pnM,11953
+scanoss/scanossbase.py,sha256=ucG85doysZT3KLgApg2CiVm3-YLcdBQ2HmkZ9YnJSxA,2806
 scanoss/scanossgrpc.py,sha256=ythZkr6F0P0hl_KPYoHkos_IL97TxLKeYfAouX_CUnM,20491
+scanoss/scanpostprocessor.py,sha256=tfQk6GBmW1Yd2rqHHp6QKiYVdmTkBAcpoE4HHN__oKo,5899
 scanoss/scantype.py,sha256=R2-ExLGOrYxaJFtIK2AEo2caD0XrN1zpF5q1qT9Zsyc,1326
 scanoss/spdxlite.py,sha256=IsWP9o1D8ryT1_5LeobIEhWJXNFbffoWCy1yaeZY2X0,15638
-scanoss/threadeddependencies.py,sha256=JotQC9X3nnviblKe--OPS-7rr1W-cZjuxsxSPL-tbPg,6284
+scanoss/threadeddependencies.py,sha256=sOIAjiPTmxybKz2yhT4-ixXBeC4K8UQVq6JQj4e8mLc,9906
 scanoss/threadedscanning.py,sha256=T0tL8W1IEX_hLY5ksrAl_iQqtxT_KbyDhTDHo6a7xFE,9387
 scanoss/winnowing.py,sha256=HzMWRYh1XB4so71br-DUPpV6OlmymDfsnU-EOCCObJM,18734
 scanoss/api/__init__.py,sha256=KlDD87JmyZP-10T-fuJo0_v2zt1gxWfTgs70wjky9xg,1139
@@ -47,12 +50,12 @@ scanoss/api/vulnerabilities/__init__.py,sha256=FLQtiDiv85Q1Chk-sJ9ky9WOV1mulZhEK
 scanoss/api/vulnerabilities/v2/__init__.py,sha256=FLQtiDiv85Q1Chk-sJ9ky9WOV1mulZhEKjiBihlwiaM,1139
 scanoss/api/vulnerabilities/v2/scanoss_vulnerabilities_pb2.py,sha256=CFhF80av8tenGvn9AIsGEtRJPuV2dC_syA5JLZb2lDw,5464
 scanoss/api/vulnerabilities/v2/scanoss_vulnerabilities_pb2_grpc.py,sha256=HlS4k4Zmx6RIAqaO9I96jD-eyF5yU6Xx04pVm7pdqOg,6864
-scanoss/data/build_date.txt,sha256=8feY4PDqu0ixPx9lW8xrv7zGbeOE1zZpaCtdJgPoVKc,40
+scanoss/data/build_date.txt,sha256=Y087LKNPYOukJKz1qnrj5bG17xeBavkMK7KMr_uNZZk,40
 scanoss/data/spdx-exceptions.json,sha256=s7UTYxC7jqQXr11YBlIWYCNwN6lRDFTR33Y8rpN_dA4,17953
 scanoss/data/spdx-licenses.json,sha256=A6Z0q82gaTLtnopBfzeIVZjJFxkdRW1g2TuumQc-lII,228794
-scanoss-1.14.0.dist-info/LICENSE,sha256=LLUaXoiyOroIbr5ubAyrxBOwSRLTm35ETO2FmLpy8QQ,1074
-scanoss-1.14.0.dist-info/METADATA,sha256=QjOh1Fz4JLUKb3Za39rv9XAy_Z4vbx84gQKp9EQhuP8,5936
-scanoss-1.14.0.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-scanoss-1.14.0.dist-info/entry_points.txt,sha256=Uy28xnaDL5KQ7V77sZD5VLDXPNxYYzSr5tsqtiXVzAs,48
-scanoss-1.14.0.dist-info/top_level.txt,sha256=V11PrQ6Pnrc-nDF9xnisnJ8e6-i7HqSIKVNqduRWcL8,27
-scanoss-1.14.0.dist-info/RECORD,,
+scanoss-1.16.0.dist-info/LICENSE,sha256=LLUaXoiyOroIbr5ubAyrxBOwSRLTm35ETO2FmLpy8QQ,1074
+scanoss-1.16.0.dist-info/METADATA,sha256=b9mSpB5aYU5kLfcWSjYwiAwAd1uBGI1Stw30NU0rKsY,5936
+scanoss-1.16.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+scanoss-1.16.0.dist-info/entry_points.txt,sha256=Uy28xnaDL5KQ7V77sZD5VLDXPNxYYzSr5tsqtiXVzAs,48
+scanoss-1.16.0.dist-info/top_level.txt,sha256=V11PrQ6Pnrc-nDF9xnisnJ8e6-i7HqSIKVNqduRWcL8,27
+scanoss-1.16.0.dist-info/RECORD,,

{scanoss-1.14.0.dist-info → scanoss-1.16.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any