scanoss 1.23.0__py3-none-any.whl → 1.25.0__py3-none-any.whl

scanoss/__init__.py

@@ -22,4 +22,4 @@ SPDX-License-Identifier: MIT
   THE SOFTWARE.
 """
 
-__version__ = '1.23.0'
+__version__ = '1.25.0'

scanoss/cli.py

@@ -31,6 +31,7 @@ from typing import List
 
 import pypac
 
+from scanoss.cryptography import Cryptography, create_cryptography_config_from_args
 from scanoss.scanners.container_scanner import (
     DEFAULT_SYFT_COMMAND,
     DEFAULT_SYFT_TIMEOUT,
@@ -50,6 +51,7 @@ from scanoss.scanossgrpc import (
 from . import __version__
 from .components import Components
 from .constants import (
+    DEFAULT_API_TIMEOUT,
     DEFAULT_POST_SIZE,
     DEFAULT_RETRY,
     DEFAULT_TIMEOUT,
@@ -292,15 +294,6 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         help='component sub-commands',
     )
 
-    # Component Sub-command: component crypto
-    c_crypto = comp_sub.add_parser(
-        'crypto',
-        aliases=['cr'],
-        description=f'Show Cryptographic algorithms: {__version__}',
-        help='Retrieve cryptographic algorithms for the given components',
-    )
-    c_crypto.set_defaults(func=comp_crypto)
-
     # Component Sub-command: component vulns
     c_vulns = comp_sub.add_parser(
         'vulns',
@@ -361,18 +354,76 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
     c_versions.add_argument('--limit', '-l', type=int, help='Generic component search')
     c_versions.set_defaults(func=comp_versions)
 
+    # Sub-command: crypto
+    p_crypto = subparsers.add_parser(
+        'crypto',
+        aliases=['cr'],
+        description=f'SCANOSS Crypto commands: {__version__}',
+        help='Crypto support commands',
+    )
+    crypto_sub = p_crypto.add_subparsers(
+        title='Crypto Commands',
+        dest='subparsercmd',
+        description='crypto sub-commands',
+        help='crypto sub-commands',
+    )
+
+    # GetAlgorithms and GetAlgorithmsInRange gRPC APIs
+    p_crypto_algorithms = crypto_sub.add_parser(
+        'algorithms',
+        aliases=['alg'],
+        description=f'Show Cryptographic algorithms: {__version__}',
+        help='Retrieve cryptographic algorithms for the given components',
+    )
+    p_crypto_algorithms.add_argument(
+        '--with-range',
+        action='store_true',
+        help='Returns the list of versions in the specified range that contains cryptographic algorithms',
+    )
+    p_crypto_algorithms.set_defaults(func=crypto_algorithms)
+
+    # GetEncryptionHints and GetHintsInRange gRPC APIs
+    p_crypto_hints = crypto_sub.add_parser(
+        'hints',
+        description=f'Show Encryption hints: {__version__}',
+        help='Retrieve encryption hints for the given components',
+    )
+    p_crypto_hints.add_argument(
+        '--with-range',
+        action='store_true',
+        help='Returns the list of versions in the specified range that contains encryption hints',
+    )
+    p_crypto_hints.set_defaults(func=crypto_hints)
+
+    p_crypto_versions_in_range = crypto_sub.add_parser(
+        'versions-in-range',
+        aliases=['vr'],
+        description=f'Show versions in range: {__version__}',
+        help="Given a list of PURLS and version ranges, get a list of versions that do/don't contain crypto algorithms",
+    )
+    p_crypto_versions_in_range.set_defaults(func=crypto_versions_in_range)
+
     # Common purl Component sub-command options
-    for p in [c_crypto, c_vulns, c_semgrep, c_provenance]:
+    for p in [c_vulns, c_semgrep, c_provenance, p_crypto_algorithms, p_crypto_hints, p_crypto_versions_in_range]:
         p.add_argument('--purl', '-p', type=str, nargs='*', help='Package URL - PURL to process.')
         p.add_argument('--input', '-i', type=str, help='Input file name')
 
     # Common Component sub-command options
-    for p in [c_crypto, c_vulns, c_search, c_versions, c_semgrep, c_provenance]:
+    for p in [
+        c_vulns,
+        c_search,
+        c_versions,
+        c_semgrep,
+        c_provenance,
+        p_crypto_algorithms,
+        p_crypto_hints,
+        p_crypto_versions_in_range,
+    ]:
         p.add_argument(
             '--timeout',
             '-M',
             type=int,
-            default=600,
+            default=DEFAULT_API_TIMEOUT,
             help='Timeout (in seconds) for API communication (optional - default 600)',
         )
 
@@ -588,7 +639,6 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         p_dep,
         p_fc,
         p_cnv,
-        c_crypto,
         c_vulns,
         c_search,
         c_versions,
@@ -597,6 +647,9 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         p_c_dwnld,
         p_folder_scan,
         p_folder_hash,
+        p_crypto_algorithms,
+        p_crypto_hints,
+        p_crypto_versions_in_range,
     ]:
         p.add_argument('--output', '-o', type=str, help='Output result file name (optional - default stdout).')
 
@@ -674,7 +727,6 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
     # Global Scan/GRPC options
     for p in [
         p_scan,
-        c_crypto,
         c_vulns,
         c_search,
         c_versions,
@@ -682,6 +734,9 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         c_provenance,
         p_folder_scan,
         p_cs,
+        p_crypto_algorithms,
+        p_crypto_hints,
+        p_crypto_versions_in_range,
     ]:
         p.add_argument(
             '--key', '-k', type=str, help='SCANOSS API Key token (optional - not required for default OSSKB URL)'
@@ -708,7 +763,19 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         )
 
     # Global GRPC options
-    for p in [p_scan, c_crypto, c_vulns, c_search, c_versions, c_semgrep, c_provenance, p_folder_scan, p_cs]:
+    for p in [
+        p_scan,
+        c_vulns,
+        c_search,
+        c_versions,
+        c_semgrep,
+        c_provenance,
+        p_folder_scan,
+        p_cs,
+        p_crypto_algorithms,
+        p_crypto_hints,
+        p_crypto_versions_in_range,
+    ]:
         p.add_argument(
             '--api2url', type=str, help='SCANOSS gRPC API 2.0 URL (optional - default: https://api.osskb.org)'
         )
@@ -751,7 +818,6 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         p_c_loc,
         p_c_dwnld,
         p_p_proxy,
-        c_crypto,
         c_vulns,
         c_search,
         c_versions,
@@ -763,6 +829,9 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         p_folder_scan,
         p_folder_hash,
         p_cs,
+        p_crypto_algorithms,
+        p_crypto_hints,
+        p_crypto_versions_in_range,
     ]:
         p.add_argument('--debug', '-d', action='store_true', help='Enable debug messages')
         p.add_argument('--trace', '-t', action='store_true', help='Enable trace messages, including API posts')
@@ -775,7 +844,9 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
     if not args.subparser:
         parser.print_help()  # No sub command subcommand, print general help
         sys.exit(1)
-    elif (args.subparser in ('utils', 'ut', 'component', 'comp', 'inspect', 'insp', 'ins')) and not args.subparsercmd:
+    elif (
+        args.subparser in ('utils', 'ut', 'component', 'comp', 'inspect', 'insp', 'ins', 'crypto', 'cr')
+    ) and not args.subparsercmd:
         parser.parse_args([args.subparser, '--help'])  # Force utils helps to be displayed
         sys.exit(1)
     args.func(parser, args)  # Execute the function associated with the sub-command
@@ -1393,9 +1464,9 @@ def get_pac_file(pac: str):
     return pac_file
 
 
-def comp_crypto(parser, args):
+def crypto_algorithms(parser, args):
     """
