scanoss 1.35.0__tar.gz → 1.37.0__tar.gz

{scanoss-1.35.0/src/scanoss.egg-info → scanoss-1.37.0}/PKG-INFO

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

{scanoss-1.35.0 → scanoss-1.37.0}/src/scanoss/__init__.py

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

{scanoss-1.35.0 → scanoss-1.37.0}/src/scanoss/api/common/v2/scanoss_common_pb2_grpc.py

@@ -3,6 +3,7 @@
 import warnings
 
 import grpc
+import warnings
 
 GRPC_GENERATED_VERSION = '1.73.1'
 GRPC_VERSION = grpc.__version__

{scanoss-1.35.0 → scanoss-1.37.0}/src/scanoss/cli.py

@@ -33,6 +33,7 @@ from typing import List
 import pypac
 
 from scanoss.cryptography import Cryptography, create_cryptography_config_from_args
+from scanoss.delta import Delta
 from scanoss.export.dependency_track import DependencyTrackExporter
 from scanoss.inspection.dependency_track.project_violation import (
     DependencyTrackProjectViolationPolicyCheck,
@@ -59,7 +60,10 @@ from . import __version__
 from .components import Components
 from .constants import (
     DEFAULT_API_TIMEOUT,
+    DEFAULT_HFH_DEPTH,
+    DEFAULT_HFH_MIN_ACCEPTED_SCORE,
     DEFAULT_HFH_RANK_THRESHOLD,
+    DEFAULT_HFH_RECURSIVE_THRESHOLD,
     DEFAULT_POST_SIZE,
     DEFAULT_RETRY,
     DEFAULT_TIMEOUT,
@@ -869,6 +873,27 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         help='Filter results to only show those with rank value at or below this threshold (e.g., --rank-threshold 3 '
         'returns results with rank 1, 2, or 3). Lower rank values indicate higher quality matches.',
     )
+    p_folder_scan.add_argument(
+        '--depth',
+        type=int,
+        default=DEFAULT_HFH_DEPTH,
+        help=f'Defines how deep to scan the root directory (optional - default {DEFAULT_HFH_DEPTH})',
+    )
+    p_folder_scan.add_argument(
+        '--recursive-threshold',
+        type=float,
+        default=DEFAULT_HFH_RECURSIVE_THRESHOLD,
+        help=f'Minimum score threshold to consider a match (optional - default: {DEFAULT_HFH_RECURSIVE_THRESHOLD})',
+    )
+    p_folder_scan.add_argument(
+        '--min-accepted-score',
+        type=float,
+        default=DEFAULT_HFH_MIN_ACCEPTED_SCORE,
+        help=(
+            'Only show results with a score at or above this threshold '
+            f'(optional - default: {DEFAULT_HFH_MIN_ACCEPTED_SCORE})'
+        ),
+    )
     p_folder_scan.set_defaults(func=folder_hashing_scan)
 
     # Sub-command: folder-hash
@@ -887,8 +912,41 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         default='json',
         help='Result output format (optional - default: json)',
     )
+    p_folder_hash.add_argument(
+        '--depth',
+        type=int,
+        default=DEFAULT_HFH_DEPTH,
+        help=f'Defines how deep to hash the root directory (optional - default {DEFAULT_HFH_DEPTH})',
+    )
     p_folder_hash.set_defaults(func=folder_hash)
 
+    # Sub-command: delta
+    p_delta = subparsers.add_parser(
+        'delta',
+        aliases=['dl'],
+        description=f'SCANOSS Delta commands: {__version__}',
+        help='Delta support commands',
+    )
+
+    delta_sub = p_delta.add_subparsers(
+        title='Delta Commands',
+        dest='subparsercmd',
+        description='Delta sub-commands',
+        help='Delta sub-commands'
+    )
+
+    # Delta Sub-command: copy
+    p_copy = delta_sub.add_parser(
+        'copy',
+        aliases=['cp'],
+        description=f'Copy file list into delta dir: {__version__}',
+        help='Copy the given list of files into a delta directory',
+    )
+    p_copy.add_argument('--input', '-i', type=str, required=True, help='Input file with diff list')
+    p_copy.add_argument('--folder', '-fd', type=str, help='Delta folder to copy into')
+    p_copy.add_argument('--root', '-rd', type=str, help='Root directory to place delta folder')
+    p_copy.set_defaults(func=delta_copy)
+
     # Output options
     for p in [
         p_scan,
@@ -909,6 +967,7 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         p_crypto_hints,
         p_crypto_versions_in_range,
         c_licenses,
+        p_copy,
     ]:
         p.add_argument('--output', '-o', type=str, help='Output result file name (optional - default stdout).')
 
