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

scanoss/scanners/folder_hasher.py

@@ -0,0 +1,358 @@
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+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
+from scanoss.utils.abstract_presenter import AbstractPresenter
+from scanoss.utils.crc64 import CRC64
+from scanoss.utils.simhash import WordFeatureSet, fingerprint, simhash, vectorize_bytes
+
+MINIMUM_FILE_COUNT = 8
+MINIMUM_CONCATENATED_NAME_LENGTH = 32
+
+class DirectoryNode:
+    """
+    Represents a node in the directory tree for folder hashing.
+    """
+
+    def __init__(self, path: str):
+        self.path = path
+        self.is_dir = True
+        self.children: Dict[str, DirectoryNode] = {}
+        self.files: List[DirectoryFile] = []
+
+
+class DirectoryFile:
+    """
+    Represents a file in the directory tree for folder hashing.
+    """
+
+    def __init__(self, path: str, key: List[bytes], key_str: str):
+        self.path = path
+        self.key = key
+        self.key_str = key_str
+
+
+@dataclass
+class FolderHasherConfig:
+    debug: bool = False
+    trace: bool = False
+    quiet: bool = False
+    output_file: Optional[str] = None
+    output_format: Literal['json'] = 'json'
+    settings_file: Optional[str] = None
+    skip_settings_file: bool = False
+
+
+def create_folder_hasher_config_from_args(args) -> FolderHasherConfig:
+    return FolderHasherConfig(
+        debug=args.debug,
+        trace=args.trace,
+        quiet=args.quiet,
+        output_file=getattr(args, 'output', None),
+        output_format=getattr(args, 'format', 'json'),
+        settings_file=getattr(args, 'settings', None),
+        skip_settings_file=getattr(args, 'skip_settings_file', False),
+    )
+
+
+class FolderHasher:
+    """
+    Folder Hasher.
+
+    This class is used to produce a folder hash for a given directory.
+
+    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__(
+        self,
+        scan_dir: str,
+        config: FolderHasherConfig,
+        scanoss_settings: Optional[ScanossSettings] = None,
+        depth: int = DEFAULT_HFH_DEPTH,
+    ):
+        self.base = ScanossBase(
+            debug=config.debug,
+            trace=config.trace,
+            quiet=config.quiet,
+        )
+        self.file_filters = FileFilters(
+            debug=config.debug,
+            trace=config.trace,
+            quiet=config.quiet,
+            scanoss_settings=scanoss_settings,
+            is_folder_hashing_scan=True,
+        )
+        self.presenter = FolderHasherPresenter(
+            self,
+            debug=config.debug,
+            trace=config.trace,
+            quiet=config.quiet,
+        )
+
+        self.scan_dir = scan_dir
+        self.tree = None
+        self.depth = depth
+
+    def hash_directory(self, path: str) -> dict:
+        """
+        Generate the folder hashing request structure from a directory path.
+
+        This method builds a directory tree (DirectoryNode) and computes the associated
+        hash data for the folder.
+
+        Args:
+            path (str): The root directory path.
+
+        Returns:
+            dict: The folder hash request structure.
+        """
+
+        root_node = self._build_root_node(path)
+        tree = self._hash_calc_from_node(root_node)
+
+        self.tree = tree
+
+        return tree
+
+    def _build_root_node(
+        self,
+        path: str,
+    ) -> DirectoryNode:
+        """
+        Build a directory tree from the given path with file information.
+
+        The tree includes DirectoryNode objects populated with filtered file items,
+        each containing their relative path and CRC64 hash key.
+
+        Args:
+            path (str): The directory path to build the tree from.
+
+        Returns:
+            DirectoryNode: The root node representing the directory.
+        """
+        root = Path(path).resolve()
+        root_node = DirectoryNode(str(root))
+
+        all_files = [
+            f for f in root.rglob('*') if f.is_file()
+        ]
+        filtered_files = self.file_filters.get_filtered_files_from_files(all_files, str(root))
+
+        # Sort the files by name to ensure the hash is the same for the same folder
+        filtered_files.sort()
+
+        bar_ctx = Bar('Hashing files...', max=len(filtered_files))
+
+        with bar_ctx as bar:
+            full_file_path = ''
+            for file_path in filtered_files:
+                try:
+                    file_path_obj = Path(file_path) if isinstance(file_path, str) else file_path
+                    full_file_path = file_path_obj if file_path_obj.is_absolute() else root / file_path_obj
+
+                    self.base.print_debug(f'\nHashing file {str(full_file_path)}')
+
+                    file_bytes = full_file_path.read_bytes()
+                    key = CRC64.get_hash_buff(file_bytes)
+                    key_str = ''.join(f'{b:02x}' for b in key)
+                    rel_path = str(full_file_path.relative_to(root))
+
+                    file_item = DirectoryFile(rel_path, key, key_str)
+
+                    current_node = root_node
+                    for part in Path(rel_path).parent.parts:
+                        child_path = str(Path(current_node.path) / part)
+                        if child_path not in current_node.children:
+                            current_node.children[child_path] = DirectoryNode(child_path)
+                        current_node = current_node.children[child_path]
+                        current_node.files.append(file_item)
+
+                    root_node.files.append(file_item)
+
+                except Exception as e:
+                    self.base.print_debug(f'Skipping file {full_file_path}: {str(e)}')
+
+                bar.next()
+        return root_node
+
+    def _hash_calc_from_node(self, node: DirectoryNode, current_depth: int = 1) -> dict:
+        """
+        Recursively compute folder hash data for a directory node.
+
+        The hash data includes the path identifier, simhash for file names,
+        simhash for file content, directory hash, language extensions, and children node hash information.
+
+        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()
+            scan_dir_path = Path(self.scan_dir).resolve()
+            rel_path = node_path.relative_to(scan_dir_path)
+        except ValueError:
+            # 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': children,
+        }
+
+    def _hash_calc(self, node: DirectoryNode) -> dict:
+        """
+        Compute folder hash values for a given directory node.
+
+        The method aggregates unique file keys and sorted file names to generate
+        simhash-based hash values for both file names and file contents.
+
+        The most significant byte of the name simhash is then replaced by a computed head value.
+
+        Args:
+            node (DirectoryNode): The directory node containing file items.
+
+        Returns:
+            dict: A dictionary with 'name_hash', 'content_hash', 'dir_hash', and 'lang_extensions' keys.
+        """
+        processed_hashes = set()
+        unique_file_names = set()
+        unique_directories = set()
+        extension_map = {}
+        file_hashes = []
+        selected_names = []
+
+        for file in node.files:
+            key_str = file.key_str
+
+            file_name = os.path.basename(file.path)
+
+            file_name_without_extension, extension = os.path.splitext(file_name)
+            current_directory = os.path.dirname(file.path)
+
+            if extension and len(extension) > 1:
+                ext_without_dot = extension[1:]
+                extension_map[ext_without_dot] = extension_map.get(ext_without_dot, 0) + 1
+
+            current_directory.replace(self.scan_dir, '', 1).lstrip(os.path.sep)
+            parts = current_directory.split(os.path.sep)
+            for d in parts:
+                if d in {'', '.', '..'}:
+                    continue
+                unique_directories.add(d)
+
+            processed_hashes.add(key_str)
+            unique_file_names.add(file_name_without_extension)
+            selected_names.append(file_name)
+            file_hashes.append(file.key)
+
+        if len(selected_names) < MINIMUM_FILE_COUNT:
+            return {'name_hash': None, 'content_hash': None, 'dir_hash': None, 'lang_extensions': None}
+
+        selected_names.sort()
+        concatenated_names = ''.join(selected_names)
+
+        if len(concatenated_names.encode('utf-8')) < MINIMUM_CONCATENATED_NAME_LENGTH:
+            return {'name_hash': None, 'content_hash': None, 'dir_hash': None, 'lang_extensions': None}
+
+        # Concatenate the unique file names without the extensions, adding a space and sorting them alphabetically
+        unique_file_names_list = list(unique_file_names)
+        unique_file_names_list.sort()
+        concatenated_names = ' '.join(unique_file_names_list)
+
+        # We do the same for the directory names, adding a space and sorting them alphabetically
+        unique_directories_list = list(unique_directories)
+        unique_directories_list.sort()
+        concatenated_directories = ' '.join(unique_directories_list)
+
+        names_simhash = simhash(WordFeatureSet(concatenated_names.encode('utf-8')))
+        dir_simhash = simhash(WordFeatureSet(concatenated_directories.encode('utf-8')))
+        content_simhash = fingerprint(vectorize_bytes(file_hashes))
+
+        # Debug logging similar to Go implementation
+        self.base.print_debug(f'Unique file names: {unique_file_names_list}')
+        self.base.print_debug(f'Unique directories: {unique_directories_list}')
+        self.base.print_debug(f'{dir_simhash:x}/{names_simhash:x} - {content_simhash:x} - {extension_map}')
+
+        return {
+            'name_hash': names_simhash,
+            'content_hash': content_simhash,
+            'dir_hash': dir_simhash,
+            'lang_extensions': extension_map,
+        }
+
+    def present(self, output_format: Optional[str] = None, output_file: Optional[str] = None):
+        """Present the hashed tree in the selected format"""
+        self.presenter.present(output_format=output_format, output_file=output_file)
+
+
+class FolderHasherPresenter(AbstractPresenter):
+    """
+    FolderHasher presenter class
+    Handles the presentation of the folder hashing scan results
+    """
+
+    def __init__(self, folder_hasher: FolderHasher, **kwargs):
+        super().__init__(**kwargs)
+        self.folder_hasher = folder_hasher
+
+    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.folder_hasher.tree, indent=2)
+
+    def _format_plain_output(self) -> str:
+        """
+        Format the scan output data into a plain text string
+        """
+        return (
+            json.dumps(self.folder_hasher.tree, indent=2)
+            if isinstance(self.folder_hasher.tree, dict)
+            else str(self.folder_hasher.tree)
+        )
+
+    def _format_cyclonedx_output(self) -> str:
+        raise NotImplementedError('CycloneDX output is not implemented')
+
+    def _format_spdxlite_output(self) -> str:
+        raise NotImplementedError('SPDXlite output is not implemented')
+
+    def _format_csv_output(self) -> str:
+        raise NotImplementedError('CSV output is not implemented')
+
+    def _format_raw_output(self) -> str:
+        raise NotImplementedError('Raw output is not implemented')

