scanoss 1.30.0__py3-none-any.whl → 1.31.1__py3-none-any.whl

scanoss/data/build_date.txt

@@ -1 +1 @@
-date: 20250722103216, utime: 1753180336
+date: 20250808142900, utime: 1754663340

scanoss/export/dependency_track.py

@@ -25,85 +25,65 @@ SPDX-License-Identifier: MIT
 import base64
 import json
 import traceback
-from dataclasses import dataclass
-from typing import Optional
 
 import requests
 
-from scanoss.cyclonedx import CycloneDx
-
+from ..cyclonedx import CycloneDx
 from ..scanossbase import ScanossBase
+from ..services.dependency_track_service import DependencyTrackService
 from ..utils.file import validate_json_file
 
 
-@dataclass
-class DependencyTrackExporterConfig:
-    debug: bool = False
-    trace: bool = False
-    quiet: bool = False
-    dt_url: str = None
-    dt_apikey: str = None
-    dt_projectid: Optional[str] = None
-    dt_projectname: Optional[str] = None
-    dt_projectversion: Optional[str] = None
+def _build_payload(encoded_sbom: str, project_id, project_name, project_version) -> dict:
+    """
+    Build the API payload
 
+    Args:
+        encoded_sbom: Base64 encoded SBOM
 
-def create_dependency_track_exporter_config_from_args(args) -> DependencyTrackExporterConfig:
-    return DependencyTrackExporterConfig(
-        debug=getattr(args, 'debug', False),
-        trace=getattr(args, 'trace', False),
-        quiet=getattr(args, 'quiet', False),
-        dt_url=getattr(args, 'dt_url', None),
-        dt_apikey=getattr(args, 'dt_apikey', None),
-        dt_projectid=getattr(args, 'dt_projectid', None),
-        dt_projectname=getattr(args, 'dt_projectname', None),
-        dt_projectversion=getattr(args, 'dt_projectversion', None),
-    )
+    Returns:
+        API payload dictionary
+    """
+    if project_id:
+        return {'project': project_id, 'bom': encoded_sbom}
+    else:
+        return {
+            'projectName': project_name,
+            'projectVersion': project_version,
+            'autoCreate': True,
+            'bom': encoded_sbom,
+        }
 
 
 class DependencyTrackExporter(ScanossBase):
     """
     Class for exporting SBOM files to Dependency Track
     """