@@ -1106,6 +1165,7 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         p_crypto_versions_in_range,
         c_licenses,
         e_dt,
+        p_copy
     ]:
         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')
@@ -1126,7 +1186,8 @@ def setup_args() -> None:  # noqa: PLR0912, PLR0915
         sys.exit(1)
     elif (
         args.subparser
-        in ('utils', 'ut', 'component', 'comp', 'inspect', 'insp', 'ins', 'crypto', 'cr', 'export', 'exp')
+        in ('utils', 'ut', 'component', 'comp', 'inspect', 'insp', 'ins',
+            'crypto', 'cr', 'export', 'exp', 'delta', 'dl')
     ) and not args.subparsercmd:
         parser.parse_args([args.subparser, '--help'])  # Force utils helps to be displayed
         sys.exit(1)
@@ -2456,6 +2517,9 @@ def folder_hashing_scan(parser, args):
             client=client,
             scanoss_settings=scanoss_settings,
             rank_threshold=args.rank_threshold,
+            depth=args.depth,
+            recursive_threshold=args.recursive_threshold,
+            min_accepted_score=args.min_accepted_score,
         )
 
         if scanner.scan():
@@ -2489,6 +2553,7 @@ def folder_hash(parser, args):
             scan_dir=args.scan_dir,
             config=folder_hasher_config,
             scanoss_settings=scanoss_settings,
+            depth=args.depth,
         )
 
         folder_hasher.hash_directory(args.scan_dir)
@@ -2569,6 +2634,43 @@ def initialise_empty_file(filename: str):
             print_stderr(f'Error: Unable to create output file {filename}: {e}')
             sys.exit(1)
 
