feat: apply same filters from go minr

feat: create standalone presenters that implement abstractpresenter

Author: matiasdaloia

Diff for: src/scanoss/cli.py

@@ -492,11 +492,14 @@ def setup_args() -> None:  # noqa: PLR0915
         '--best-match',
         '-bm',
         action='store_true',
+        default=False,
         help='Enable best match mode (optional - default: False)',
     )
     p_folder_scan.add_argument(
         '--threshold',
         type=int,
+        choices=range(1, 101),
+        default=100,
         help='Threshold for result matching (optional - default: 100)',
     )
     p_folder_scan.set_defaults(func=folder_hashing_scan)

Diff for: src/scanoss/file_filters.py

@@ -514,3 +514,39 @@ def _should_skip_file(self, file_rel_path: str) -> bool:  # noqa: PLR0911
             self.print_debug(f'Skipping file: {file_rel_path} (matches custom pattern)')
             return True
         return False
+
+    def _should_skip_file_for_hfh(self, file_path: Path) -> bool:
+        """
+        Check if a file should be skipped during folder hashing scan.
+
+        Args:
+            file_path (Path): The path to the file to check.
+
+        Returns:
+            bool: True if the file should be skipped, False otherwise.
+        """
+        try:
+            if (
+                any(part.startswith('.') for part in file_path.parts)  # Hidden files/folders
+                or file_path.is_symlink()  # Symlinks
+                or file_path.stat().st_size == 0  # Empty files
+            ):
+                self.print_debug(f'Skipping file: {file_path} (hidden/symlink/empty)')
+                return True
+
+            # Files ending with null
+            if file_path.suffix.lower() == '.txt':
+                try:
+                    with open(file_path, 'rb') as f:
+                        if f.read().endswith(b'\x00'):
+                            self.print_debug(f'Skipping file: {file_path} (text file ending with null)')
+                            return True
+                except (OSError, IOError):
+                    self.print_debug(f'Skipping file: {file_path} (cannot read file content)')
+                    return True
+
+            return False
+
+        except Exception as e:
+            self.print_debug(f'Error checking file {file_path}: {str(e)}')
+            return True

Diff for: src/scanoss/results.py

@@ -50,7 +50,70 @@
 }
 
 
-class Results(AbstractPresenter, ScanossBase):
+class ResultsPresenter(AbstractPresenter):
+    """
+    SCANOSS Results presenter class
+    Handles the presentation of the scan results
+    """
+
+    def __init__(self, results_instance, **kwargs):
+        super().__init__(**kwargs)
+        self.results = results_instance
+
+    def _format_json_output(self) -> str:
+        """
+        Format the output data into a JSON object
+        """
+
+        formatted_data = []
+        for item in self.results.data:
+            formatted_data.append(
+                {
+                    'file': item.get('filename'),
+                    'status': item.get('status', 'N/A'),
+                    'match_type': item['id'],
+                    'matched': item.get('matched', 'N/A'),
+                    'purl': (item.get('purl')[0] if item.get('purl') else 'N/A'),
+                    'license': (item.get('licenses')[0].get('name', 'N/A') if item.get('licenses') else 'N/A'),
+                }
+            )
+        try:
+            return json.dumps({'results': formatted_data, 'total': len(formatted_data)}, indent=2)
+        except Exception as e:
+            self.base.print_stderr(f'ERROR: Problem formatting JSON output: {e}')
+            return ''
+
+    def _format_plain_output(self) -> str:
+        """Format the output data into a plain text string
+
+        Returns:
+            str: The formatted output data
+        """
+        if not self.results.data:
+            msg = 'No results to present'
+            return msg
+
+        formatted = ''
+        for item in self.results.data:
+            formatted += f'{self._format_plain_output_item(item)}\n'
+        return formatted
+
+    @staticmethod
+    def _format_plain_output_item(item):
+        purls = item.get('purl', [])
+        licenses = item.get('licenses', [])
+
+        return (
+            f'File: {item.get("filename")}\n'
+            f'Match type: {item.get("id")}\n'
+            f'Status: {item.get("status", "N/A")}\n'
+            f'Matched: {item.get("matched", "N/A")}\n'
+            f'Purl: {purls[0] if purls else "N/A"}\n'
+            f'License: {licenses[0].get("name", "N/A") if licenses else "N/A"}\n'
+        )
+
+
+class Results:
     """
     SCANOSS Results class \n
     Handles the parsing and filtering of the scan results
@@ -80,10 +143,17 @@ def __init__(  # noqa: PLR0913
             output_format (str, optional): Output format. Defaults to None.
         """
 
