quapp-common 0.0.11.dev4__tar.gz → 0.0.11.dev6__tar.gz

{quapp_common-0.0.11.dev4/quapp_common.egg-info → quapp_common-0.0.11.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.11.dev4
+Version: 0.0.11.dev6
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-common"
-version = "0.0.11.dev4"
+version = "0.0.11.dev6"
 description = "Quapp common library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/async_tasks/export_circuit_task.py

@@ -11,6 +11,7 @@ from .async_task import AsyncTask
 from ..config.logging_config import job_logger
 from ..data.async_task.circuit_export.backend_holder import BackendDataHolder
 from ..data.async_task.circuit_export.circuit_holder import CircuitDataHolder
+from ..data.response.custom_header import CustomHeader
 from ..enum.media_type import MediaType
 from ..util.file_utils import FileUtils
 from ..util.http_utils import create_bearer_header, get_job_id_from_url
@@ -20,8 +21,11 @@ class CircuitExportTask(AsyncTask):
     MAX_CIRCUIT_IMAGE_SIZE = 5 * (1024 ** 2)
 
     def __init__(self, circuit_data_holder: CircuitDataHolder,
-                 backend_data_holder: BackendDataHolder):
+                 backend_data_holder: BackendDataHolder,
+                 project_header: CustomHeader, workspace_header: CustomHeader):
         super().__init__()
