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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.11.dev3
+Version: 0.0.11.dev4
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -38,15 +38,29 @@ Quapp common library supporting Quapp Platform for Quantum Computing.
 
 ## Overview
 
-`quapp-common` is a Python library designed to support the Quapp Platform for Quantum Computing by
-providing common utilities, configurations, and abstractions for working with quantum providers and
-devices.
+`quapp-common` is a Python library designed to support the Quapp Platform for
+Quantum Computing by providing common utilities, configurations, and
+abstractions for working with
+quantum providers and devices.
+
+Recent improvements focus on cleaner and more consistent logging, enhanced error
+handling, and
+standardizing header management by adding workspace-specific headers instead of
+tenant-specific ones,
+improving maintainability and clarity.
 
 ## Features
 
 - Provider and device factory for quantum computing platforms.
-- Logging and configuration utilities.
-- Support for AWS Braket, OQC Cloud, Qiskit, PennyLane, DWave Ocean and Quapp quantum simulators.
+- Logging and configuration utilities with improved and detailed log messages.
+- Support for AWS Braket, OQC Cloud, Qiskit, PennyLane, DWave Ocean, and Quapp
+  quantum simulators.
+- Refactored classes and utilities to remove tenant-specific request, response,
+  and promise classes.
+- Standardized naming by renaming `ProjectHeader` to `CustomHeader`.
+- Enhanced error handling and job metadata update mechanisms.
+- Simplified and cleaner HTTP request/response logging and URL parsing
+  utilities.
 
 ## Installation
 
@@ -54,3 +68,24 @@ Install via pip:
 
 ```bash
 pip install quapp-common
+```
+
+## Recently Changes Highlights
+
+- Added workspace-specific classes for request, response, and promise,
+  consolidating code to unify context handling.
+- Refactored logging throughout the codebase, removing redundant debug logs and
+  adding context-rich log messages.
+- Improved URL parsing and job ID extraction, especially in HTTP utilities, to
+  better track jobs.
+- Cleaned up logging configuration files to standardize log formats and levels.
+- Added robust error handling in job execution and analysis pipelines, ensuring
+  detailed failure reporting.
+- Simplified header and request body logging, improving performance and
+  readability.
+
+---
+
+For detailed usage and API references, please refer to the in-code documentation
+or contact the maintainers.
+ 

quapp_common-0.0.11.dev4/README.md