-    Run the "component crypto" sub-command
+    Run the "crypto algorithms" sub-command
     Parameters
     ----------
         parser: ArgumentParser
@@ -1410,22 +1481,112 @@ def comp_crypto(parser, args):
     if args.ca_cert and not os.path.exists(args.ca_cert):
         print_stderr(f'Error: Certificate file does not exist: {args.ca_cert}.')
         sys.exit(1)
-    pac_file = get_pac_file(args.pac)
 
-    comps = Components(
-        debug=args.debug,
-        trace=args.trace,
-        quiet=args.quiet,
-        grpc_url=args.api2url,
-        api_key=args.key,
-        ca_cert=args.ca_cert,
-        proxy=args.proxy,
-        grpc_proxy=args.grpc_proxy,
-        pac=pac_file,
-        timeout=args.timeout,
-        req_headers=process_req_headers(args.header),
-    )
-    if not comps.get_crypto_details(args.input, args.purl, args.output):
+    try:
+        config = create_cryptography_config_from_args(args)
+        grpc_config = create_grpc_config_from_args(args)
+        if args.pac:
+            grpc_config.pac = get_pac_file(args.pac)
+        if args.header:
+            grpc_config.req_headers = process_req_headers(args.header)
+        client = ScanossGrpc(**asdict(grpc_config))
+
+        cryptography = Cryptography(config=config, client=client)
+        cryptography.get_algorithms()
+        cryptography.present(output_file=args.output)
+    except ScanossGrpcError as e:
+        print_stderr(f'API ERROR: {e}')
+        sys.exit(1)
+    except Exception as e:
+        if args.debug:
+            import traceback
+
+            traceback.print_exc()
+        print_stderr(f'ERROR: {e}')
+        sys.exit(1)
+
+
+def crypto_hints(parser, args):
+    """
+    Run the "crypto hints" sub-command
+    Parameters
+    ----------
+        parser: ArgumentParser
+            command line parser object
+        args: Namespace
+            Parsed arguments
+    """
+    if (not args.purl and not args.input) or (args.purl and args.input):
+        print_stderr('Please specify an input file or purl to decorate (--purl or --input)')
+        parser.parse_args([args.subparser, args.subparsercmd, '-h'])
+        sys.exit(1)
+    if args.ca_cert and not os.path.exists(args.ca_cert):
+        print_stderr(f'Error: Certificate file does not exist: {args.ca_cert}.')
+        sys.exit(1)
+
+    try:
+        config = create_cryptography_config_from_args(args)
+        grpc_config = create_grpc_config_from_args(args)
+        if args.pac:
+            grpc_config.pac = get_pac_file(args.pac)
+        if args.header:
+            grpc_config.req_headers = process_req_headers(args.header)
+        client = ScanossGrpc(**asdict(grpc_config))
+
+        cryptography = Cryptography(config=config, client=client)
+        cryptography.get_encryption_hints()
+        cryptography.present(output_file=args.output)
+    except ScanossGrpcError as e:
+        print_stderr(f'API ERROR: {e}')
+        sys.exit(1)
+    except Exception as e:
+        if args.debug:
+            import traceback
+
+            traceback.print_exc()
+        print_stderr(f'ERROR: {e}')
+        sys.exit(1)
+
+
+def crypto_versions_in_range(parser, args):
+    """
+    Run the "crypto versions-in-range" sub-command
+    Parameters
+    ----------
+        parser: ArgumentParser
+            command line parser object
+        args: Namespace
+            Parsed arguments
+    """
+    if (not args.purl and not args.input) or (args.purl and args.input):
+        print_stderr('Please specify an input file or purl to decorate (--purl or --input)')
+        parser.parse_args([args.subparser, args.subparsercmd, '-h'])
+        sys.exit(1)
+    if args.ca_cert and not os.path.exists(args.ca_cert):
+        print_stderr(f'Error: Certificate file does not exist: {args.ca_cert}.')
+        sys.exit(1)
+
+    try:
+        config = create_cryptography_config_from_args(args)
+        grpc_config = create_grpc_config_from_args(args)
+        if args.pac:
+            grpc_config.pac = get_pac_file(args.pac)
+        if args.header:
+            grpc_config.req_headers = process_req_headers(args.header)
+        client = ScanossGrpc(**asdict(grpc_config))
+
+        cryptography = Cryptography(config=config, client=client)
+        cryptography.get_versions_in_range()
+        cryptography.present(output_file=args.output)
+    except ScanossGrpcError as e:
+        print_stderr(f'API ERROR: {e}')
+        sys.exit(1)
+    except Exception as e:
+        if args.debug:
+            import traceback
+
+            traceback.print_exc()
+        print_stderr(f'ERROR: {e}')
         sys.exit(1)
 
 

scanoss/constants.py

@@ -10,3 +10,5 @@ DEFAULT_NB_THREADS = 5
 
 DEFAULT_URL = 'https://api.osskb.org'  # default free service URL
 DEFAULT_URL2 = 'https://api.scanoss.com'  # default premium service URL
