scanoss 1.12.2__py3-none-any.whl → 1.43.1__py3-none-any.whl

scanoss/scanner.py

@@ -1,89 +1,65 @@
 """
- SPDX-License-Identifier: MIT
-
-   Copyright (c) 2021, 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.
+SPDX-License-Identifier: MIT
+
+  Copyright (c) 2021, 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 datetime
 import json
 import os
 import sys
-import datetime
-import pkg_resources
+from contextlib import nullcontext
+from pathlib import Path
+from typing import Any, Dict, List, Optional
 
-from progress.bar import Bar
+import importlib_resources
 from progress.spinner import Spinner
 from pypac.parser import PACFile
 
-from .scanossapi import ScanossApi
-from .cyclonedx import CycloneDx
-from .spdxlite import SpdxLite
+from scanoss.file_filters import FileFilters
+
+from . import __version__
 from .csvoutput import CsvOutput
-from .threadedscanning import ThreadedScanning
+from .cyclonedx import CycloneDx
 from .scancodedeps import ScancodeDeps
-from .threadeddependencies import ThreadedDependencies
+from .scanoss_settings import ScanossSettings
+from .scanossapi import ScanossApi
+from .scanossbase import ScanossBase
 from .scanossgrpc import ScanossGrpc
+from .scanpostprocessor import ScanPostProcessor
 from .scantype import ScanType
-from .scanossbase import ScanossBase
-from . import __version__
+from .spdxlite import SpdxLite
+from .threadeddependencies import SCOPE, ThreadedDependencies
+from .threadedscanning import ThreadedScanning
 
 FAST_WINNOWING = False
 try:
     from scanoss_winnowing.winnowing import Winnowing
 
     FAST_WINNOWING = True
-except ModuleNotFoundError or ImportError:
+except (ModuleNotFoundError, ImportError):
     FAST_WINNOWING = False
     from .winnowing import Winnowing
 
-FILTERED_DIRS = {  # Folders to skip
-    "nbproject", "nbbuild", "nbdist", "__pycache__", "venv", "_yardoc", "eggs", "wheels", "htmlcov", "__pypackages__"
-}
-FILTERED_DIR_EXT = {  # Folder endings to skip
-    ".egg-info"
-}
-FILTERED_EXT = [  # File extensions to skip
-    ".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", ".doc", ".docx", ".dtd", ".dts", ".iws", ".c9", ".c9revisions",
-    ".dtsi", ".dump", ".eot", ".eps", ".geojson", ".gdoc", ".gif",
-    ".glif", ".gmo", ".gradle", ".guess", ".hex", ".htm", ".html", ".ico", ".iml",
-    ".in", ".inc", ".info", ".ini", ".ipynb", ".jpeg", ".jpg", ".json", ".jsonld", ".lock",
-    ".log", ".m4", ".map", ".markdown", ".md", ".md5", ".meta", ".mk", ".mxml",
-    ".o", ".otf", ".out", ".pbtxt", ".pdf", ".pem", ".phtml", ".plist", ".png",
-    ".po", ".ppt", ".prefs", ".properties", ".pyc", ".qdoc", ".result", ".rgb",
-    ".rst", ".scss", ".sha", ".sha1", ".sha2", ".sha256", ".sln", ".spec", ".sql",
-    ".sub", ".svg", ".svn-base", ".tab", ".template", ".test", ".tex", ".tiff",
-    ".toml", ".ttf", ".txt", ".utf-8", ".vim", ".wav", ".woff", ".woff2", ".xht",
-    ".xhtml", ".xls", ".xlsx", ".xml", ".xpm", ".xsd", ".xul", ".yaml", ".yml", ".wfp",
-    ".editorconfig", ".dotcover", ".pid", ".lcov", ".egg", ".manifest", ".cache", ".coverage", ".cover",
-    ".gem", ".lst", ".pickle", ".pdb", ".gml", ".pot", ".plt",
-    # File endings
-    "-doc", "changelog", "config", "copying", "license", "authors", "news", "licenses", "notice",
-    "readme", "swiftdoc", "texidoc", "todo", "version", "ignore", "manifest", "sqlite", "sqlite3"
-]
-FILTERED_FILES = {  # Files to skip
-    "gradlew", "gradlew.bat", "mvnw", "mvnw.cmd", "gradle-wrapper.jar", "maven-wrapper.jar",
-    "thumbs.db", "babel.config.js", "license.txt", "license.md", "copying.lib", "makefile"
-}
-WFP_FILE_START = "file="
+WFP_FILE_START = 'file='
 MAX_POST_SIZE = 64 * 1024  # 64k Max post size
 
 
@@ -93,29 +69,56 @@ class Scanner(ScanossBase):
     Handle the scanning of files, snippets and dependencies
     """
 
-    def __init__(self, wfp: str = None, scan_output: str = None, output_format: str = 'plain',
-                 debug: bool = False, trace: bool = False, quiet: bool = False, api_key: str = None, url: str = None,
-                 sbom_path: str = None, scan_type: str = None, flags: str = None, nb_threads: int = 5,
-                 post_size: int = 32, timeout: int = 180, no_wfp_file: bool = False,
-                 all_extensions: bool = False, all_folders: bool = False, hidden_files_folders: bool = False,
-                 scan_options: int = 7, sc_timeout: int = 600, sc_command: str = None, grpc_url: str = None,
-                 obfuscate: bool = False, ignore_cert_errors: bool = False, proxy: str = None, grpc_proxy: str = None,
-                 ca_cert: str = None, pac: PACFile = None, retry: int = 5, hpsm: bool = False,
-                 skip_size: int = 0, skip_extensions=None, skip_folders=None,
-                 strip_hpsm_ids=None, strip_snippet_ids=None, skip_md5_ids=None
-                 ):
-        """
-        Initialise scanning class, including Winnowing, ScanossApi and ThreadedScanning
+    def __init__( # noqa: PLR0913, PLR0915
+        self,
+        scan_output: str = None,
+        output_format: str = 'plain',
+        debug: bool = False,
+        trace: bool = False,
+        quiet: bool = False,
+        api_key: str = None,
+        url: str = None,
+        flags: str = None,
+        nb_threads: int = 5,
+        post_size: int = 32,
+        timeout: int = 180,
+        all_extensions: bool = False,
+        all_folders: bool = False,
+        hidden_files_folders: bool = False,
+        scan_options: int = 7,
+        sc_timeout: int = 600,
+        sc_command: str = None,
+        grpc_url: str = None,
+        obfuscate: bool = False,
+        ignore_cert_errors: bool = False,
+        proxy: str = None,
+        grpc_proxy: str = None,
+        ca_cert: str = None,
+        pac: PACFile = None,
+        retry: int = 5,
+        hpsm: bool = False,
+        skip_size: int = 0,
+        skip_extensions=None,
+        skip_folders=None,
+        strip_hpsm_ids=None,
+        strip_snippet_ids=None,
+        skip_md5_ids=None,
+        scan_settings: 'ScanossSettings | None' = None,
+        req_headers: dict = None,
+        use_grpc: bool = False,
+        skip_headers: bool = False,
+        skip_headers_limit: int = 0,
+    ):
+        """
+        Initialise scanning class, including Winnowing, ScanossApi, ThreadedScanning
         """
         super().__init__(debug, trace, quiet)
         if skip_folders is None:
             skip_folders = []
         if skip_extensions is None:
             skip_extensions = []
-        self.wfp = wfp if wfp else "scanner_output.wfp"
         self.scan_output = scan_output
         self.output_format = output_format
-        self.no_wfp_file = no_wfp_file
         self.isatty = sys.stderr.isatty()
         self.all_extensions = all_extensions
         self.all_folders = all_folders
@@ -125,104 +128,81 @@ class Scanner(ScanossBase):
         self.hpsm = hpsm
         self.skip_folders = skip_folders
         self.skip_size = skip_size
+        self.skip_extensions = skip_extensions
+        self.req_headers = req_headers
         ver_details = Scanner.version_details()
 
-        self.winnowing = Winnowing(debug=debug, quiet=quiet, skip_snippets=self._skip_snippets,
-                                   all_extensions=all_extensions, obfuscate=obfuscate, hpsm=self.hpsm,
-                                   strip_hpsm_ids=strip_hpsm_ids, strip_snippet_ids=strip_snippet_ids,
-                                   skip_md5_ids=skip_md5_ids
-                                   )
-        self.scanoss_api = ScanossApi(debug=debug, trace=trace, quiet=quiet, api_key=api_key, url=url,
-                                      sbom_path=sbom_path, scan_type=scan_type, flags=flags, timeout=timeout,
-                                      ver_details=ver_details, ignore_cert_errors=ignore_cert_errors,
-                                      proxy=proxy, ca_cert=ca_cert, pac=pac, retry=retry
-                                      )
+        self.winnowing = Winnowing(
+            debug=debug,
+            trace=trace,
+            quiet=quiet,
+            skip_snippets=self._skip_snippets,
+            all_extensions=all_extensions,
+            obfuscate=obfuscate,
+            hpsm=self.hpsm,
+            strip_hpsm_ids=strip_hpsm_ids,
+            strip_snippet_ids=strip_snippet_ids,
+            skip_md5_ids=skip_md5_ids,
+            skip_headers=skip_headers,
+            skip_headers_limit=skip_headers_limit,
+        )
+        self.scanoss_api = ScanossApi(
+            debug=debug,
+            trace=trace,
+            quiet=quiet,
+            api_key=api_key,
+            url=url,
+            flags=flags,
+            timeout=timeout,
+            ver_details=ver_details,
+            ignore_cert_errors=ignore_cert_errors,
+            proxy=proxy,
+            ca_cert=ca_cert,
+            pac=pac,
+            retry=retry,
+            req_headers= self.req_headers,
+        )
         sc_deps = ScancodeDeps(debug=debug, quiet=quiet, trace=trace, timeout=sc_timeout, sc_command=sc_command)
-        grpc_api = ScanossGrpc(url=grpc_url, debug=debug, quiet=quiet, trace=trace, api_key=api_key,
-                               ver_details=ver_details, ca_cert=ca_cert, proxy=proxy, pac=pac, grpc_proxy=grpc_proxy
-                               )
+        grpc_api = ScanossGrpc(
+            url=grpc_url,
+            debug=debug,
+            quiet=quiet,
+            trace=trace,
+            api_key=api_key,
+            ver_details=ver_details,
+            ca_cert=ca_cert,
+            proxy=proxy,
+            pac=pac,
+            grpc_proxy=grpc_proxy,
+            req_headers=self.req_headers,
+            ignore_cert_errors=ignore_cert_errors,
+            use_grpc=use_grpc
+        )
         self.threaded_deps = ThreadedDependencies(sc_deps, grpc_api, debug=debug, quiet=quiet, trace=trace)
         self.nb_threads = nb_threads
         if nb_threads and nb_threads > 0:
-            self.threaded_scan = ThreadedScanning(self.scanoss_api, debug=debug, trace=trace, quiet=quiet,
-                                                  nb_threads=nb_threads
-                                                  )
+            self.threaded_scan = ThreadedScanning(
+                self.scanoss_api, debug=debug, trace=trace, quiet=quiet, nb_threads=nb_threads
+            )
         else:
             self.threaded_scan = None
         self.max_post_size = post_size * 1024 if post_size > 0 else MAX_POST_SIZE  # Set the max post size (default 64k)
         self.post_file_count = post_size if post_size > 0 else 32  # Max number of files for any given POST (default 32)
         if self._skip_snippets:
             self.max_post_size = 8 * 1024  # 8k Max post size if we're skipping snippets
-        self.skip_extensions = FILTERED_EXT
-        if skip_extensions:  # Append extra file extensions to skip
-            self.skip_extensions.extend(skip_extensions)
 
-    def __filter_files(self, files: list) -> list:
-        """
-        Filter which files should be considered for processing
-        :param files: list of files to filter
-        :return list of filtered files
-        """
-        file_list = []
-        for f in files:
-            ignore = False
-            if f.startswith(".") and not self.hidden_files_folders:  # Ignore all . files unless requested
-                ignore = True
-            if not ignore and not self.all_extensions:  # Skip this check if we're allowing all extensions
-                f_lower = f.lower()
-                if f_lower in FILTERED_FILES:  # Check for exact files to ignore
-                    ignore = True
-                if not ignore:
-                    for ending in self.skip_extensions:  # Check for file endings to ignore (static and user supplied)
-                        if ending and f_lower.endswith(ending):
-                            ignore = True
-                            break
-            if not ignore:
-                file_list.append(f)
-        return file_list
-
-    def __filter_dirs(self, dirs: list) -> list:
-        """
-        Filter which folders should be considered for processing
-        :param dirs: list of directories to filter
-        :return: list of filtered directories
-        """
-        dir_list = []
-        for d in dirs:
-            ignore = False
-            if d.startswith(".") and not self.hidden_files_folders:  # Ignore all . folders unless requested
-                ignore = True
-            if not ignore and not self.all_folders:  # Skip this check if we're allowing all folders
-                d_lower = d.lower()
-                if d_lower in FILTERED_DIRS:  # Ignore specific folders (case insensitive)
-                    ignore = True
-                elif self.skip_folders and d in self.skip_folders:  # Ignore user-supplied folders (case sensitive)
-                    ignore = True
-                if not ignore:
-                    for de in FILTERED_DIR_EXT:  # Ignore specific folder endings (case insensitive)
-                        if d_lower.endswith(de):
-                            ignore = True
-                            break
-            if not ignore:
-                dir_list.append(d)
-        return dir_list
+        self.scan_settings = scan_settings
+        self.post_processor = (
+            ScanPostProcessor(scan_settings, debug=debug, trace=trace, quiet=quiet) if scan_settings else None
+        )
+        self._maybe_set_api_sbom()
 
-    @staticmethod
-    def __strip_dir(scan_dir: str, length: int, path: str) -> str:
-        """
-        Strip the leading string from the specified path
-        Parameters
-        ----------
-            scan_dir: str
-                Root path
-            length: int
-                length of the root path string
-            path: str
-                Path to strip
-        """
-        if length > 0 and path.startswith(scan_dir):
-            path = path[length:]
-        return path
+    def _maybe_set_api_sbom(self):
+        if not self.scan_settings:
+            return
+        sbom = self.scan_settings.get_sbom()
+        if sbom:
+            self.scanoss_api.set_sbom(sbom)
 
     @staticmethod
     def __count_files_in_wfp_file(wfp_file: str):
@@ -241,27 +221,6 @@ class Scanner(ScanossBase):
                         count += 1
         return count
 
-    @staticmethod
-    def valid_json_file(json_file: str) -> bool:
-        """
-        Validate if the specified file is indeed valid JSON
-        :param: str JSON file to load
-        :return bool True if valid, False otherwise
-        """
-        if not json_file:
-            Scanner.print_stderr('ERROR: No JSON file provided to parse.')
-            return False
-        if not os.path.isfile(json_file):
-            Scanner.print_stderr(f'ERROR: JSON file does not exist or is not a file: {json_file}')
-            return False
-        try:
-            with open(json_file) as f:
-                json.load(f)
-        except Exception as e:
-            Scanner.print_stderr(f'Problem parsing JSON file "{json_file}": {e}')
-            return False
-        return True
-
     @staticmethod
     def version_details() -> str:
         """
@@ -270,9 +229,10 @@ class Scanner(ScanossBase):
         """
         data = None
         try:
-            f_name = pkg_resources.resource_filename(__name__, 'data/build_date.txt')
-            with open(f_name, 'r') as f:
-                data = f.read().rstrip()
+            f_name = importlib_resources.files(__name__) / 'data/build_date.txt'
+            with importlib_resources.as_file(f_name) as f:
+                with open(f, 'r', encoding='utf-8') as file:
+                    data = file.read().rstrip()
         except Exception as e:
             Scanner.print_stderr(f'Warning: Problem loading build time details: {e}')
         if not data or len(data) == 0:
@@ -287,7 +247,7 @@ class Scanner(ScanossBase):
         if not outfile and self.scan_output:
             outfile = self.scan_output
         if outfile:
-            with open(outfile, "a") as rf:
+            with open(outfile, 'a') as rf:
                 rf.write(string + '\n')
         else:
             print(string)
@@ -328,26 +288,45 @@ class Scanner(ScanossBase):
             return True
         return False
 
-    def scan_folder_with_options(self, scan_dir: str, deps_file: str = None, file_map: dict = None) -> bool:
+    def scan_folder_with_options(  # noqa: PLR0913
+        self,
+        scan_dir: str,
+        deps_file: str = None,
+        file_map: dict = None,
+        dep_scope: SCOPE = None,
+        dep_scope_include: str = None,
+        dep_scope_exclude: str = None,
+    ) -> bool:
         """
         Scan the given folder for whatever scaning options that have been configured
+        :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 scan_dir: directory to scan
         :param deps_file: pre-parsed dependency file to decorate
         :param file_map: mapping of obfuscated files back into originals
         :return: True if successful, False otherwise
         """
+
         success = True
         if not scan_dir:
-            raise Exception(f"ERROR: Please specify a folder to scan")
+            raise Exception('ERROR: Please specify a folder to scan')
         if not os.path.exists(scan_dir) or not os.path.isdir(scan_dir):
-            raise Exception(f"ERROR: Specified folder does not exist or is not a folder: {scan_dir}")
+            raise Exception(f'ERROR: Specified folder does not exist or is not a folder: {scan_dir}')
         if not self.is_file_or_snippet_scan() and not self.is_dependency_scan():
-            raise Exception(f"ERROR: No scan options defined to scan folder: {scan_dir}")
+            raise Exception(f'ERROR: No scan options defined to scan folder: {scan_dir}')
 
         if self.scan_output:
             self.print_msg(f'Writing results to {self.scan_output}...')
         if self.is_dependency_scan():
-            if not self.threaded_deps.run(what_to_scan=scan_dir, deps_file=deps_file, wait=False):  # Kick off a background dependency scan
+            if not self.threaded_deps.run(
+                what_to_scan=scan_dir,
+                deps_file=deps_file,
+                wait=False,
+                dep_scope=dep_scope,
+                dep_scope_include=dep_scope_include,
+                dep_scope_exclude=dep_scope_exclude,
+            ):  # Kick off a background dependency scan
                 success = False
         if self.is_file_or_snippet_scan():
             if not self.scan_folder(scan_dir):
@@ -357,7 +336,7 @@ class Scanner(ScanossBase):
                 success = False
         return success
 
-    def scan_folder(self, scan_dir: str) -> bool:
+    def scan_folder(self, scan_dir: str) -> bool:  # noqa: PLR0912, PLR0915
         """
         Scan the specified folder producing fingerprints, send to the SCANOSS API and return results
 
