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

scanoss/inspection/summary/component_summary.py

@@ -0,0 +1,170 @@
+"""
+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
+from typing import Any
+
+from ...scanossbase import ScanossBase
+from ..policy_check.policy_check import T
+from ..utils.scan_result_processor import ScanResultProcessor
+
+
+class ComponentSummary(ScanossBase):
+
+    def __init__( # noqa: PLR0913
+        self,
+        debug: bool = False,
+        trace: bool = False,
+        quiet: bool = False,
+        filepath: str = None,
+        format_type: str = 'json',
+        output: str = None,
+    ):
+        """
+        Initialize the ComponentSummary class.
+
+        :param debug: Enable debug mode
+        :param trace: Enable trace mode
+        :param quiet: Enable quiet mode
+        :param filepath: Path to the file containing component data
+        :param format_type: Output format ('json' or 'md')
+        """
+        super().__init__(debug, trace, quiet)
+        self.filepath = filepath
+        self.output = output
+        self.results_processor = ScanResultProcessor(debug, trace, quiet, filepath)
+
+
+    def _json(self, data: dict[str,Any]) -> dict[str,Any]:
+        """
+        Format component summary data as JSON.
+
+        This method returns the component summary data in its original JSON structure
+        without any transformation. The data can be directly serialized to JSON format.
+
+        :param data: Dictionary containing component summary information including:
+                     - components: List of component-license pairs with status and metadata
+                     - totalComponents: Total number of unique components
+                     - undeclaredComponents: Number of components with 'pending' status
+                     - declaredComponents: Number of components with 'identified' status
+                     - totalFilesDetected: Total count of files where components were detected
+                     - totalFilesUndeclared: Count of files with undeclared components
+                     - totalFilesDeclared: Count of files with declared components
+        :return: The same data dictionary, ready for JSON serialization
+        """
+        return data
+
+    def _markdown(self, data: list[T]) -> dict[str, Any]:
+        """
+        Format component summary data as Markdown (not yet implemented).
+
+        This method is intended to convert component summary data into a human-readable
+        Markdown format with tables and formatted sections.
+
+        :param data: List of component summary items to format
+        :return: Dictionary containing formatted Markdown output
+        """
+        pass
+
+    def _jira_markdown(self, data: list[T]) -> dict[str, Any]:
+        """
+        Format component summary data as Jira-flavored Markdown (not yet implemented).
+
+        This method is intended to convert component summary data into Jira-compatible
+        Markdown format, which may include Jira-specific syntax for tables and formatting.
+
+        :param data: List of component summary items to format
+        :return: Dictionary containing Jira-formatted Markdown output
+        """
+        pass
+
+    def _get_component_summary_from_components(self, scan_components: list)-> dict:
+        """
+        Get a component summary from detected components.
+
+        :param scan_components: List of all components
+        :return: Dict with license summary information
+        """
+        # A component is considered unique by its combination of PURL (Package URL) and license
+        component_licenses = self.results_processor.group_components_by_license(scan_components)
+        total_components = len(component_licenses)
+        # Get undeclared components
+        undeclared_components = len([c for c in component_licenses if c['status'] == 'pending'])
+
+        components: list = []
+        total_undeclared_files = 0
+        total_files_detected = 0
+        for component in scan_components:
+            total_files_detected += component['count']
+            total_undeclared_files += component['undeclared']
+            components.append({
+                'purl': component['purl'],
+                'version': component['version'],
+                'count': component['count'],
+                'undeclared': component['undeclared'],
+                'declared': component['count'] - component['undeclared'],
+            })
+        ## End for loop components
+        return {
+            "components": component_licenses,
+            'totalComponents': total_components,
+            'undeclaredComponents': undeclared_components,
+            'declaredComponents': total_components - undeclared_components,
+            'totalFilesDetected': total_files_detected,
+            'totalFilesUndeclared': total_undeclared_files,
+            'totalFilesDeclared': total_files_detected - total_undeclared_files,
+        }
+
+    def _get_components(self):
+        """
+        Extract and process components from results and their dependencies.
+
+        This method performs the following steps:
+        1. Validates that `self.results` is loaded. Returns `None` if not.
+        2. Extracts file, snippet, and dependency components into a dictionary.
+        3. Converts components to a list and processes their licenses.
+
+        :return: A list of processed components with license data, or `None` if `self.results` is not set.
+        """
+        if self.results_processor.get_results() is None:
+            raise ValueError(f'Error: No results found in {self.filepath}')
+
+        components: dict = {}
+        # Extract component and license data from file and dependency results. Both helpers mutate `components`
+        self.results_processor.get_components_data(components)
+        return self.results_processor.convert_components_to_list(components)
+
+    def _format(self, component_summary) -> str:
+        # TODO: Implement formatter to support dynamic outputs
+        json_data = self._json(component_summary)
+        return json.dumps(json_data, indent=2)
+
+    def run(self):
+        components = self._get_components()
+        component_summary = self._get_component_summary_from_components(components)
+        output = self._format(component_summary)
+        self.print_to_file_or_stdout(output, self.output)
+        return component_summary
+#
+# End of ComponentSummary Class
+#

scanoss/inspection/{license_summary.py → summary/license_summary.py}

@@ -23,11 +23,14 @@ SPDX-License-Identifier: MIT
 """
 
 import json