+
+DEFAULT_API_TIMEOUT = 600

scanoss/cryptography.py

@@ -0,0 +1,274 @@
+import json
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+from scanoss.scanossbase import ScanossBase
+from scanoss.scanossgrpc import ScanossGrpc
+from scanoss.utils.abstract_presenter import AbstractPresenter
+from scanoss.utils.file import validate_json_file
+
+
+class ScanossCryptographyError(Exception):
+    pass
+
+
+MIN_SPLIT_PARTS = 2
+
+
+@dataclass
+class CryptographyConfig:
+    purl: List[str]
+    input_file: Optional[str] = None
+    output_file: Optional[str] = None
+    header: Optional[str] = None
+    debug: bool = False
+    trace: bool = False
+    quiet: bool = False
+    with_range: bool = False
+
+    def __post_init__(self):
+        """
+        Validate that the configuration is valid.
+        """
+        if self.purl:
+            if self.with_range:
+                for purl in self.purl:
+                    parts = purl.split('@')
+                    if not (len(parts) >= MIN_SPLIT_PARTS and parts[1]):
+                        raise ScanossCryptographyError(
+                            f'Invalid PURL format: "{purl}".' f'It must include a version (e.g., pkg:type/name@version)'
+                        )
+        if self.input_file:
+            input_file_validation = validate_json_file(self.input_file)
+            if not input_file_validation.is_valid:
+                raise ScanossCryptographyError(
+                    f'There was a problem with the purl input file. {input_file_validation.error}'
+                )
+            if (
+                not isinstance(input_file_validation.data, dict)
+                or 'purls' not in input_file_validation.data
+                or not isinstance(input_file_validation.data['purls'], list)
+                or not all(isinstance(p, dict) and 'purl' in p for p in input_file_validation.data['purls'])
+            ):
+                raise ScanossCryptographyError('The supplied input file is not in the correct PurlRequest format.')
+            purls = input_file_validation.data['purls']
+            purls_with_requirement = []
+            if self.with_range:
+                if any('requirement' not in p for p in purls):
+                    raise ScanossCryptographyError(
+                        f'One or more PURLs in "{self.input_file}" are missing the "requirement" field.'
+                    )
+                else:
+                    for purl in purls:
+                        purls_with_requirement.append(f'{purl["purl"]}@{purl["requirement"]}')
+            else:
+                purls_with_requirement = purls
+            self.purl = purls_with_requirement
+
+
+def create_cryptography_config_from_args(args) -> CryptographyConfig:
+    return CryptographyConfig(
+        debug=getattr(args, 'debug', False),
+        trace=getattr(args, 'trace', False),
+        quiet=getattr(args, 'quiet', False),
+        with_range=getattr(args, 'with_range', False),
+        purl=getattr(args, 'purl', []),
+        input_file=getattr(args, 'input', None),
+        output_file=getattr(args, 'output', None),
+        header=getattr(args, 'header', None),
+    )
+
+
+class Cryptography:
+    """
+    Cryptography Class
+
+    This class is used to decorate purls with cryptography information.
+    """
+
+    def __init__(
+        self,
+        config: CryptographyConfig,
+        client: ScanossGrpc,
+    ):
+        """
+        Initialize the Cryptography.
+
+        Args:
+            config (CryptographyConfig): Configuration parameters for the cryptography.
+            client (ScanossGrpc): gRPC client for communicating with the scanning service.
+        """
+        self.base = ScanossBase(
+            debug=config.debug,
+            trace=config.trace,
+            quiet=config.quiet,
+        )
+        self.presenter = CryptographyPresenter(
+            self,
+            debug=config.debug,
+            trace=config.trace,
+            quiet=config.quiet,
+        )
+
+        self.client = client
+        self.config = config
+        self.purls_request = self._build_purls_request()
+        self.results = None
+
+    def get_algorithms(self) -> Optional[Dict]:
+        """
+        Get the cryptographic algorithms for the provided purl or input file.
+
+        Returns:
+            Optional[Dict]: The folder hash response from the gRPC client, or None if an error occurs.
+        """
+
+        if not self.purls_request:
+            raise ScanossCryptographyError('No PURLs supplied. Provide --purl or --input.')
+        self.base.print_stderr(
+            f'Getting cryptographic algorithms for {", ".join([p["purl"] for p in self.purls_request["purls"]])}'
+        )
+        if self.config.with_range:
+            response = self.client.get_crypto_algorithms_in_range_for_purl(self.purls_request)
+        else:
+            response = self.client.get_crypto_algorithms_for_purl(self.purls_request)
+        if response:
+            self.results = response
+
+        return self.results
+
+    def get_encryption_hints(self) -> Optional[Dict]:
+        """
+        Get the encryption hints for the provided purl or input file.
+
+        Returns:
+            Optional[Dict]: The encryption hints response from the gRPC client, or None if an error occurs.
+        """
+
+        if not self.purls_request:
+            raise ScanossCryptographyError('No PURLs supplied. Provide --purl or --input.')
+        self.base.print_stderr(
+            f'Getting encryption hints '
+            f'{"in range" if self.config.with_range else ""} '
+            f'for {", ".join([p["purl"] for p in self.purls_request["purls"]])}'
+        )
+        if self.config.with_range:
+            response = self.client.get_encryption_hints_in_range_for_purl(self.purls_request)
+        else:
+            response = self.client.get_encryption_hints_for_purl(self.purls_request)
+        if response:
+            self.results = response
+
+        return self.results
+
+    def get_versions_in_range(self) -> Optional[Dict]:
+        """
+        Given a list of PURLS and version ranges, get a list of versions that do/do not contain cryptographic algorithms
+
+        Returns:
+            Optional[Dict]: The versions in range response from the gRPC client, or None if an error occurs.
+        """
+
+        if not self.purls_request:
+            raise ScanossCryptographyError('No PURLs supplied. Provide --purl or --input.')
+
+        self.base.print_stderr(
+            f'Getting versions in range for {", ".join([p["purl"] for p in self.purls_request["purls"]])}'
+        )
+
+        response = self.client.get_versions_in_range_for_purl(self.purls_request)
+        if response:
+            self.results = response
+
+        return self.results
+
+    def _build_purls_request(
+        self,
+    ) -> Optional[dict]:
+        """
+        Load the specified purls from a JSON file or a list of PURLs and return a dictionary
+
+        Args:
+            json_file (Optional[str], optional): The JSON file containing the PURLs. Defaults to None.
+            purls (Optional[List[str]], optional): The list of PURLs. Defaults to None.
+
+        Returns:
+            Optional[dict]: The dictionary containing the PURLs
+        """
+        return {
+            'purls': [
+                {
+                    'purl': p,
+                    'requirement': self._extract_version_from_purl(p),
+                }
+                for p in self.config.purl
+            ]
+        }
+
+    def _extract_version_from_purl(self, purl: str) -> str:
+        """
+        Extract version from purl
+
+        Args:
+            purl (str): The purl string to extract the version from
+
+        Returns:
+            str: The extracted version
+
+        Raises:
+            ScanossCryptographyError: If the purl is not in the correct format
+        """
+        try:
+            return purl.split('@')[-1]
+        except IndexError:
+            raise ScanossCryptographyError(f'Invalid purl format: {purl}')
+
+    def present(
+        self,
+        output_format: Optional[str] = None,
+        output_file: Optional[str] = None,
+    ):
+        """Present the results in the selected format"""
+        self.presenter.present(output_format=output_format, output_file=output_file)
+
+
+class CryptographyPresenter(AbstractPresenter):
+    """
+    Cryptography presenter class
+    Handles the presentation of the cryptography results
+    """
+
+    def __init__(self, cryptography: Cryptography, **kwargs):
+        super().__init__(**kwargs)
+        self.cryptography = cryptography
+
+    def _format_json_output(self) -> str:
+        """
+        Format the scan output data into a JSON object
+
+        Returns:
+            str: The formatted JSON string
+        """
+        return json.dumps(self.cryptography.results, indent=2)
+
+    def _format_plain_output(self) -> str:
+        """
+        Format the scan output data into a plain text string
+        """
+        return (
+            json.dumps(self.cryptography.results, indent=2)
+            if isinstance(self.cryptography.results, dict)
+            else str(self.cryptography.results)
+        )
+
+    def _format_cyclonedx_output(self) -> str:
+        raise NotImplementedError('CycloneDX output is not implemented')
+
+    def _format_spdxlite_output(self) -> str:
+        raise NotImplementedError('SPDXlite output is not implemented')
+
+    def _format_csv_output(self) -> str:
+        raise NotImplementedError('CSV output is not implemented')
+
+    def _format_raw_output(self) -> str:
+        raise NotImplementedError('Raw output is not implemented')