@@ -367,87 +346,80 @@ class Scanner(ScanossBase):
         """
         success = True
         if not scan_dir:
-            raise Exception(f"ERROR: Please specify a folder to scan")
+            raise Exception('ERROR: Please specify a folder to scan')
         if not os.path.exists(scan_dir) or not os.path.isdir(scan_dir):
-            raise Exception(f"ERROR: Specified folder does not exist or is not a folder: {scan_dir}")
-
-        scan_dir_len = len(scan_dir) if scan_dir.endswith(os.path.sep) else len(scan_dir) + 1
+            raise Exception(f'ERROR: Specified folder does not exist or is not a folder: {scan_dir}')
+
+        file_filters = FileFilters(
+            debug=self.debug,
+            trace=self.trace,
+            quiet=self.quiet,
+            scanoss_settings=self.scan_settings,
+            all_extensions=self.all_extensions,
+            all_folders=self.all_folders,
+            hidden_files_folders=self.hidden_files_folders,
+            skip_size=self.skip_size,
+            skip_folders=self.skip_folders,
+            skip_extensions=self.skip_extensions,
+            operation_type='scanning',
+        )
         self.print_msg(f'Searching {scan_dir} for files to fingerprint...')
-        spinner = None
-        if not self.quiet and self.isatty:
-            spinner = Spinner('Fingerprinting ')
-        save_wfps_for_print = not self.no_wfp_file or not self.threaded_scan
-        wfp_list = []
-        scan_block = ''
-        scan_size = 0
-        queue_size = 0
-        file_count = 0  # count all files fingerprinted
-        wfp_file_count = 0  # count number of files in each queue post
-        scan_started = False
-        for root, dirs, files in os.walk(scan_dir):
-            self.print_trace(f'U Root: {root}, Dirs: {dirs}, Files {files}')
-            if self.threaded_scan and self.threaded_scan.stop_scanning():
-                self.print_stderr('Warning: Aborting fingerprinting as the scanning service is not available.')
-                break
-            dirs[:] = self.__filter_dirs(dirs)  # Strip out unwanted directories
-            filtered_files = self.__filter_files(files)  # Strip out unwanted files
-            self.print_debug(f'F Root: {root}, Dirs: {dirs}, Files {filtered_files}')
-            for file in filtered_files:  # Cycle through each filtered file
-                path = os.path.join(root, file)
-                f_size = 0
-                try:
-                    f_size = os.stat(path).st_size
-                except Exception as e:
-                    self.print_trace(
-                        f'Ignoring missing symlink file: {file} ({e})')  # Can fail if there is a broken symlink
-                # Ignore broken links and empty files or if a user-specified size limit is supplied
-                if f_size > 0 and (self.skip_size <= 0 or f_size > self.skip_size):
-                    self.print_trace(f'Fingerprinting {path}...')
-                    if spinner:
-                        spinner.next()
-                    wfp = self.winnowing.wfp_for_file(path, Scanner.__strip_dir(scan_dir, scan_dir_len, path))
-                    if wfp is None or wfp == '':
-                        self.print_debug(f'No WFP returned for {path}. Skipping.')
-                        continue
-                    if save_wfps_for_print:
-                        wfp_list.append(wfp)
-                    file_count += 1
-                    if self.threaded_scan:
-                        wfp_size = len(wfp.encode("utf-8"))
-                        # If the WFP is bigger than the max post size and we already have something stored in the scan block, add it to the queue
-                        if scan_block != '' and (wfp_size + scan_size) >= self.max_post_size:
-                            self.threaded_scan.queue_add(scan_block)
-                            queue_size += 1
-                            scan_block = ''
-                            wfp_file_count = 0
-                        scan_block += wfp
-                        scan_size = len(scan_block.encode("utf-8"))
-                        wfp_file_count += 1
-                        # If the scan request block (group of WFPs) or larger than the POST size or we have reached the file limit, add it to the queue
-                        if wfp_file_count > self.post_file_count or scan_size >= self.max_post_size:
-                            self.threaded_scan.queue_add(scan_block)
-                            queue_size += 1
-                            scan_block = ''
-                            wfp_file_count = 0
-                        if not scan_started and queue_size > self.nb_threads:  # Start scanning if we have something to do
-                            scan_started = True
-                            if not self.threaded_scan.run(wait=False):
-                                self.print_stderr(
-                                    f'Warning: Some errors encounted while scanning. Results might be incomplete.')
-                                success = False
-        # End for loop
-        if self.threaded_scan and scan_block != '':
-            self.threaded_scan.queue_add(scan_block)  # Make sure all files have been submitted
-        if spinner:
-            spinner.finish()
+        spinner_ctx = Spinner('Fingerprinting ') if (not self.quiet and self.isatty) else nullcontext()
+
+        with spinner_ctx as spinner:
+            scan_block = ''
+            scan_size = 0
+            queue_size = 0
+            file_count = 0  # count all files fingerprinted
+            wfp_file_count = 0  # count number of files in each queue post
+            scan_started = False
+
+            to_scan_files = file_filters.get_filtered_files_from_folder(scan_dir)
+            for to_scan_file in to_scan_files:
+                if self.threaded_scan and self.threaded_scan.stop_scanning():
+                    self.print_stderr('Warning: Aborting fingerprinting as the scanning service is not available.')
+                    break
+                self.print_debug(f'Fingerprinting {to_scan_file}...')
+                if spinner:
+                    spinner.next()
+                abs_path = Path(scan_dir, to_scan_file).resolve()
+                wfp = self.winnowing.wfp_for_file(str(abs_path), to_scan_file)
+                if wfp is None or wfp == '':
+                    self.print_debug(f'No WFP returned for {to_scan_file}. Skipping.')
+                    continue
+                file_count += 1
+                if self.threaded_scan:
+                    wfp_size = len(wfp.encode('utf-8'))
+                    # If the WFP is bigger than the max post size and we already have something
+                    # stored in the scan block, add it to the queue
+                    if scan_block != '' and (wfp_size + scan_size) >= self.max_post_size:
+                        self.threaded_scan.queue_add(scan_block)
+                        queue_size += 1
+                        scan_block = ''
+                        wfp_file_count = 0
+                    scan_block += wfp
+                    scan_size = len(scan_block.encode('utf-8'))
+                    wfp_file_count += 1
+                    # If the scan request block (group of WFPs) is larger than the POST size
+                    # or we have reached the file limit, add it to the queue
+                    if wfp_file_count > self.post_file_count or scan_size >= self.max_post_size:
+                        self.threaded_scan.queue_add(scan_block)
+                        queue_size += 1
+                        scan_block = ''
+                        wfp_file_count = 0
+                    if not scan_started and queue_size > self.nb_threads:  # Start scanning if we have something to do
+                        scan_started = True
+                        if not self.threaded_scan.run(wait=False):
+                            self.print_stderr(
+                                'Warning: Some errors encountered while scanning. '
+                                'Results might be incomplete.'
+                            )
+                            success = False
+            # End for loop
+            if self.threaded_scan and scan_block != '':
+                self.threaded_scan.queue_add(scan_block)  # Make sure all files have been submitted
 
         if file_count > 0:
-            if save_wfps_for_print:  # Write a WFP file if no threading is requested
-                self.print_debug(f'Writing fingerprints to {self.wfp}')
-                with open(self.wfp, 'w') as f:
-                    f.write(''.join(wfp_list))
-            else:
-                self.print_debug(f'Skipping writing WFP file {self.wfp}')
             if self.threaded_scan:
                 success = self.__run_scan_threaded(scan_started, file_count)
         else:
@@ -465,103 +437,109 @@ class Scanner(ScanossBase):
         self.threaded_scan.update_bar(create=True, file_count=file_count)
         if not scan_started:
             if not self.threaded_scan.run(wait=False):  # Run the scan but do not wait for it to complete
-                self.print_stderr(f'Warning: Some errors encounted while scanning. Results might be incomplete.')
+                self.print_stderr('Warning: Some errors encounted while scanning. Results might be incomplete.')
                 success = False
         return success
 
-    def __finish_scan_threaded(self, file_map: dict = None) -> bool:
-        """
-        Wait for the threaded scans to complete
-        :param file_map: mapping of obfuscated files back into originals
-        :return: True if successful, False otherwise
+    def __finish_scan_threaded(self, file_map: Optional[Dict[Any, Any]] = None) -> bool:
+        """Wait for the threaded scan to complete and process the results
+
+        Args:
+            file_map: Mapping of obfuscated files back to originals
+
+        Returns:
+            bool: True if successful, False otherwise
+
+        Raises:
+            ValueError: If output format is invalid
         """
-        success = True
-        responses = None
+        success: bool = True
+        scan_responses = None
         dep_responses = None
         if self.is_file_or_snippet_scan():
             if not self.threaded_scan.complete():  # Wait for the scans to complete
-                self.print_stderr(f'Warning: Scanning analysis ran into some trouble.')
+                self.print_stderr('Warning: Scanning analysis ran into some trouble.')
                 success = False
             self.threaded_scan.complete_bar()
-            responses = self.threaded_scan.responses
+            scan_responses = self.threaded_scan.responses
         if self.is_dependency_scan():
             self.print_msg('Retrieving dependency data...')
             if not self.threaded_deps.complete():
-                self.print_stderr(f'Warning: Dependency analysis ran into some trouble.')
+                self.print_stderr('Warning: Dependency analysis ran into some trouble.')
                 success = False
             dep_responses = self.threaded_deps.responses
-            # self.print_stderr(f'Dep Data: {dep_responses}')
-        # TODO change to dictionary
-        raw_output = "{\n"
-        # TODO look into merging the two dictionaries. See https://favtutor.com/blogs/merge-dictionaries-python
-        if responses or dep_responses:
-            first = True
-            if responses:
-                for scan_resp in responses:
-                    if scan_resp is not None:
-                        for key, value in scan_resp.items():
-                            if file_map:  # We have a map for obfuscated files. Check if we can revert it
-                                fm = file_map.get(key)
-                                if fm:
-                                    key = fm  # Replace the obfuscated filename
-                            if first:
-                                raw_output += "  \"%s\":%s" % (key, json.dumps(value, indent=2))
-                                first = False
-                            else:
-                                raw_output += ",\n  \"%s\":%s" % (key, json.dumps(value, indent=2))
-                # End for loop
-            if dep_responses:
-                dep_files = dep_responses.get("files")
-                if dep_files and len(dep_files) > 0:
-                    for dep_file in dep_files:
-                        file = dep_file.pop("file", None)
-                        if file is not None:
-                            if first:
-                                raw_output += "  \"%s\":[%s]" % (file, json.dumps(dep_file, indent=2))
-                                first = False
-                            else:
-                                raw_output += ",\n  \"%s\":[%s]" % (file, json.dumps(dep_file, indent=2))
-                    # End for loop
+
+        raw_scan_results = self._merge_scan_results(scan_responses, dep_responses, file_map)
+
+        if self.post_processor:
+            results = self.post_processor.load_results(raw_scan_results).post_process()
         else:
-            success = False
-        raw_output += "\n}"
-        parsed_json = None
-        try:
-            parsed_json = json.loads(raw_output)
-        except Exception as e:
-            self.print_stderr(f'Warning: Problem decoding parsed json: {e}')
+            results = raw_scan_results
 
         if self.output_format == 'plain':
-            if parsed_json:
-                self.__log_result(json.dumps(parsed_json, indent=2, sort_keys=True))
-            else:
-                self.__log_result(raw_output)
+            self.__log_result(json.dumps(results, indent=2, sort_keys=True))
         elif self.output_format == 'cyclonedx':
             cdx = CycloneDx(self.debug, self.scan_output)
-            if parsed_json:
-                success = cdx.produce_from_json(parsed_json)
-            else:
-                success = cdx.produce_from_str(raw_output)
+            success, _ = cdx.produce_from_json(results)
         elif self.output_format == 'spdxlite':
             spdxlite = SpdxLite(self.debug, self.scan_output)
-            if parsed_json:
-                success = spdxlite.produce_from_json(parsed_json)
-            else:
-                success = spdxlite.produce_from_str(raw_output)
+            success = spdxlite.produce_from_json(results)
         elif self.output_format == 'csv':
             csvo = CsvOutput(self.debug, self.scan_output)
-            if parsed_json:
-                success = csvo.produce_from_json(parsed_json)
-            else:
-                success = csvo.produce_from_str(raw_output)
+            success = csvo.produce_from_json(results)
         else:
             self.print_stderr(f'ERROR: Unknown output format: {self.output_format}')
             success = False
         return success
 
