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

scanoss/filecount.py

@@ -1,30 +1,32 @@
 """
- SPDX-License-Identifier: MIT
-
-   Copyright (c) 2022, 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) 2022, 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 csv
 import os
 import pathlib
 import sys
+from contextlib import nullcontext
 
 from progress.spinner import Spinner
 
@@ -36,9 +38,15 @@ class FileCount(ScanossBase):
     SCANOSS File Type Count class
     Handle the scanning of files, snippets and dependencies
     """
-    def __init__(self, scan_output: str = None, hidden_files_folders: bool = False,
-                 debug: bool = False, trace: bool = False, quiet: bool = False
-                 ):
+
+    def __init__(
+        self,
+        scan_output: str = None,
+        hidden_files_folders: bool = False,
+        debug: bool = False,
+        trace: bool = False,
+        quiet: bool = False,
+    ):
         """
         Initialise scanning class
         """
@@ -56,7 +64,7 @@ class FileCount(ScanossBase):
         file_list = []
         for f in files:
             ignore = False
-            if f.startswith(".") and not self.hidden_files_folders:  # Ignore all . files unless requested
+            if f.startswith('.') and not self.hidden_files_folders:  # Ignore all . files unless requested
                 ignore = True
             if not ignore:
                 file_list.append(f)
@@ -71,7 +79,7 @@ class FileCount(ScanossBase):
         dir_list = []
         for d in dirs:
             ignore = False
-            if d.startswith(".") and not self.hidden_files_folders:  # Ignore all . folders unless requested
+            if d.startswith('.') and not self.hidden_files_folders:  # Ignore all . folders unless requested
                 ignore = True
             if not ignore:
                 dir_list.append(d)
@@ -84,7 +92,7 @@ class FileCount(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)
@@ -98,60 +106,58 @@ class FileCount(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}")
+            raise Exception(f'ERROR: Specified folder does not exist or is not a folder: {scan_dir}')
 
         self.print_msg(f'Searching {scan_dir} for files to count...')
-        spinner = None
-        if not self.quiet and self.isatty:
-            spinner = Spinner('Searching ')
-        file_types = {}
-        file_count = 0
-        file_size = 0
-        for root, dirs, files in os.walk(scan_dir):
-            self.print_trace(f'U Root: {root}, Dirs: {dirs}, Files {files}')
-            dirs[:] = self.__filter_dirs(dirs)                             # Strip out unwanted directories
-            filtered_files = self.__filter_files(files)                    # Strip out unwanted files
-            self.print_trace(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})')  # broken symlink
-                if f_size > 0:                                                 # Ignore broken links and empty files
-                    file_count = file_count + 1
-                    file_size = file_size + f_size
-                    f_suffix = pathlib.Path(file).suffix
-                    if not f_suffix or f_suffix == '':
-                        f_suffix = 'no_suffix'
-                    self.print_trace(f'Counting {path} ({f_suffix} - {f_size})..')
-                    fc = file_types.get(f_suffix)
-                    if not fc:
-                        fc = [1, f_size]
-                    else:
-                        fc[0] = fc[0] + 1
-                        fc[1] = fc[1] + f_size
-                    file_types[f_suffix] = fc
-                    if spinner:
-                        spinner.next()
-        # End for loop
-        if spinner:
-            spinner.finish()
-        self.print_stderr(f'Found {file_count:,.0f} files with a total size of {file_size/(1<<20):,.2f} MB.')
+        spinner_ctx = Spinner('Searching ') if (not self.quiet and self.isatty) else nullcontext()
+
+        with spinner_ctx as spinner:
+            file_types = {}
+            file_count = 0
+            file_size = 0
+            for root, dirs, files in os.walk(scan_dir):
+                self.print_trace(f'U Root: {root}, Dirs: {dirs}, Files {files}')
+                dirs[:] = self.__filter_dirs(dirs)  # Strip out unwanted directories
+                filtered_files = self.__filter_files(files)  # Strip out unwanted files
+                self.print_trace(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})')  # broken symlink
+                    if f_size > 0:  # Ignore broken links and empty files
+                        file_count = file_count + 1
+                        file_size = file_size + f_size
+                        f_suffix = pathlib.Path(file).suffix
+                        if not f_suffix or f_suffix == '':
+                            f_suffix = 'no_suffix'
+                        self.print_trace(f'Counting {path} ({f_suffix} - {f_size})..')
+                        fc = file_types.get(f_suffix)
+                        if not fc:
+                            fc = [1, f_size]
+                        else:
+                            fc[0] = fc[0] + 1
+                            fc[1] = fc[1] + f_size
+                        file_types[f_suffix] = fc
+                        if spinner:
+                            spinner.next()
+            # End for loop
+        self.print_stderr(f'Found {file_count:,.0f} files with a total size of {file_size / (1 << 20):,.2f} MB.')
         if file_types:
             csv_dict = []
             for k in file_types:
                 d = file_types[k]