scanoss/data/build_date.txt

@@ -1 +1 @@
-date: 20250425091203, utime: 1745572323
+date: 20250610161304, utime: 1749571984

scanoss/inspection/policy_check.py

@@ -26,9 +26,10 @@ import json
 import os.path
 from abc import abstractmethod
 from enum import Enum
-from typing import Callable, List, Dict, Any
-from .utils.license_utils import LicenseUtil
+from typing import Any, Callable, Dict, List
+
 from ..scanossbase import ScanossBase
+from .utils.license_utils import LicenseUtil
 
 
 class PolicyStatus(Enum):
@@ -87,7 +88,7 @@ class PolicyCheck(ScanossBase):
 
     VALID_FORMATS = {'md', 'json', 'jira_md'}
 
-    def __init__(
+    def __init__( # noqa: PLR0913
         self,
         debug: bool = False,
         trace: bool = True,
@@ -181,10 +182,9 @@ class PolicyCheck(ScanossBase):
         :param status: The new component status
         :return: The updated components dictionary
         """
-
         # Determine the component key and purl based on component type
         if id in [ComponentID.FILE.value, ComponentID.SNIPPET.value]:
-            purl = new_component['purl'][0]  # Take first purl for these component types
+            purl = new_component['purl'][0]  # Take the first purl for these component types
         else:
             purl = new_component['purl']
 
@@ -195,14 +195,13 @@ class PolicyCheck(ScanossBase):
             'licenses': {},
             'status': status,
         }
-
         if not new_component.get('licenses'):
-            self.print_stderr(f'WARNING: Results missing licenses. Skipping.')
+            self.print_debug(f'WARNING: Results missing licenses. Skipping: {new_component}')
             return components
         # Process licenses for this component
-        for l in new_component['licenses']:
-            if l.get('name'):
-                spdxid = l['name']
+        for license_item in new_component['licenses']:
+            if license_item.get('name'):
+                spdxid = license_item['name']
                 components[component_key]['licenses'][spdxid] = {
                     'spdxid': spdxid,
                     'copyleft': self.license_util.is_copyleft(spdxid),
@@ -210,71 +209,103 @@ class PolicyCheck(ScanossBase):
                 }
         return components
 
-    def _get_components_from_results(self, results: Dict[str, Any]) -> list or None:
+    def _get_components_data(self, results: Dict[str, Any], components: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Process the results dictionary to extract and format component information.
-
-        This function iterates through the results dictionary, identifying components from
-        different sources (files, snippets, and dependencies). It consolidates this information
-        into a list of unique components, each with its associated licenses and other details.
+        Extract and process file and snippet components from results.
 
         :param results: A dictionary containing the raw results of a component scan
-        :return: A list of dictionaries, each representing a unique component with its details
+        :param components: Existing components dictionary to update
+        :return: Updated components dictionary with file and snippet data
         """
-        if results is None:
-            self.print_stderr(f'ERROR: Results cannot be empty')
-            return None
-        components = {}
         for component in results.values():
             for c in component:
                 component_id = c.get('id')
                 if not component_id:
-                    self.print_stderr(f'WARNING: Result missing id. Skipping.')
+                    self.print_debug(f'WARNING: Result missing id. Skipping: {c}')
                     continue
                 status = c.get('status')
-                if not component_id:
-                    self.print_stderr(f'WARNING: Result missing status. Skipping.')
+                if not status:
+                    self.print_debug(f'WARNING: Result missing status. Skipping: {c}')
                     continue
                 if component_id in [ComponentID.FILE.value, ComponentID.SNIPPET.value]:
                     if not c.get('purl'):
-                        self.print_stderr(f'WARNING: Result missing purl. Skipping.')
+                        self.print_debug(f'WARNING: Result missing purl. Skipping: {c}')
                         continue
                     if len(c.get('purl')) <= 0:
-                        self.print_stderr(f'WARNING: Result missing purls. Skipping.')
+                        self.print_debug(f'WARNING: Result missing purls. Skipping: {c}')
                         continue
                     if not c.get('version'):
-                        self.print_stderr(f'WARNING: Result missing version. Skipping.')
+                        self.print_msg(f'WARNING: Result missing version. Skipping: {c}')
                         continue
                     component_key = f'{c["purl"][0]}@{c["version"]}'
-                    # Initialize or update the component entry
                     if component_key not in components:
                         components = self._append_component(components, c, component_id, status)
+            # End component loop
+        # End components loop
+        return components
 
-                if c['id'] == ComponentID.DEPENDENCY.value:
+    def _get_dependencies_data(self, results: Dict[str, Any], 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 c in component:
+                component_id = c.get('id')
+                if not component_id:
+                    self.print_debug(f'WARNING: Result missing id. Skipping: {c}')
+                    continue
+                status = c.get('status')
+                if not status:
+                    self.print_debug(f'WARNING: Result missing status. Skipping: {c}')
+                    continue
+                if component_id == ComponentID.DEPENDENCY.value:
                     if c.get('dependencies') is None:
                         continue
-                    for d in c['dependencies']:
-                        if not d.get('purl'):
-                            self.print_stderr(f'WARNING: Result missing purl. Skipping.')
-                            continue
-                        if len(d.get('purl')) <= 0:
-                            self.print_stderr(f'WARNING: Result missing purls. Skipping.')
+                    for dependency in c['dependencies']:
+                        if not dependency.get('purl'):
+                            self.print_debug(f'WARNING: Dependency result missing purl. Skipping: {dependency}')
                             continue
-                        if not d.get('version'):
-                            self.print_stderr(f'WARNING: Result missing version. Skipping.')
+                        if not dependency.get('version'):
+                            self.print_msg(f'WARNING: Dependency result missing version. Skipping: {dependency}')
                             continue
-                        component_key = f'{d["purl"]}@{d["version"]}'
+                        component_key = f'{dependency["purl"]}@{dependency["version"]}'
                         if component_key not in components:
-                            components = self._append_component(components, d, component_id, status)
-                    # End of dependencies loop
-                # End if
-            # End of component loop
-        # End of results loop
-        results = list(components.values())
-        for component in results:
+                            components = self._append_component(components, dependency, component_id, status)
+                    # End dependency loop
+            # End component loop
+        # End of result loop
+        return components
+
+    def _get_components_from_results(self, results: Dict[str, Any]) -> list or None:
+        """
+        Process the results dictionary to extract and format component information.
+
+        This function iterates through the results dictionary, identifying components from
+        different sources (files, snippets, and dependencies). It consolidates this information
+        into a list of unique components, each with its associated licenses and other details.
+
+        :param results: A dictionary containing the raw results of a component scan
+        :return: A list of dictionaries, each representing a unique component with its details
+        """
+        if results is None:
+            self.print_stderr('ERROR: Results cannot be empty')
+            return None
+        
+        components = {}
+        # Extract file and snippet components
+        components = self._get_components_data(results, components)
+        # Extract dependency components
+        components = self._get_dependencies_data(results, components)
+        # Convert to list and process licenses
+        results_list = list(components.values())
+        for component in results_list:
             component['licenses'] = list(component['licenses'].values())
 
-        return results
+        return results_list
 
     def generate_table(self, headers, rows, centered_columns=None):
         """
@@ -403,7 +434,6 @@ class PolicyCheck(ScanossBase):
         components = self._get_components_from_results(self.results)
         return components
 
-
 #
 # End of PolicyCheck Class
 #

scanoss/scanossgrpc.py

@@ -54,7 +54,6 @@ from .api.components.v2.scanoss_components_pb2 import (
     CompVersionResponse,
 )
 from .api.components.v2.scanoss_components_pb2_grpc import ComponentsStub
-from .api.cryptography.v2.scanoss_cryptography_pb2 import AlgorithmResponse
 from .api.cryptography.v2.scanoss_cryptography_pb2_grpc import CryptographyStub
 from .api.dependencies.v2.scanoss_dependencies_pb2 import DependencyRequest
 from .api.dependencies.v2.scanoss_dependencies_pb2_grpc import DependenciesStub
@@ -312,36 +311,6 @@ class ScanossGrpc(ScanossBase):
                     merged_response['status'] = response['status']
         return merged_response
 
-    def get_crypto_json(self, purls: dict) -> dict:
-        """
-        Client function to call the rpc for Cryptography GetAlgorithms
-        :param purls: Message to send to the service
-        :return: Server response or None
-        """
-        if not purls:
-            self.print_stderr('ERROR: No message supplied to send to gRPC service.')
-            return None
-        request_id = str(uuid.uuid4())
-        resp: AlgorithmResponse
-        try:
-            request = ParseDict(purls, PurlRequest())  # Parse the JSON/Dict into the purl request object
-            metadata = self.metadata[:]
-            metadata.append(('x-request-id', request_id))  # Set a Request ID
-            self.print_debug(f'Sending crypto data for decoration (rqId: {request_id})...')
-            resp = self.crypto_stub.GetAlgorithms(request, metadata=metadata, timeout=self.timeout)
-        except Exception as e:
-            self.print_stderr(
-                f'ERROR: {e.__class__.__name__} Problem encountered sending gRPC message (rqId: {request_id}): {e}'
-            )
-        else:
-            if resp:
-                if not self._check_status_response(resp.status, request_id):
-                    return None
-                resp_dict = MessageToDict(resp, preserving_proto_field_name=True)  # Convert gRPC response to a dict
-                del resp_dict['status']
-                return resp_dict
-        return None
-
     def get_vulnerabilities_json(self, purls: dict) -> dict:
         """
         Client function to call the rpc for Vulnerability GetVulnerabilities
@@ -607,6 +576,91 @@ class ScanossGrpc(ScanossBase):
             'Sending data for provenance origin decoration (rqId: {rqId})...',
         )
 
+    def get_crypto_algorithms_for_purl(self, request: Dict) -> Optional[Dict]:
+        """
+        Client function to call the rpc for GetAlgorithms for a list of purls
+
+        Args:
+            request (Dict): PurlRequest
+
+        Returns:
+            Optional[Dict]: AlgorithmResponse, or None if the request was not successfull
+        """
+        return self._call_rpc(
+            self.crypto_stub.GetAlgorithms,
+            request,
+            PurlRequest,
+            'Sending data for cryptographic algorithms decoration (rqId: {rqId})...',
+        )
+
+    def get_crypto_algorithms_in_range_for_purl(self, request: Dict) -> Optional[Dict]:
+        """
+        Client function to call the rpc for GetAlgorithmsInRange for a list of purls
+
+        Args:
+            request (Dict): PurlRequest
+
+        Returns:
+            Optional[Dict]: AlgorithmsInRangeResponse, or None if the request was not successfull
+        """
+        return self._call_rpc(
+            self.crypto_stub.GetAlgorithmsInRange,
+            request,
+            PurlRequest,
+            'Sending data for cryptographic algorithms in range decoration (rqId: {rqId})...',
+        )
+
+    def get_encryption_hints_for_purl(self, request: Dict) -> Optional[Dict]:
+        """
+        Client function to call the rpc for GetEncryptionHints for a list of purls
+
+        Args:
+            request (Dict): PurlRequest
+
+        Returns:
+            Optional[Dict]: HintsResponse, or None if the request was not successfull
+        """
+        return self._call_rpc(
+            self.crypto_stub.GetEncryptionHints,
+            request,
+            PurlRequest,
+            'Sending data for encryption hints decoration (rqId: {rqId})...',
+        )
+
+    def get_encryption_hints_in_range_for_purl(self, request: Dict) -> Optional[Dict]:
+        """
+        Client function to call the rpc for GetHintsInRange for a list of purls
+
+        Args:
+            request (Dict): PurlRequest
+
+        Returns:
+            Optional[Dict]: HintsInRangeResponse, or None if the request was not successfull
+        """
+        return self._call_rpc(
+            self.crypto_stub.GetHintsInRange,
+            request,
+            PurlRequest,
+            'Sending data for encryption hints in range decoration (rqId: {rqId})...',
+        )
+
+    def get_versions_in_range_for_purl(self, request: Dict) -> Optional[Dict]:
+        """
+        Client function to call the rpc for GetVersionsInRange for a list of purls
+
+        Args:
+            request (Dict): PurlRequest
+
+        Returns:
+            Optional[Dict]: VersionsInRangeResponse, or None if the request was not successfull
+        """
+        return self._call_rpc(
+            self.crypto_stub.GetVersionsInRange,
+            request,
+            PurlRequest,
+            'Sending data for cryptographic versions in range decoration (rqId: {rqId})...',
+        )
+
     def load_generic_headers(self):
         """
         Adds custom headers from req_headers to metadata.
@@ -637,10 +691,11 @@ class GrpcConfig:
     quiet: Optional[bool] = False
     ver_details: Optional[str] = None
     ca_cert: Optional[str] = None
-    pac: Optional[PACFile] = None
     timeout: Optional[int] = DEFAULT_TIMEOUT
     proxy: Optional[str] = None
     grpc_proxy: Optional[str] = None
+    pac: Optional[PACFile] = None
+    req_headers: Optional[dict] = None
 
 
 def create_grpc_config_from_args(args) -> GrpcConfig:
@@ -652,7 +707,6 @@ def create_grpc_config_from_args(args) -> GrpcConfig:
         quiet=getattr(args, 'quiet', False),
         ver_details=getattr(args, 'ver_details', None),
         ca_cert=getattr(args, 'ca_cert', None),
-        pac=getattr(args, 'pac', None),
         timeout=getattr(args, 'timeout', DEFAULT_TIMEOUT),
         proxy=getattr(args, 'proxy', None),
         grpc_proxy=getattr(args, 'grpc_proxy', None),

scanoss/utils/file.py

@@ -49,8 +49,8 @@ def validate_json_file(json_file_path: str) -> JsonValidation:
         json_file_path (str): The JSON file to validate
 
     Returns:
-        Tuple[bool, str]: A tuple containing a boolean indicating if the file is valid and a message
-    """
+        JsonValidation: A JsonValidation object containing a boolean indicating if the file is valid, the data, error, and error code
+    """  # noqa: E501
     if not json_file_path:
         return JsonValidation(is_valid=False, error='No JSON file specified')
     if not os.path.isfile(json_file_path):

scanoss/winnowing.py

@@ -32,9 +32,10 @@ import hashlib
 import pathlib
 import platform
 import re
+from typing import Tuple
 
-from crc32c import crc32c
 from binaryornot.check import is_binary
+from crc32c import crc32c
 
 from .scanossbase import ScanossBase
 
@@ -157,7 +158,7 @@ class Winnowing(ScanossBase):
     a list of WFP fingerprints with their corresponding line numbers.
     """
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         size_limit: bool = False,
         debug: bool = False,
@@ -197,6 +198,7 @@ class Winnowing(ScanossBase):
         self.strip_hpsm_ids = strip_hpsm_ids
         self.strip_snippet_ids = strip_snippet_ids
         self.hpsm = hpsm
+        self.is_windows = platform.system() == 'Windows'
         if hpsm:
             self.crc8_maxim_dow_table = []
             self.crc8_generate_table()
@@ -218,11 +220,11 @@ class Winnowing(ScanossBase):
             return byte
         if byte >= ASCII_a:
             return byte
-        if (byte >= 65) and (byte <= 90):
+        if (byte >= ASCII_A) and (byte <= ASCII_Z):
             return byte + 32
         return 0
 
-    def __skip_snippets(self, file: str, src: str) -> bool:
+    def __skip_snippets(self, file: str, src: str) -> bool:  # noqa: PLR0911
         """
         Determine files that are not of interest based on their content or file extension
         Parameters
@@ -351,7 +353,55 @@ class Winnowing(ScanossBase):
             self.print_debug(f'Stripped snippet ids from {file}')
         return wfp
 
-    def wfp_for_contents(self, file: str, bin_file: bool, contents: bytes) -> str:
+    def __detect_line_endings(self, contents: bytes) -> Tuple[bool, bool, bool]:
+        """Detect the types of line endings present in file contents.
+
+        Args:
+            contents: File contents as bytes.
+
+        Returns:
+            Tuple of (has_crlf, has_lf_only, has_cr_only, has_mixed) indicating which line ending types are present.
+        """
+        has_crlf = b'\r\n' in contents
+        # For LF detection, we need to find LF that's not part of CRLF
+        content_without_crlf = contents.replace(b'\r\n', b'')
+        has_standalone_lf = b'\n' in content_without_crlf
+        # For CR detection, we need to find CR that's not part of CRLF
+        has_standalone_cr = b'\r' in content_without_crlf
+
+        return has_crlf, has_standalone_lf, has_standalone_cr
+
+    def __calculate_opposite_line_ending_hash(self, contents: bytes):
+        """Calculate hash for contents with opposite line endings.
+
+        If the file is primarily Unix (LF), calculates Windows (CRLF) hash.
+        If the file is primarily Windows (CRLF), calculates Unix (LF) hash.
+
+        Args:
+            contents: File contents as bytes.
+
+        Returns:
+            Hash with opposite line endings as hex string, or None if no line endings detected.
+        """
+        has_crlf, has_standalone_lf, has_standalone_cr = self.__detect_line_endings(contents)
+
+        if not has_crlf and not has_standalone_lf and not has_standalone_cr:
+            return None
+
+        # Normalize all line endings to LF first
+        normalized = contents.replace(b'\r\n', b'\n').replace(b'\r', b'\n')
+
+        # Determine the dominant line ending type
+        if has_crlf and not has_standalone_lf and not has_standalone_cr:
+            # File is Windows (CRLF) - produce Unix (LF) hash
+            opposite_contents = normalized
+        else:
+            # File is Unix (LF/CR) or mixed - produce Windows (CRLF) hash
+            opposite_contents = normalized.replace(b'\n', b'\r\n')
+
+        return hashlib.md5(opposite_contents).hexdigest()
+
+    def wfp_for_contents(self, file: str, bin_file: bool, contents: bytes) -> str:  # noqa: PLR0912, PLR0915
         """
         Generate a Winnowing fingerprint (WFP) for the given file contents
         Parameters
@@ -371,7 +421,7 @@ class Winnowing(ScanossBase):
         content_length = len(contents)
         original_filename = file
 
-        if platform.system() == 'Windows':
+        if self.is_windows:
             original_filename = file.replace('\\', '/')
         wfp_filename = repr(original_filename).strip("'")  # return a utf-8 compatible version of the filename
         if self.obfuscate:  # hide the real size of the file and its name, but keep the suffix
@@ -380,6 +430,13 @@ class Winnowing(ScanossBase):
             self.file_map[wfp_filename] = original_filename  # Save the file name map for later (reverse lookup)
 
         wfp = 'file={0},{1},{2}\n'.format(file_md5, content_length, wfp_filename)
+
+        # Add opposite line ending hash based on line ending analysis
+        if not bin_file:
+            opposite_hash = self.__calculate_opposite_line_ending_hash(contents)
+            if opposite_hash is not None:
+                wfp += f'fh2={opposite_hash}\n'
+
         # We don't process snippets for binaries, or other uninteresting files, or if we're requested to skip
         if bin_file or self.skip_snippets or self.__skip_snippets(file, contents.decode('utf-8', 'ignore')):
             return wfp
@@ -467,7 +524,7 @@ class Winnowing(ScanossBase):
         for i, byte in enumerate(content):
             c = byte
             if c == ASCII_LF:  # When there is a new line
-                if len(list_normalized):
+                if list_normalized:
                     crc_lines.append(self.crc8_buffer(list_normalized))
                     list_normalized = []
                 elif last_line + 1 == i:

{scanoss-1.23.0.dist-info → scanoss-1.25.0.dist-info}/METADATA

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

{scanoss-1.23.0.dist-info → scanoss-1.25.0.dist-info}/RECORD

@@ -4,10 +4,11 @@ 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=CqMRnCqzsM3UDMfg2QSfEduDTsshr2swd5eqsOOvrv4,1146
-scanoss/cli.py,sha256=fdByS-OjSYQbzoZpkT7cez4qkSILpkHPJtRfmSbqDHU,63706
+scanoss/__init__.py,sha256=T3J1XVw8Hyutct8ClOLn1tqQ_NnHlMfxUSVYfLSuVJg,1146
+scanoss/cli.py,sha256=SAB0xuHjEEw20YtYAPSZwrQaVf4JUsm8NRcVArMzd4U,69099
 scanoss/components.py,sha256=b0R9DdKuXqyQiw5nZZwjQ6NJXBr1U9gyx1RI2FP9ozA,14511
-scanoss/constants.py,sha256=9cJxbaXMP4GUIMVn0O1eEyT7Qfq4Jl6BWgZsYQqxQ20,293
+scanoss/constants.py,sha256=FWCZG8gQputKwV7XwvW1GuwDXL4wDLQyVRGdwygg578,320
+scanoss/cryptography.py,sha256=Q39MOCscP-OFvrnPXaPOMFFkc8OKnf3mC3SgZYEtCog,9407
 scanoss/csvoutput.py,sha256=qNKRwcChSkgIwLm00kZiVX6iHVQUF4Apl-sMbzJ5Taw,10192
 scanoss/cyclonedx.py,sha256=UktDuqZUbXSggdt864Pg8ziTD7sdEQtLxfYL7vd_ZCE,12756
 scanoss/file_filters.py,sha256=_1Ehb_rLnHw_-6N5Zhh4Es2lz6rlx0LozGPn-u52cok,20338
@@ -18,13 +19,13 @@ scanoss/scanner.py,sha256=ZL8I8KtVyXgUMcl7Ccbip_Q1IlU9WTgI-mFtSpF1JWw,45223
 scanoss/scanoss_settings.py,sha256=393JnWLsEZhvMg5tPUGgxmqnBKp8AcLxYsDRbLP7aV4,10650
 scanoss/scanossapi.py,sha256=v4D9i9Impa82Enw-5hZ7KLlscDIpaILNbGOMj3MJXqs,13067
 scanoss/scanossbase.py,sha256=Dkpwxa8NH8XN1iRl03NM_Mkvby0JQ4qfvCiiUrJ5ul0,3163
-scanoss/scanossgrpc.py,sha256=2SzIEi9tt5REZ6XVR_TrpP2E8wYVZDBKircTIlY8npw,28614
+scanoss/scanossgrpc.py,sha256=B0rl676-B-ZxqXRp7blXnqbAGPC5rqLAQHG28NoC32E,30004
 scanoss/scanpostprocessor.py,sha256=-JsThlxrU70r92GHykTMERnicdd-6jmwNsE4PH0MN2o,11063
 scanoss/scantype.py,sha256=gFmyVmKQpHWogN2iCmMj032e_sZo4T92xS3_EH5B3Tc,1310
 scanoss/spdxlite.py,sha256=MQqFgQhIO-yrbRwEAQS77HmRgP5GDxff-2JYLVoceA0,28946
 scanoss/threadeddependencies.py,sha256=CAeZnoYd3d1ayoRvfm_aVjYbaTDLsk6DMWDxkoBPvq0,9866
 scanoss/threadedscanning.py,sha256=38ryN_kZGpzmrd_hkuiY9Sb3tOG248canGCDQDmGEwI,9317
-scanoss/winnowing.py,sha256=68_AL3iI-yR8GMfOD1LemToA_rvbNHeghKTX5-AK698,19254
+scanoss/winnowing.py,sha256=RsR9jRTR3TzS1pEeKQ2RuYlIG8Q7RnUQFfgPLog6B-A,21679
 scanoss/api/__init__.py,sha256=hx-P78xbDsh6WQIigewkJ7Y7y1fqc_eYnyHC5IZTKmo,1122
 scanoss/api/common/__init__.py,sha256=hx-P78xbDsh6WQIigewkJ7Y7y1fqc_eYnyHC5IZTKmo,1122
 scanoss/api/common/v2/__init__.py,sha256=hx-P78xbDsh6WQIigewkJ7Y7y1fqc_eYnyHC5IZTKmo,1122
@@ -56,13 +57,13 @@ scanoss/api/vulnerabilities/__init__.py,sha256=IFrDk_DTJgKSZmmU-nuLXuq_s8sQZlrSC
 scanoss/api/vulnerabilities/v2/__init__.py,sha256=IFrDk_DTJgKSZmmU-nuLXuq_s8sQZlrSCHhIDMJT4r0,1122
 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=G5TAnGlLvFVpqBLQYKD1FtFr0kpQDLVD8zI69TRvA90,40
+scanoss/data/build_date.txt,sha256=3dG3QmOR7re5yDaUAaCa2noLbeaUxqlhd4ZYGn2-eo0,40
 scanoss/data/scanoss-settings-schema.json,sha256=ClkRYAkjAN0Sk704G8BE_Ok006oQ6YnIGmX84CF8h9w,8798
 scanoss/data/spdx-exceptions.json,sha256=s7UTYxC7jqQXr11YBlIWYCNwN6lRDFTR33Y8rpN_dA4,17953
 scanoss/data/spdx-licenses.json,sha256=A6Z0q82gaTLtnopBfzeIVZjJFxkdRW1g2TuumQc-lII,228794
 scanoss/inspection/__init__.py,sha256=0hjb5ktavp7utJzFhGMPImPaZiHWgilM2HwvTp5lXJE,1122
 scanoss/inspection/copyleft.py,sha256=VynluuCUVxR7uQUz026sp4_yE0Eh3dwpPK0YJ6FNFFw,7579
-scanoss/inspection/policy_check.py,sha256=NYBGKElaeHXKsMOFfSS4IKCiS71h3CKoL20uwhdjaoU,15685
+scanoss/inspection/policy_check.py,sha256=wUUQD2WTBibjf3MOPXKOmB8jFGIX0cd1K3flU0pjTjc,17295
 scanoss/inspection/undeclared_component.py,sha256=0YEiWQ4Q1xu7j4YHLPsS3b5Mf9fplHJdHRXgUoQyF2w,10102
 scanoss/inspection/utils/license_utils.py,sha256=Zb6QLmVJb86lKCwZyBsmwakyAtY1SXa54kUyyKmWMqA,5093
 scanoss/scanners/__init__.py,sha256=D4C0lWLuNp8k_BjQZEc07WZcUgAvriVwQWOk063b0ZU,1122
@@ -73,11 +74,11 @@ scanoss/scanners/scanner_hfh.py,sha256=KksrC1XnOv7mXSlGyo_AJXwtPfKjqffkttdPoNDc-
 scanoss/utils/__init__.py,sha256=0hjb5ktavp7utJzFhGMPImPaZiHWgilM2HwvTp5lXJE,1122
 scanoss/utils/abstract_presenter.py,sha256=teiDTxBj5jBMCk2T8i4l1BJPf_u4zBLWrtCTFHSSECM,3148
 scanoss/utils/crc64.py,sha256=TMrwQimSdE6imhFOUL7oAG6Kxu-8qMpGWMuMg8QpSVs,3169
-scanoss/utils/file.py,sha256=yVyv7C7xLWtFNfUrv3r6W8tkIqEuPjZ7_mgIT01IjJs,2933
+scanoss/utils/file.py,sha256=62cA9a17TU9ZvfA3FY5HY4-QOajJeSrc8S6xLA_f-3M,2980
 scanoss/utils/simhash.py,sha256=6iu8DOcecPAY36SZjCOzrrLMT9oIE7-gI6QuYwUQ7B0,5793
-scanoss-1.23.0.dist-info/licenses/LICENSE,sha256=LLUaXoiyOroIbr5ubAyrxBOwSRLTm35ETO2FmLpy8QQ,1074
-scanoss-1.23.0.dist-info/METADATA,sha256=pdGRVPWFrt8Xw86e3X3IXd1_n7mrbyTmGY340ybaCRw,6060
-scanoss-1.23.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-scanoss-1.23.0.dist-info/entry_points.txt,sha256=Uy28xnaDL5KQ7V77sZD5VLDXPNxYYzSr5tsqtiXVzAs,48
-scanoss-1.23.0.dist-info/top_level.txt,sha256=V11PrQ6Pnrc-nDF9xnisnJ8e6-i7HqSIKVNqduRWcL8,27
-scanoss-1.23.0.dist-info/RECORD,,
+scanoss-1.25.0.dist-info/licenses/LICENSE,sha256=LLUaXoiyOroIbr5ubAyrxBOwSRLTm35ETO2FmLpy8QQ,1074
+scanoss-1.25.0.dist-info/METADATA,sha256=mvajvjxQSlBpII6nFUq44pp7-Kedgf9hXGblfCjqjWU,6060
+scanoss-1.25.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+scanoss-1.25.0.dist-info/entry_points.txt,sha256=Uy28xnaDL5KQ7V77sZD5VLDXPNxYYzSr5tsqtiXVzAs,48
+scanoss-1.25.0.dist-info/top_level.txt,sha256=V11PrQ6Pnrc-nDF9xnisnJ8e6-i7HqSIKVNqduRWcL8,27
+scanoss-1.25.0.dist-info/RECORD,,

{scanoss-1.23.0.dist-info → scanoss-1.25.0.dist-info}/WHEEL

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