scanoss 1.32.0__py3-none-any.whl → 1.34.0__py3-none-any.whl

scanoss/scanossgrpc.py

@@ -24,14 +24,13 @@ SPDX-License-Identifier: MIT
 
 import concurrent.futures
 import http.client as http_client
-import json
 import logging
 import os
 import sys
 import time
 import uuid
 from dataclasses import dataclass
-from enum import IntEnum
+from enum import Enum, IntEnum
 from typing import Dict, Optional
 from urllib.parse import urlparse
 
@@ -44,6 +43,7 @@ from pypac.parser import PACFile
 from pypac.resolver import ProxyResolver
 from urllib3.exceptions import InsecureRequestWarning
 
+from scanoss.api.licenses.v2.scanoss_licenses_pb2_grpc import LicenseStub
 from scanoss.api.scanning.v2.scanoss_scanning_pb2_grpc import ScanningStub
 from scanoss.constants import DEFAULT_TIMEOUT
 
@@ -51,27 +51,20 @@ from . import __version__
 from .api.common.v2.scanoss_common_pb2 import (
     ComponentsRequest,
     EchoRequest,
-    EchoResponse,
-    PurlRequest,
     StatusCode,
     StatusResponse,
 )
 from .api.components.v2.scanoss_components_pb2 import (
     CompSearchRequest,
-    CompSearchResponse,
     CompVersionRequest,
-    CompVersionResponse,
 )
 from .api.components.v2.scanoss_components_pb2_grpc import ComponentsStub
 from .api.cryptography.v2.scanoss_cryptography_pb2_grpc import CryptographyStub
 from .api.dependencies.v2.scanoss_dependencies_pb2 import DependencyRequest
 from .api.dependencies.v2.scanoss_dependencies_pb2_grpc import DependenciesStub
-from .api.geoprovenance.v2.scanoss_geoprovenance_pb2 import ContributorResponse
 from .api.geoprovenance.v2.scanoss_geoprovenance_pb2_grpc import GeoProvenanceStub
 from .api.scanning.v2.scanoss_scanning_pb2 import HFHRequest
-from .api.semgrep.v2.scanoss_semgrep_pb2 import SemgrepResponse
 from .api.semgrep.v2.scanoss_semgrep_pb2_grpc import SemgrepStub
-from .api.vulnerabilities.v2.scanoss_vulnerabilities_pb2 import ComponentsVulnerabilityResponse
 from .api.vulnerabilities.v2.scanoss_vulnerabilities_pb2_grpc import VulnerabilitiesStub
 from .scanossbase import ScanossBase
 