-        AbstractPresenter.__init__(self, output_file=output_file, output_format=output_format)
-        ScanossBase.__init__(self, debug, trace, quiet)
+        self.base = ScanossBase(debug, trace, quiet)
         self.data = self._load_and_transform(filepath)
         self.filters = self._load_filters(match_type=match_type, status=status)
+        self.presenter = ResultsPresenter(
+            self,
+            debug=debug,
+            trace=trace,
+            quiet=quiet,
+            output_file=output_file,
+            output_format=output_format,
+        )
 
     def load_file(self, file: str) -> Dict[str, Any]:
         """Load the JSON file
@@ -98,7 +168,7 @@ def load_file(self, file: str) -> Dict[str, Any]:
             try:
                 return json.load(jsonfile)
             except Exception as e:
-                self.print_stderr(f'ERROR: Problem parsing input JSON: {e}')
+                self.base.print_stderr(f'ERROR: Problem parsing input JSON: {e}')
 
     def _load_and_transform(self, file: str) -> List[Dict[str, Any]]:
         """
@@ -173,8 +243,8 @@ def _item_matches_filters(self, item):
     def _validate_filter_values(filter_key: str, filter_value: List[str]):
         if any(value not in AVAILABLE_FILTER_VALUES.get(filter_key, []) for value in filter_value):
             valid_values = ', '.join(AVAILABLE_FILTER_VALUES.get(filter_key, []))
