quapp-common 0.0.11.dev1__tar.gz

quapp_common-0.0.11.dev1/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

quapp_common-0.0.11.dev1/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: quapp-common
+Version: 0.0.11.dev1
+Summary: Quapp common library supporting Quapp Platform for Quantum Computing
+Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
+License: The MIT License (MIT)
+        Copyright © CITYNOW Co. Ltd. All rights reserved.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Project-URL: Homepage, https://citynow.asia/
+Keywords: quapp,quapp-common,quantum
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: loguru
+Requires-Dist: requests
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pylatexenc
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pip-tools; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# qapp-common
+
+# changes
+- Add pennylane in enum sdk
+- Change function in `device.py` to protected to override in pennylane sdk
+
+

quapp_common-0.0.11.dev1/README.md

@@ -0,0 +1,7 @@
+# qapp-common
+
+# changes
+- Add pennylane in enum sdk
+- Change function in `device.py` to protected to override in pennylane sdk
+
+

quapp_common-0.0.11.dev1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quapp-common"
+version = "0.0.11.dev1"
+description = "Quapp common library supporting Quapp Platform for Quantum Computing"
+readme = "README.md"
+authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = ["quapp", "quapp-common", "quantum"]
+dependencies = [
+    "loguru",
+    "requests",
+    "numpy",
+    "matplotlib",
+    "pylatexenc"
+]
+requires-python = ">=3.7"
+
+[project.optional-dependencies]
+dev = ["black", "bumpver", "isort", "pip-tools", "pytest"]
+
+[project.urls]
+Homepage = "https://citynow.asia/"

quapp_common-0.0.11.dev1/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

quapp_common-0.0.11.dev1/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')

quapp_common-0.0.11.dev1/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)

quapp_common-0.0.11.dev1/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')