@@ -81,24 +74,66 @@ SCANOSS_GRPC_URL = os.environ.get('SCANOSS_GRPC_URL') if os.environ.get('SCANOSS
 SCANOSS_API_KEY = os.environ.get('SCANOSS_API_KEY') if os.environ.get('SCANOSS_API_KEY') else ''
 DEFAULT_URI_PREFIX = '/v2'
 
-MAX_CONCURRENT_REQUESTS = 5 # Maximum number of concurrent requests to make
+MAX_CONCURRENT_REQUESTS = 5  # Maximum number of concurrent requests to make
+
+# REST API endpoint mappings with HTTP methods
+REST_ENDPOINTS = {
+    'vulnerabilities.GetComponentsVulnerabilities': {'path': '/vulnerabilities/components', 'method': 'POST'},
+    'dependencies.Echo': {'path': '/dependencies/echo', 'method': 'POST'},
+    'dependencies.GetDependencies': {'path': '/dependencies/dependencies', 'method': 'POST'},
+    'cryptography.Echo': {'path': '/cryptography/echo', 'method': 'POST'},
+    'cryptography.GetComponentsAlgorithms': {'path': '/cryptography/algorithms/components', 'method': 'POST'},
+    'cryptography.GetComponentsAlgorithmsInRange': {
+        'path': '/cryptography/algorithms/range/components',
+        'method': 'POST',
+    },
+    'cryptography.GetComponentsEncryptionHints': {'path': '/cryptography/hints/components', 'method': 'POST'},
+    'cryptography.GetComponentsHintsInRange': {'path': '/cryptography/hints/components/range', 'method': 'POST'},
+    'cryptography.GetComponentsVersionsInRange': {
+        'path': '/cryptography/algorithms/versions/range/components',
+        'method': 'POST',
+    },
+    'components.SearchComponents': {'path': '/components/search', 'method': 'GET'},
+    'components.GetComponentVersions': {'path': '/components/versions', 'method': 'GET'},
+    'geoprovenance.GetCountryContributorsByComponents': {
+        'path': '/geoprovenance/countries/components',
+        'method': 'POST',
+    },
+    'geoprovenance.GetOriginByComponents': {'path': '/geoprovenance/origin/components', 'method': 'POST'},
+    'licenses.GetComponentsLicenses': {'path': '/licenses/components', 'method': 'POST'},
+    'semgrep.GetComponentsIssues': {'path': '/semgrep/issues/components', 'method': 'POST'},
+    'scanning.FolderHashScan': {'path': '/scanning/hfh/scan', 'method': 'POST'},
+}
 
 
 class ScanossGrpcError(Exception):
     """
     Custom exception for SCANOSS gRPC errors
     """
+
     pass
 
 
 class ScanossGrpcStatusCode(IntEnum):
     """Status codes for SCANOSS gRPC responses"""
+
+    UNSPECIFIED = 0
     SUCCESS = 1
-    SUCCESS_WITH_WARNINGS = 2
-    FAILED_WITH_WARNINGS = 3
+    SUCCEEDED_WITH_WARNINGS = 2
+    WARNING = 3
     FAILED = 4
 
 
+class ScanossRESTStatusCode(Enum):
+    """Status codes for SCANOSS REST responses"""
+
+    UNSPECIFIED = 'UNSPECIFIED'
+    SUCCESS = 'SUCCESS'
+    SUCCEEDED_WITH_WARNINGS = 'SUCCEEDED_WITH_WARNINGS'
+    WARNING = 'WARNING'
+    FAILED = 'FAILED'
+
+
 class ScanossGrpc(ScanossBase):
     """
     Client for gRPC functionality
@@ -106,20 +141,20 @@ class ScanossGrpc(ScanossBase):
 
     def __init__(  # noqa: PLR0912, PLR0913, PLR0915
         self,
-        url: str = None,
+        url: Optional[str] = None,
         debug: bool = False,
         trace: bool = False,
         quiet: bool = False,
-        ca_cert: str = None,
-        api_key: str = None,
-        ver_details: str = None,
+        ca_cert: Optional[str] = None,
+        api_key: Optional[str] = None,
+        ver_details: Optional[str] = None,
         timeout: int = 600,
-        proxy: str = None,
-        grpc_proxy: str = None,
-        pac: PACFile = None,
-        req_headers: dict = None,
+        proxy: Optional[str] = None,
+        grpc_proxy: Optional[str] = None,
+        pac: Optional[PACFile] = None,
+        req_headers: Optional[dict] = None,
         ignore_cert_errors: bool = False,
-        use_grpc: bool = False,
+        use_grpc: Optional[bool] = False,
     ):
         """
 
@@ -208,6 +243,7 @@ class ScanossGrpc(ScanossBase):
             self.vuln_stub = VulnerabilitiesStub(grpc.insecure_channel(self.url))
             self.provenance_stub = GeoProvenanceStub(grpc.insecure_channel(self.url))
             self.scanning_stub = ScanningStub(grpc.insecure_channel(self.url))
+            self.license_stub = LicenseStub(grpc.insecure_channel(self.url))
         else:
             if ca_cert is not None:
                 credentials = grpc.ssl_channel_credentials(cert_data)  # secure with specified certificate
@@ -220,59 +256,32 @@ class ScanossGrpc(ScanossBase):
             self.vuln_stub = VulnerabilitiesStub(grpc.secure_channel(self.url, credentials))
             self.provenance_stub = GeoProvenanceStub(grpc.secure_channel(self.url, credentials))
             self.scanning_stub = ScanningStub(grpc.secure_channel(self.url, credentials))
+            self.license_stub = LicenseStub(grpc.secure_channel(self.url, credentials))
 
     @classmethod
     def _load_cert(cls, cert_file: str) -> bytes:
         with open(cert_file, 'rb') as f:
             return f.read()
 
-    def deps_echo(self, message: str = 'Hello there!') -> str:
+    def deps_echo(self, message: str = 'Hello there!') -> Optional[dict]:
         """
         Send Echo message to the Dependency service
         :param self:
         :param message: Message to send (default: Hello there!)
         :return: echo or None
         """
-        request_id = str(uuid.uuid4())
-        resp: EchoResponse
-        try:
-            metadata = self.metadata[:]
-            metadata.append(('x-request-id', request_id))  # Set a Request ID
-            resp = self.dependencies_stub.Echo(EchoRequest(message=message), metadata=metadata, timeout=3)
-        except Exception as e:
-            self.print_stderr(
-                f'ERROR: {e.__class__.__name__} Problem encountered sending gRPC message (rqId: {request_id}): {e}'
-            )
-        else:
-            if resp:
-                return resp.message
-            self.print_stderr(f'ERROR: Problem sending Echo request ({message}) to {self.url}. rqId: {request_id}')
-        return None
+        return self._call_api('dependencies.Echo', self.dependencies_stub.Echo, {'message': message}, EchoRequest)
 
-    def crypto_echo(self, message: str = 'Hello there!') -> str:
+    def crypto_echo(self, message: str = 'Hello there!') -> Optional[dict]:
         """
         Send Echo message to the Cryptography service
         :param self:
         :param message: Message to send (default: Hello there!)
         :return: echo or None
         """
-        request_id = str(uuid.uuid4())
-        resp: EchoResponse
-        try:
-            metadata = self.metadata[:]
-            metadata.append(('x-request-id', request_id))  # Set a Request ID
-            resp = self.crypto_stub.Echo(EchoRequest(message=message), metadata=metadata, timeout=3)
-        except Exception as e:
-            self.print_stderr(
-                f'ERROR: {e.__class__.__name__} Problem encountered sending gRPC message (rqId: {request_id}): {e}'
-            )
-        else:
-            if resp:
-                return resp.message
-            self.print_stderr(f'ERROR: Problem sending Echo request ({message}) to {self.url}. rqId: {request_id}')
-        return None
+        return self._call_api('cryptography.Echo', self.crypto_stub.Echo, {'message': message}, EchoRequest)
 
-    def get_dependencies(self, dependencies: json, depth: int = 1) -> dict:
+    def get_dependencies(self, dependencies: Optional[dict] = None, depth: int = 1) -> Optional[dict]:
         if not dependencies:
             self.print_stderr('ERROR: No dependency data supplied to submit to the API.')
             return None
@@ -281,7 +290,7 @@ class ScanossGrpc(ScanossBase):
             self.print_stderr(f'ERROR: No response for dependency request: {dependencies}')
         return resp
 
-    def get_dependencies_json(self, dependencies: dict, depth: int = 1) -> dict:
+    def get_dependencies_json(self, dependencies: dict, depth: int = 1) -> Optional[dict]:
         """
         Client function to call the rpc for GetDependencies
         :param dependencies: Message to send to the service
@@ -296,11 +305,11 @@ class ScanossGrpc(ScanossBase):
             self.print_stderr('ERROR: No dependency data supplied to send to decoration service.')
             return None
         all_responses = []
-        # determine if we are using gRPC or REST based on the use_grpc flag
-        process_file = self._process_dep_file_grpc if self.use_grpc else self._process_dep_file_rest
         # Process the dependency files in parallel
         with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_CONCURRENT_REQUESTS) as executor:
-            future_to_file = {executor.submit(process_file, file, depth): file for file in files_json}
+            future_to_file = {
+                executor.submit(self._process_dep_file, file, depth, self.use_grpc): file for file in files_json
+            }
             for future in concurrent.futures.as_completed(future_to_file):
                 response = future.result()
                 if response:
@@ -318,161 +327,104 @@ class ScanossGrpc(ScanossBase):
                     merged_response['status'] = response['status']
         return merged_response
 
-    def _process_dep_file_grpc(self, file, depth: int = 1) -> dict:
+    def _process_dep_file(self, file, depth: int = 1, use_grpc: Optional[bool] = None) -> Optional[dict]:
         """
-        Process a single file using gRPC
+        Process a single dependency file using either gRPC or REST
 
-        :param file: dependency file purls
-        :param depth: depth to search (default: 1)
-        :return: response JSON or None
-        """
-        request_id = str(uuid.uuid4())
-        try:
-            file_request = {'files': [file]}
-            request = ParseDict(file_request, DependencyRequest())
-            request.depth = depth
-            metadata = self.metadata[:]
-            metadata.append(('x-request-id', request_id))
-            self.print_debug(f'Sending dependency data via gRPC for decoration (rqId: {request_id})...')
-            resp = self.dependencies_stub.GetDependencies(request, metadata=metadata, timeout=self.timeout)
-            return MessageToDict(resp, preserving_proto_field_name=True)
-        except Exception as e:
-            self.print_stderr(
-                f'ERROR: {e.__class__.__name__} Problem encountered sending gRPC message (rqId: {request_id}): {e}'
-            )
-        return None
+        Args:
+            file: dependency file purls
+            depth: depth to search (default: 1)
+            use_grpc: Whether to use gRPC or REST (None = use instance default)
 
-    def get_vulnerabilities_json(self, purls: dict) -> dict:
-        """
-        Client function to call the rpc for Vulnerability GetVulnerabilities
-        It will either use REST (default) or gRPC depending on the use_grpc flag
-        :param purls: Message to send to the service
-        :return: Server response or None
+        Returns:
+            response JSON or None
         """
-        if self.use_grpc:
-            return self._get_vulnerabilities_grpc(purls)
-        else:
-            return self._get_vulnerabilities_rest(purls)
+        file_request = {'files': [file], 'depth': depth}
 
-    def _get_vulnerabilities_grpc(self, purls: dict) -> dict:
+        return self._call_api(
+            'dependencies.GetDependencies',
+            self.dependencies_stub.GetDependencies,
+            file_request,
+            DependencyRequest,
+            'Sending dependency data for decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
+        )
+
+    def get_vulnerabilities_json(self, purls: Optional[dict] = None, use_grpc: Optional[bool] = None) -> Optional[dict]:
         """
         Client function to call the rpc for Vulnerability GetVulnerabilities
-        :param purls: Message to send to the service
-        :return: Server response or None
-        """
-        if not purls:
-            self.print_stderr('ERROR: No message supplied to send to gRPC service.')
-            return None
-        request_id = str(uuid.uuid4())
-        resp: ComponentsVulnerabilityResponse
-        try:
-            request = ParseDict(purls, ComponentsRequest())  # Parse the JSON/Dict into the purl request object
-            metadata = self.metadata[:]
-            metadata.append(('x-request-id', request_id))  # Set a Request ID
-            self.print_debug(f'Sending vulnerability data for decoration (rqId: {request_id})...')
-            resp = self.vuln_stub.GetComponentsVulnerabilities(request, metadata=metadata, timeout=self.timeout)
-        except Exception as e:
-            self.print_stderr(
-                f'ERROR: {e.__class__.__name__} Problem encountered sending gRPC message (rqId: {request_id}): {e}'
-            )
-        else:
-            if resp:
-                if not self._check_status_response(resp.status, request_id):
-                    return None
-                resp_dict = MessageToDict(resp, preserving_proto_field_name=True)  # Convert gRPC response to a dict
-                del resp_dict['status']
-                return resp_dict
-        return None
+        It will either use REST (default) or gRPC
+
+        Args:
+            purls (dict): Message to send to the service
+
+        Returns:
+            Server response or None
+        """
+        return self._call_api(
+            'vulnerabilities.GetComponentsVulnerabilities',
+            self.vuln_stub.GetComponentsVulnerabilities,
+            purls,
+            ComponentsRequest,
+            'Sending vulnerability data for decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
+        )
 
-    def get_semgrep_json(self, purls: dict) -> dict:
+    def get_semgrep_json(self, purls: Optional[dict] = None, use_grpc: Optional[bool] = None) -> Optional[dict]:
         """
         Client function to call the rpc for Semgrep GetIssues
-        :param purls: Message to send to the service
-        :return: Server response or None
-        """
-        if not purls:
-            self.print_stderr('ERROR: No message supplied to send to gRPC service.')
-            return None
-        request_id = str(uuid.uuid4())
-        resp: SemgrepResponse
-        try:
-            request = ParseDict(purls, PurlRequest())  # Parse the JSON/Dict into the purl request object
-            metadata = self.metadata[:]
-            metadata.append(('x-request-id', request_id))  # Set a Request ID
-            self.print_debug(f'Sending semgrep data for decoration (rqId: {request_id})...')
-            resp = self.semgrep_stub.GetIssues(request, metadata=metadata, timeout=self.timeout)
-        except Exception as e:
-            self.print_stderr(
-                f'ERROR: {e.__class__.__name__} Problem encountered sending gRPC message (rqId: {request_id}): {e}'
-            )
-        else:
-            if resp:
-                if not self._check_status_response(resp.status, request_id):
-                    return None
-                resp_dict = MessageToDict(resp, preserving_proto_field_name=True)  # Convert gRPC response to a dict
-                del resp_dict['status']
-                return resp_dict
-        return None
 
-    def search_components_json(self, search: dict) -> dict:
+        Args:
+            purls (dict): Message to send to the service
+            use_grpc (bool): Whether to use gRPC or REST
+
+        Returns:
+            Server response or None
+        """
+        return self._call_api(
+            'semgrep.GetComponentsIssues',
+            self.semgrep_stub.GetComponentsIssues,
+            purls,
+            ComponentsRequest,
+            'Sending semgrep data for decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
+        )
+
+    def search_components_json(self, search: dict, use_grpc: Optional[bool] = None) -> Optional[dict]:
         """
         Client function to call the rpc for Components SearchComponents
-        :param search: Message to send to the service
-        :return: Server response or None
-        """
-        if not search:
-            self.print_stderr('ERROR: No message supplied to send to gRPC service.')
-            return None
-        request_id = str(uuid.uuid4())
-        resp: CompSearchResponse
-        try:
-            request = ParseDict(search, CompSearchRequest())  # Parse the JSON/Dict into the purl request object
-            metadata = self.metadata[:]
-            metadata.append(('x-request-id', request_id))  # Set a Request ID
-            self.print_debug(f'Sending component search data (rqId: {request_id})...')
-            resp = self.comp_search_stub.SearchComponents(request, metadata=metadata, timeout=self.timeout)
-        except Exception as e:
-            self.print_stderr(
-                f'ERROR: {e.__class__.__name__} Problem encountered sending gRPC message (rqId: {request_id}): {e}'
-            )
-        else:
-            if resp:
-                if not self._check_status_response(resp.status, request_id):
-                    return None
-                resp_dict = MessageToDict(resp, preserving_proto_field_name=True)  # Convert gRPC response to a dict
-                del resp_dict['status']
-                return resp_dict
-        return None
 
-    def get_component_versions_json(self, search: dict) -> dict:
+        Args:
+            search (dict): Message to send to the service
+        Returns:
+            Server response or None
+        """
+        return self._call_api(
+            'components.SearchComponents',
+            self.comp_search_stub.SearchComponents,
+            search,
+            CompSearchRequest,
+            'Sending component search data for decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
+        )
+
+    def get_component_versions_json(self, search: dict, use_grpc: Optional[bool] = None) -> Optional[dict]:
         """
         Client function to call the rpc for Components GetComponentVersions
-        :param search: Message to send to the service
-        :return: Server response or None
-        """
-        if not search:
-            self.print_stderr('ERROR: No message supplied to send to gRPC service.')
-            return None
-        request_id = str(uuid.uuid4())
-        resp: CompVersionResponse
-        try:
-            request = ParseDict(search, CompVersionRequest())  # Parse the JSON/Dict into the purl request object
-            metadata = self.metadata[:]
-            metadata.append(('x-request-id', request_id))  # Set a Request ID
-            self.print_debug(f'Sending component version data (rqId: {request_id})...')
-            resp = self.comp_search_stub.GetComponentVersions(request, metadata=metadata, timeout=self.timeout)
-        except Exception as e:
-            self.print_stderr(
-                f'ERROR: {e.__class__.__name__} Problem encountered sending gRPC message (rqId: {request_id}): {e}'
-            )
-        else:
-            if resp:
-                if not self._check_status_response(resp.status, request_id):
-                    return None
-                resp_dict = MessageToDict(resp, preserving_proto_field_name=True)  # Convert gRPC response to a dict
-                del resp_dict['status']
-                return resp_dict
-        return None
+
+        Args:
+            search (dict): Message to send to the service
+        Returns:
+            Server response or None
+        """
+        return self._call_api(
+            'components.GetComponentVersions',
+            self.comp_search_stub.GetComponentVersions,
+            search,
+            CompVersionRequest,
+            'Sending component version data for decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
+        )
 
     def folder_hash_scan(self, request: Dict) -> Optional[Dict]:
         """
@@ -491,6 +443,44 @@ class ScanossGrpc(ScanossBase):
             'Sending folder hash scan data (rqId: {rqId})...',
         )
 