scanoss/scanners/scanner_config.py

@@ -0,0 +1,73 @@
+"""
+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.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from pypac.parser import PACFile
+
+from scanoss.constants import (
+    DEFAULT_NB_THREADS,
+    DEFAULT_POST_SIZE,
+    DEFAULT_SC_TIMEOUT,
+    DEFAULT_TIMEOUT,
+)
+
+
+@dataclass
+class ScannerConfig:
+    debug: bool = False
+    trace: bool = False
+    quiet: bool = False
+    api_key: Optional[str] = None
+    url: Optional[str] = None
+    grpc_url: Optional[str] = None
+    post_size: int = DEFAULT_POST_SIZE
+    timeout: int = DEFAULT_TIMEOUT
+    sc_timeout: int = DEFAULT_SC_TIMEOUT
+    nb_threads: int = DEFAULT_NB_THREADS
+    proxy: Optional[str] = None
+    grpc_proxy: Optional[str] = None
+
+    ca_cert: Optional[str] = None
+    pac: Optional[PACFile] = None
+
+
+def create_scanner_config_from_args(args) -> ScannerConfig:
+    return ScannerConfig(
+        debug=args.debug,
+        trace=args.trace,
+        quiet=args.quiet,
+        api_key=getattr(args, 'key', None),
+        url=getattr(args, 'api_url', None),
+        grpc_url=getattr(args, 'grpc_url', None),
+        post_size=getattr(args, 'post_size', DEFAULT_POST_SIZE),
+        timeout=getattr(args, 'timeout', DEFAULT_TIMEOUT),
+        sc_timeout=getattr(args, 'sc_timeout', DEFAULT_SC_TIMEOUT),
+        nb_threads=getattr(args, 'nb_threads', DEFAULT_NB_THREADS),
+        proxy=getattr(args, 'proxy', None),
+        grpc_proxy=getattr(args, 'grpc_proxy', None),
+        ca_cert=getattr(args, 'ca_cert', None),
+        pac=getattr(args, 'pac', None),
+    )

scanoss/scanners/scanner_hfh.py

@@ -0,0 +1,252 @@
+"""
+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 json
+import threading
+import time
+from typing import Dict, Optional
+
+from progress.spinner import Spinner
+
+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
+from scanoss.scanners.scanner_config import ScannerConfig
+from scanoss.scanoss_settings import ScanossSettings
+from scanoss.scanossbase import ScanossBase
+from scanoss.scanossgrpc import ScanossGrpc
+from scanoss.utils.abstract_presenter import AbstractPresenter
+
+
+class ScannerHFH:
+    """
+    Folder Hashing Scanner.
+
+    This scanner processes a directory, computes CRC64 hashes for the files,
+    and calculates simhash values based on file names and content to detect folder-level similarities.
+    """
+
+    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,
+        use_grpc: bool = False,
+    ):
+        """
+        Initialize the ScannerHFH.
+
+        Args:
+            scan_dir (str): The directory to be scanned.
+            config (ScannerConfig): Configuration parameters for the scanner.
+            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,
+            trace=config.trace,
+            quiet=config.quiet,
+        )
+        self.presenter = ScannerHFHPresenter(
+            self,
+            debug=config.debug,
+            trace=config.trace,
+            quiet=config.quiet,
+        )
+        self.file_filters = FileFilters(
+            debug=config.debug,
+            trace=config.trace,
+            quiet=config.quiet,
+            scanoss_settings=scanoss_settings,
+        )
+        self.folder_hasher = FolderHasher(
+            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
+        self.use_grpc = use_grpc
+
+    def _execute_grpc_scan(self, hfh_request: Dict) -> None:
+        """
+        Execute folder hash scan.
+
+        Args:
+            hfh_request: Request dictionary for the gRPC call
+        """
+        try:
+            self.scan_results = self.client.folder_hash_scan(hfh_request, self.use_grpc)
+        except Exception as e:
+            self.base.print_stderr(f'Error during folder hash scan: {e}')
+            self.scan_results = None
+
+    def scan(self) -> Optional[Dict]:
+        """
+        Scan the provided directory using the folder hashing algorithm.
+
+        Returns:
+            Optional[Dict]: The folder hash response from the gRPC client, or None if an error occurs.
+        """
+        hfh_request = {
+            '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_ctx = Spinner('Scanning folder...')
+
+        with spinner_ctx as spinner:
+            grpc_thread = threading.Thread(target=self._execute_grpc_scan, args=(hfh_request,))
+            grpc_thread.start()
+
+            while grpc_thread.is_alive():
+                spinner.next()
+                time.sleep(0.1)
+
+            grpc_thread.join()
+
+        return self.scan_results
+
+    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.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.scanner.scan_results, indent=2)
+            if isinstance(self.scanner.scan_results, dict)
+            else str(self.scanner.scan_results)
+        )
+
+    def _format_cyclonedx_output(self) -> str:  # noqa: PLR0911
+        if not self.scanner.scan_results:
+            return ''
+        try:
+            if 'results' not in self.scanner.scan_results or not self.scanner.scan_results['results']:
+                self.base.print_stderr('ERROR: No scan results found')
+                return ''
+
+            first_result = self.scanner.scan_results['results'][0]
+
+            best_match_components = [c for c in first_result.get('components', []) if c.get('order') == 1]
+            if not best_match_components:
+                self.base.print_stderr('ERROR: No best match component found')
+                return ''
+
+            best_match_component = best_match_components[0]
+            if not best_match_component.get('versions'):
+                self.base.print_stderr('ERROR: No versions found for best match component')
+                return ''
+
+            best_match_version = best_match_component['versions'][0]
+            purl = best_match_component['purl']
+
+            get_dependencies_json_request = {
+                'files': [
+                    {
+                        'file': f'{best_match_component["name"]}:{best_match_version["version"]}',
+                        'purls': [{'purl': purl, 'requirement': best_match_version['version']}],
+                    }
+                ]
+            }
+
+            get_vulnerabilities_json_request = {
+                'components': [{'purl': purl, 'requirement': best_match_version['version']}],
+            }
+
+            decorated_scan_results = self.scanner.client.get_dependencies(get_dependencies_json_request)
+            vulnerabilities = self.scanner.client.get_vulnerabilities_json(get_vulnerabilities_json_request)
+
+            cdx = CycloneDx(self.base.debug)
+            scan_results = {}
+            for f in decorated_scan_results['files']:
+                scan_results[f['file']] = [f]
+            success, cdx_output = cdx.produce_from_json(scan_results)
+            if not success:
+                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}')
+            return None
+
+    def _format_spdxlite_output(self) -> str:
+        raise NotImplementedError('SPDXlite output is not implemented')
+
+    def _format_csv_output(self) -> str:
+        raise NotImplementedError('CSV output is not implemented')
+
+    def _format_raw_output(self) -> str:
+        raise NotImplementedError('Raw output is not implemented')