-    def scan_file_with_options(self, file: str, deps_file: str = None, file_map: dict = None) -> bool:
+    def _merge_scan_results(
+        self,
+        scan_responses: Optional[List],
+        dep_responses: Optional[Dict[str, Any]],
+        file_map: Optional[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        """Merge scan and dependency responses into a single dictionary"""
+        results: Dict[str, Any] = {}
+
+        if scan_responses:
+            for response in scan_responses:
+                if response is not None:
+                    if file_map:
+                        response = self._deobfuscate_filenames(response, file_map)  # noqa: PLW2901
+                    results.update(response)
+
+        dep_files = dep_responses.get('files', None) if dep_responses else None
+        if dep_files:
+            for dep_file in dep_files:
+                file = dep_file.pop('file', None)
+                if file:
+                    results[file] = [dep_file]
+
+        return results
+
+    def _deobfuscate_filenames(self, response: dict, file_map: dict) -> dict:
+        """Convert obfuscated filenames back to original names"""
+        deobfuscated = {}
+        for key, value in response.items():
+            deobfuscated_name = file_map.get(key, None)
+            if deobfuscated_name:
+                deobfuscated[deobfuscated_name] = value
+            else:
+                deobfuscated[key] = value
+        return deobfuscated
+
+    def scan_file_with_options(  # noqa: PLR0913
+        self,
+        file: str,
+        deps_file: str = None,
+        file_map: dict = None,
+        dep_scope: SCOPE = None,
+        dep_scope_include: str = None,
+        dep_scope_exclude: str = None,
+    ) -> bool:
         """
         Scan the given file for whatever scaning options that have been configured
+        :param dep_scope:
         :param file: file to scan
         :param deps_file: pre-parsed dependency file to decorate
         :param file_map: mapping of obfuscated files back into originals
@@ -569,16 +547,23 @@ class Scanner(ScanossBase):
         """
         success = True
         if not file:
-            raise Exception(f"ERROR: Please specify a file to scan")
+            raise Exception('ERROR: Please specify a file to scan')
         if not os.path.exists(file) or not os.path.isfile(file):
-            raise Exception(f"ERROR: Specified file does not exist or is not a file: {file}")
+            raise Exception(f'ERROR: Specified file does not exist or is not a file: {file}')
         if not self.is_file_or_snippet_scan() and not self.is_dependency_scan():
-            raise Exception(f"ERROR: No scan options defined to scan file: {file}")
+            raise Exception(f'ERROR: No scan options defined to scan file: {file}')
 
         if self.scan_output:
             self.print_msg(f'Writing results to {self.scan_output}...')
         if self.is_dependency_scan():
-            if not self.threaded_deps.run(what_to_scan=file, deps_file=deps_file, wait=False):  # Kick off a background dependency scan
+            if not self.threaded_deps.run(
+                what_to_scan=file,
+                deps_file=deps_file,
+                wait=False,
+                dep_scope=dep_scope,
+                dep_scope_include=dep_scope_include,
+                dep_scope_exclude=dep_scope_exclude,
+            ):  # Kick off a background dependency scan
                 success = False
         if self.is_file_or_snippet_scan():
             if not self.scan_file(file):
@@ -599,9 +584,9 @@ class Scanner(ScanossBase):
         """
         success = True
         if not file:
-            raise Exception(f"ERROR: Please specify a file to scan")
+            raise Exception('ERROR: Please specify a file to scan')
         if not os.path.exists(file) or not os.path.isfile(file):
-            raise Exception(f"ERROR: Specified files does not exist or is not a file: {file}")
+            raise Exception(f'ERROR: Specified files does not exist or is not a file: {file}')
         self.print_debug(f'Fingerprinting {file}...')
         wfp = self.winnowing.wfp_for_file(file, file)
         if wfp is not None and wfp != '':
@@ -614,7 +599,7 @@ class Scanner(ScanossBase):
             success = False
         return success
 
-    def scan_files(self, files: []) -> bool:
+    def scan_files(self, files: []) -> bool:  # noqa: PLR0912, PLR0915
         """
         Scan the specified list of files, producing fingerprints, send to the SCANOSS API and return results
         Please note that by providing an explicit list you bypass any exclusions that may be defined on the scanner
@@ -624,52 +609,58 @@ class Scanner(ScanossBase):
         """
         success = True
         if not files:
-            raise Exception(f"ERROR: Please provide a non-empty list of filenames to scan")
-        self.print_msg(f'Scanning {len(files)} files...')
-        spinner = None
-        if not self.quiet and self.isatty:
-            spinner = Spinner('Fingerprinting ')
-        save_wfps_for_print = not self.no_wfp_file or not self.threaded_scan
-        wfp_list = []
-        scan_block = ''
-        scan_size = 0
-        queue_size = 0
-        file_count = 0  # count all files fingerprinted
-        wfp_file_count = 0  # count number of files in each queue post
-        scan_started = False
-        for file in files:
-            if self.threaded_scan and self.threaded_scan.stop_scanning():
-                self.print_stderr('Warning: Aborting fingerprinting as the scanning service is not available.')
-                break
-            f_size = 0
-            try:
-                f_size = os.stat(file).st_size
-            except Exception as e:
-                self.print_trace(
-                    f'Ignoring missing symlink file: {file} ({e})')  # Can fail if there is a broken symlink
-            if f_size > 0:  # Ignore broken links and empty files
-                self.print_trace(f'Fingerprinting {file}...')
+            raise Exception('ERROR: Please provide a non-empty list of filenames to scan')
+
+        file_filters = FileFilters(
+            debug=self.debug,
+            trace=self.trace,
+            quiet=self.quiet,
+            scanoss_settings=self.scan_settings,
+            all_extensions=self.all_extensions,
+            all_folders=self.all_folders,
+            hidden_files_folders=self.hidden_files_folders,
+            skip_size=self.skip_size,
+            skip_folders=self.skip_folders,
+            skip_extensions=self.skip_extensions,
+            operation_type='scanning',
+        )
+        spinner_ctx = Spinner('Fingerprinting ') if (not self.quiet and self.isatty) else nullcontext()
+
+        with spinner_ctx as spinner:
+            scan_block = ''
+            scan_size = 0
+            queue_size = 0
+            file_count = 0  # count all files fingerprinted
+            wfp_file_count = 0  # count number of files in each queue post
+            scan_started = False
+
+            to_scan_files = file_filters.get_filtered_files_from_files(files)
+            for file in to_scan_files:
+                if self.threaded_scan and self.threaded_scan.stop_scanning():
+                    self.print_stderr('Warning: Aborting fingerprinting as the scanning service is not available.')
+                    break
+                self.print_debug(f'Fingerprinting {file}...')
                 if spinner:
                     spinner.next()
                 wfp = self.winnowing.wfp_for_file(file, file)
                 if wfp is None or wfp == '':
                     self.print_debug(f'No WFP returned for {file}. Skipping.')
                     continue
-                if save_wfps_for_print:
-                    wfp_list.append(wfp)
                 file_count += 1
                 if self.threaded_scan:
-                    wfp_size = len(wfp.encode("utf-8"))
-                    # If the WFP is bigger than the max post size and we already have something stored in the scan block, add it to the queue
+                    wfp_size = len(wfp.encode('utf-8'))
+                    # If the WFP is bigger than the max post size and we already have something
+                    # stored in the scan block, add it to the queue
                     if scan_block != '' and (wfp_size + scan_size) >= self.max_post_size:
                         self.threaded_scan.queue_add(scan_block)
                         queue_size += 1
                         scan_block = ''
                         wfp_file_count = 0
                     scan_block += wfp
-                    scan_size = len(scan_block.encode("utf-8"))
+                    scan_size = len(scan_block.encode('utf-8'))
                     wfp_file_count += 1
-                    # If the scan request block (group of WFPs) or larger than the POST size or we have reached the file limit, add it to the queue
+                    # If the scan request block (group of WFPs) is larger than the POST size
+                    # or we have reached the file limit, add it to the queue
                     if wfp_file_count > self.post_file_count or scan_size >= self.max_post_size:
                         self.threaded_scan.queue_add(scan_block)
                         queue_size += 1
@@ -679,27 +670,22 @@ class Scanner(ScanossBase):
                         scan_started = True
                         if not self.threaded_scan.run(wait=False):
                             self.print_stderr(
-                                f'Warning: Some errors encounted while scanning. Results might be incomplete.')
+                                'Warning: Some errors encountered while scanning. '
+                                'Results might be incomplete.'
+                            )
                             success = False
-        # End for loop
-        if self.threaded_scan and scan_block != '':
-            self.threaded_scan.queue_add(scan_block)  # Make sure all files have been submitted
-        if spinner:
-            spinner.finish()
+
+            # End for loop
+            if self.threaded_scan and scan_block != '':
+                self.threaded_scan.queue_add(scan_block)  # Make sure all files have been submitted
 
         if file_count > 0:
-            if save_wfps_for_print:  # Write a WFP file if no threading is requested
-                self.print_debug(f'Writing fingerprints to {self.wfp}')
-                with open(self.wfp, 'w') as f:
-                    f.write(''.join(wfp_list))
-            else:
-                self.print_debug(f'Skipping writing WFP file {self.wfp}')
             if self.threaded_scan:
                 success = self.__run_scan_threaded(scan_started, file_count)
         else:
-            Scanner.print_stderr(f'Warning: No files found to scan from: {files}')
+            Scanner.print_stderr(f'Warning: No files found to scan from: {to_scan_files}')
         return success
-    
+
     def scan_files_with_options(self, files: [], deps_file: str = None, file_map: dict = None) -> bool:
         """
         Scan the given list of files for whatever scaning options that have been configured
@@ -710,11 +696,13 @@ class Scanner(ScanossBase):
         """
         success = True
         if not files:
-            raise Exception(f"ERROR: Please specify a list of files to scan")
+            raise Exception('ERROR: Please specify a list of files to scan')
         if not self.is_file_or_snippet_scan():
-            raise Exception(f"ERROR: file or snippet scan options have to be set to scan files: {files}")
+            raise Exception(f'ERROR: file or snippet scan options have to be set to scan files: {files}')
         if self.is_dependency_scan() or deps_file:
-            raise Exception(f"ERROR: The dependency scan option is currently not supported when scanning a list of files")
+            raise Exception(
+                'ERROR: The dependency scan option is currently not supported when scanning a list of files'
+            )
         if self.scan_output:
             self.print_msg(f'Writing results to {self.scan_output}...')
         if self.is_file_or_snippet_scan():
@@ -735,9 +723,9 @@ class Scanner(ScanossBase):
         """
         success = True
         if not filename:
-            raise Exception(f"ERROR: Please specify a filename to scan")
+            raise Exception('ERROR: Please specify a filename to scan')
         if not contents:
-            raise Exception(f"ERROR: Please specify a file contents to scan")
+            raise Exception('ERROR: Please specify a file contents to scan')
 
         self.print_debug(f'Fingerprinting {filename}...')
         wfp = self.winnowing.wfp_for_contents(filename, False, contents)
@@ -754,121 +742,22 @@ class Scanner(ScanossBase):
                 success = False
         return success
 
-    def scan_wfp_file(self, file: str = None) -> bool:
-        """
-        Scan the contents of the specified WFP file (in the current process)
-        :param file: Scan the contents of the specified WFP file (in the current process)
-        :return: True if successful, False otherwise
-        """
-        success = True
-        wfp_file = file if file else self.wfp  # If a WFP file is specified, use it, otherwise us the default
-        if not os.path.exists(wfp_file) or not os.path.isfile(wfp_file):
-            raise Exception(f"ERROR: Specified WFP file does not exist or is not a file: {wfp_file}")
-        file_count = Scanner.__count_files_in_wfp_file(wfp_file)
-        cur_files = 0
-        cur_size = 0
-        batch_files = 0
-        wfp = ''
-        max_component = {'name': '', 'hits': 0}
-        components = {}
-        self.print_debug(f'Found {file_count} files to process.')
-        raw_output = "{\n"
-        file_print = ''
-        bar = None
-        if not self.quiet and self.isatty:
-            bar = Bar('Scanning', max=file_count)
-            bar.next(0)
-        with open(wfp_file) as f:
-            for line in f:
-                if line.startswith(WFP_FILE_START):
-                    if file_print:
-                        wfp += file_print  # Store the WFP for the current file
-                        cur_size = len(wfp.encode("utf-8"))
-                    file_print = line  # Start storing the next file
-                    cur_files += 1
-                    batch_files += 1
-                else:
-                    file_print += line  # Store the rest of the WFP for this file
-                l_size = cur_size + len(file_print.encode('utf-8'))
-                # Hit the max post size, so sending the current batch and continue processing
-                if l_size >= self.max_post_size and wfp:
-                    self.print_debug(f'Sending {batch_files} ({cur_files}) of'
-                                     f' {file_count} ({len(wfp.encode("utf-8"))} bytes) files to the ScanOSS API.')
-                    if self.debug and cur_size > self.max_post_size:
-                        Scanner.print_stderr(f'Warning: Post size {cur_size} greater than limit {self.max_post_size}')
-                    scan_resp = self.scanoss_api.scan(wfp, max_component['name'])  # Scan current WFP and store
-                    if bar:
-                        bar.next(batch_files)
-                    if scan_resp is not None:
-                        for key, value in scan_resp.items():
-                            raw_output += "  \"%s\":%s," % (key, json.dumps(value, indent=2))
-                            for v in value:
-                                if hasattr(v, 'get'):
-                                    if v.get('id') != 'none':
-                                        vcv = '%s:%s:%s' % (v.get('vendor'), v.get('component'), v.get('version'))
-                                        components[vcv] = components[vcv] + 1 if vcv in components else 1
-                                        if max_component['hits'] < components[vcv]:
-                                            max_component['name'] = v.get('component')
-                                            max_component['hits'] = components[vcv]
-                                else:
-                                    Scanner.print_stderr(f'Warning: Unknown value: {v}')
-                    else:
-                        success = False
-                    batch_files = 0
-                    wfp = ''
-        if file_print:
-            wfp += file_print  # Store the WFP for the current file
-        if wfp:
-            self.print_debug(f'Sending {batch_files} ({cur_files}) of'
-                             f' {file_count} ({len(wfp.encode("utf-8"))} bytes) files to the ScanOSS API.')
-            scan_resp = self.scanoss_api.scan(wfp, max_component['name'])  # Scan current WFP and store
-            if bar:
-                bar.next(batch_files)
-            first = True
-            if scan_resp is not None:
-                for key, value in scan_resp.items():
-                    if first:
-                        raw_output += "  \"%s\":%s" % (key, json.dumps(value, indent=2))
-                        first = False
-                    else:
-                        raw_output += ",\n  \"%s\":%s" % (key, json.dumps(value, indent=2))
-            else:
-                success = False
-        raw_output += "\n}"
-        if bar:
-            bar.finish()
-        if self.output_format == 'plain':
-            self.__log_result(raw_output)
-        elif self.output_format == 'cyclonedx':
-            cdx = CycloneDx(self.debug, self.scan_output)
-            cdx.produce_from_str(raw_output)
-        elif self.output_format == 'spdxlite':
-            spdxlite = SpdxLite(self.debug, self.scan_output)
-            success = spdxlite.produce_from_str(raw_output)
-        elif self.output_format == 'csv':
-            csvo = CsvOutput(self.debug, self.scan_output)
-            csvo.produce_from_str(raw_output)
-        else:
-            self.print_stderr(f'ERROR: Unknown output format: {self.output_format}')
-            success = False
-
-        return success
-
-    def scan_wfp_with_options(self, wfp: str, deps_file: str, file_map: dict = None) -> bool:
+    def scan_wfp_with_options(self, wfp_file: str, deps_file: str, file_map: dict = None) -> bool:
         """
         Scan the given WFP file for whatever scaning options that have been configured
-        :param wfp: WFP file to scan
+        :param wfp_file: WFP file to scan
         :param deps_file: pre-parsed dependency file to decorate
         :param file_map: mapping of obfuscated files back into originals
         :return: True if successful, False otherwise
         """
         success = True
-        wfp_file = wfp if wfp else self.wfp  # If a WFP file is specified, use it, otherwise us the default
+        if not wfp_file:
+            raise Exception('ERROR: Please specify a WFP file to scan')
         if not os.path.exists(wfp_file) or not os.path.isfile(wfp_file):
-            raise Exception(f"ERROR: Specified WFP file does not exist or is not a file: {wfp_file}")
+            raise Exception(f'ERROR: Specified WFP file does not exist or is not a file: {wfp_file}')
 
         if not self.is_file_or_snippet_scan() and not self.is_dependency_scan():
-            raise Exception(f"ERROR: No scan options defined to scan WFP: {wfp}")
+            raise Exception(f'ERROR: No scan options defined to scan WFP: {wfp_file}')
 
         if self.scan_output:
             self.print_msg(f'Writing results to {self.scan_output}...')
@@ -883,16 +772,17 @@ class Scanner(ScanossBase):
                 success = False
         return success
 
-    def scan_wfp_file_threaded(self, file: str = None) -> bool:
+    def scan_wfp_file_threaded(self, wfp_file: str) -> bool:  # noqa: PLR0912
         """
         Scan the contents of the specified WFP file (threaded)
-        :param file: WFP file to scan (optional)
+        :param wfp_file: WFP file to scan
         return: True if successful, False otherwise
         """
         success = True
-        wfp_file = file if file else self.wfp  # If a WFP file is specified, use it, otherwise us the default
+        if not wfp_file:
+            raise Exception('ERROR: Please specify a WFP file to scan')
         if not os.path.exists(wfp_file) or not os.path.isfile(wfp_file):
-            raise Exception(f"ERROR: Specified WFP file does not exist or is not a file: {wfp_file}")
+            raise Exception(f'ERROR: Specified WFP file does not exist or is not a file: {wfp_file}')
         cur_size = 0
         queue_size = 0
         file_count = 0  # count all files fingerprinted
@@ -905,7 +795,7 @@ class Scanner(ScanossBase):
                 if line.startswith(WFP_FILE_START):
                     if scan_block:
                         wfp += scan_block  # Store the WFP for the current file
-                        cur_size = len(wfp.encode("utf-8"))
+                        cur_size = len(wfp.encode('utf-8'))
                     scan_block = line  # Start storing the next file
                     file_count += 1
                     wfp_file_count += 1
@@ -924,7 +814,8 @@ class Scanner(ScanossBase):
                         scan_started = True
                         if not self.threaded_scan.run(wait=False):
                             self.print_stderr(
-                                f'Warning: Some errors encounted while scanning. Results might be incomplete.')
+                                'Warning: Some errors uncounted while scanning. Results might be incomplete.'
+                            )
                             success = False
             # End for loop
         if scan_block:
@@ -947,15 +838,15 @@ class Scanner(ScanossBase):
         """
         success = True
         if not wfp:
-            raise Exception(f"ERROR: Please specify a WFP to scan")
-        raw_output = "{\n"
+            raise Exception('ERROR: Please specify a WFP to scan')
+        raw_output = '{\n'
         scan_resp = self.scanoss_api.scan(wfp)
         if scan_resp is not None:
             for key, value in scan_resp.items():
-                raw_output += "  \"%s\":%s" % (key, json.dumps(value, indent=2))
+                raw_output += '  "%s":%s' % (key, json.dumps(value, indent=2))
         else:
             success = False
-        raw_output += "\n}"
+        raw_output += '\n}'
         if self.output_format == 'plain':
             self.__log_result(raw_output)
         elif self.output_format == 'cyclonedx':
@@ -983,9 +874,9 @@ class Scanner(ScanossBase):
         :return:
         """
         if not filename:
-            raise Exception(f"ERROR: Please specify a filename to scan")
+            raise Exception('ERROR: Please specify a filename to scan')
         if not contents:
-            raise Exception(f"ERROR: Please specify a file contents to scan")
+            raise Exception('ERROR: Please specify a file contents to scan')
 
         self.print_debug(f'Fingerprinting {filename}...')
         wfp = self.winnowing.wfp_for_contents(filename, False, contents)
@@ -1004,9 +895,9 @@ class Scanner(ScanossBase):
         Fingerprint the specified file
         """
         if not scan_file:
-            raise Exception(f"ERROR: Please specify a file to fingerprint")
+            raise Exception('ERROR: Please specify a file to fingerprint')
         if not os.path.exists(scan_file) or not os.path.isfile(scan_file):
-            raise Exception(f"ERROR: Specified file does not exist or is not a file: {scan_file}")
+            raise Exception(f'ERROR: Specified file does not exist or is not a file: {scan_file}')
 
         self.print_debug(f'Fingerprinting {scan_file}...')
         wfp = self.winnowing.wfp_for_file(scan_file, scan_file)
@@ -1025,34 +916,34 @@ class Scanner(ScanossBase):
         Fingerprint the specified folder producing fingerprints
         """
         if not scan_dir:
-            raise Exception(f"ERROR: Please specify a folder to fingerprint")
+            raise Exception('ERROR: Please specify a folder to fingerprint')
         if not os.path.exists(scan_dir) or not os.path.isdir(scan_dir):
-            raise Exception(f"ERROR: Specified folder does not exist or is not a folder: {scan_dir}")
+            raise Exception(f'ERROR: Specified folder does not exist or is not a folder: {scan_dir}')
+        file_filters = FileFilters(
+            debug=self.debug,
+            trace=self.trace,
+            quiet=self.quiet,
+            scanoss_settings=self.scan_settings,
+            all_extensions=self.all_extensions,
+            all_folders=self.all_folders,
+            hidden_files_folders=self.hidden_files_folders,
+            skip_size=self.skip_size,
+            skip_folders=self.skip_folders,
+            skip_extensions=self.skip_extensions,
+            operation_type='scanning',
+        )
         wfps = ''
-        scan_dir_len = len(scan_dir) if scan_dir.endswith(os.path.sep) else len(scan_dir) + 1
         self.print_msg(f'Searching {scan_dir} for files to fingerprint...')
-        spinner = None
-        if not self.quiet and self.isatty:
-            spinner = Spinner('Fingerprinting ')
-        for root, dirs, files in os.walk(scan_dir):
-            dirs[:] = self.__filter_dirs(dirs)  # Strip out unwanted directories
-            filtered_files = self.__filter_files(files)  # Strip out unwanted files
-            self.print_trace(f'Root: {root}, Dirs: {dirs}, Files {filtered_files}')
-            for file in filtered_files:
-                path = os.path.join(root, file)
-                f_size = 0
-                try:
-                    f_size = os.stat(path).st_size
-                except Exception as e:
-                    self.print_trace(
-                        f'Ignoring missing symlink file: {file} ({e})')  # Can fail if there is a broken symlink
-                if f_size > 0:  # Ignore empty files
-                    self.print_debug(f'Fingerprinting {path}...')
-                    if spinner:
-                        spinner.next()
-                    wfps += self.winnowing.wfp_for_file(path, Scanner.__strip_dir(scan_dir, scan_dir_len, path))
-        if spinner:
-            spinner.finish()
+        spinner_ctx = Spinner('Fingerprinting ') if (not self.quiet and self.isatty) else nullcontext()
+
+        with spinner_ctx as spinner:
+            to_fingerprint_files = file_filters.get_filtered_files_from_folder(scan_dir)
+            for file in to_fingerprint_files:
+                if spinner:
+                    spinner.next()
+                abs_path = Path(scan_dir, file).resolve()
+                self.print_debug(f'Fingerprinting {file}...')
+                wfps += self.winnowing.wfp_for_file(str(abs_path), file)
         if wfps:
             if wfp_file:
                 self.print_stderr(f'Writing fingerprints to {wfp_file}')
@@ -1063,6 +954,7 @@ class Scanner(ScanossBase):
         else:
             Scanner.print_stderr(f'Warning: No files found to fingerprint in folder: {scan_dir}')
 
+
 #
 # End of ScanOSS Class
 #