+from typing import Any
 
-from .inspect_base import InspectBase
+from ...scanossbase import ScanossBase
+from ..policy_check.policy_check import T
+from ..utils.scan_result_processor import ScanResultProcessor
 
 
-class LicenseSummary(InspectBase):
+class LicenseSummary(ScanossBase):
     """
        SCANOSS LicenseSummary class
        Inspects results and generates comprehensive license summaries from detected components.
@@ -55,7 +58,7 @@ class LicenseSummary(InspectBase):
         Initialize the LicenseSummary class.
 
         :param debug: Enable debug mode
-        :param trace: Enable trace mode (default True)
+        :param trace: Enable trace mode
         :param quiet: Enable quiet mode
         :param filepath: Path to the file containing component data
         :param output: Path to save detailed output
@@ -63,8 +66,8 @@ class LicenseSummary(InspectBase):
         :param exclude: Licenses to exclude from the analysis
         :param explicit: Explicitly defined licenses
         """
-        super().__init__(debug, trace, quiet, filepath, output)
-        self.license_util.init(include, exclude, explicit)
+        super().__init__(debug=debug, trace=trace, quiet=quiet)
+        self.results_processor = ScanResultProcessor(debug, trace, quiet, filepath, include, exclude, explicit)
         self.filepath = filepath
         self.output = output
         self.status = status
@@ -72,6 +75,47 @@ class LicenseSummary(InspectBase):
         self.exclude = exclude
         self.explicit = explicit
 
+    def _json(self, data: dict[str,Any]) -> dict[str, Any]:
+        """
+        Format license summary data as JSON.
+
+        This method is intended to return the license summary data in JSON structure
+        for serialization. The data should include license information with copyleft
+        analysis and license statistics.
+
+        :param data: List of license summary items to format
+        :return: Dictionary containing license summary information including:
+                 - licenses: List of detected licenses with SPDX IDs, URLs, and copyleft status
+                 - detectedLicenses: Total number of unique licenses
+                 - detectedLicensesWithCopyleft: Count of licenses marked as copyleft
+        """
+        return data
+
+    def _markdown(self, data: list[T]) -> dict[str, Any]:
+        """
+        Format license summary data as Markdown (not yet implemented).
+
+        This method is intended to convert license summary data into a human-readable
+        Markdown format with tables and formatted sections.
+
+        :param data: List of license summary items to format
+        :return: Dictionary containing formatted Markdown output
+        """
+        pass
+
+    def _jira_markdown(self, data: list[T]) -> dict[str, Any]:
+        """
+        Format license summary data as Jira-flavored Markdown (not yet implemented).
+
+        This method is intended to convert license summary data into Jira-compatible
+        Markdown format, which may include Jira-specific syntax for tables and formatting.
+
+        :param data: List of license summary items to format
+        :return: Dictionary containing Jira-formatted Markdown output
+        """
+        pass
+
+
     def _get_licenses_summary_from_components(self, components: list)-> dict:
         """
         Get a license summary from detected components.
@@ -80,7 +124,7 @@ class LicenseSummary(InspectBase):
         :return: Dict with license summary information
         """
         # A component is considered unique by its combination of PURL (Package URL) and license
-        component_licenses = self._group_components_by_license(components)
+        component_licenses = self.results_processor.group_components_by_license(components)
         license_component_count = {}
         # Count license per component
         for lic in component_licenses:
@@ -122,19 +166,25 @@ class LicenseSummary(InspectBase):
 
         :return: A list of processed components with license data, or `None` if `self.results` is not set.
         """
-        if self.results is None:
-            return None
+        if self.results_processor.get_results() is None:
+            raise ValueError(f'Error: No results found in {self.filepath}')
 
         components: dict = {}
         # Extract component and license data from file and dependency results. Both helpers mutate `components`
-        self._get_components_data(self.results, components)
-        self._get_dependencies_data(self.results, components)
-        return self._convert_components_to_list(components)
+        self.results_processor.get_components_data(components)
+        self.results_processor.get_dependencies_data(components)
+        return self.results_processor.convert_components_to_list(components)
+
+    def _format(self, license_summary) -> str:
+        # TODO: Implement formatter to support dynamic outputs
+        json_data = self._json(license_summary)
+        return json.dumps(json_data, indent=2)
 
     def run(self):
         components = self._get_components()
         license_summary = self._get_licenses_summary_from_components(components)
-        self.print_to_file_or_stdout(json.dumps(license_summary, indent=2), self.output)
+        output = self._format(license_summary)
+        self.print_to_file_or_stdout(output, self.output)
         return license_summary
 #
 # End of LicenseSummary Class

scanoss/inspection/summary/match_summary.py

@@ -0,0 +1,341 @@
+"""
+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 ...scanossbase import ScanossBase
+from ...utils import scanoss_scan_results_utils
+from ..utils.file_utils import load_json_file
+from ..utils.markdown_utils import generate_table
+
+
+@dataclass
+class MatchSummaryItem:
+    """
+    Represents a single match entry in the SCANOSS results.
+
+    This data class encapsulates all the relevant information about a component
+    match found during scanning, including file location, license details, and
+    match quality metrics.
+    """
+    file: str
+    file_url: str
+    license: str
+    similarity: str
+    purl: str
+    purl_url: str
+    version: str
+    lines: str
+
+
+@dataclass
+class ComponentMatchSummary:
+    """
+    Container for categorized SCANOSS match results.
+
+    Organizes matches into two categories: full file matches and snippet matches.
+    This separation allows for different presentation and analysis of match types.
+    """
+    files: list[MatchSummaryItem]
+    snippet: list[MatchSummaryItem]
+
+class MatchSummary(ScanossBase):
+    """
+    Generates Markdown summaries from SCANOSS scan results.
+
+    This class processes SCANOSS scan results and creates human-readable Markdown
+    reports with collapsible sections for file and snippet matches. The reports
+    include clickable links to files when a line range
+    prefix is provided.
+    """
+
+    def __init__(  # noqa: PLR0913
+            self,
+            debug: bool = False,
+            trace: bool = False,
+            quiet: bool = False,
+            line_range_prefix: str = None,
+            scanoss_results_path: str = None,
+            output: str = None,
+    ):
+        """
+        Initialize the Matches Summary generator.
+
+        :param debug: Enable debug output for troubleshooting
+        :param trace: Enable trace-level logging for detailed execution tracking
+        :param quiet: Suppress informational messages
+        :param line_range_prefix: Base URL prefix for GitLab file links with line ranges
+                                  (e.g., 'https://gitlab.com/org/project/-/blob/main')
+        :param scanoss_results_path: Path to SCANOSS scan results file in JSON format
+        :param output: Output file path for the generated Markdown report (default: stdout)
+        """
+        super().__init__(debug=debug, trace=trace, quiet=quiet)
+        self.scanoss_results_path = scanoss_results_path
+        self.line_range_prefix = line_range_prefix
+        self.output = output
+        self.print_debug("Initializing MatchSummary class")
+
+
+    def _get_match_summary_item(self, file_name: str, result: dict) -> MatchSummaryItem:
+        """
+        Create a MatchSummaryItem from a single scan result.
+
+        Processes a SCANOSS scan result and creates a MatchSummaryItem with appropriate
+        file URLs, license information, and line ranges. Handles both snippet matches
+        (with specific line ranges) and file matches (entire file).
+
+        :param file_name: Name of the scanned file (relative path in the repository)
+        :param result: SCANOSS scan result dictionary containing match details
+        :return: Populated match summary item with all relevant information
+        """
+        self.print_trace(f"Creating match summary item for file: {file_name}, id: {result.get('id')}")
+
+        if result.get('id') == "snippet":
+            # Snippet match: create URL with line range anchor
+            lines = scanoss_scan_results_utils.get_lines(result.get('lines'))
+            end_line = lines[len(lines) - 1] if len(lines) > 1 else lines[0]
+            file_url = f"{self.line_range_prefix}/{file_name}#L{lines[0]}-L{end_line}"
+
+            self.print_trace(f"Snippet match: lines {lines[0]}-{end_line}, purl: {result.get('purl')[0]}")
+
+            return MatchSummaryItem(
+                file_url=file_url,
+                file=file_name,
+                license=result.get('licenses')[0].get('name'),
+                similarity=result.get('matched'),
+                purl=result.get('purl')[0],
+                purl_url=result.get('url'),
+                version=result.get('version'),
+                lines=f"{lines[0]}-{lines[len(lines) - 1] if len(lines) > 1 else lines[0]}"
+            )
+        # File match: create URL without line range
+        self.print_trace(f"File match: {file_name}, purl: {result.get('purl')[0]}, version: {result.get('version')}")
+
+        return MatchSummaryItem(
+            file=file_name,
+            file_url=f"{self.line_range_prefix}/{file_name}",
+            license=result.get('licenses')[0].get('name'),
+            similarity=result.get('matched'),
+            purl=result.get('purl')[0],
+            purl_url=result.get('url'),
+            version=result.get('version'),
+            lines="all"
+        )
+
+    def _validate_result(self, file_name: str, result: dict) -> bool:
+        """
+        Validate that a scan result has all required fields.
+
+        :param file_name: Name of the file being validated
+        :param result: The scan result to validate
+        :return: True if valid, False otherwise
+        """
+        validations = [
+            ('id', 'No id found'),
+            ('lines', 'No lines found'),
+            ('purl', 'No purl found'),
+            ('licenses', 'No licenses found'),
+            ('version', 'No version found'),
+            ('matched', 'No matched found'),
+            ('url', 'No url found'),
+        ]
+
+        for field, error_msg in validations:
+            if not result.get(field):
+                self.print_debug(f'ERROR: {error_msg} for file {file_name}')
+                return False
+
+        # Additional validation for non-empty lists
+        if len(result.get('purl')) == 0:
+            self.print_debug(f'ERROR: No purl found for file {file_name}')
+            return False
+        if len(result.get('licenses')) == 0:
+            self.print_debug(f'ERROR: Empty licenses list for file {file_name}')
+            return False
+
+        return True
+
+    def _get_matches_summary(self) -> ComponentMatchSummary:
+        """
+        Parse SCANOSS scan results and create categorized match summaries.
+
+        Loads the SCANOSS scan results file and processes each match, validating
+        required fields and categorizing matches into file matches and snippet matches.
+        Skips invalid or incomplete results with debug messages.
+        """
+        self.print_debug(f"Loading scan results from: {self.scanoss_results_path}")
+
+        # Load scan results from JSON file
+        scan_results = load_json_file(self.scanoss_results_path)
+        gitlab_matches_summary = ComponentMatchSummary(files=[], snippet=[])
+
+        self.print_debug(f"Processing {len(scan_results)} files from scan results")
+        self.print_trace(f"Line range prefix set to: {self.line_range_prefix}")
+
+        # Process each file and its results
+        for file_name, results in scan_results.items():
+            self.print_trace(f"Processing file: {file_name} with {len(results)} results")
+
+            for result in results:
+                # Skip non-matches
+                if result.get('id') == "none":
+                    self.print_debug(f'Skipping non-match for file {file_name}')
+                    continue
+
+                # Validate required fields
+                if not self._validate_result(file_name, result):
+                    continue
+
+                # Create summary item and categorize by match type
+                summary_item = self._get_match_summary_item(file_name, result)
+                if result.get('id') == "snippet":
+                    gitlab_matches_summary.snippet.append(summary_item)
+                    self.print_trace(f"Added snippet match for {file_name}")
+                else:
+                    gitlab_matches_summary.files.append(summary_item)
+                    self.print_trace(f"Added file match for {file_name}")
+
+        self.print_debug(
+            f"Match summary complete: {len(gitlab_matches_summary.files)} file matches, "
+            f"{len(gitlab_matches_summary.snippet)} snippet matches"
+        )
+
+        return gitlab_matches_summary
+
+
+    def _markdown(self, gitlab_matches_summary: ComponentMatchSummary) -> str:
+        """
+        Generate Markdown from match summaries.
+
+        Creates a formatted Markdown document with collapsible sections for file
+        and snippet matches.
+
+        :param gitlab_matches_summary: Container with categorized file and snippet matches to format
+        :return: Complete Markdown document with formatted match tables
+        """
+        self.print_debug("Generating Markdown from match summaries")
+
+        if len(gitlab_matches_summary.files) == 0 and len(gitlab_matches_summary.snippet) == 0:
+            self.print_debug("No matches to format - returning empty string")
+            return ""
+
+        self.print_trace(
+            f"Formatting {len(gitlab_matches_summary.files)} file matches and "
+            f"{len(gitlab_matches_summary.snippet)} snippet matches"
+        )
+
+        # Define table headers
+        file_match_headers = ['File', 'License', 'Similarity', 'PURL', 'Version']
+        snippet_match_headers = ['File', 'License', 'Similarity', 'PURL', 'Version', 'Lines']
+
+        # Build file matches table
+        self.print_trace("Building file matches table")
+        file_match_rows = []
+        for file_match in gitlab_matches_summary.files:
+            row = [
+                f"[{file_match.file}]({file_match.file_url})",
+                file_match.license,
+                file_match.similarity,
+                f"[{file_match.purl}]({file_match.purl_url})",
+                file_match.version,
+            ]
+            file_match_rows.append(row)
+        file_match_table = generate_table(file_match_headers, file_match_rows)
+
+        # Build snippet matches table
+        self.print_trace("Building snippet matches table")
+        snippet_match_rows = []
+        for snippet_match in gitlab_matches_summary.snippet:
+            row = [
+                f"[{snippet_match.file}]({snippet_match.file_url})",
+                snippet_match.license,
+                snippet_match.similarity,
+                f"[{snippet_match.purl}]({snippet_match.purl_url})",
+                snippet_match.version,
+                snippet_match.lines
+            ]
+            snippet_match_rows.append(row)
+        snippet_match_table = generate_table(snippet_match_headers, snippet_match_rows)
+
+        # Assemble complete Markdown document
+        markdown = ""
+        markdown += "### SCANOSS Match Summary\n\n"
+
+        # File matches section (collapsible)
+        markdown += "<details>\n"
+        markdown += "<summary>File Match Summary</summary>\n\n"
+        markdown += file_match_table
+        markdown += "\n</details>\n"
+
+        # Snippet matches section (collapsible)
+        markdown += "<details>\n"
+        markdown += "<summary>Snippet Match Summary</summary>\n\n"
+        markdown += snippet_match_table
+        markdown += "\n</details>\n"
+
+        self.print_trace(f"Markdown generation complete (length: {len(markdown)} characters)")
+        self.print_debug("Match summary Markdown generation complete")
+        return markdown
+
+    def run(self):
+        """
+        Execute the matches summary generation process.
+
+        This is the main entry point for generating the matches summary report.
+        It orchestrates the entire workflow:
+        1. Loads and parses SCANOSS scan results
+        2. Validates and categorizes matches
+        3. Generates Markdown report
+        4. Outputs to file or stdout
+        """
+        self.print_debug("Starting match summary generation process")
+        self.print_trace(
+            f"Configuration - Results path: {self.scanoss_results_path}, Output: {self.output}, "
+            f"Line range prefix: {self.line_range_prefix}"
+        )
+
+        # Load and process scan results into categorized matches
+        self.print_trace("Loading and processing scan results")
+        matches = self._get_matches_summary()
+
+        # Format matches as GitLab-compatible Markdown
+        self.print_trace("Generating Markdown output")
+        matches_md = self._markdown(matches)
+        if matches_md == "":
+            self.print_debug("No matches found - exiting")
+            self.print_stdout("No matches found.")
+            return
+
+        # Output to file or stdout
+        self.print_trace("Writing output")
+        if self.output:
+            self.print_debug(f"Writing match summary to file: {self.output}")
+        else:
+            self.print_debug("Writing match summary to 'stdout'")
+
+        self.print_to_file_or_stdout(matches_md, self.output)
+        self.print_debug("Match summary generation complete")
+
+
+

scanoss/inspection/utils/file_utils.py

@@ -0,0 +1,44 @@
+"""
+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 os
+
+
+def load_json_file(file_path: str) -> dict:
+    """
+    Load the file
+
+    :param file_path: file path to the JSON file
+
+      Returns:
+          Dict[str, Any]: The parsed JSON data
+    """
+    if not os.path.exists(file_path):
+        raise ValueError(f'The file "{file_path}" does not exist.')
+    with open(file_path, 'r') as jsonfile:
+        try:
+            return json.load(jsonfile)
+        except Exception as e:
+            raise ValueError(f'ERROR: Problem parsing input JSON: {e}')