-            raise Exception(
-                f"ERROR: Invalid filter value '{filter_value}' for filter '{filter_key.value}'. "
+            raise ValueError(
+                f"ERROR: Invalid filter value '{filter_value}' for filter '{filter_key}'. "
                 f'Valid values are: {valid_values}'
             )
 
@@ -188,51 +258,6 @@ def get_pending_identifications(self):
     def has_results(self):
         return bool(self.data)
 
-    def _format_json_output(self) -> str:
-        """
-        Format the output data into a JSON object
-        """
-
-        formatted_data = []
-        for item in self.data:
-            formatted_data.append(
-                {
-                    'file': item.get('filename'),
-                    'status': item.get('status', 'N/A'),
-                    'match_type': item['id'],
-                    'matched': item.get('matched', 'N/A'),
-                    'purl': (item.get('purl')[0] if item.get('purl') else 'N/A'),
-                    'license': (item.get('licenses')[0].get('name', 'N/A') if item.get('licenses') else 'N/A'),
-                }
-            )
-        return json.dumps({'results': formatted_data, 'total': len(formatted_data)}, indent=2)
-
-    def _format_plain_output(self) -> str:
-        """Format the output data into a plain text string
-
-        Returns:
-            str: The formatted output data
-        """
-        if not self.data:
-            msg = 'No results to present'
-            self.print_stderr(msg)
-            return msg
-
-        formatted = ''
-        for item in self.data:
-            formatted += f'{self._format_plain_output_item(item)}\n'
-        return formatted
-
-    @staticmethod
-    def _format_plain_output_item(item):
-        purls = item.get('purl', [])
-        licenses = item.get('licenses', [])
-
-        return (
-            f'File: {item.get("filename")}\n'
-            f'Match type: {item.get("id")}\n'
-            f'Status: {item.get("status", "N/A")}\n'
-            f'Matched: {item.get("matched", "N/A")}\n'
-            f'Purl: {purls[0] if purls else "N/A"}\n'
-            f'License: {licenses[0].get("name", "N/A") if licenses else "N/A"}\n'
-        )
+    def present(self, output_format: str = None, output_file: str = None):
+        """Present the results in the selected format"""
+        self.presenter.present(output_format=output_format, output_file=output_file)

Diff for: src/scanoss/scanners/scanner_hfh.py

@@ -60,7 +60,7 @@ def __init__(self, path: str, key: bytes, key_str: str):
         self.key_str = key_str
 
 
-class ScannerHFH(AbstractPresenter, ScanossBase):
+class ScannerHFH:
     """
     Folder Hashing Scanner.
 
@@ -84,13 +84,12 @@ def __init__(
             client (ScanossGrpc): gRPC client for communicating with the scanning service.
             scanoss_settings (Optional[ScanossSettings]): Optional settings for Scanoss.
         """
-        AbstractPresenter.__init__(
-            self,
+        self.base = ScanossBase(
             debug=config.debug,
             trace=config.trace,
             quiet=config.quiet,
         )
-        ScanossBase.__init__(
+        self.presenter = ScannerHFHPresenter(
             self,
             debug=config.debug,
             trace=config.trace,
@@ -159,11 +158,12 @@ def _build_root_node(self, path: str) -> DirectoryNode:
         Returns:
             DirectoryNode: The root node representing the directory.
         """
-
         root = Path(path).resolve()
         root_node = DirectoryNode(str(root))
 
-        filtered_files = [Path(f) for f in self.file_filters.get_filtered_files_from_folder(path)]
+        filtered_files = [
+            f for f in root.rglob('*') if f.is_file() and not self.file_filters._should_skip_file_for_hfh(f)
+        ]
         # Sort the files by name to ensure the hash is the same for the same folder
         filtered_files.sort()
 
@@ -281,19 +281,36 @@ def _head_calc(self, sim_hash: int) -> int:
         # Shift right by 4 bits and extract the lowest 8 bits
         return (total >> 4) & 0xFF
 
+    def present(self, output_format: str = None, output_file: str = None):
+        """Present the results in the selected format"""
+        self.presenter.present(output_format=output_format, output_file=output_file)
+
+
+class ScannerHFHPresenter(AbstractPresenter):
+    """
+    ScannerHFH presenter class
+    Handles the presentation of the folder hashing scan results
+    """
+
+    def __init__(self, scanner: ScannerHFH, **kwargs):
+        super().__init__(**kwargs)
+        self.scanner = scanner
+
     def _format_json_output(self) -> str:
         """
         Format the scan output data into a JSON object
 
         Returns:
             str: The formatted JSON string
         """
-        return json.dumps(self.scan_results, indent=2)
+        return json.dumps(self.scanner.scan_results, indent=2)
 
     def _format_plain_output(self) -> str:
         """
         Format the scan output data into a plain text string
         """
         return (
-            json.dumps(self.scan_results, indent=2) if isinstance(self.scan_results, dict) else str(self.scan_results)
+            json.dumps(self.scanner.scan_results, indent=2)
+            if isinstance(self.scanner.scan_results, dict)
+            else str(self.scanner.scan_results)
         )

Diff for: src/scanoss/utils/abstract_presenter.py

@@ -5,7 +5,7 @@
 AVAILABLE_OUTPUT_FORMATS = ['json', 'plain']
 
 
-class AbstractPresenter(ABC, ScanossBase):
+class AbstractPresenter(ABC):
     """
     Abstract presenter class for presenting output in a given format.
     Subclasses must implement the _format_json_output and _format_plain_output methods.
@@ -22,7 +22,7 @@ def __init__(
         """
         Initialize the presenter with the given output file and format.
         """
-        super().__init__(debug=debug, trace=trace, quiet=quiet)
+        self.base = ScanossBase(debug=debug, trace=trace, quiet=quiet)
         self.output_file = output_file
         self.output_format = output_format
 
@@ -51,7 +51,7 @@ def _present_output(self, content: str, file_path: str = None):
         """
         If a file path is provided, write to that file; otherwise, print the content to stdout.
         """
-        self.print_to_file_or_stdout(content, file_path)
+        self.base.print_to_file_or_stdout(content, file_path)
 
     @abstractmethod
     def _format_json_output(self) -> str: