quapp-common 0.0.11.dev1__py3-none-any.whl

qapp_common/async_tasks/async_task.py

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

qapp_common/async_tasks/export_circuit_task.py

@@ -0,0 +1,119 @@
+"""
+    QApp Platform Project export_circuit.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from io import BytesIO
+
+import requests
+
+from .async_task import AsyncTask
+from ..data.async_task.circuit_export.backend_holder import BackendDataHolder
+from ..data.async_task.circuit_export.circuit_holder import CircuitDataHolder
+from ..config.logging_config import logger
+from ..enum.media_type import MediaType
+from ..util.file_utils import FileUtils
+from ..util.http_utils import HttpUtils
+
+
+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
+
+    def do(self):
+        """
+          Export circuit to svg file then send to QuaO server for saving
+        """
+        logger.debug("[Circuit export] Start")
+
+        circuit_export_url = self.circuit_data_holder.export_url
+
+        if circuit_export_url is None or len(circuit_export_url) < 1:
+            return
+
+        figure_buffer = self.__convert()
+
+        io_buffer_value, content_type = self.__determine_zip(figure_buffer=figure_buffer)
+
+        self.__send(io_buffer_value=io_buffer_value,
+                    content_type=content_type)
+
+    def __convert(self):
+        """
+
+        @return:
+        """
+        logger.debug("[Circuit export] Preparing circuit figure...")
+        transpiled_circuit = self._transpile_circuit()
+        circuit_figure = transpiled_circuit.draw(output='mpl', fold=-1)
+
+        logger.debug("[Circuit export] Converting circuit figure to svg file...")
+        figure_buffer = BytesIO()
+        circuit_figure.savefig(figure_buffer, format='svg', bbox_inches='tight')
+
+        return figure_buffer
+
+    @staticmethod
+    def __determine_zip(figure_buffer):
+        """
+
+        @param figure_buffer:
+        @return:
+        """
+        buffer_value = figure_buffer.getvalue()
+        content_type = MediaType.SVG_XML
+
+        logger.debug("[Circuit export] Checking max file size")
+        estimated_file_size = len(buffer_value)
+
+        if estimated_file_size > CircuitExportTask.MAX_CIRCUIT_IMAGE_SIZE:
+            logger.debug("[Circuit export] 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):
+        """
+
+        @param io_buffer_value:
+        @param content_type:
+        """
+        url = self.circuit_data_holder.export_url
+
+        logger.debug(
+            "[Circuit export] Sending circuit svg image to [{0}] with POST method ...".format(
+                url))
+
+        payload = {'circuit': (
+            'circuit_image.svg',
+            io_buffer_value,
+            content_type.value)}
+
+        response = requests.post(
+            url=url,
+            headers=HttpUtils.create_bearer_header(self.backend_data_holder.user_token),
+            files=payload)
+
+        if response.ok:
+            logger.debug("Sending request to QuaO backend successfully!")
+        else:
+            logger.debug("Sending request to QuaO backend failed with status {0}!".format(
+                response.status_code))
+
+        logger.debug("[Circuit export] Finish")
+
+    def _transpile_circuit(self):
+        """
+
+        @return: Transpiled circuit
+        """
+
+        raise NotImplemented('[CircuitExportTask] __transpile_circuit() method must be implemented')

qapp_common/async_tasks/post_processing_task.py

@@ -0,0 +1,59 @@
+"""
+    QApp Platform Project post_processing_task.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from .async_task import AsyncTask
+from ..component.callback.update_job_metadata import update_job_metadata
+from ..config.logging_config import logger
+from ..data.promise.post_processing_promise import PostProcessingPromise
+from ..data.response.job_response import JobResponse
+from ..enum.media_type import MediaType
+from ..enum.status.job_status import JobStatus
+from ..enum.status.status_code import StatusCode
+from ..util.json_parser_utils import JsonParserUtils
+
+
+class PostProcessingTask(AsyncTask):
+    def __init__(self,
+                 post_processing_fn,
+                 promise: PostProcessingPromise):
+        self.post_processing_fn = post_processing_fn
+        self.promise = promise
+
+    def do(self):
+        """
+           Execute post_processing and send to backend
+        """
+
+        job_response = JobResponse(
+            authentication=self.promise.authentication,
+            project_header=self.promise.project_header,
+            job_status=JobStatus.DONE.value,
+            status_code=StatusCode.DONE)
+
+        update_job_metadata(job_response=job_response,
+                            callback_url=self.promise.callback_url.on_start)
+
+        job_response.content_type = MediaType.APPLICATION_JSON
+
+        try:
+
+            logger.info("Execute post_processing ...")
+            job_result_post_processing = self.post_processing_fn(self.promise.job_result)
+
+            logger.debug("Parsing job result....")
+            print(job_result_post_processing)
+            job_response.job_result = JsonParserUtils.parse(job_result_post_processing)
+
+            update_job_metadata(job_response=job_response,
+                                callback_url=self.promise.callback_url.on_done)
+
+        except Exception as exception:
+            job_response.job_result = {
+                "error": "Error when execute post_processing(): ",
+                "exception": str(exception),
+            }
+            job_response.status_code = StatusCode.ERROR
+            job_response.job_status = JobStatus.ERROR.value
+
+            update_job_metadata(job_response=job_response,
+                                callback_url=self.promise.callback_url.on_error)