+def delta_copy(parser, args):
+    """
+    Handle delta copy command.
+
+    Copies files listed in an input file to a target directory while preserving
+    their directory structure. Creates a unique delta directory if none is specified.
+
+    Parameters
+    ----------
+    parser : ArgumentParser
+        Command line parser object for help display
+    args : Namespace
+        Parsed command line arguments containing:
+        - input: Path to file containing list of files to copy
+        - folder: Optional target directory path
+        - output: Optional output file path
+    """
+    # Validate required input file parameter
+    if args.input is None:
+        print_stderr('ERROR: Input file is required for copying')
+        parser.parse_args([args.subparser, args.subparsercmd, '-h'])
+        sys.exit(1)
+    # Initialise output file if specified
+    if args.output:
+        initialise_empty_file(args.output)
+    try:
+        # Create and configure delta copy command
+        delta = Delta(debug=args.debug, trace=args.trace, quiet=args.quiet, filepath=args.input, folder=args.folder,
+                      output=args.output, root_dir=args.root)
+        # Execute copy and exit with appropriate status code
+        status, _ = delta.copy()
+        sys.exit(status)
+    except Exception as e:
+        print_stderr(e)
+        if args.debug:
+            traceback.print_exc()
+        sys.exit(1)
 
 def main():
     """

{scanoss-1.35.0 → scanoss-1.37.0}/src/scanoss/constants.py

@@ -13,4 +13,7 @@ DEFAULT_URL2 = 'https://api.scanoss.com'  # default premium service URL
 
 DEFAULT_API_TIMEOUT = 600
 
-DEFAULT_HFH_RANK_THRESHOLD = 5
+DEFAULT_HFH_RANK_THRESHOLD = 5
+DEFAULT_HFH_DEPTH = 1
+DEFAULT_HFH_RECURSIVE_THRESHOLD = 0.8
+DEFAULT_HFH_MIN_ACCEPTED_SCORE = 0.15

scanoss-1.37.0/src/scanoss/data/build_date.txt

@@ -0,0 +1 @@
+date: 20251017144212, utime: 1760712132

scanoss-1.37.0/src/scanoss/delta.py

@@ -0,0 +1,197 @@
+"""
+SPDX-License-Identifier: MIT
+
+  Copyright (c) 2025, 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 os
+import shutil
+import tempfile
+from typing import Optional
+
+from .scanossbase import ScanossBase
+
+
+class Delta(ScanossBase):
+    """
+    Handle delta scan operations by copying files into a dedicated delta directory.
+
+    This class manages the creation of delta directories and copying of specified files
+    while preserving the directory structure. Files are read from an input file where each
+    line contains a file path to copy.
+    """
+
+    def __init__(  # noqa: PLR0913
+            self,
+            debug: bool = False,
+            trace: bool = False,
+            quiet: bool = False,
+            filepath: str = None,
+            folder: str = None,
+            output: str = None,
+            root_dir: str = None,
+    ):
+        """
+        Initialise the Delta instance.
+
+        :param debug: Enable debug logging.
+        :param trace: Enable trace logging.
+        :param quiet: Enable quiet mode (suppress non-essential output).
+        :param filepath: Path to an input file containing a list of files to copy.
+        :param folder: A target delta directory path (auto-generated if not provided).
+        :param output: Output file path for the delta directory location (stdout if not provided).
+        """
+        super().__init__(debug, trace, quiet)
+        self.filepath = filepath
+        self.folder = folder
+        self.output = output
+        self.root_dir = root_dir if root_dir else '.'
+
+    def copy(self, input_file: str = None):
+        """
+        Copy files listed in the input file to the delta directory.
+
+        Reads the input file line by line, where each line contains a file path.
+        Creates the delta directory if it doesn't exist, then copies each file
+        while preserving its directory structure.
+
+        :return: Tuple of (status_code, folder_path) where status_code is 0 for success,
+                 1 for error, and folder_path is the delta directory path
+        """
+        input_file = input_file if input_file else self.filepath
+        if not input_file:
+            self.print_stderr('ERROR: No input file specified')
+            return 1, ''
+        # Validate that an input file exists
+        if not os.path.isfile(input_file):
+            self.print_stderr(f'ERROR: Input file {input_file} does not exist or is not a file')
+            return 1, ''
+        # Load the input file and validate it contains valid file paths
+        files = self.load_input_file(input_file)
+        if files is None:
+            return 1, ''
+        # Create delta dir (folder)
+        delta_folder = self.create_delta_dir(self.folder, self.root_dir)
+        if not delta_folder:
+            return 1, ''
+        # Print delta folder location to output
+        self.print_to_file_or_stdout(delta_folder, self.output)
+        # Process each file and copy it to the delta dir
+        for source_file in files:
+            # Normalise the source path to handle ".." and redundant separators
+            normalised_source = os.path.normpath(source_file)
+            if '..' in normalised_source:
+                self.print_stderr(f'WARNING: Source path escapes root directory for {source_file}. Skipping.')
+                continue
+            # Resolve to the absolute path for source validation
+            abs_source = os.path.abspath(os.path.join(self.root_dir, normalised_source))
+            # Check if the source file exists and is a file
+            if not os.path.exists(abs_source) or not os.path.isfile(abs_source):
+                self.print_stderr(f'WARNING: File {source_file} does not exist or is not a file, skipping')
+                continue
+            # Use a normalised source for destination to prevent traversal
+            dest_path = os.path.normpath(os.path.join(self.root_dir, delta_folder, normalised_source.lstrip(os.sep)))
+            # Final safety check: ensure destination is within the delta folder
+            abs_dest = os.path.abspath(dest_path)
+            abs_folder = os.path.abspath(os.path.join(self.root_dir, delta_folder))
+            if not abs_dest.startswith(abs_folder + os.sep):
+                self.print_stderr(
+                    f'WARNING: Destination path ({abs_dest}) escapes delta directory for {source_file}. Skipping.')
+                continue
+            # Create the destination directory if it doesn't exist and copy the file
+            try:
+                dest_dir = os.path.dirname(dest_path)
+                if dest_dir:
+                    self.print_trace(f'Creating directory {dest_dir}...')
+                    os.makedirs(dest_dir, exist_ok=True)
+                self.print_debug(f'Copying {source_file} to {dest_path} ...')
+                shutil.copy(abs_source, dest_path)
+            except (OSError, shutil.Error) as e:
+                self.print_stderr(f'ERROR: Failed to copy {source_file} to {dest_path}: {e}')
+                return 1, ''
+        return 0, delta_folder
+
+    def create_delta_dir(self, folder: str, root_dir: str = '.') -> str or None:
+        """
+        Create the delta directory.
+
+        If no folder is specified, creates a unique temporary directory with
+        a 'delta-' prefix in the current directory. If a folder is specified,
+        validates that it doesn't already exist before creating it.
+
+        :param root_dir: Root directory to create the delta directory in (default: current directory)
+        :param folder: Optional target directory
+        :return: Path to the delta directory, or None if it already exists or creation fails
+        """
+        if folder:
+            # Resolve a relative folder under root_dir so checks/creation apply to the right place
+            resolved = folder if os.path.isabs(folder) else os.path.join(root_dir, folder)
+            resolved = os.path.normpath(resolved)
+            # Validate the target directory doesn't already exist and create it
+            if os.path.exists(resolved):
+                self.print_stderr(f'ERROR: Folder {resolved} already exists.')
+                return None
+            else:
+                try:
+                    self.print_debug(f'Creating delta directory {resolved}...')
+                    os.makedirs(resolved)
+                except (OSError, IOError) as e:
+                    self.print_stderr(f'ERROR: Failed to create directory {resolved}: {e}')
+                    return None
+        else:
+            # Create a unique temporary directory in the given root directory
+            try:
+                self.print_debug(f'Creating temporary delta directory in {root_dir} ...')
+                folder = tempfile.mkdtemp(prefix="delta-", dir=root_dir)
+                if folder:
+                    folder = os.path.relpath(folder, start=root_dir)  # Get the relative path from root_dir
+                self.print_debug(f'Created temporary delta directory: {folder}')
+            except (OSError, IOError) as e:
+                self.print_stderr(f'ERROR: Failed to create temporary directory in {root_dir}: {e}')
+                return None
+        return folder
+
+    def load_input_file(self, input_file: str) -> Optional[list[str]]:
+        """
+        Loads and parses the input file line by line. Each line in the input
+        file represents a source file path, which will be stripped of trailing
+        whitespace and appended to the resulting list if it is not empty.
+
+        :param input_file: The path to the input file to be read.
+        :type input_file: String
+        :return: A list of source file paths extracted from the input file,
+            or None if an error occurs or the file path is invalid.
+        :rtype: An array list[str] or None
+        """
+        files = []
+        if input_file:
+            try:
+                with open(input_file, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        source_file = line.rstrip()
+                        if source_file:
+                            # Save the file path without any leading separators
+                            files.append(source_file.lstrip(os.sep))
+                    # End of for loop
+            except (OSError, IOError) as e:
+                self.print_stderr(f'ERROR: Failed to read input file; {input_file}: {e}')
+                return None
+        self.print_debug(f'Loaded {len(files)} files from input file.')
+        return files

{scanoss-1.35.0 → scanoss-1.37.0}/src/scanoss/file_filters.py

@@ -269,162 +269,6 @@ DEFAULT_SKIPPED_EXT = {
     'sqlite3',
 }
 
-# TODO: For hfh add the .gitignore patterns
-DEFAULT_SKIPPED_EXT_HFH = {
-    '.1',
-    '.2',
-    '.3',
-    '.4',
-    '.5',
-    '.6',
-    '.7',
-    '.8',
-    '.9',
-    '.ac',
-    '.adoc',
-    '.am',
-    '.asciidoc',
-    '.bmp',
-    '.build',
-    '.cfg',
-    '.chm',
-    '.class',
-    '.cmake',
-    '.cnf',
-    '.conf',
-    '.config',
-    '.contributors',
-    '.copying',
-    '.crt',
-    '.csproj',
-    '.css',
-    '.csv',
-    '.dat',
-    '.data',
-    '.dtd',
-    '.dts',
-    '.iws',
-    '.c9',
-    '.c9revisions',
-    '.dtsi',
-    '.dump',
-    '.eot',
-    '.eps',
-    '.geojson',
-    '.gif',
-    '.glif',
-    '.gmo',
-    '.guess',
-    '.hex',
-    '.htm',
-    '.html',
-    '.ico',
-    '.iml',
-    '.in',
-    '.inc',
-    '.info',
-    '.ini',
-    '.ipynb',
-    '.jpeg',
-    '.jpg',
-    '.json',
-    '.jsonld',
-    '.lock',
-    '.log',
-    '.m4',
-    '.map',
-    '.md5',
-    '.meta',
-    '.mk',
-    '.mxml',
-    '.o',
-    '.otf',
-    '.out',
-    '.pbtxt',
-    '.pdf',
-    '.pem',
-    '.phtml',
-    '.plist',
-    '.png',
-    '.prefs',
-    '.properties',
-    '.pyc',
-    '.qdoc',
-    '.result',
-    '.rgb',
-    '.rst',
-    '.scss',
-    '.sha',
-    '.sha1',
-    '.sha2',
-    '.sha256',
-    '.sln',
-    '.spec',
-    '.sub',
-    '.svg',
-    '.svn-base',
-    '.tab',
-    '.template',
-    '.test',
-    '.tex',
-    '.tiff',
-    '.ttf',
-    '.txt',
-    '.utf-8',
-    '.vim',
-    '.wav',
-    '.woff',
-    '.woff2',
-    '.xht',
-    '.xhtml',
-    '.xml',
-    '.xpm',
-    '.xsd',
-    '.xul',
-    '.yaml',
-    '.yml',
-    '.wfp',
-    '.editorconfig',
-    '.dotcover',
-    '.pid',
-    '.lcov',
-    '.egg',
-    '.manifest',
-    '.cache',
-    '.coverage',
-    '.cover',
-    '.gem',
-    '.lst',
-    '.pickle',
-    '.pdb',
-    '.gml',
-    '.pot',
-    '.plt',
-    '.whml',
-    '.pom',
-    '.smtml',
-    '.min.js',
-    '.mf',
-    '.base64',
-    '.s',
-    '.diff',
-    '.patch',
-    '.rules',
-    # File endings
-    '-doc',
-    'config',
-    'news',
-    'readme',
-    'swiftdoc',
-    'texidoc',
-    'todo',
-    'version',
-    'ignore',
-    'manifest',
-    'sqlite',
-    'sqlite3',
-}
-
 
 class FileFilters(ScanossBase):
     """
@@ -707,9 +551,8 @@ class FileFilters(ScanossBase):
             bool: True if file should be skipped, False otherwise
         """
         file_name = os.path.basename(file_rel_path)
-
+        DEFAULT_SKIPPED_EXT_LIST = {} if self.is_folder_hashing_scan else DEFAULT_SKIPPED_EXT
         DEFAULT_SKIPPED_FILES_LIST = DEFAULT_SKIPPED_FILES_HFH if self.is_folder_hashing_scan else DEFAULT_SKIPPED_FILES
-        DEFAULT_SKIPPED_EXT_LIST = DEFAULT_SKIPPED_EXT_HFH if self.is_folder_hashing_scan else DEFAULT_SKIPPED_EXT
 
         if not self.hidden_files_folders and file_name.startswith('.'):
             self.print_debug(f'Skipping file: {file_rel_path} (hidden file)')

{scanoss-1.35.0 → scanoss-1.37.0}/src/scanoss/scanners/folder_hasher.py

@@ -6,6 +6,7 @@ from typing import Dict, List, Literal, Optional
 
 from progress.bar import Bar
 
+from scanoss.constants import DEFAULT_HFH_DEPTH
 from scanoss.file_filters import FileFilters
 from scanoss.scanoss_settings import ScanossSettings
 from scanoss.scanossbase import ScanossBase
@@ -15,8 +16,6 @@ from scanoss.utils.simhash import WordFeatureSet, fingerprint, simhash, vectoriz
 
 MINIMUM_FILE_COUNT = 8
 MINIMUM_CONCATENATED_NAME_LENGTH = 32
-MAXIMUM_FILE_NAME_LENGTH = 32
-
 
 class DirectoryNode:
     """
@@ -72,6 +71,12 @@ class FolderHasher:
 
     It builds a directory tree (DirectoryNode) and computes the associated
     hash data for the folder.
+
+    Args:
+        scan_dir (str): The directory to be hashed.
+        config (FolderHasherConfig): Configuration parameters for the folder hasher.
+        scanoss_settings (Optional[ScanossSettings]): Optional settings for Scanoss.
+        depth (int): How many levels to hash from the root directory (default: 1).
     """
 
     def __init__(
@@ -79,6 +84,7 @@ class FolderHasher:
         scan_dir: str,
         config: FolderHasherConfig,
         scanoss_settings: Optional[ScanossSettings] = None,
+        depth: int = DEFAULT_HFH_DEPTH,
     ):
         self.base = ScanossBase(
             debug=config.debug,
@@ -101,6 +107,7 @@ class FolderHasher:
 
         self.scan_dir = scan_dir
         self.tree = None
+        self.depth = depth
 
     def hash_directory(self, path: str) -> dict:
         """
@@ -123,7 +130,10 @@ class FolderHasher:
 
         return tree
 
-    def _build_root_node(self, path: str) -> DirectoryNode:
+    def _build_root_node(
+        self,
+        path: str,
+    ) -> DirectoryNode:
         """
         Build a directory tree from the given path with file information.
 
@@ -140,7 +150,7 @@ class FolderHasher:
         root_node = DirectoryNode(str(root))
 
         all_files = [
-            f for f in root.rglob('*') if f.is_file() and len(f.name.encode('utf-8')) <= MAXIMUM_FILE_NAME_LENGTH
+            f for f in root.rglob('*') if f.is_file()
         ]
         filtered_files = self.file_filters.get_filtered_files_from_files(all_files, str(root))
 
@@ -180,7 +190,7 @@ class FolderHasher:
         bar.finish()
         return root_node
 
-    def _hash_calc_from_node(self, node: DirectoryNode) -> dict:
+    def _hash_calc_from_node(self, node: DirectoryNode, current_depth: int = 1) -> dict:
         """
         Recursively compute folder hash data for a directory node.
 
@@ -189,12 +199,13 @@ class FolderHasher:
 
         Args:
             node (DirectoryNode): The directory node to compute the hash for.
+            current_depth (int): The current depth level (1-based, root is depth 1).
 
         Returns:
             dict: The computed hash data for the node.
         """
         hash_data = self._hash_calc(node)
-        
+
         # Safely calculate relative path
         try:
             node_path = Path(node.path).resolve()
@@ -204,13 +215,18 @@ class FolderHasher:
             # If relative_to fails, use the node path as is or a fallback
             rel_path = Path(node.path).name if node.path else Path('.')
 
+        # Only process children if we haven't reached the depth limit
+        children = []
+        if current_depth < self.depth:
+            children = [self._hash_calc_from_node(child, current_depth + 1) for child in node.children.values()]
+
         return {
             'path_id': str(rel_path),
             'sim_hash_names': f'{hash_data["name_hash"]:02x}' if hash_data['name_hash'] is not None else None,
             'sim_hash_content': f'{hash_data["content_hash"]:02x}' if hash_data['content_hash'] is not None else None,
             'sim_hash_dir_names': f'{hash_data["dir_hash"]:02x}' if hash_data['dir_hash'] is not None else None,
             'lang_extensions': hash_data['lang_extensions'],
-            'children': [self._hash_calc_from_node(child) for child in node.children.values()],
+            'children': children,
         }
 
     def _hash_calc(self, node: DirectoryNode) -> dict:
@@ -237,8 +253,6 @@ class FolderHasher:
 
         for file in node.files:
             key_str = file.key_str
-            if key_str in processed_hashes:
-                continue
 
             file_name = os.path.basename(file.path)
 

{scanoss-1.35.0 → scanoss-1.37.0}/src/scanoss/scanners/scanner_hfh.py

@@ -29,7 +29,12 @@ from typing import Dict, Optional
 
 from progress.spinner import Spinner
 
-from scanoss.constants import DEFAULT_HFH_RANK_THRESHOLD
+from scanoss.constants import (
+    DEFAULT_HFH_DEPTH,
+    DEFAULT_HFH_MIN_ACCEPTED_SCORE,
+    DEFAULT_HFH_RANK_THRESHOLD,
+    DEFAULT_HFH_RECURSIVE_THRESHOLD,
+)
 from scanoss.cyclonedx import CycloneDx
 from scanoss.file_filters import FileFilters
 from scanoss.scanners.folder_hasher import FolderHasher
@@ -48,13 +53,16 @@ class ScannerHFH:
     and calculates simhash values based on file names and content to detect folder-level similarities.
     """
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         scan_dir: str,
         config: ScannerConfig,
         client: Optional[ScanossGrpc] = None,
         scanoss_settings: Optional[ScanossSettings] = None,
         rank_threshold: int = DEFAULT_HFH_RANK_THRESHOLD,
+        depth: int = DEFAULT_HFH_DEPTH,
+        recursive_threshold: float = DEFAULT_HFH_RECURSIVE_THRESHOLD,
+        min_accepted_score: float = DEFAULT_HFH_MIN_ACCEPTED_SCORE,
     ):
         """
         Initialize the ScannerHFH.
@@ -65,6 +73,9 @@ class ScannerHFH:
             client (ScanossGrpc): gRPC client for communicating with the scanning service.
             scanoss_settings (Optional[ScanossSettings]): Optional settings for Scanoss.
             rank_threshold (int): Get results with rank below this threshold (default: 5).
+            depth (int): How many levels to scan (default: 1).
+            recursive_threshold (float): Minimum score threshold to consider a match (default: 0.25).
+            min_accepted_score (float): Only show results with a score at or above this threshold (default: 0.15).
         """
         self.base = ScanossBase(
             debug=config.debug,
@@ -87,12 +98,15 @@ class ScannerHFH:
             scan_dir=scan_dir,
             config=config,
             scanoss_settings=scanoss_settings,
+            depth=depth,
         )
 
         self.scan_dir = scan_dir
         self.client = client
         self.scan_results = None
         self.rank_threshold = rank_threshold
+        self.recursive_threshold = recursive_threshold
+        self.min_accepted_score = min_accepted_score
 
     def scan(self) -> Optional[Dict]:
         """
@@ -102,8 +116,10 @@ class ScannerHFH:
             Optional[Dict]: The folder hash response from the gRPC client, or None if an error occurs.
         """
         hfh_request = {
-            'root': self.folder_hasher.hash_directory(self.scan_dir),
+            'root': self.folder_hasher.hash_directory(path=self.scan_dir),
             'rank_threshold': self.rank_threshold,
+            'recursive_threshold': self.recursive_threshold,
+            'min_accepted_score': self.min_accepted_score,
         }
 
         spinner = Spinner('Scanning folder...')
@@ -193,7 +209,7 @@ class ScannerHFHPresenter(AbstractPresenter):
                     }
                 ]
             }
-            
+
             get_vulnerabilities_json_request = {
                 'purls': [{'purl': purl, 'requirement': best_match_version['version']}],
             }
@@ -210,10 +226,10 @@ class ScannerHFHPresenter(AbstractPresenter):
                 error_msg = 'ERROR: Failed to produce CycloneDX output'
                 self.base.print_stderr(error_msg)
                 return None
-            
+
             if vulnerabilities:
                 cdx_output = cdx.append_vulnerabilities(cdx_output, vulnerabilities, purl)
-                
+
             return json.dumps(cdx_output, indent=2)
         except Exception as e:
             self.base.print_stderr(f'ERROR: Failed to get license information: {e}')

{scanoss-1.35.0 → scanoss-1.37.0/src/scanoss.egg-info}/PKG-INFO

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

{scanoss-1.35.0 → scanoss-1.37.0}/src/scanoss.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ src/scanoss/constants.py
 src/scanoss/cryptography.py
 src/scanoss/csvoutput.py
 src/scanoss/cyclonedx.py
+src/scanoss/delta.py
 src/scanoss/file_filters.py
 src/scanoss/filecount.py
 src/scanoss/results.py

scanoss-1.35.0/src/scanoss/data/build_date.txt

@@ -1 +0,0 @@
-date: 20251007151647, utime: 1759850207