-
-    def __init__(
+    def __init__( # noqa: PLR0913
         self,
-        config: DependencyTrackExporterConfig,
+        url: str = None,
+        apikey: str = None,
+        output: str = None,
         debug: bool = False,
         trace: bool = False,
-        quiet: bool = False,
+        quiet: bool = False
     ):
         """
         Initialize DependencyTrackExporter
 
         Args:
-            config: Configuration parameters for the dependency track exporter
+            url: Dependency Track URL
+            apikey: Dependency Track API Key
+            output: File to store output response data (optional)
             debug: Enable debug output
             trace: Enable trace output
             quiet: Enable quiet mode
         """
         super().__init__(debug=debug, trace=trace, quiet=quiet)
-
-        self.dt_url = config.dt_url.rstrip('/')
-        self.dt_apikey = config.dt_apikey
-        self.dt_projectid = config.dt_projectid
-        self.dt_projectname = config.dt_projectname
-        self.dt_projectversion = config.dt_projectversion
-
-        self._validate_config()
-
-    def _validate_config(self):
-        """
-        Validate that the configuration is valid.
-        """
-        has_id = bool(self.dt_projectid)
-        has_name_version = bool(self.dt_projectname and self.dt_projectversion)
-
-        if not (has_id or has_name_version):
-            raise ValueError('Either --dt-projectid OR (--dt-projectname and --dt-projectversion) must be provided')
-
-        if has_id and has_name_version:
-            self.print_debug('Both DT project ID and name/version provided. Using project ID.')
+        self.url = url.rstrip('/')
+        self.apikey = apikey
+        self.output = output
+        self.dt_service = DependencyTrackService(self.apikey, self.url, debug=debug, trace=trace, quiet=quiet)
 
     def _read_and_validate_sbom(self, input_file: str) -> dict:
         """
@@ -116,7 +96,7 @@ class DependencyTrackExporter(ScanossBase):
             Parsed SBOM content as dictionary
 
         Raises:
-            ValueError: If file doesn't exist or is invalid or not a valid CycloneDX SBOM
+            ValueError: If the file doesn't exist or is invalid or not a valid CycloneDX SBOM
         """
         result = validate_json_file(input_file)
         if not result.is_valid:
@@ -125,7 +105,6 @@ class DependencyTrackExporter(ScanossBase):
         cdx = CycloneDx(debug=self.debug)
         if not cdx.is_cyclonedx_json(json.dumps(result.data)):
             raise ValueError(f'Input file is not a valid CycloneDX SBOM: {input_file}')
-
         return result.data
 
     def _encode_sbom(self, sbom_content: dict) -> str:
@@ -138,84 +117,106 @@ class DependencyTrackExporter(ScanossBase):
         Returns:
             Base64 encoded string
         """
+        if not sbom_content:
+            self.print_stderr('Warning: Empty SBOM content')
         json_str = json.dumps(sbom_content, separators=(',', ':'))
         encoded = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
         return encoded
 
-    def _build_payload(self, encoded_sbom: str) -> dict:
+    def upload_sbom_file(self, input_file, project_id, project_name, project_version, output_file):
         """
-        Build the API payload
+        Uploads an SBOM file to the specified project with an
+        optional output file and processes the file content for validation.
 
         Args:
-            encoded_sbom: Base64 encoded SBOM
+            input_file (str): The path to the SBOM file to be read and uploaded.
+            project_id (str): The unique identifier of the project to which the SBOM is being uploaded.
+            project_name (str): The name of the project to which the SBOM is being uploaded.
+            project_version (str): The version of the project to which the SBOM is being uploaded.
+            output_file (str): The path to save output related to the SBOM upload process.
 
         Returns:
-            API payload dictionary
-        """
-        if self.dt_projectid:
-            return {'project': self.dt_projectid, 'bom': encoded_sbom}
-        else:
-            return {
-                'projectName': self.dt_projectname,
-                'projectVersion': self.dt_projectversion,
-                'autoCreate': True,
-                'bom': encoded_sbom,
-            }
-
-    def upload_sbom(self, input_file: str) -> bool:
-        """
-        Upload SBOM file to Dependency Track
+            bool: Returns True if the SBOM file was uploaded successfully, False otherwise.
 
-        Args:
-            input_file: Path to the SBOM file
-
-        Returns:
-            True if successful, False otherwise
+        Raises:
+            ValueError: Raised if there are validation issues with the SBOM content.
         """
         try:
-            self.print_stderr(f'Reading SBOM file: {input_file}')
+            if not self.quiet:
+                self.print_stderr(f'Reading SBOM file: {input_file}')
             sbom_content = self._read_and_validate_sbom(input_file)
+            return self.upload_sbom_contents(sbom_content, project_id, project_name, project_version, output_file)
+        except ValueError as e:
+            self.print_stderr(f'Validation error: {e}')
+        return False
 
-            self.print_debug('Encoding SBOM to base64')
-            encoded_sbom = self._encode_sbom(sbom_content)
-
-            payload = self._build_payload(encoded_sbom)
+    def upload_sbom_contents(self, sbom_content: dict, project_id, project_name, project_version, output_file) -> bool:
+        """
+        Uploads an SBOM to a Dependency Track server.
 
-            url = f'{self.dt_url}/api/v1/bom'
-            headers = {'Content-Type': 'application/json', 'X-Api-Key': self.dt_apikey}
+        Parameters:
+            sbom_content (dict): The SBOM content in dictionary format to be uploaded.
+            project_id: The unique identifier for the project.
+            project_name: The name of the project in Dependency Track.
+            project_version: The version of the project in Dependency Track.
+            output_file: The path to the file where the token and UUID data
+                should be written. If not provided, the data will be written to
+                standard output.
 
-            if self.trace:
-                self.print_trace(f'URL: {url}')
-                self.print_trace(f'Headers: {headers}')
-                self.print_trace(f'Payload keys: {list(payload.keys())}')
+        Returns:
+            bool: True if the upload is successful; False otherwise.
 
+        Raises:
+            ValueError: If the SBOM encoding process fails.
+            requests.exceptions.RequestException: If an error occurs during the HTTP request.
+            Exception: For any other unexpected error.
+        """
+        if not project_id and not (project_name and project_version):
+            self.print_stderr('Error: Missing project id or name and version.')
+            return False
+        output = self.output
+        if output_file:
+            output = output_file
+        try:
+            self.print_debug('Encoding SBOM to base64')
+            payload = _build_payload(self._encode_sbom(sbom_content), project_id, project_name, project_version)
+            url = f'{self.url}/api/v1/bom'
+            headers = {'Content-Type': 'application/json', 'X-Api-Key': self.apikey}
+            self.print_trace(f'URL: {url}, Headers: {headers}, Payload keys: {list(payload.keys())}')
             self.print_msg('Uploading SBOM to Dependency Track...')
             response = requests.put(url, json=payload, headers=headers)
-
-            if response.status_code in [200, 201]:
-                self.print_stderr('SBOM uploaded successfully')
-
+            response.raise_for_status()
+            # Treat any 2xx status as success
+            if (requests.codes.ok <= response.status_code < requests.codes.multiple_choices and
+                    response.status_code != requests.codes.no_content):
+                self.print_msg('SBOM uploaded successfully')
                 try:
                     response_data = response.json()
+                    token = ''
+                    project_uuid = project_id
                     if 'token' in response_data:
-                        self.print_stderr(f'Upload token: {response_data["token"]}')
+                        token = response_data['token']
+                    if project_name and project_version:
+                      project_data = self.dt_service.get_project_by_name_version(project_name, project_version)
+                      if project_data:
+                         project_uuid = project_data.get("uuid", project_id)
+                    token_json = json.dumps(
+                        {"token": token, "project_uuid": project_uuid},
+                        indent=2
+                    )
+                    self.print_to_file_or_stdout(token_json, output)
                 except json.JSONDecodeError:
                     pass
-
                 return True
             else:
                 self.print_stderr(f'Upload failed with status code: {response.status_code}')
                 self.print_stderr(f'Response: {response.text}')
-                return False
-
         except ValueError as e:
-            self.print_stderr(f'Validation error: {e}')
-            return False
+            self.print_stderr(f'DT SBOM Upload Validation error: {e}')
         except requests.exceptions.RequestException as e:
-            self.print_stderr(f'Request error: {e}')
-            return False
+            self.print_stderr(f'DT API Request error: {e}')
         except Exception as e:
             self.print_stderr(f'Unexpected error: {e}')
             if self.debug:
                 traceback.print_exc()
-            return False
+        return False

scanoss/file_filters.py

@@ -72,11 +72,7 @@ DEFAULT_SKIPPED_DIRS = {
     'htmlcov',
     '__pypackages__',
     'example',
-    'examples',
-    'docs',
-    'tests',
-    'doc',
-    'test',
+    'examples'
 }
 
 DEFAULT_SKIPPED_DIRS_HFH = {