+    def _call_api(
+        self,
+        endpoint_key: str,
+        rpc_method,
+        request_input,
+        request_type,
+        debug_msg: Optional[str] = None,
+        use_grpc: Optional[bool] = None,
+    ) -> Optional[Dict]:
+        """
+        Unified method to call either gRPC or REST API based on configuration
+
+        Args:
+            endpoint_key (str): The key to lookup the REST endpoint in REST_ENDPOINTS
+            rpc_method: The gRPC stub method (used only if use_grpc is True)
+            request_input: Either a dict or a gRPC request object
+            request_type: The type of the gRPC request object (used only if use_grpc is True)
+            debug_msg (str, optional): Debug message template that can include {rqId} placeholder
+            use_grpc (bool, optional): Override the instance's use_grpc setting. If None, uses self.use_grpc
+
+        Returns:
+            dict: The parsed response as a dictionary, or None if something went wrong
+        """
+        if not request_input:
+            self.print_stderr('ERROR: No message supplied to send to service.')
+            return None
+
+        # Determine whether to use gRPC or REST
+        use_grpc_flag = use_grpc if use_grpc is not None else self.use_grpc
+
+        if use_grpc_flag:
+            return self._call_rpc(rpc_method, request_input, request_type, debug_msg)
+        else:
+            # For REST, we only need the dict input
+            if not isinstance(request_input, dict):
+                request_input = MessageToDict(request_input, preserving_proto_field_name=True)
+            return self._call_rest(endpoint_key, request_input, debug_msg)
+
     def _call_rpc(self, rpc_method, request_input, request_type, debug_msg: Optional[str] = None) -> Optional[Dict]:
         """
         Call a gRPC method and return the response as a dictionary
@@ -510,20 +500,21 @@ class ScanossGrpc(ScanossBase):
         else:
             request_obj = request_input
         metadata = self.metadata[:] + [('x-request-id', request_id)]
-        self.print_debug(debug_msg.format(rqId=request_id))
+        if debug_msg:
+            self.print_debug(debug_msg.format(rqId=request_id))
         try:
             resp = rpc_method(request_obj, metadata=metadata, timeout=self.timeout)
         except grpc.RpcError as e:
             raise ScanossGrpcError(
                 f'{e.__class__.__name__} while sending gRPC message (rqId: {request_id}): {e.details()}'
             )
-        if resp and not self._check_status_response(resp.status, request_id):
+        if resp and not self._check_status_response_grpc(resp.status, request_id):
             return None
 
         resp_dict = MessageToDict(resp, preserving_proto_field_name=True)
         return resp_dict
 
-    def _check_status_response(self, status_response: StatusResponse, request_id: str = None) -> bool:
+    def _check_status_response_grpc(self, status_response: StatusResponse, request_id: str = None) -> bool:
         """
         Check the response object to see if the command was successful or not
         :param status_response: Status Response