+        self.project_header = project_header
+        self.workspace_header = workspace_header
         self.circuit_data_holder = circuit_data_holder
         self.backend_data_holder = backend_data_holder
         self.logger = job_logger(
@@ -43,8 +47,8 @@ class CircuitExportTask(AsyncTask):
             self.logger.debug('Converting circuit to SVG')
             figure_buffer = self.__convert()
         except Exception as e:
-            self.logger.error(f"Error converting circuit to SVG: {e}",
-                              exc_info=True)
+            self.logger.exception(f"Error converting circuit to SVG: {e}",
+                                  exc_info=True)
             return
 
         try:
@@ -54,7 +58,7 @@ class CircuitExportTask(AsyncTask):
             self.logger.debug(f"Content type: {content_type}")
             self.logger.debug(f"Buffer size: {len(io_buffer_value)} bytes")
         except Exception as e:
-            self.logger.error(
+            self.logger.exception(
                     f"Error determining if circuit SVG should be zipped: {e}",
                     exc_info=True)
             return
@@ -64,11 +68,12 @@ class CircuitExportTask(AsyncTask):
             self.__send(io_buffer_value=io_buffer_value,
                         content_type=content_type)
             self.logger.debug("Circuit sent to backend successfully.")
+            return
         except Exception as e:
-            self.logger.error(f"Error sending exported circuit to backend: {e}",
-                              exc_info=True)
-
-        self.logger.info("Circuit export task finished.")
+            self.logger.exception(
+                    f"Error sending exported circuit to backend: {e}",
+                    exc_info=True)
+            return
 
     def __convert(self):
         """
@@ -81,8 +86,8 @@ class CircuitExportTask(AsyncTask):
         try:
             circuit_figure = transpiled_circuit.draw(output='mpl', fold=-1)
         except Exception as exception:
-            self.logger.error(f"Error drawing circuit: {exception}",
-                              exc_info=True)
+            self.logger.exception(f"Error drawing circuit: {exception}",
+                                  exc_info=True)
             raise exception
 
         self.logger.debug("Converting circuit figure to SVG file...")
@@ -93,7 +98,7 @@ class CircuitExportTask(AsyncTask):
             self.logger.debug(
                     f"SVG export complete. Size: {figure_buffer.getbuffer().nbytes} bytes")
         except Exception as exception:
-            self.logger.error(
+            self.logger.exception(
                     f"Error saving circuit figure to SVG: {exception}",
                     exc_info=True)
             raise exception
@@ -135,16 +140,17 @@ class CircuitExportTask(AsyncTask):
 
         try:
             response = requests.post(url=url, headers=create_bearer_header(
-                    self.backend_data_holder.user_token), files=payload)
+                    self.backend_data_holder.user_token, self.project_header,
+                    self.workspace_header), files=payload)
         except Exception as exception:
-            self.logger.error(f"HTTP request failed: {exception}",
-                              exc_info=True)
+            self.logger.exception(f"HTTP request failed: {exception}",
+                                  exc_info=True)
             raise
 
         if response.ok:
             self.logger.info("Request sent to QuaO backend successfully.")
         else:
-            self.logger.error(
+            self.logger.exception(
                     f"Sending request to QuaO backend failed with status {response.status_code}! Response: {response.content}")
 
         self.logger.debug("HTTP request complete.")

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/component/backend/invocation.py

@@ -77,9 +77,9 @@ class Invocation(ABC):
         circuit = self.__prepare_circuit(circuit_preparation_fn)
 
         if circuit is None:
-            self.logger.error(
+            self.logger.exception(
                     "Circuit preparation failed, returning None from pre-execute")
-            return None
+            raise ValueError("Circuit preparation failed")
 
         try:
             self.logger.debug("Preparing backend data")
@@ -88,12 +88,13 @@ class Invocation(ABC):
                     f"Backend data prepared: device {self.backend_information.device_name}, provider {self.backend_information.provider_tag.value}")
 
         except Exception as exception:
-            self.logger.error(f"Error when prepare backend data: {exception}",
-                              exc_info=True)
+            self.logger.exception(
+                f"Error when prepare backend data: {exception}",
+                exc_info=True)
 
             job_response = build_error_job_response(exception,
                                                     message='Error when prepare backend data')
-
+            job_response.authentication = self.authentication
             update_job_metadata(job_response, self.callback_dict.get(
                     InvocationStep.PREPARATION).on_error)
 
@@ -113,7 +114,7 @@ class Invocation(ABC):
 
         try:
             if self.backend_information is None:
-                self.logger.error(
+                self.logger.exception(
                         "Backend information is None before execution")
                 raise ValueError("Backend is not found")
 
@@ -129,7 +130,7 @@ class Invocation(ABC):
             device = self._create_device(provider)
 
         except Exception as exception:
-            self.logger.error(
+            self.logger.exception(
                     f"Exception when create provider or device: {exception}",
                     exc_info=True)
 
@@ -182,8 +183,8 @@ class Invocation(ABC):
             return circuit
 
         except Exception as exception:
-            self.logger.error(f'Error when prepare circuit: {exception}',
-                              exc_info=True)
+            self.logger.exception(f'Error when prepare circuit: {exception}',
+                                  exc_info=True)
 
             job_response = build_error_job_response(exception, job_response,
                                                     message='Error when prepare circuit')

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/component/backend/job_fetcher.py

@@ -116,7 +116,7 @@ class JobFetcher(ABC):
                 update_job_metadata(job_response, self.callback_urls[
                     InvocationStep.EXECUTION].on_done)
             elif job_status == JobStatus.ERROR.value:
-                self.logger.error("Job resulted in error, handling failure")
+                self.logger.exception("Job resulted in error, handling failure")
 
                 self._handle_failed_job(original_job_result, job_response)
                 update_job_metadata(job_response, self.callback_urls[
@@ -127,7 +127,7 @@ class JobFetcher(ABC):
                 job_response.status_code = StatusCode.POLLING
 
         except Exception as exception:
-            self.logger.error(
+            self.logger.exception(
                     f"Exception during job fetch for provider_job_id {self.provider_job_id}: {exception}",
                     exc_info=True)
 
@@ -151,7 +151,7 @@ class JobFetcher(ABC):
     def _handle_failed_job(self, original_job_result,
                            job_response: JobResponse):
         """Handles the job result when the job has encountered an error."""
-        self.logger.error("Parsing job result from failed job")
+        self.logger.exception("Parsing job result from failed job")
         job_response.job_result = parse(original_job_result)
 
     def _process_job_result(self, original_job_result,
@@ -205,7 +205,7 @@ class JobFetcher(ABC):
             return job_response
 
         except Exception as exception:
-            self.logger.error(f"Exception during analysis: {exception}",
+            self.logger.exception(f"Exception during analysis: {exception}",
                               exc_info=True)
             from ...util.response_utils import build_error_job_response
             job_response = build_error_job_response(exception, job_response,

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/component/backend/job_fetching.py

@@ -75,7 +75,7 @@ class JobFetching(ABC):
                         InvocationStep.EXECUTION).on_done)
 
             elif JobStatus.ERROR.value.__eq__(job_response.job_status):
-                self.logger.error("Job resulted in error, handling failure")
+                self.logger.exception("Job resulted in error, handling failure")
 
                 job_response.job_result = parse(original_job_result)
 
@@ -152,7 +152,7 @@ class JobFetching(ABC):
             return job_response
 
         except Exception as exception:
-            self.logger.error(
+            self.logger.exception(
                     "Exception when analyst job result with provider_job_id {0}: {1}".format(
                             self.provider_job_id, str(exception)))
 

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/component/callback/update_job_metadata.py

@@ -35,7 +35,7 @@ def update_job_metadata(job_response: JobResponse, callback_url: str):
 
 
     except Exception as exception:
-        logger.error(f"Error occurred while calling backend: {exception}",
+        logger.exception(f"Error occurred while calling backend: {exception}",
                      exc_info=True)
 
         raise exception

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/component/device/device_selection.py

@@ -60,7 +60,7 @@ class DeviceSelection:
         response = requests.get(self.url, params=request, headers=header)
 
         if response.status_code != 200:
-            logger.error(
+            logger.exception(
                     'Select device fail with status code: {0} and content: {1}'.format(
                             response.status_code, response.content))
 

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/config/logging_config.py

@@ -21,11 +21,13 @@ def __custom_format(record):
 
     # Get the color for the current level, default to white if the level is unknown
     level_color = level_colors.get(record["level"].name, "white")
-    return (
-        f"<{level_color}>{{level}}</{level_color}> : <green>{{time: %Y-%m-%d %H:%M:%S}}</green> : <yellow>[{context}]</yellow> <{level_color}>{{message}}</{level_color}> : <magenta>{{process}}</magenta>\n")
+    return (f"<yellow>[ConsoleJobLog][{context}]</yellow> "
+            f"<{level_color}>{{level}}</{level_color}> : "
+            f"<green>{{time:YYYY-MM-DD HH:mm:ss.SSS}}</green> : "
+            f"<{level_color}>{{message}}</{level_color}>: "
+            f"<magenta>{{process}}</magenta>\n")
 
 
 logger.add(sink=sys.stderr, format=__custom_format, # Use custom format function
-           level="DEBUG", colorize=True
-           # Enable colors (supported by sys.stderr)
+           level="DEBUG", colorize=True# Enable colors (supported by sys.stderr)
            )

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/data/request/invocation_request.py

@@ -45,7 +45,7 @@ class InvocationRequest(Request):
             try:
                 Sdk.resolve(sdk_value)
             except Exception:
-                self.logger.error(
+                self.logger.exception(
                         'sdk must be a valid Sdk value, got {0}'.format(
                                 sdk_value))
                 raise ValueError(
@@ -54,7 +54,7 @@ class InvocationRequest(Request):
         # Validate authentication (if provided)
         authentication = request_data.get("authentication")
         if authentication is not None and not isinstance(authentication, dict):
-            self.logger.error(
+            self.logger.exception(
                     'authentication must be a dictionary if provided, got {0}'.format(
                             type(authentication).__name__))
             raise ValueError(

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/data/request/job_fetching_request.py

@@ -8,7 +8,7 @@ class JobFetchingRequest(Request):
     def __init__(self, request_data: dict | None):
 
         if not isinstance(request_data, dict):
-            self.logger.error(
+            self.logger.exception(
                     f"request_data must be a dictionary, got {type(request_data).__name__}")
             raise ValueError(
                     f"request_data must be a dictionary, got {type(request_data).__name__}")
@@ -17,7 +17,7 @@ class JobFetchingRequest(Request):
         provider_authentication = request_data.get("providerAuthentication")
         if provider_authentication is not None and not isinstance(
                 provider_authentication, dict):
-            self.logger.error(
+            self.logger.exception(
                     f"Invalid provider_authentication: {type(provider_authentication).__name__}")
             raise ValueError(
                     f"provider_authentication must be a dictionary if provided, got {type(provider_authentication).__name__}")

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/data/response/job_response.py

@@ -23,8 +23,8 @@ class JobResponse(object):
         self.job_result = job_result
         self.content_type = content_type
         self.job_histogram = job_histogram
-        self.user_identity = authentication.user_identity
-        self.user_token = authentication.user_token
+        self.user_identity = getattr(authentication, 'user_identity', None)
+        self.user_token = getattr(authentication, 'user_token', None)
         self.execution_time = execution_time
         self.status_code = status_code
         self.project_header = project_header

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/model/device/custom_device.py

@@ -55,7 +55,7 @@ class CustomDevice(Device, ABC):
             return job_response
 
         except Exception as exception:
-            self.logger.error(
+            self.logger.exception(
                     f"Exception when analyzing job result: {exception}",
                     exc_info=True)
 

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6}/quapp_common/model/device/device.py

@@ -176,7 +176,7 @@ class Device(ABC):
             return job_response
 
         except Exception as exception:
-            self.logger.error(
+            self.logger.exception(
                     f"Exception when analyzing job result: {exception}",
                     exc_info=True)
 

quapp_common-0.0.11.dev6/quapp_common/util/http_utils.py

@@ -0,0 +1,141 @@
+#  Quapp Platform Project
+#  http_utils.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from urllib.parse import urlparse
+
+from ..config.logging_config import logger
+from ..data.response.custom_header import CustomHeader
+from ..enum.http_header import HttpHeader
+from ..enum.media_type import MediaType
+from ..enum.token_type import TokenType
+
+DEFAULT_WORKSPACE_HEADER = 'workspaceHeader'
+DEFAULT_PROJECT_HEADER = 'projectHeader'
+CUSTOM_HEADER_VALUE = 'value'
+CUSTOM_HEADER_NAME = 'name'
+
+
+def create_bearer_header(token, project_header: CustomHeader,
+                         workspace_header: CustomHeader):
+    """
+    Creates an HTTP Bearer authorization header.
+
+    This function takes a token as an input and constructs a dictionary containing the
+    Bearer authorization header. The header consists of the token type "Bearer"
+    followed by the provided token.
+
+    Parameters:
+    token: str
+        The token string used for the authorization header.
+
+    Returns:
+    dict
+        A dictionary containing the constructed Bearer authorization header.
+    """
+    project_header_name = getattr(project_header, CUSTOM_HEADER_NAME,
+                                  DEFAULT_PROJECT_HEADER)
+    project_header_value = getattr(project_header, CUSTOM_HEADER_VALUE, None)
+    workspace_header_name = getattr(workspace_header, CUSTOM_HEADER_NAME,
+                                    DEFAULT_WORKSPACE_HEADER)
+    workspace_header_value = getattr(workspace_header, CUSTOM_HEADER_VALUE,
+                                     None)
+
+    return {
+        HttpHeader.AUTHORIZATION.value: TokenType.BEARER.value + ' ' + token,
+        project_header_name           : project_header_value,
+        workspace_header_name         : workspace_header_value}
+
+
+def create_application_json_header(token: str, project_header: CustomHeader,
+                                   workspace_header: CustomHeader) -> dict:
+    """
+    Generates HTTP headers for JSON-based API requests, including authorization
+    and optional custom project and workspace headers.
+
+    Args:
+        token: Authorization token of type string for the HTTP headers.
+        project_header: CustomHeader object representing the project-specific
+            custom header details.
+        workspace_header: CustomHeader object representing the workspace-specific
+            custom header details.
+
+    Returns:
+        dict: Dictionary containing HTTP headers with authorization, content type,
+        accept headers, and custom project and workspace headers where applicable.
+    """
+    project_header_name = getattr(project_header, CUSTOM_HEADER_NAME,
+                                  DEFAULT_PROJECT_HEADER)
+    project_header_value = getattr(project_header, CUSTOM_HEADER_VALUE, None)
+    workspace_header_name = getattr(workspace_header, CUSTOM_HEADER_NAME,
+                                    DEFAULT_WORKSPACE_HEADER)
+    workspace_header_value = getattr(workspace_header, CUSTOM_HEADER_VALUE,
+                                     None)
+    return {
+        HttpHeader.AUTHORIZATION.value: '{0} {1}'.format(TokenType.BEARER.value,
+                                                         token),
+        HttpHeader.CONTENT_TYPE.value : MediaType.APPLICATION_JSON.value,
+        HttpHeader.ACCEPT.value       : MediaType.APPLICATION_JSON.value,
+        project_header_name           : project_header_value,
+        workspace_header_name         : workspace_header_value}
+
+
+def get_custom_header(request_data: dict, key: str) -> CustomHeader:
+    """
+    Retrieve and construct a CustomHeader object from request data.
+
+    This function accesses a specified key in the request_data dictionary
+    to extract the necessary information for creating a CustomHeader
+    object. It retrieves the 'name' and 'value' properties from the
+    nested dictionary corresponding to the provided key.
+
+    Parameters:
+    request_data (dict): The dictionary containing header details.
+    key (str): The key used to extract the relevant header data.
+
+    Returns:
+    CustomHeader: An object that encapsulates the extracted 'name' and
+    'value' of the custom header.
+    """
+    custom_header = request_data.get(key, {})
+    return CustomHeader(name=custom_header.get(CUSTOM_HEADER_NAME),
+                        value=custom_header.get(CUSTOM_HEADER_VALUE))
+
+
+def get_job_id_from_url(url: str):
+    """
+    Extracts the job ID from a given URL. This function securely parses the given URL
+    and attempts to retrieve the job ID located in the path, typically after the 'jobs'
+    keyword. If the pattern is not found or the URL is invalid, it returns None.
+
+    Args:
+        url: The URL string from which the job ID will be extracted.
+
+    Returns:
+        str or None: The extracted job ID if present, otherwise returns None.
+    """
+
+    path = urlparse(url).path
+    segments = [seg for seg in path.split('/') if seg]
+    job_id = None
+
+    logger.debug(f'Parsed URL segments: {segments}')
+
+    if 'jobs' in segments:
+        idx = segments.index('jobs')
+        try:
+            job_id = segments[idx + 1]
+            logger.debug(f"Found job id after 'jobs': {job_id}")
+        except IndexError:
+            logger.exception("No job id found after 'jobs'")
+    elif 'job' in segments:
+        idx = segments.index('job')
+        try:
+            job_id = segments[idx + 1]
+            logger.debug(f"Found job id after 'job': {job_id}")
+        except IndexError:
+            logger.exception("No job id found after 'job'")
+    else:
+        logger.exception("Neither 'job' nor 'jobs' found in URL segments.")
+
+    return job_id

quapp_common-0.0.11.dev6/quapp_common/util/response_utils.py

@@ -0,0 +1,200 @@
+#  Quapp Platform Project
+#  response_utils.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from .http_utils import CUSTOM_HEADER_VALUE
+from ..component.backend.job_fetcher import JobFetcher
+from ..data.promise.post_processing_promise import PostProcessingPromise
+from ..data.response.job_response import JobResponse
+from ..enum.status.job_status import JobStatus
+from ..enum.status.status_code import StatusCode
+
+AUTHENTICATION = 'authentication'
+BACKEND_AUTHENTICATION = 'backend_authentication'
+PROJECT_HEADER = 'project_header'
+PROVIDER_JOB_ID = 'provider_job_id'
+WORKSPACE_HEADER = 'workspace_header'
+
+
+def generate_response(job_response: JobResponse) -> dict:
+    """
+    Generates a standardized response dictionary based on the given job response.
+
+    This function processes the provided JobResponse instance and constructs a
+    response dictionary containing relevant job details such as status code,
+    execution time, job results, and additional attributes if they exist. It ensures
+    that all necessary information is included in the response for further
+    processing or communication with other systems.
+
+    Parameters:
+        job_response (JobResponse): An instance of the JobResponse class containing
+        detailed job information.
+
+    Returns:
+        dict: A dictionary containing the processed job response with keys such as
+        'statusCode', 'body', 'userIdentity', 'userToken', 'projectId', and
+        'workspaceId'.
+
+    Raises:
+        This function does not explicitly raise exceptions.
+    """
+    if job_response:
+        status_code = job_response.status_code.value
+        body = {'providerJobId': job_response.provider_job_id,
+                'jobStatus'    : job_response.job_status,
+                'jobResult'    : job_response.job_result,
+                'contentType'  : job_response.content_type.value,
+                'histogram'    : job_response.job_histogram,
+                'executionTime': job_response.execution_time}
+
+        # Add 'shots' only if it exists in the job_response
+        if hasattr(job_response, 'shots'):
+            body['shots'] = job_response.shots
+
+    else:
+        status_code = job_response.status_code.value
+        body = 'Error in function code. Please contact the developer.'
+
+    return {'statusCode'  : status_code,
+            'body'        : body,
+            'userIdentity': job_response.user_identity,
+            'userToken'   : job_response.user_token,
+            'projectId'   : getattr(
+                    job_response.project_header, CUSTOM_HEADER_VALUE, None),
+            'workspaceId' : getattr(
+                    job_response.workspace_header, CUSTOM_HEADER_VALUE, None)}
+
+
+def build_done_job_response(fetcher: JobFetcher = None,
+                            post_promise: PostProcessingPromise = None) -> JobResponse | None:
+    """
+    Builds a JobResponse object for a completed job.
+
+    This function assembles a JobResponse object which signifies the completion
+    of a job. It extracts relevant information such as the provider job ID,
+    authentication details, project header, and workspace header, and sets the
+    status code to indicate the job is done. If both input parameters are missing,
+    the function returns None.
+
+    Parameters:
+    fetcher (JobFetcher, optional): An optional job fetcher instance used to
+        extract the provider job ID and other details.
+    post_promise (PostProcessingPromise, optional): An optional post-processing
+        promise instance to assist in extracting relevant details.
+
+    Returns:
+    JobResponse | None: A JobResponse object with the completed job information,
+        or None if no inputs were provided.
+    """
+    return JobResponse(
+            provider_job_id=__extract_value(PROVIDER_JOB_ID, fetcher,
+                                            post_promise),
+            authentication=__extract_authentication(fetcher, post_promise),
+            project_header=__extract_value(PROJECT_HEADER, fetcher,
+                                           post_promise),
+            workspace_header=__extract_value(WORKSPACE_HEADER, fetcher,
+                                             post_promise),
+            status_code=StatusCode.DONE)
+
+
+def build_error_job_response(exception: Exception,
+                             job_response: JobResponse = None,
+                             fetcher: JobFetcher = None,
+                             post_promise: PostProcessingPromise = None,
+                             message: str = None) -> JobResponse:
+    """
+    Builds and returns a JobResponse object populated with error-related information.
+
+    This function constructs a JobResponse object that provides comprehensive details
+    about an error occurrence. It extracts specific headers and identifiers from
+    the given fetcher or post-promise if provided, and includes information
+    about the error such as the exception and a corresponding message. The status
+    and result of the job indicate an error state.
+
+    Parameters:
+    exception: Exception
+        The exception instance representing the error that occurred.
+
+    job_response: JobResponse, optional
+        A JobResponse object to populate with error details. If not provided,
+        a new JobResponse object will be created.
+
+    fetcher: JobFetcher, optional
+        An optional fetcher from which relevant headers and identifiers can
+        be extracted.
+
+    post_promise: PostProcessingPromise, optional
+        An optional post-processing promise from which relevant headers and
+        identifiers can be extracted.
+
+    message: str, optional
+        A custom error message to be included in the job response. If not
+        specified, a default message "Unknown error occurred." will be used.
+
+    Returns:
+    JobResponse
+        A JobResponse object populated with error-related details such as
+        status, exception, and error message.
+    """
+    if job_response is None:
+        job_response = JobResponse()
+    job_response.provider_job_id = __extract_value(PROVIDER_JOB_ID, fetcher,
+                                                   post_promise)
+    job_response.authentication = __extract_authentication(fetcher,
+                                                           post_promise)
+    job_response.project_header = __extract_value(PROJECT_HEADER, fetcher,
+                                                  post_promise)
+    job_response.tenant_header = __extract_value(WORKSPACE_HEADER, fetcher,
+                                                 post_promise)
+    job_response.status_code = StatusCode.ERROR
+    job_response.job_status = JobStatus.ERROR.value
+    job_response.job_result = {'message'  : message or 'Unknown error occurred.',
+                               'exception': str(exception)}
+    return job_response
+
+
+def __extract_authentication(fetcher: JobFetcher,
+                             post_promise: PostProcessingPromise):
+    """
+    Extract authentication information from the provided fetcher or post promise.
+
+    This function retrieves authentication data by first attempting to extract it from
+    the JobFetcher instance. If it's not available on the JobFetcher, it then falls back
+    to extracting it from the PostProcessingPromise instance. If neither source contains
+    authentication data, a default value of None is returned.
+
+    Parameters:
+        fetcher (JobFetcher): The JobFetcher instance to retrieve authentication data from.
+        post_promise (PostProcessingPromise): The PostProcessingPromise instance to retrieve
+            authentication data from if not available on the fetcher.
+
+    Returns:
+        Any: The extracted authentication data, or None if no authentication data is found.
+    """
+    return getattr(fetcher, BACKEND_AUTHENTICATION,
+                   getattr(post_promise, AUTHENTICATION, None))
+
+
+def __extract_value(property_name: str, fetcher: JobFetcher,
+                    post_promise: PostProcessingPromise):
+    """
+    Extracts a specified property value from a fetcher object or a fallback
+    post-processing promise object.
+
+    Parameters:
+    property_name: str
+        The name of the property to extract.
+    fetcher: JobFetcher
+        The primary object from which the property value is retrieved.
+    post_promise: PostProcessingPromise
+        The fallback object from which the property value is retrieved if
+        unavailable in the fetcher.
+
+    Returns:
+    Any
+        The value of the specified property retrieved from the fetcher or the
+        fallback post-promise object.
+
+    """
+    return getattr(fetcher, property_name,
+                   getattr(post_promise, property_name, None))

{quapp_common-0.0.11.dev4 → quapp_common-0.0.11.dev6/quapp_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.11.dev4
+Version: 0.0.11.dev6
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)

quapp_common-0.0.11.dev4/quapp_common/util/http_utils.py

@@ -1,93 +0,0 @@
-#  Quapp Platform Project
-#  http_utils.py
-#  Copyright © CITYNOW Co. Ltd. All rights reserved.
-
-from urllib.parse import urlparse
-
-from ..config.logging_config import logger
-from ..data.response.custom_header import CustomHeader
-from ..enum.http_header import HttpHeader
-from ..enum.media_type import MediaType
-from ..enum.token_type import TokenType
-
-CUSTOM_HEADER_VALUE = 'value'
-CUSTOM_HEADER_NAME = 'name'
-
-
-def create_bearer_header(token, project_header: CustomHeader = None,
-                         workspace_header: CustomHeader = None):
-    """
-    Creates an HTTP Bearer authorization header.
-
-    This function takes a token as an input and constructs a dictionary containing the
-    Bearer authorization header. The header consists of the token type "Bearer"
-    followed by the provided token.
-
-    Parameters:
-    token: str
-        The token string used for the authorization header.
-
-    Returns:
-    dict
-        A dictionary containing the constructed Bearer authorization header.
-    """
-
-    return {
-        HttpHeader.AUTHORIZATION.value: TokenType.BEARER.value + ' ' + token,
-        project_header.name           : project_header.value,
-        workspace_header.name         : workspace_header.value}
-
-
-def create_application_json_header(token: str, project_header: CustomHeader,
-                                   workspace_header: CustomHeader):
-    return {
-        HttpHeader.AUTHORIZATION.value: TokenType.BEARER.value + ' ' + token,
-        HttpHeader.CONTENT_TYPE.value : MediaType.APPLICATION_JSON.value,
-        HttpHeader.ACCEPT.value       : MediaType.APPLICATION_JSON.value,
-        project_header.name           : project_header.value,
-        workspace_header.name         : workspace_header.value}
-
-
-def get_custom_header(request_data: dict, key: str) -> CustomHeader:
-    custom_header = request_data.get(key, {})
-    return CustomHeader(name=custom_header.get(CUSTOM_HEADER_NAME),
-                        value=custom_header.get(CUSTOM_HEADER_VALUE))
-
-
-def get_job_id_from_url(url: str):
-    """
-    Extracts the job ID from a given URL. This function securely parses the given URL
-    and attempts to retrieve the job ID located in the path, typically after the 'jobs'
-    keyword. If the pattern is not found or the URL is invalid, it returns None.
-
-    Args:
-        url: The URL string from which the job ID will be extracted.
-
-    Returns:
-        str or None: The extracted job ID if present, otherwise returns None.
-    """
-
-    path = urlparse(url).path
-    segments = [seg for seg in path.split('/') if seg]
-    job_id = None
-
-    logger.debug(f'Parsed URL segments: {segments}')
-
-    if 'jobs' in segments:
-        idx = segments.index('jobs')
-        try:
-            job_id = segments[idx + 1]
-            logger.debug(f"Found job id after 'jobs': {job_id}")
-        except IndexError:
-            logger.error("No job id found after 'jobs'")
-    elif 'job' in segments:
-        idx = segments.index('job')
-        try:
-            job_id = segments[idx + 1]
-            logger.debug(f"Found job id after 'job': {job_id}")
-        except IndexError:
-            logger.error("No job id found after 'job'")
-    else:
-        logger.error("Neither 'job' nor 'jobs' found in URL segments.")
-
-    return job_id

quapp_common-0.0.11.dev4/quapp_common/util/response_utils.py

@@ -1,97 +0,0 @@
-'''
-    QApp Platform Project response_utils.py Copyright © CITYNOW Co. Ltd. All rights reserved.
-'''
-
-from ..component.backend.job_fetcher import JobFetcher
-from ..config.logging_config import job_logger
-from ..data.promise.post_processing_promise import PostProcessingPromise
-from ..data.response.job_response import JobResponse
-from ..enum.status.job_status import JobStatus
-from ..enum.status.status_code import StatusCode
-
-AUTHENTICATION = 'authentication'
-BACKEND_AUTHENTICATION = 'backend_authentication'
-PROJECT_HEADER = 'project_header'
-PROVIDER_JOB_ID = 'provider_job_id'
-WORKSPACE_HEADER = 'workspace_header'
-
-
-def generate_response(job_response: JobResponse) -> dict:
-    if job_response:
-        status_code = job_response.status_code.value
-        body = {'providerJobId': job_response.provider_job_id,
-                'jobStatus'    : job_response.job_status,
-                'jobResult'    : job_response.job_result,
-                'contentType'  : job_response.content_type.value,
-                'histogram'    : job_response.job_histogram,
-                'executionTime': job_response.execution_time}
-
-        # Add 'shots' only if it exists in the job_response
-        if hasattr(job_response, 'shots'):
-            body['shots'] = job_response.shots
-
-    else:
-        status_code = job_response.status_code.value
-        body = 'Error in function code. Please contact the developer.'
-
-    return {'statusCode'  : status_code, 'body': body,
-            'userIdentity': job_response.user_identity,
-            'userToken'   : job_response.user_token,
-            'projectId'   : job_response.project_header.value,
-            'workspaceId' : job_response.workspace_header.value}
-
-
-def build_done_job_response(fetcher: JobFetcher = None,
-                            post_promise: PostProcessingPromise = None) -> JobResponse | None:
-    return JobResponse(
-            provider_job_id=__extract_provider_job_id(fetcher, post_promise),
-            authentication=__extract_authentication(fetcher, post_promise),
-            project_header=__extract_project_header(fetcher, post_promise),
-            workspace_header=__extract_workspace_header(fetcher, post_promise),
-            status_code=StatusCode.DONE)
-
-
-def build_error_job_response(exception: Exception,
-                             job_response: JobResponse = None,
-                             fetcher: JobFetcher = None,
-                             post_promise: PostProcessingPromise = None,
-                             message: str = None) -> JobResponse:
-    if job_response is None:
-        job_response = JobResponse()
-    job_response.provider_job_id = __extract_provider_job_id(fetcher,
-                                                             post_promise)
-    job_response.authentication = __extract_authentication(fetcher,
-                                                           post_promise)
-    job_response.project_header = __extract_project_header(fetcher,
-                                                           post_promise)
-    job_response.tenant_header = __extract_workspace_header(fetcher,
-                                                            post_promise)
-    job_response.status_code = StatusCode.ERROR
-    job_response.job_status = JobStatus.ERROR.value
-    job_response.job_result = {'message'  : message or 'Unknown error occurred.',
-                               'exception': str(exception)}
-    return job_response
-
-
-def __extract_authentication(fetcher: JobFetcher,
-                             post_promise: PostProcessingPromise):
-    return getattr(fetcher, BACKEND_AUTHENTICATION,
-                   getattr(post_promise, AUTHENTICATION, None))
-
-
-def __extract_project_header(fetcher: JobFetcher,
-                             post_promise: PostProcessingPromise):
-    return getattr(fetcher, PROJECT_HEADER,
-                   getattr(post_promise, PROJECT_HEADER, None))
-
-
-def __extract_provider_job_id(fetcher: JobFetcher,
-                              post_promise: PostProcessingPromise):
-    return getattr(fetcher, PROVIDER_JOB_ID,
-                   getattr(post_promise, PROVIDER_JOB_ID, None))
-
-
-def __extract_workspace_header(fetcher: JobFetcher,
-                               post_promise: PostProcessingPromise):
-    return getattr(fetcher, WORKSPACE_HEADER,
-                   getattr(post_promise, WORKSPACE_HEADER, None))