-                csv_dict.append({'extension': k, 'count': d[0], 'size(MB)': f'{d[1]/(1<<20):,.2f}'})
+                csv_dict.append({'extension': k, 'count': d[0], 'size(MB)': f'{d[1] / (1 << 20):,.2f}'})
             fields = ['extension', 'count', 'size(MB)']
             file = sys.stdout
             if self.scan_output:
                 file = open(self.scan_output, 'w')
             writer = csv.DictWriter(file, fieldnames=fields)
-            writer.writeheader()        # writing headers (field names)
+            writer.writeheader()  # writing headers (field names)
             writer.writerows(csv_dict)  # writing data rows
             if self.scan_output:
                 file.close()

scanoss/gitlabqualityreport.py

@@ -0,0 +1,214 @@
+"""
+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
+import sys
+from dataclasses import dataclass
+
+from .scanossbase import ScanossBase
+from .utils import scanoss_scan_results_utils
+
+
+@dataclass
+class Lines:
+    begin: int
+
+@dataclass
+class Location:
+    path: str
+    lines: Lines
+
+@dataclass
+class CodeQuality:
+    description: str
+    check_name: str
+    fingerprint: str
+    severity: str
+    location: Location
+
+    def to_dict(self):
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "description": self.description,
+            "check_name": self.check_name,
+            "fingerprint": self.fingerprint,
+            "severity": self.severity,
+            "location": {
+                "path": self.location.path,
+                "lines": {
+                    "begin": self.location.lines.begin
+                }
+            }
+        }
+
+class GitLabQualityReport(ScanossBase):
+    """
+    GitLabCodeQuality management class
+    Handle all interaction with GitLab Code Quality Report formatting
+    """
+
+    def __init__(self, debug: bool = False, trace: bool = False, quiet: bool = False):
+        """
+        Initialise the GitLabCodeQuality class
+        """
+        super().__init__(debug, trace, quiet)
+        self.print_trace(f"GitLabQualityReport initialized with debug={debug}, trace={trace}, quiet={quiet}")
+
+
+    def _get_code_quality(self, file_name: str, result: dict) -> CodeQuality or None:
+        self.print_trace(f"_get_code_quality called for file: {file_name}")
+        self.print_trace(f"Processing result: {result}")
+
+        if not result.get('file_hash'):
+            self.print_debug(f"Warning: no hash found for result: {result}")
+            return None
+
+        if result.get('id') == 'file':
+            self.print_debug(f"Processing file match for: {file_name}")
+            description = f"File match found in: {file_name}"
+            code_quality = CodeQuality(
+                description=description,
+                check_name=file_name,
+                fingerprint=result.get('file_hash'),
+                severity="info",
+                location=Location(
+                    path=file_name,
+                    lines = Lines(
+                        begin= 1
+                    )
+                )
+            )
+            self.print_trace(f"Created file CodeQuality object: {code_quality}")
+            return code_quality
+
+        if not result.get('lines'):
+            self.print_debug(f"Warning: No lines found for result: {result}")
+            return None
+        lines = scanoss_scan_results_utils.get_lines(result.get('lines'))
+        self.print_trace(f"Extracted lines: {lines}")
+        if len(lines) == 0:
+            self.print_debug(f"Warning: empty lines for result: {result}")
+            return None
+        end_line = lines[len(lines) - 1] if len(lines) > 1 else lines[0]
+        description = f"Snippet found in: {file_name} - lines {lines[0]}-{end_line}"
+        self.print_debug(f"Processing snippet match for: {file_name}, lines: {lines[0]}-{end_line}")
+        code_quality = CodeQuality(
+            description=description,
+            check_name=file_name,
+            fingerprint=result.get('file_hash'),
+            severity="info",
+            location=Location(
+                path=file_name,
+                lines=Lines(
+                    begin=lines[0]
+                )
+            )
+        )
+        self.print_trace(f"Created snippet CodeQuality object: {code_quality}")
+        return code_quality
+
+    def _write_output(self, data: list[CodeQuality], output_file: str = None) -> bool:
+        """Write the Gitlab Code Quality Report to output."""
+        self.print_trace(f"_write_output called with {len(data)} items, output_file: {output_file}")
+        try:
+            json_data = [item.to_dict() for item in data]
+            self.print_trace(f"JSON data: {json_data}")
+            file = open(output_file, 'w') if output_file else sys.stdout
+            print(json.dumps(json_data, indent=2), file=file)
+            if output_file:
+                file.close()
+                self.print_debug(f"Wrote output to file: {output_file}")
+            else:
+                self.print_debug("Wrote output to 'stdout'")
+            return True
+        except Exception as e:
+            self.print_stderr(f'Error writing output: {str(e)}')
+            return False
+
+    def _produce_from_json(self, data: dict, output_file: str = None) -> bool:
+        self.print_trace(f"_produce_from_json called with output_file: {output_file}")
+        self.print_debug(f"Processing {len(data)} files from JSON data")
+        code_quality = []
+        for file_name, results in data.items():
+            self.print_trace(f"Processing file: {file_name} with {len(results)} results")
+            for result in results:
+                if not result.get('id'):
+                    self.print_debug(f"Warning: No ID found for result: {result}")
+                    continue
+                if result.get('id') != 'snippet' and result.get('id') != 'file':
+                    self.print_debug(f"Skipping non-snippet/file match: {file_name}, id: '{result['id']}'")
+                    continue
+                code_quality_item = self._get_code_quality(file_name, result)
+                if code_quality_item:
+                    code_quality.append(code_quality_item)
+                    self.print_trace(f"Added code quality item for {file_name}")
+                else:
+                    self.print_debug(f"Warning: No Code Quality found for result: {result}")
+        self.print_debug(f"Generated {len(code_quality)} code quality items")
+        self._write_output(data=code_quality,output_file=output_file)
+        return True
+
+    def _produce_from_str(self, json_str: str, output_file: str = None) -> bool:
+        """
+        Produce Gitlab Code Quality Report output from input JSON string
+        :param json_str: input JSON string
+        :param output_file: Output file (optional)
+        :return: True if successful, False otherwise
+        """
+        self.print_trace(f"_produce_from_str called with output_file: {output_file}")
+        if not json_str:
+            self.print_stderr('ERROR: No JSON string provided to parse.')
+            return False
+        self.print_debug(f"Parsing JSON string of length: {len(json_str)}")
+        try:
+            data = json.loads(json_str)
+            self.print_debug("Successfully parsed JSON data")
+            self.print_trace(f"Parsed data structure: {type(data)}")
+        except Exception as e:
+            self.print_stderr(f'ERROR: Problem parsing input JSON: {e}')
+            return False
+        return self._produce_from_json(data, output_file)
+
+
+    def produce_from_file(self, json_file: str, output_file: str = None) -> bool:
+        """
+        Parse plain/raw input JSON file and produce GitLab Code Quality JSON output
+        :param json_file:
+        :param output_file:
+        :return: True if successful, False otherwise
+        """
+        self.print_trace(f"produce_from_file called with json_file: {json_file}, output_file: {output_file}")
+        self.print_debug(f"Input JSON file: {json_file}, output_file: {output_file}")
+        if not json_file:
+            self.print_stderr('ERROR: No JSON file provided to parse.')
+            return False
+        if not os.path.isfile(json_file):
+            self.print_stderr(f'ERROR: JSON file does not exist or is not a file: {json_file}')
+            return False
+        self.print_debug(f"Reading JSON file: {json_file}")
+        with open(json_file, 'r') as f:
+            json_content = f.read()
+            success = self._produce_from_str(json_content, output_file)
+        return success