@@ -538,15 +529,59 @@ class ScanossGrpc(ScanossBase):
         if status_code > ScanossGrpcStatusCode.SUCCESS:
             ret_val = False  # default to failed
             msg = 'Unsuccessful'
-            if status_code == ScanossGrpcStatusCode.SUCCESS_WITH_WARNINGS:
+            if status_code == ScanossGrpcStatusCode.SUCCEEDED_WITH_WARNINGS:
                 msg = 'Succeeded with warnings'
                 ret_val = True  # No need to fail as it succeeded with warnings
-            elif status_code == ScanossGrpcStatusCode.FAILED_WITH_WARNINGS:
+            elif status_code == ScanossGrpcStatusCode.WARNING:
                 msg = 'Failed with warnings'
             self.print_stderr(f'{msg} (rqId: {request_id} - status: {status_code}): {status_response.message}')
             return ret_val
         return True
 
+    def check_status_response_rest(self, status_dict: dict, request_id: Optional[str] = None) -> bool:
+        """
+        Check the REST response dictionary to see if the command was successful or not
+
+        Args:
+            status_dict (dict): Status dictionary from REST response containing 'status' and 'message' keys
+            request_id (str, optional): Request ID for logging
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        if not status_dict:
+            self.print_stderr(f'Warning: No status response supplied (rqId: {request_id}). Assuming it was ok.')
+            return True
+
+        if request_id:
+            self.print_debug(f'Checking response status (rqId: {request_id}): {status_dict}')
+
+        # Get status from dictionary - it can be either a string or nested dict
+        status = status_dict.get('status')
+        message = status_dict.get('message', '')
+        ret_val = True
+
+        # Handle case where status might be a string directly
+        if isinstance(status, str):
+            status_str = status.upper()
+            if status_str == ScanossRESTStatusCode.SUCCESS.value:
+                ret_val = True
+            elif status_str == ScanossRESTStatusCode.SUCCEEDED_WITH_WARNINGS.value:
+                self.print_stderr(f'Succeeded with warnings (rqId: {request_id}): {message}')
+                ret_val = True
+            elif status_str == ScanossRESTStatusCode.WARNING.value:
+                self.print_stderr(f'Failed with warnings (rqId: {request_id}): {message}')
+                ret_val = False
+            elif status_str == ScanossRESTStatusCode.FAILED.value:
+                self.print_stderr(f'Unsuccessful (rqId: {request_id}): {message}')
+                ret_val = False
+            else:
+                self.print_debug(f'Unknown status "{status_str}" (rqId: {request_id}). Assuming success.')
+                ret_val = True
+
+        # Otherwise asume success
+        self.print_debug(f'Unexpected status type {type(status)} (rqId: {request_id}). Assuming success.')
+        return ret_val
+
     def _get_proxy_config(self):
         """
         Set the grpc_proxy/http_proxy/https_proxy environment variables if PAC file has been specified
@@ -569,138 +604,165 @@ class ScanossGrpc(ScanossBase):
             os.environ['http_proxy'] = proxies.get('http') or ''
             os.environ['https_proxy'] = proxies.get('https') or ''
 
-    def get_provenance_json(self, purls: dict) -> dict:
-        """
-        Client function to call the rpc for GetComponentProvenance
-        :param purls: Message to send to the service
-        :return: Server response or None
+    def get_provenance_json(self, purls: dict, use_grpc: Optional[bool] = None) -> Optional[Dict]:
         """
-        if not purls:
-            self.print_stderr('ERROR: No message supplied to send to gRPC service.')
-            return None
-        request_id = str(uuid.uuid4())
-        resp: ContributorResponse
-        try:
-            request = ParseDict(purls, PurlRequest())  # Parse the JSON/Dict into the purl request object
-            metadata = self.metadata[:]
-            metadata.append(('x-request-id', request_id))  # Set a Request ID
-            self.print_debug(f'Sending data for provenance decoration (rqId: {request_id})...')
-            resp = self.provenance_stub.GetComponentContributors(request, metadata=metadata, timeout=self.timeout)
-        except Exception as e:
-            self.print_stderr(
-                f'ERROR: {e.__class__.__name__} Problem encountered sending gRPC message (rqId: {request_id}): {e}'
-            )
-        else:
-            if resp:
-                if not self._check_status_response(resp.status, request_id):
-                    return None
-                resp_dict = MessageToDict(resp, preserving_proto_field_name=True)  # Convert gRPC response to a dict
-                return resp_dict
-        return None
+        Client function to call the rpc for GetComponentContributors
+
+        Args:
+            purls (dict): ComponentsRequest
+            use_grpc (bool): Whether to use gRPC or REST (None = use instance default)
+
+        Returns:
+            dict: JSON response or None
+        """
+        return self._call_api(
+            'geoprovenance.GetCountryContributorsByComponents',
+            self.provenance_stub.GetCountryContributorsByComponents,
+            purls,
+            ComponentsRequest,
+            'Sending data for provenance decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
+        )
 
-    def get_provenance_origin(self, request: Dict) -> Optional[Dict]:
+    def get_provenance_origin(self, request: Dict, use_grpc: Optional[bool] = None) -> Optional[Dict]:
         """
-        Client function to call the rpc for GetComponentOrigin
+        Client function to call the rpc for GetOriginByComponents
 
         Args:
-            request (Dict): GetComponentOrigin Request
+            request (Dict): GetOriginByComponents Request
 
         Returns:
             Optional[Dict]: OriginResponse, or None if the request was not successfull
         """
-        return self._call_rpc(
-            self.provenance_stub.GetComponentOrigin,
+        return self._call_api(
+            'geoprovenance.GetOriginByComponents',
+            self.provenance_stub.GetOriginByComponents,
             request,
-            PurlRequest,
+            ComponentsRequest,
             'Sending data for provenance origin decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
         )
 
-    def get_crypto_algorithms_for_purl(self, request: Dict) -> Optional[Dict]:
+    def get_crypto_algorithms_for_purl(self, request: Dict, use_grpc: Optional[bool] = None) -> Optional[Dict]:
         """
-        Client function to call the rpc for GetAlgorithms for a list of purls
+        Client function to call the rpc for GetComponentsAlgorithms for a list of purls
 
         Args:
-            request (Dict): PurlRequest
+            request (Dict): ComponentsRequest
+            use_grpc (Optional[bool]): Whether to use gRPC or REST (None = use instance default)
 
         Returns:
             Optional[Dict]: AlgorithmResponse, or None if the request was not successfull
         """
-        return self._call_rpc(
-            self.crypto_stub.GetAlgorithms,
+        return self._call_api(
+            'cryptography.GetComponentsAlgorithms',
+            self.crypto_stub.GetComponentsAlgorithms,
             request,
-            PurlRequest,
+            ComponentsRequest,
             'Sending data for cryptographic algorithms decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
         )
 
-    def get_crypto_algorithms_in_range_for_purl(self, request: Dict) -> Optional[Dict]:
+    def get_crypto_algorithms_in_range_for_purl(self, request: Dict, use_grpc: Optional[bool] = None) -> Optional[Dict]:
         """
-        Client function to call the rpc for GetAlgorithmsInRange for a list of purls
+        Client function to call the rpc for GetComponentsAlgorithmsInRange for a list of purls
 
         Args:
-            request (Dict): PurlRequest
+            request (Dict): ComponentsRequest
+            use_grpc (Optional[bool]): Whether to use gRPC or REST (None = use instance default)
 
         Returns:
             Optional[Dict]: AlgorithmsInRangeResponse, or None if the request was not successfull
         """
-        return self._call_rpc(
-            self.crypto_stub.GetAlgorithmsInRange,
+        return self._call_api(
+            'cryptography.GetComponentsAlgorithmsInRange',
+            self.crypto_stub.GetComponentsAlgorithmsInRange,
             request,
-            PurlRequest,
+            ComponentsRequest,
             'Sending data for cryptographic algorithms in range decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
         )
 
-    def get_encryption_hints_for_purl(self, request: Dict) -> Optional[Dict]:
+    def get_encryption_hints_for_purl(self, request: Dict, use_grpc: Optional[bool] = None) -> Optional[Dict]:
         """
-        Client function to call the rpc for GetEncryptionHints for a list of purls
+        Client function to call the rpc for GetComponentsEncryptionHints for a list of purls
 
         Args:
-            request (Dict): PurlRequest
+            request (Dict): ComponentsRequest
+            use_grpc (Optional[bool]): Whether to use gRPC or REST (None = use instance default)
 
         Returns:
             Optional[Dict]: HintsResponse, or None if the request was not successfull
         """
-        return self._call_rpc(
-            self.crypto_stub.GetEncryptionHints,
+        return self._call_api(
+            'cryptography.GetComponentsEncryptionHints',
+            self.crypto_stub.GetComponentsEncryptionHints,
             request,
-            PurlRequest,
+            ComponentsRequest,
             'Sending data for encryption hints decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
         )
 
-    def get_encryption_hints_in_range_for_purl(self, request: Dict) -> Optional[Dict]:
+    def get_encryption_hints_in_range_for_purl(self, request: Dict, use_grpc: Optional[bool] = None) -> Optional[Dict]:
         """
-        Client function to call the rpc for GetHintsInRange for a list of purls
+        Client function to call the rpc for GetComponentsHintsInRange for a list of purls
 
         Args:
-            request (Dict): PurlRequest
+            request (Dict): ComponentsRequest
+            use_grpc (Optional[bool]): Whether to use gRPC or REST (None = use instance default)
 
         Returns:
             Optional[Dict]: HintsInRangeResponse, or None if the request was not successfull
         """
-        return self._call_rpc(
-            self.crypto_stub.GetHintsInRange,
+        return self._call_api(
+            'cryptography.GetComponentsHintsInRange',
+            self.crypto_stub.GetComponentsHintsInRange,
             request,
-            PurlRequest,
+            ComponentsRequest,
             'Sending data for encryption hints in range decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
         )
 
-    def get_versions_in_range_for_purl(self, request: Dict) -> Optional[Dict]:
+    def get_versions_in_range_for_purl(self, request: Dict, use_grpc: Optional[bool] = None) -> Optional[Dict]:
         """
-        Client function to call the rpc for GetVersionsInRange for a list of purls
+        Client function to call the rpc for GetComponentsVersionsInRange for a list of purls
 
         Args:
-            request (Dict): PurlRequest
+            request (Dict): ComponentsRequest
+            use_grpc (Optional[bool]): Whether to use gRPC or REST (None = use instance default)
 
         Returns:
             Optional[Dict]: VersionsInRangeResponse, or None if the request was not successfull
         """
-        return self._call_rpc(
-            self.crypto_stub.GetVersionsInRange,
+        return self._call_api(
+            'cryptography.GetComponentsVersionsInRange',
+            self.crypto_stub.GetComponentsVersionsInRange,
             request,
-            PurlRequest,
+            ComponentsRequest,
             'Sending data for cryptographic versions in range decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
+        )
+
+    def get_licenses(self, request: Dict, use_grpc: Optional[bool] = None) -> Optional[Dict]:
+        """
+        Client function to call the rpc for Licenses GetComponentsLicenses
+        It will either use REST (default) or gRPC depending on the use_grpc flag
+
+        Args:
+            request (Dict): ComponentsRequest
+        Returns:
+            Optional[Dict]: ComponentsLicenseResponse, or None if the request was not successfull
+        """
+        return self._call_api(
+            'licenses.GetComponentsLicenses',
+            self.license_stub.GetComponentsLicenses,
+            request,
+            ComponentsRequest,
+            'Sending data for license decoration (rqId: {rqId})...',
+            use_grpc=use_grpc,
         )
 
-    def load_generic_headers(self, url):
+    def load_generic_headers(self, url: Optional[str] = None):
         """
         Adds custom headers from req_headers to metadata.
 
@@ -722,32 +784,91 @@ class ScanossGrpc(ScanossBase):
     # Start of REST Client Functions
     #
 
-    def rest_post(self, uri: str, request_id: str, data: dict) -> dict:
+    def _rest_get(self, uri: str, request_id: str, params: Optional[dict] = None) -> Optional[dict]:
+        """
+        Send a GET request to the specified URI with optional query parameters.
+
+        Args:
+            uri (str): URI to send GET request to
+            request_id (str): request id
+            params (dict, optional): Optional query parameters as dictionary
+
+        Returns:
+            dict: JSON response or None
+        """
+        if not uri:
+            self.print_stderr('Error: Missing URI. Cannot perform GET request.')
+            return None
+        self.print_trace(f'Sending REST GET request to {uri}...')
+        headers = self.headers.copy()
+        headers['x-request-id'] = request_id
+        retry = 0
+        while retry <= self.retry_limit:
+            retry += 1
+            try:
+                response = self.session.get(uri, headers=headers, params=params, timeout=self.timeout)
+                response.raise_for_status()  # Raises an HTTPError for bad responses
+                return response.json()
+            except (requests.exceptions.SSLError, requests.exceptions.ProxyError) as e:
+                self.print_stderr(f'ERROR: Exception ({e.__class__.__name__}) sending GET request - {e}.')
+                raise Exception(f'ERROR: The SCANOSS API GET request failed for {uri}') from e
+            except requests.exceptions.HTTPError as e:
+                self.print_stderr(f'ERROR: HTTP error sending GET request ({request_id}): {e}')
+                raise Exception(
+                    f'ERROR: The SCANOSS API GET request failed with status {e.response.status_code} for {uri}'
+                ) from e
+            except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
+                if retry > self.retry_limit:  # Timed out retry_limit or more times, fail
+                    self.print_stderr(f'ERROR: {e.__class__.__name__} sending GET request ({request_id}): {e}')
+                    raise Exception(
+                        f'ERROR: The SCANOSS API GET request timed out ({e.__class__.__name__}) for {uri}'
+                    ) from e
+                else:
+                    self.print_stderr(f'Warning: {e.__class__.__name__} communicating with {self.url}. Retrying...')
+                    time.sleep(5)
+            except requests.exceptions.RequestException as e:
+                self.print_stderr(f'Error: Problem sending GET request to {uri}: {e}')
+                raise Exception(f'ERROR: The SCANOSS API GET request failed for {uri}') from e
+            except Exception as e:
+                self.print_stderr(
+                    f'ERROR: Exception ({e.__class__.__name__}) sending GET request ({request_id}) to {uri}: {e}'
+                )
+                raise Exception(f'ERROR: The SCANOSS API GET request failed for {uri}') from e
+        return None
+
+    def _rest_post(self, uri: str, request_id: str, data: dict) -> Optional[dict]:
         """
         Post the specified data to the given URI.
-        :param request_id: request id
-        :param uri: URI to post to
-        :param data: json data to post
-        :return: JSON response or None
+
+        Args:
+            uri (str): URI to post to
+            request_id (str): request id
+            data (dict): json data to post
+
+        Returns:
+            dict: JSON response or None
         """
         if not uri:
             self.print_stderr('Error: Missing URI. Cannot search for project.')
             return None
         self.print_trace(f'Sending REST POST data to {uri}...')
-        headers = self.headers
-        headers['x-request-id'] = request_id  # send a unique request id for each post
-        retry = 0  # Add some retry logic to cater for timeouts, etc.
+        headers = self.headers.copy()
+        headers['x-request-id'] = request_id
+        retry = 0
         while retry <= self.retry_limit:
             retry += 1
             try:
                 response = self.session.post(uri, headers=headers, json=data, timeout=self.timeout)
                 response.raise_for_status()  # Raises an HTTPError for bad responses
                 return response.json()
-            except requests.exceptions.RequestException as e:
-                self.print_stderr(f'Error: Problem posting data to {uri}: {e}')
             except (requests.exceptions.SSLError, requests.exceptions.ProxyError) as e:
                 self.print_stderr(f'ERROR: Exception ({e.__class__.__name__}) POSTing data - {e}.')
                 raise Exception(f'ERROR: The SCANOSS Decoration API request failed for {uri}') from e
+            except requests.exceptions.HTTPError as e:
+                self.print_stderr(f'ERROR: HTTP error POSTing data ({request_id}): {e}')
+                raise Exception(
+                    f'ERROR: The SCANOSS Decoration API request failed with status {e.response.status_code} for {uri}'
+                ) from e
             except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
                 if retry > self.retry_limit:  # Timed out retry_limit or more times, fail
                     self.print_stderr(f'ERROR: {e.__class__.__name__} POSTing decoration data ({request_id}): {e}')
@@ -757,6 +878,9 @@ class ScanossGrpc(ScanossBase):
                 else:
                     self.print_stderr(f'Warning: {e.__class__.__name__} communicating with {self.url}. Retrying...')
                     time.sleep(5)
+            except requests.exceptions.RequestException as e:
+                self.print_stderr(f'Error: Problem posting data to {uri}: {e}')
+                raise Exception(f'ERROR: The SCANOSS Decoration API request failed for {uri}') from e
             except Exception as e:
                 self.print_stderr(
                     f'ERROR: Exception ({e.__class__.__name__}) POSTing data ({request_id}) to {uri}: {e}'
@@ -764,52 +888,46 @@ class ScanossGrpc(ScanossBase):
                 raise Exception(f'ERROR: The SCANOSS Decoration API request failed for {uri}') from e
         return None
 
-    def _get_vulnerabilities_rest(self, purls: dict):
+    def _call_rest(self, endpoint_key: str, request_input: dict, debug_msg: Optional[str] = None) -> Optional[Dict]:
         """
-        Get the vulnerabilities for the given purls using REST API
-        :param purls: Purl Request dictionary
-        :return: Vulnerability Response, or None if the request was unsuccessful
-        """
-        if not purls:
-            self.print_stderr('ERROR: No message supplied to send to REST decoration service.')
-            return None
-        request_id = str(uuid.uuid4())
-        self.print_debug(f'Sending data for Vulnerabilities via REST (request id: {request_id})...')
-        response = self.rest_post(f'{self.orig_url}{DEFAULT_URI_PREFIX}/vulnerabilities/components', request_id, purls)
-        self.print_trace(f'Received response for Vulnerabilities via REST (request id: {request_id}): {response}')
-        if response:
-            # Parse the JSON/Dict into the purl response
-            resp_obj = ParseDict(response, ComponentsVulnerabilityResponse(), True)
-            if resp_obj:
-                self.print_debug(f'Vulnerability Response: {resp_obj}')
-                if not self._check_status_response(resp_obj.status, request_id):
-                    return None
-            del response['status']
-            return response
-        return None
+        Call a REST endpoint and return the response as a dictionary
 
-    def _process_dep_file_rest(self, file, depth: int = 1) -> dict:
-        """
-        Porcess a single dependency file using REST
+        Args:
+            endpoint_key (str): The key to lookup the REST endpoint in REST_ENDPOINTS
+            request_input (dict): The request data to send
+            debug_msg (str, optional): Debug message template that can include {rqId} placeholder.
 
-        :param file: dependency file purls
-        :param depth: depth to search (default: 1)
-        :return: response JSON or None
+        Returns:
+            dict: The parsed REST response as a dictionary, or None if something went wrong
         """
+        if endpoint_key not in REST_ENDPOINTS:
+            raise ScanossGrpcError(f'Unknown REST endpoint key: {endpoint_key}')
+
+        endpoint_config = REST_ENDPOINTS[endpoint_key]
+        endpoint_path = endpoint_config['path']
+        method = endpoint_config['method']
+        endpoint_url = f'{self.orig_url}{DEFAULT_URI_PREFIX}{endpoint_path}'
         request_id = str(uuid.uuid4())
-        self.print_debug(f'Sending data for Dependencies via REST (request id: {request_id})...')
-        file_request = {'files': [file], 'depth': depth}
-        response = self.rest_post(f'{self.orig_url}{DEFAULT_URI_PREFIX}/dependencies/dependencies',
-                                  request_id, file_request
-                                  )
-        self.print_trace(f'Received response for Dependencies via REST (request id: {request_id}): {response}')
-        if response:
-            return response
-        return None
+
+        if debug_msg:
+            self.print_debug(debug_msg.format(rqId=request_id))
+
+        if method == 'GET':
+            response = self._rest_get(endpoint_url, request_id, params=request_input)
+        else:  # POST
+            response = self._rest_post(endpoint_url, request_id, request_input)
+
+        if response and 'status' in response and not self.check_status_response_rest(response['status'], request_id):
+            return None
+
+        return response
+
+
 #
 # End of ScanossGrpc Class
 #
 
+
 @dataclass
 class GrpcConfig:
     url: str = DEFAULT_URL
@@ -840,6 +958,7 @@ def create_grpc_config_from_args(args) -> GrpcConfig:
         grpc_proxy=getattr(args, 'grpc_proxy', None),
     )
 
+
 #
 # End of GrpcConfig class
-#
+#