qapp_common/component/backend/invocation.py

@@ -0,0 +1,255 @@
+"""
+    QApp Platform Project backend.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from abc import abstractmethod, ABC
+
+from ..callback.update_job_metadata import update_job_metadata
+from ...component.device.device_selection import DeviceSelection
+from ...config.logging_config import 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.job_response import JobResponse
+from ...data.response.project_header import ProjectHeader
+from ...enum.invocation_step import InvocationStep
+from ...enum.media_type import MediaType
+from ...enum.sdk import Sdk
+from ...enum.status.job_status import JobStatus
+from ...enum.status.status_code import StatusCode
+from ...model.provider.provider import Provider
+
+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: ProjectHeader = request_data.project_header
+        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
+
+    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
+        """
+        logger.debug("[Invocation] Invoke job")
+
+        circuit = self.__pre_execute(circuit_preparation_fn)
+
+        if circuit is None:
+            return
+
+        self.__execute(circuit, post_processing_fn)
+
+    def __pre_execute(self, circuit_preparation_fn):
+        """
+
+        @param circuit_preparation_fn: Circuit preparation function
+        """
+        circuit = self.__prepare_circuit(circuit_preparation_fn)
+
+        if circuit is None:
+            return None
+
+        try:
+            self.__prepare_backend_data(circuit)
+
+        except Exception as exception:
+            job_response = JobResponse(
+                status_code=StatusCode.ERROR,
+                authentication=self.authentication,
+                project_header=self.project_header,
+                job_result={"error": str(exception)},
+                content_type=MediaType.APPLICATION_JSON,
+                job_status=JobStatus.ERROR.value,
+            )
+
+            update_job_metadata(
+                job_response=job_response,
+                callback_url=self.callback_dict.get(
+                    InvocationStep.PREPARATION
+                ).on_error,
+            )
+
+        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
+        """
+
+        logger.debug("[Invocation] Execute job")
+
+        try:
+            if self.backend_information is None:
+                raise Exception("Backend is not found")
+
+            device_name = self.backend_information.device_name
+            provider_tag = self.backend_information.provider_tag
+            backend_authentication = self.backend_information.authentication
+
+            logger.debug(
+                "[Invocation] Execute job with provider tag: {0}".format(
+                    provider_tag.value
+                )
+            )
+
+            provider = self._create_provider()
+
+            logger.debug(
+                "[Invocation] Execute job with device name: {0}".format(device_name)
+            )
+            device = self._create_device(provider)
+
+        except Exception as exception:
+            job_response = JobResponse(
+                job_status=JobStatus.ERROR.value,
+                content_type=MediaType.APPLICATION_JSON,
+                status_code=StatusCode.ERROR,
+                authentication=self.authentication,
+                project_header=self.project_header,
+                job_result={"error": str(exception)},
+            )
+            update_job_metadata(
+                job_response=job_response,
+                callback_url=self.callback_dict.get(InvocationStep.EXECUTION).on_error,
+            )
+
+            return
+
+        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,
+        )
+
+    def __prepare_circuit(self, circuit_preparation_fn):
+        """
+
+        @param circuit_preparation_fn: Circuit preparation function
+        @return: circuit
+        """
+        logger.debug("[Invocation] Prepare circuit")
+
+        job_response = JobResponse(
+            status_code=StatusCode.DONE,
+            authentication=self.authentication,
+            project_header=self.project_header,
+        )
+        update_job_metadata(
+            job_response=job_response,
+            callback_url=self.callback_dict.get(InvocationStep.PREPARATION).on_start,
+        )
+
+        try:
+            circuit = circuit_preparation_fn(self.input)
+
+            if circuit is None:
+                raise Exception("Invalid circuit")
+
+            update_job_metadata(
+                job_response=job_response,
+                callback_url=self.callback_dict.get(InvocationStep.PREPARATION).on_done,
+            )
+
+            return circuit
+
+        except Exception as exception:
+            job_response.job_status = JobStatus.ERROR.value
+            job_response.content_type = MediaType.APPLICATION_JSON
+            job_response.status_code = StatusCode.ERROR
+            job_response.job_result = {"error": str(exception)}
+
+            update_job_metadata(
+                job_response=job_response,
+                callback_url=self.callback_dict.get(
+                    InvocationStep.PREPARATION
+                ).on_error,
+            )
+
+            return None
+
+    def __prepare_backend_data(self, circuit):
+        """
+
+        @param circuit: Circuit was run
+        """
+
+        required_qubit_amount = self._get_qubit_amount(circuit)
+
+        device_selection = DeviceSelection(
+            required_qubit_amount,
+            self.device_id,
+            self.authentication.user_token,
+            self.device_selection_url,
+        )
+
+        self.backend_information = device_selection.select()
+        logger.info("before")
+        logger.info(self.backend_information.authentication)
+        self.backend_information.authentication = self.invoke_authentication
+        logger.info("after")
+        logger.info(self.backend_information.authentication)
+
+    @abstractmethod
+    def _export_circuit(self, circuit):
+        """
+
+        @param circuit: Circuit was exported
+        """
+
+        raise NotImplemented('[Invocation] _export_circuit() method must be implemented')
+
+    @abstractmethod
+    def _create_provider(self, ):
+        """
+        Create provider with ProviderFactory
+        """
+
+        raise NotImplemented('[Invocation] _create_provider() method must be implemented')
+
+    @abstractmethod
+    def _create_device(self, provider: Provider):
+        """
+        Create device with DeviceFactory
+        """
+
+        raise NotImplemented('[Invocation] _create_device() method must be implemented')
+
+    @abstractmethod
+    def _get_qubit_amount(self, circuit):
+        """
+        Get number qubit of circuit
+        """
+
+        raise NotImplemented('[Invocation] _get_qubit_amount() method must be implemented')

qapp_common/component/backend/job_fetching.py

@@ -0,0 +1,247 @@
+"""
+    QApp Platform Project job_fetching.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from abc import ABC, abstractmethod
+from typing import Any
+
+from ..callback.update_job_metadata import update_job_metadata
+from ...async_tasks.post_processing_task import PostProcessingTask
+from ...config.thread_config import circuit_running_pool
+from ...data.callback.callback_url import CallbackUrl
+from ...data.promise.post_processing_promise import PostProcessingPromise
+from ...data.request.job_fetching_request import JobFetchingRequest
+from ...data.response.authentication import Authentication
+from ...data.response.job_response import JobResponse
+from ...data.response.project_header import ProjectHeader
+from ...enum.invocation_step import InvocationStep
+from ...config.logging_config import logger
+from ...enum.media_type import MediaType
+from ...enum.status.job_status import JobStatus
+from ...enum.status.status_code import StatusCode
+from ...util.json_parser_utils import JsonParserUtils
+from ...util.response_utils import ResponseUtils
+
+
+class JobFetching(ABC):
+    def __init__(self, request_data: JobFetchingRequest):
+        self.provider_authentication: dict = request_data.provider_authentication
+        self.provider_job_id: str = request_data.provider_job_id
+        self.backend_authentication: Authentication = request_data.authentication
+        self.project_header: ProjectHeader = request_data.project_header
+        self.callback_dict: dict = {
+            InvocationStep.EXECUTION: request_data.execution,
+            InvocationStep.ANALYSIS: request_data.analysis,
+            InvocationStep.FINALIZATION: request_data.finalization
+        }
+
+    def fetch(self, post_processing_fn):
+        """
+
+        @param post_processing_fn:
+        @return:
+        """
+        logger.debug("[Fetching] Fetch job")
+
+        job_response = JobResponse(
+            provider_job_id=self.provider_job_id,
+            authentication=self.backend_authentication,
+            project_header=self.project_header,
+            status_code=StatusCode.DONE)
+
+        try:
+            provider = self._collect_provider()
+
+            job = self._retrieve_job(provider)
+            job_status = self._get_job_status(job)
+            original_job_result = self._get_job_result(job)
+
+            job_response.job_status = job_status
+
+            if JobStatus.DONE.value.__eq__(job_response.job_status):
+                circuit_running_pool.submit(self.__handle_job_result,
+                                            original_job_result,
+                                            job_response,
+                                            self.callback_dict,
+                                            post_processing_fn)
+
+                update_job_metadata(
+                    job_response=job_response,
+                    callback_url=self.callback_dict.get(InvocationStep.EXECUTION).on_done)
+
+            elif JobStatus.ERROR.value.__eq__(job_response.job_status):
+                job_response.job_result = JsonParserUtils.parse(original_job_result)
+
+                update_job_metadata(
+                    job_response=job_response,
+                    callback_url=self.callback_dict.get(InvocationStep.EXECUTION).on_error)
+
+            else:
+                job_response.status_code = StatusCode.POLLING
+
+        except Exception as exception:
+            logger.debug("Exception when fetch job with provider_job_id {0}: {1}".format(
+                self.provider_job_id, str(exception)))
+
+            job_response.job_result = {
+                "error": "Exception when fetch job with provider_job_id {0}: {1}".format(
+                    self.provider_job_id, str(exception)),
+                "exception": str(exception),
+            }
+            job_response.status_code = StatusCode.ERROR
+            job_response.job_status = JobStatus.ERROR.value
+
+            update_job_metadata(
+                job_response=job_response,
+                callback_url=self.callback_dict.get(InvocationStep.EXECUTION).on_error)
+
+        return ResponseUtils.generate_response(job_response)
+
+    def __handle_job_result(self,
+                            original_job_result,
+                            job_response: JobResponse,
+                            callback_dict: dict,
+                            post_processing_fn):
+        """
+        Fetch job from IBM Quantum
+
+        @return: Job status
+        """
+
+        job_response = self.__on_analysis(
+            callback_url=callback_dict.get(InvocationStep.ANALYSIS),
+            job_response=job_response,
+            original_job_result=original_job_result)
+
+        if job_response is None:
+            return
+
+        self.__on_finalization(post_processing_fn=post_processing_fn,
+                               callback_url=callback_dict.get(InvocationStep.FINALIZATION),
+                               original_job_result=original_job_result)
+
+    def __on_analysis(self,
+                      callback_url: CallbackUrl,
+                      job_response: JobResponse,
+                      original_job_result):
+        """
+
+        @param callback_url:
+        @param job_response:
+        @param original_job_result:
+        @return:
+        """
+        logger.debug("[Fetching] On analysis")
+
+        update_job_metadata(job_response=job_response,
+                            callback_url=callback_url.on_start)
+
+        try:
+            job_response.content_type = MediaType.APPLICATION_JSON
+
+            job_response.job_histogram = self.__produce_histogram_data(original_job_result)
+
+            job_result_parse = JsonParserUtils.parse(original_job_result.result())
+            
+            job_response.execution_time = self.__get_execution_time(original_job_result)
+
+            update_job_metadata(
+                job_response=job_response,
+                callback_url=callback_url.on_done)
+
+            return job_response
+
+        except Exception as exception:
+            logger.error("Exception when analyst job result with provider_job_id {0}: {1}".format(
+                self.provider_job_id, str(exception)))
+
+            job_response.status_code = StatusCode.ERROR
+            job_response.job_status = JobStatus.ERROR.value
+            job_response.job_result = {
+                "error": "Exception when analyst job result with provider_job_id {0}".format(
+                    self.provider_job_id),
+                "exception": str(exception),
+            }
+
+            update_job_metadata(
+                job_response=job_response,
+                callback_url=callback_url.on_error)
+
+            return None
+
+    def __on_finalization(self,
+                          post_processing_fn,
+                          callback_url: CallbackUrl,
+                          original_job_result):
+        """
+
+        @param post_processing_fn:
+        @param callback_url:
+        @param original_job_result:
+        """
+        logger.debug("[Fetching] On finalization")
+
+        promise = PostProcessingPromise(callback_url=callback_url,
+                                        authentication=self.backend_authentication,
+                                        job_result=original_job_result.result(),
+                                        project_header=self.project_header)
+
+        PostProcessingTask(post_processing_fn=post_processing_fn,
+                           promise=promise).do()
+
+    @staticmethod
+    def __produce_histogram_data(job_result) -> Any | None:
+        """
+
+        @param job_result:
+        @return:
+        """
+        logger.debug("[Fetching] Produce histogram")
+
+        try:
+            histogram_data = job_result.result()[0].data.meas.get_counts()
+
+        except Exception as e:
+            logger.debug("[QiskitDevice] Can't produce histogram with error: {0}".format(str(e)))
+            histogram_data = None
+
+        return histogram_data
+
+    @staticmethod
+    def __get_execution_time(job_result):
+        """
+
+        @param job_result:
+        @return:
+        """
+        return job_result.usage()
+    @abstractmethod
+    def _collect_provider(self, ):
+        """
+        Create provider with ProviderFactory
+        """
+
+        raise NotImplemented('[Invocation] _create_provider() method must be implemented')
+
+    @abstractmethod
+    def _retrieve_job(self, provider):
+        """
+        Retrieve job from provider
+        """
+
+        raise NotImplemented('[Invocation] _retrieve_job() method must be implemented')
+
+    @abstractmethod
+    def _get_job_status(self, job):
+        """
+        Get job status
+        """
+
+        raise NotImplemented('[Invocation] _get_job_status() method must be implemented')
+
+    @abstractmethod
+    def _get_job_result(self, job):
+        """
+        Get job result
+        """
+
+        raise NotImplemented('[Invocation] _get_job_result() method must be implemented')