@@ -0,0 +1,57 @@
+# quapp-common
+
+Quapp common library supporting Quapp Platform for Quantum Computing.
+
+## Overview
+
+`quapp-common` is a Python library designed to support the Quapp Platform for
+Quantum Computing by providing common utilities, configurations, and
+abstractions for working with
+quantum providers and devices.
+
+Recent improvements focus on cleaner and more consistent logging, enhanced error
+handling, and
+standardizing header management by adding workspace-specific headers instead of
+tenant-specific ones,
+improving maintainability and clarity.
+
+## Features
+
+- Provider and device factory for quantum computing platforms.
+- Logging and configuration utilities with improved and detailed log messages.
+- Support for AWS Braket, OQC Cloud, Qiskit, PennyLane, DWave Ocean, and Quapp
+  quantum simulators.
+- Refactored classes and utilities to remove tenant-specific request, response,
+  and promise classes.
+- Standardized naming by renaming `ProjectHeader` to `CustomHeader`.
+- Enhanced error handling and job metadata update mechanisms.
+- Simplified and cleaner HTTP request/response logging and URL parsing
+  utilities.
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install quapp-common
+```
+
+## Recently Changes Highlights
+
+- Added workspace-specific classes for request, response, and promise,
+  consolidating code to unify context handling.
+- Refactored logging throughout the codebase, removing redundant debug logs and
+  adding context-rich log messages.
+- Improved URL parsing and job ID extraction, especially in HTTP utilities, to
+  better track jobs.
+- Cleaned up logging configuration files to standardize log formats and levels.
+- Added robust error handling in job execution and analysis pipelines, ensuring
+  detailed failure reporting.
+- Simplified header and request body logging, improving performance and
+  readability.
+
+---
+
+For detailed usage and API references, please refer to the in-code documentation
+or contact the maintainers.
+ 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-common"
-version = "0.0.11.dev3"
+version = "0.0.11.dev4"
 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.dev3 → quapp_common-0.0.11.dev4}/quapp_common/async_tasks/async_task.py

@@ -1,10 +1,10 @@
 """
     QApp Platform Project async_task.py Copyright © CITYNOW Co. Ltd. All rights reserved.
 """
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 
 
-class AsyncTask:
+class AsyncTask(ABC):
 
     @abstractmethod
     def do(self):

quapp_common-0.0.11.dev4/quapp_common/async_tasks/export_circuit_task.py

@@ -0,0 +1,161 @@
+#  Quapp Platform Project
+#  export_circuit_task.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from abc import abstractmethod
+from io import BytesIO
+
+import requests
+
+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 ..enum.media_type import MediaType
+from ..util.file_utils import FileUtils
+from ..util.http_utils import create_bearer_header, get_job_id_from_url
+
+
+class CircuitExportTask(AsyncTask):
+    MAX_CIRCUIT_IMAGE_SIZE = 5 * (1024 ** 2)
+
+    def __init__(self, circuit_data_holder: CircuitDataHolder,
+                 backend_data_holder: BackendDataHolder):
+        super().__init__()
+        self.circuit_data_holder = circuit_data_holder
+        self.backend_data_holder = backend_data_holder
+        self.logger = job_logger(
+                get_job_id_from_url(self.circuit_data_holder.export_url))
+
+    def do(self):
+        """
+          Export circuit to svg file, then send it to QuaO server for saving
+        """
+        self.logger.info("Starting circuit export task...")
+
+        circuit_export_url = self.circuit_data_holder.export_url
+
+        if circuit_export_url is None or len(circuit_export_url) < 1:
+            self.logger.warning("Export URL is missing. Task will exit.")
+            return
+
+        try:
+            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)
+            return
+
+        try:
+            self.logger.debug('Determining if circuit SVG should be zipped')
+            io_buffer_value, content_type = self.__determine_zip(
+                    figure_buffer=figure_buffer)
+            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(
+                    f"Error determining if circuit SVG should be zipped: {e}",
+                    exc_info=True)
+            return
+
+        try:
+            self.logger.debug('Sending circuit to backend')
+            self.__send(io_buffer_value=io_buffer_value,
+                        content_type=content_type)
+            self.logger.debug("Circuit sent to backend successfully.")
+        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.")
+
+    def __convert(self):
+        """
+        Convert circuit to SVG, return as BytesIO.
+        """
+        self.logger.debug("Preparing circuit figure...")
+        transpiled_circuit = self._transpile_circuit()
+        self.logger.debug("Transpiled circuit successfully.")
+
+        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)
+            raise exception
+
+        self.logger.debug("Converting circuit figure to SVG file...")
+        figure_buffer = BytesIO()
+        try:
+            circuit_figure.savefig(figure_buffer, format='svg',
+                                   bbox_inches='tight')
+            self.logger.debug(
+                    f"SVG export complete. Size: {figure_buffer.getbuffer().nbytes} bytes")
+        except Exception as exception:
+            self.logger.error(
+                    f"Error saving circuit figure to SVG: {exception}",
+                    exc_info=True)
+            raise exception
+
+        return figure_buffer
+
+    def __determine_zip(self, figure_buffer):
+        """
+        Determine if the buffer needs to be zipped; return (buffer, content_type).
+        """
+        self.logger.debug("Checking if SVG file needs to be zipped.")
+        buffer_value = figure_buffer.getvalue()
+        content_type = MediaType.SVG_XML
+
+        self.logger.debug("Checking max file size")
+        estimated_file_size = len(buffer_value)
+
+        if estimated_file_size > CircuitExportTask.MAX_CIRCUIT_IMAGE_SIZE:
+            self.logger.debug("Zip file")
+            zip_file_buffer = FileUtils.zip(io_buffer_value=buffer_value,
+                                            file_name="circuit_image.svg")
+
+            buffer_value = zip_file_buffer.getvalue()
+            content_type = MediaType.APPLICATION_ZIP
+
+        return buffer_value, content_type
+
+    def __send(self, io_buffer_value, content_type: MediaType):
+        """
+       Send circuit SVG (or zipped SVG) to the backend.
+       """
+        url = self.circuit_data_holder.export_url
+
+        self.logger.debug(
+                f"Sending circuit svg image to [{url}] with POST method ...")
+
+        payload = {'circuit': ('circuit_image.svg', io_buffer_value,
+                               content_type.value)}
+
+        try:
+            response = requests.post(url=url, headers=create_bearer_header(
+                    self.backend_data_holder.user_token), files=payload)
+        except Exception as exception:
+            self.logger.error(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(
+                    f"Sending request to QuaO backend failed with status {response.status_code}! Response: {response.content}")
+
+        self.logger.debug("HTTP request complete.")
+
+    @abstractmethod
+    def _transpile_circuit(self):
+        """
+        Should be implemented in subclass to return transpiled circuit.
+        """
+        self.logger.debug(
+                "Calling _transpile_circuit (must be implemented in subclass)")
+
+        raise NotImplementedError(
+                '[CircuitExportTask] __transpile_circuit() method must be implemented')

quapp_common-0.0.11.dev4/quapp_common/async_tasks/post_processing_task.py

@@ -0,0 +1,49 @@
+"""
+    QApp Platform Project post_processing_task.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from .async_task import AsyncTask
+from ..config.logging_config import job_logger
+from ..data.promise.post_processing_promise import PostProcessingPromise
+from ..enum.media_type import MediaType
+from ..util.http_utils import get_job_id_from_url
+from ..util.json_parser_utils import parse
+
+
+class PostProcessingTask(AsyncTask):
+    def __init__(self, post_processing_fn, promise: PostProcessingPromise):
+        self.post_processing_fn = post_processing_fn
+        self.promise = promise
+        self.logger = job_logger(
+                get_job_id_from_url(self.promise.callback_url.on_done))
+
+    def do(self):
+        """
+           Execute post_processing and send to backend
+        """
+        from ..component.callback.update_job_metadata import update_job_metadata
+        from ..util.response_utils import build_done_job_response, \
+            build_error_job_response
+
+        job_response = build_done_job_response(post_promise=self.promise)
+
+        update_job_metadata(job_response, self.promise.callback_url.on_start)
+
+        job_response.content_type = MediaType.APPLICATION_JSON
+
+        try:
+            self.logger.info("Execute post_processing ...")
+            job_result_post_processing = self.post_processing_fn(
+                    self.promise.job_result)
+
+            self.logger.debug("Parsing job result....")
+            print(job_result_post_processing)
+            job_response.job_result = parse(job_result_post_processing)
+
+            update_job_metadata(job_response, self.promise.callback_url.on_done)
+
+        except Exception as exception:
+            job_response = build_error_job_response(exception, job_response,
+                                                    message='Error when post processing job result')
+
+            update_job_metadata(job_response,
+                                self.promise.callback_url.on_error)

quapp_common-0.0.11.dev4/quapp_common/component/backend/invocation.py

@@ -0,0 +1,253 @@
+#  Quapp Platform Project
+#  invocation.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from abc import ABC, abstractmethod
+
+from ..callback.update_job_metadata import update_job_metadata
+from ...component.device.device_selection import DeviceSelection
+from ...config.logging_config import job_logger
+from ...config.thread_config import circuit_running_pool
+from ...data.backend.backend_information import BackendInformation
+from ...data.device.circuit_running_option import CircuitRunningOption
+from ...data.request.invocation_request import InvocationRequest
+from ...data.response.authentication import Authentication
+from ...data.response.custom_header import CustomHeader
+from ...data.response.job_response import JobResponse
+from ...enum.invocation_step import InvocationStep
+from ...enum.sdk import Sdk
+from ...enum.status.status_code import StatusCode
+from ...model.provider.provider import Provider
+from ...util.response_utils import build_error_job_response
+
+EXPORT_CIRCUIT_SDK = {Sdk.QISKIT, Sdk.BRAKET}
+
+
+class Invocation(ABC):
+    def __init__(self, request_data: InvocationRequest):
+        self.sdk: Sdk = Sdk.resolve(request_data.sdk)
+        self.input = request_data.input
+        self.device_id = request_data.device_id
+        self.backend_information: BackendInformation
+        self.authentication: Authentication = request_data.authentication
+        self.project_header: CustomHeader = request_data.project_header
+        self.workspace_header: CustomHeader = request_data.workspace_header
+        self.job_id = request_data.job_id
+        self.options = CircuitRunningOption(shots=request_data.shots,
+                                            processing_unit=request_data.processing_unit,
+                                            executor=circuit_running_pool,
+                                            max_job_size=1, )
+        self.device_selection_url: str = request_data.device_selection_url
+        self.circuit_export_url: str = request_data.circuit_export_url
+        self.callback_dict: dict = {
+            InvocationStep.PREPARATION : request_data.preparation,
+            InvocationStep.EXECUTION   : request_data.execution,
+            InvocationStep.ANALYSIS    : request_data.analysis,
+            InvocationStep.FINALIZATION: request_data.finalization, }
+        self.invoke_authentication = request_data.invoke_authentication
+        self.logger = job_logger(self.job_id)
+        self.logger.info(
+                f"Initializing Invocation with job id: {self.job_id}, sdk: {self.sdk}, device id: {self.device_id}")
+
+    def submit_job(self, circuit_preparation_fn, post_processing_fn):
+        """
+
+        @param post_processing_fn: Post-processing function
+        @param circuit_preparation_fn: Circuit-preparation function
+        @return: Job result
+        """
+        self.logger.debug("Invoke job started")
+
+        circuit = self.__pre_execute(circuit_preparation_fn)
+
+        if circuit is None:
+            self.logger.warning(
+                    "Circuit preparation returned None, cancelling job submission")
+            return
+
+        self.__execute(circuit, post_processing_fn)
+        self.logger.info("Submit job completed")
+
+    def __pre_execute(self, circuit_preparation_fn):
+        """
+
+        @param circuit_preparation_fn: Circuit preparation function
+        """
+        self.logger.debug("Pre-execute: preparing circuit")
+        circuit = self.__prepare_circuit(circuit_preparation_fn)
+
+        if circuit is None:
+            self.logger.error(
+                    "Circuit preparation failed, returning None from pre-execute")
+            return None
+
+        try:
+            self.logger.debug("Preparing backend data")
+            self.__prepare_backend_data(circuit)
+            self.logger.info(
+                    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)
+
+            job_response = build_error_job_response(exception,
+                                                    message='Error when prepare backend data')
+
+            update_job_metadata(job_response, self.callback_dict.get(
+                    InvocationStep.PREPARATION).on_error)
+
+        self.logger.debug("Exporting circuit")
+        self._export_circuit(circuit)
+
+        return circuit
+
+    def __execute(self, circuit, post_processing_fn):
+        """
+
+        @param circuit: Circuit was run
+        @param post_processing_fn: Post-processing function
+        @return: Job response
+        """
+        self.logger.debug("Execute: starting job execution")
+
+        try:
+            if self.backend_information is None:
+                self.logger.error(
+                        "Backend information is None before execution")
+                raise ValueError("Backend is not found")
+
+            device_name = self.backend_information.device_name
+            provider_tag = self.backend_information.provider_tag
+
+            self.logger.debug(
+                    f"Executing job with provider tag: {provider_tag.value}")
+
+            provider = self._create_provider()
+
+            self.logger.debug(f"Executing job with device name: {device_name}")
+            device = self._create_device(provider)
+
+        except Exception as exception:
+            self.logger.error(
+                    f"Exception when create provider or device: {exception}",
+                    exc_info=True)
+
+            job_response = build_error_job_response(exception,
+                                                    message='Error when create provider or device')
+            update_job_metadata(job_response, self.callback_dict.get(
+                    InvocationStep.EXECUTION).on_error, )
+
+            return
+
+        self.logger.info(
+                f"Running circuit on device {device_name} with provider {provider_tag.value}")
+
+        device.run_circuit(circuit=circuit,
+                           post_processing_fn=post_processing_fn,
+                           options=self.options,
+                           callback_dict=self.callback_dict,
+                           authentication=self.authentication,
+                           project_header=self.project_header,
+                           workspace_header=self.workspace_header)
+
+    def __prepare_circuit(self, circuit_preparation_fn):
+        """
+
+        @param circuit_preparation_fn: Circuit preparation function
+        @return: circuit
+        """
+        self.logger.debug('Prepare circuit started')
+
+        job_response = JobResponse(status_code=StatusCode.DONE,
+                                   authentication=self.authentication,
+                                   project_header=self.project_header,
+                                   workspace_header=self.workspace_header)
+        update_job_metadata(job_response, self.callback_dict.get(
+                InvocationStep.PREPARATION).on_start)
+
+        try:
+            circuit = circuit_preparation_fn(self.input)
+
+            if circuit is None:
+                self.logger.warning(
+                        "Circuit preparation function returned None")
+                raise ValueError('Error when prepare circuit')
+
+            self.logger.debug(f"Circuit prepared: {circuit}")
+
+            update_job_metadata(job_response, self.callback_dict.get(
+                    InvocationStep.PREPARATION).on_done)
+
+            return circuit
+
+        except Exception as exception:
+            self.logger.error(f'Error when prepare circuit: {exception}',
+                              exc_info=True)
+
+            job_response = build_error_job_response(exception, job_response,
+                                                    message='Error when prepare circuit')
+
+            update_job_metadata(job_response, self.callback_dict.get(
+                    InvocationStep.PREPARATION).on_error)
+
+            return None
+
+    def __prepare_backend_data(self, circuit):
+        """
+
+        @param circuit: Circuit was run
+        """
+        self.logger.debug("Prepare backend data started")
+
+        required_qubit_amount = self._get_qubit_amount(circuit)
+        self.logger.info(
+                f"Qubit amount required for circuit: {required_qubit_amount}")
+
+        device_selection = DeviceSelection(required_qubit_amount,
+                                           self.device_id,
+                                           self.authentication.user_token,
+                                           self.device_selection_url,
+                                           self.project_header,
+                                           self.workspace_header)
+
+        self.backend_information = device_selection.select()
+        self.backend_information.authentication = self.invoke_authentication
+        self.logger.debug(
+                f"Selected backend: deviceName={self.backend_information.device_name}, provider_tag={self.backend_information.provider_tag}")
+
+    @abstractmethod
+    def _export_circuit(self, circuit):
+        """
+
+        @param circuit: Circuit was exported
+        """
+
+        raise NotImplementedError(
+                '_export_circuit() method must be implemented')
+
+    @abstractmethod
+    def _create_provider(self, ):
+        """
+        Create a provider with ProviderFactory
+        """
+
+        raise NotImplementedError(
+                '_create_provider() method must be implemented')
+
+    @abstractmethod
+    def _create_device(self, provider: Provider):
+        """
+        Create a device with DeviceFactory
+        """
+
+        raise NotImplementedError('_create_device() method must be implemented')
+
+    @abstractmethod
+    def _get_qubit_amount(self, circuit):
+        """
+        Get number qubit of circuit
+        """
+
+        raise NotImplementedError(
+                '_get_qubit_amount() method must be implemented')