quapp-braket 0.0.11.dev2__tar.gz → 0.0.11.dev4__tar.gz

{quapp_braket-0.0.11.dev2/quapp_braket.egg-info → quapp_braket-0.0.11.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-braket
-Version: 0.0.11.dev2
+Version: 0.0.11.dev4
 Summary: Quapp braket library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -19,12 +19,13 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: quapp-common==0.0.11.dev1
+Requires-Dist: quapp-common==0.0.11.dev2
 Requires-Dist: amazon-braket-sdk==1.83.0
 Requires-Dist: oqc-qcaas-client==3.7.0
 Requires-Dist: qiskit
 Requires-Dist: pytket
 Requires-Dist: pytket-braket
+Requires-Dist: pymorphous
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"
@@ -33,6 +34,15 @@ Requires-Dist: pip-tools; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Dynamic: license-file
 
-# qapp-braket
+# quapp-braket
 
-qapp-braket
+`quapp-braket` is a logging utility built on top of Loguru, designed to provide enhanced logging
+features such as context binding, colored output, and flexible formatting for quantum application
+projects.
+
+## Installation
+
+Install dependencies (if any) or the package via pip:
+
+```bash
+pip install quapp-braket

quapp_braket-0.0.11.dev4/README.md

@@ -0,0 +1,12 @@
+# quapp-braket
+
+`quapp-braket` is a logging utility built on top of Loguru, designed to provide enhanced logging
+features such as context binding, colored output, and flexible formatting for quantum application
+projects.
+
+## Installation
+
+Install dependencies (if any) or the package via pip:
+
+```bash
+pip install quapp-braket

{quapp_braket-0.0.11.dev2 → quapp_braket-0.0.11.dev4}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools>=70.1.0"]
+requires = ["setuptools>=70.1.0", "wheel>=0.45.1,<0.46.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-braket"
-version = "0.0.11.dev2"
+version = "0.0.11.dev4"
 description = "Quapp braket library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]
@@ -16,12 +16,13 @@ classifiers = [
 ]
 keywords = ["quapp", "quapp-braket", "braket", "quantum"]
 dependencies = [
-    "quapp-common==0.0.11.dev1",
+    "quapp-common==0.0.11.dev2",
     "amazon-braket-sdk==1.83.0",
     "oqc-qcaas-client==3.7.0",
     "qiskit",
     "pytket",
-    "pytket-braket"
+    "pytket-braket",
+    "pymorphous"
 ]
 requires-python = ">=3.7"
 

quapp_braket-0.0.11.dev4/quapp_braket/async_tasks/braket_circuit_export_task.py

@@ -0,0 +1,44 @@
+#  Quapp Platform Project
+#  braket_circuit_export_task.py
+#  Copyright © CITYNOW Co. Ltd.All rights reserved.
+
+from braket.circuits import Circuit
+from qiskit import QuantumCircuit
+from quapp_common.async_tasks.export_circuit_task import CircuitExportTask
+from quapp_common.config.logging_config import logger
+
+from quapp_braket.util.circuit_convert_utils import braket_to_qiskit
+
+logger = logger.bind(context='BraketCircuitExportTask')
+
+
+class BraketCircuitExportTask(CircuitExportTask):
+
+    def __init__(self, circuit_data_holder, backend_data_holder):
+        super().__init__(circuit_data_holder, backend_data_holder)
+
+    def _transpile_circuit(self) -> QuantumCircuit:
+        """
+        Transpiles the circuit held in the circuit_data_holder to a Qiskit quantum circuit.
+
+        This method checks if the circuit is an instance of Braket's Circuit. If so, it
+        converts it to a Qiskit QuantumCircuit using the braket_to_qiskit utility function.
+
+        Returns:
+            QuantumCircuit: Transpiled Qiskit quantum circuit.
+
+        Raises:
+            ValueError: If the circuit is not of type Circuit.
+        """
+        logger.info(f"Transpiling Braket circuit to Qiskit")
+        circuit = self.circuit_data_holder.circuit
+        if not circuit:
+            logger.error(f"Circuit is None")
+            raise ValueError("Circuit must not be None")
+
+        if isinstance(circuit, Circuit):
+            logger.debug(f"Converting Braket circuit")
+            return braket_to_qiskit(circuit)
+
+        logger.error(f"Invalid circuit type: {type(circuit)}")
+        raise ValueError(f"Expected Braket Circuit, got {type(circuit)}")

quapp_braket-0.0.11.dev4/quapp_braket/component/backend/braket_invocation.py

@@ -0,0 +1,127 @@
+#  Quapp Platform Project
+#  braket_invocation.py
+#  Copyright © CITYNOW Co. Ltd.All rights reserved.
+
+from braket.circuits import Circuit
+from quapp_common.component.backend.invocation import Invocation
+from quapp_common.config.logging_config import logger
+from quapp_common.config.thread_config import circuit_exporting_pool
+from quapp_common.data.async_task.circuit_export.backend_holder import BackendDataHolder
+from quapp_common.data.async_task.circuit_export.circuit_holder import CircuitDataHolder
+from quapp_common.data.request.invocation_request import InvocationRequest
+from quapp_common.model.provider.provider import Provider
+
+from ...async_tasks.braket_circuit_export_task import BraketCircuitExportTask
+from ...factory.braket_device_factory import create_device
+from ...factory.braket_provider_factory import create_provider
+
+logger = logger.bind(context='BraketInvocation')
+
+
+class BraketInvocation(Invocation):
+
+    def __init__(self, request_data: InvocationRequest):
+        super().__init__(request_data)
+
+    def _export_circuit(self, circuit):
+        """
+        Initiates the export of a quantum circuit using BraketCircuitExportTask.
+
+        This method creates a BraketCircuitExportTask with the provided circuit
+        and submits it to the circuit exporting pool for asynchronous execution.
+
+        Args:
+            circuit: The quantum circuit to be exported.
+
+        Raises:
+            ValueError: If circuit_export_url or backend_information is invalid.
+        """
+        logger.info("Exporting circuit")
+
+        if not self.circuit_export_url or not self.backend_information:
+            logger.error("Invalid circuit_export_url or backend_information")
+            raise ValueError("Circuit export URL and backend information must not be None")
+
+        circuit_export_task = BraketCircuitExportTask(
+            circuit_data_holder=CircuitDataHolder(circuit, self.circuit_export_url),
+            backend_data_holder=BackendDataHolder(
+                self.backend_information, self.authentication.user_token
+            )
+        )
+        circuit_exporting_pool.submit(circuit_export_task.do)
+        logger.debug("Circuit export task submitted")
+
+    def _create_provider(self):
+        """
+        Creates a provider instance using the specified backend information.
+
+        This method utilizes the `create_provider` function to generate a provider
+        based on the provider tag, SDK, and authentication details from the
+        backend information.
+
+        Returns:
+            Provider: An instance of the provider created using the specified details.
+
+        Raises:
+            ValueError: If backend_information or authentication is invalid.
+        """
+        logger.info("Creating provider")
+
+        provider = create_provider(
+            provider_type=self.backend_information.provider_tag,
+            sdk=self.sdk,
+            authentication=self.backend_information.authentication
+        )
+        logger.debug("Provider created")
+        return provider
+
+    def _create_device(self, provider: Provider):
+        """
+        Creates a device instance using the provider and specified backend information.
+
+        This method utilizes the `create_device` function to generate a device
+        based on the provider instance, device name, authentication details, and
+        SDK from the backend information.
+
+        Args:
+            provider (Provider): An instance of the provider used to create the device.
+
+        Returns:
+            CustomDevice: An instance of the device created using the specified details.
+
+        Raises:
+            ValueError: If backend_information or authentication is invalid.
+        """
+        logger.info("Creating device")
+
+        device = create_device(
+            provider=provider,
+            device_specification=self.backend_information.device_name,
+            authentication=self.backend_information.authentication,
+            sdk=self.sdk
+        )
+        logger.debug("Device created")
+        return device
+
+    def _get_qubit_amount(self, circuit):
+        """
+        Retrieves the number of qubits used in the given quantum circuit.
+
+        Args:
+            circuit: The quantum circuit for which to retrieve the qubit count.
+
+        Returns:
+            int: The number of qubits used in the circuit.
+
+        Raises:
+            ValueError: If the circuit is not of type Circuit.
+        """
+        logger.info("Retrieving qubit count")
+
+        if isinstance(circuit, Circuit):
+            qubit_count = circuit.qubit_count
+            logger.debug(f"Qubit count: {qubit_count}")
+            return qubit_count
+
+        logger.error(f"Invalid circuit type: {type(circuit)}")
+        raise ValueError(f"Invalid circuit type: {type(circuit)}")

quapp_braket-0.0.11.dev4/quapp_braket/factory/braket_device_factory.py

@@ -0,0 +1,68 @@
+#  Quapp Platform Project
+#  braket_device_factory.py
+#  Copyright © CITYNOW Co. Ltd.All rights reserved.
+
+from quapp_common.config.logging_config import logger
+from quapp_common.enum.provider_tag import ProviderTag
+from quapp_common.enum.sdk import Sdk
+from quapp_common.model.provider.provider import Provider
+
+from quapp_braket.constant.authentication_const import BUCKET_NAME, PREFIX
+from quapp_braket.model.device.aws_braket_device import AwsBraketDevice
+from quapp_braket.model.device.oqc_cloud_device import OqcCloudDevice
+from quapp_braket.model.device.qapp_braket_device import QuappBraketDevice
+
+logger = logger.bind(context='BraketDeviceFactory')
+
+
+def create_device(provider: Provider, device_specification: str, authentication: dict, sdk: Sdk):
+    logger.info("Creating device")
+
+    # Validate inputs
+    if not isinstance(provider, Provider):
+        logger.error("Invalid provider: %s", type(provider).__name__)
+        raise ValueError(f"provider must be a Provider instance, got {type(provider).__name__}")
+    if not isinstance(device_specification, str):
+        logger.error("Invalid device_specification: %s", type(device_specification).__name__)
+        raise ValueError(
+            f"device_specification must be a string, got {type(device_specification).__name__}")
+    if not isinstance(sdk, Sdk):
+        logger.error("Invalid sdk: %s", type(sdk).__name__)
+        raise ValueError(f"sdk must be an Sdk instance, got {type(sdk).__name__}")
+
+    provider_type = ProviderTag.resolve(provider.get_provider_type().value)
+    logger.debug(f"Resolved provider_type: {provider_type}")
+
+    if provider_type == ProviderTag.QUAO_QUANTUM_SIMULATOR and sdk == Sdk.BRAKET:
+        logger.info("Creating QuappBraketDevice")
+        device = QuappBraketDevice(provider, device_specification)
+        logger.info("QuappBraketDevice created successfully")
+        return device
+
+    if provider_type == ProviderTag.AWS_BRAKET:
+        if not isinstance(authentication, dict):
+            logger.error(f"Invalid authentication: {type(authentication).__name__}")
+            raise ValueError(
+                f"authentication must be a dictionary, got {type(authentication).__name__}")
+
+        bucket = authentication.get(BUCKET_NAME)
+        prefix = authentication.get(PREFIX)
+        if bucket is None or prefix is None:
+            logger.error("Missing AWS authentication details - bucket: %s, prefix: %s", bucket,
+                         prefix)
+            raise ValueError(
+                f"AWS authentication requires {BUCKET_NAME} and {PREFIX}, got bucket={bucket}, prefix={prefix}")
+        logger.debug(f"AWS authentication details - bucket: {bucket}, prefix: {prefix}")
+        logger.info("Creating AwsBraketDevice")
+        device = AwsBraketDevice(provider, device_specification, bucket, prefix)
+        logger.info("AwsBraketDevice created successfully")
+        return device
+
+    if provider_type == ProviderTag.OQC_CLOUD:
+        logger.info("Creating OqcCloudDevice")
+        device = OqcCloudDevice(provider, device_specification)
+        logger.info("OqcCloudDevice created successfully")
+        return device
+
+    logger.error(f"Unsupported device for provider_type: {provider_type}, sdk: {sdk}")
+    raise ValueError(f"Unsupported device for provider_type={provider_type}, sdk={sdk}")

quapp_braket-0.0.11.dev4/quapp_braket/factory/braket_handler_factory.py

@@ -0,0 +1,42 @@
+#  Quapp Platform Project
+#  braket_handler_factory.py
+#  Copyright © CITYNOW Co. Ltd.All rights reserved.
+
+from quapp_common.config.logging_config import logger
+from quapp_common.factory.handler_factory import HandlerFactory
+from quapp_common.handler.handler import Handler
+
+from ..handler.invocation_handler import InvocationHandler
+from ..handler.job_fetching_handler import JobFetchingHandler
+from ..util.provider_job_utils import is_valid_job_arn, is_valid_quantum_task_arn
+
+logger = logger.bind(context='BraketHandlerFactory')
+
+
+class BraketHandlerFactory(HandlerFactory):
+
+    @staticmethod
+    def create_handler(event, circuit_preparation_fn, post_processing_fn) -> Handler:
+        logger.info("create_handler() started")
+
+        request_data = event.json()
+        logger.debug(f"Parsed request_data: {request_data}")
+
+        provider_job_id = request_data.get('providerJobId')
+        logger.debug(f"providerJobId: {provider_job_id}")
+
+        if provider_job_id is None:
+            logger.debug("No providerJobId found, returning InvocationHandler")
+            return InvocationHandler(
+                request_data=request_data,
+                circuit_preparation_fn=circuit_preparation_fn,
+                post_processing_fn=post_processing_fn,
+            )
+
+        if is_valid_quantum_task_arn(provider_job_id) or is_valid_job_arn(provider_job_id):
+            logger.info("Valid providerJobId found, returning JobFetchingHandler")
+            return JobFetchingHandler(request_data=request_data,
+                                      post_processing_fn=post_processing_fn)
+
+        logger.error(f"Invalid providerJobId: {provider_job_id}")
+        raise ValueError(f"Invalid providerJobId: {provider_job_id}")

quapp_braket-0.0.11.dev4/quapp_braket/factory/braket_provider_factory.py

@@ -0,0 +1,45 @@
+#  Quapp Platform Project
+#  braket_provider_factory.py
+#  Copyright © CITYNOW Co. Ltd.All rights reserved.
+
+from quapp_common.config.logging_config import logger
+from quapp_common.enum.provider_tag import ProviderTag
+from quapp_common.enum.sdk import Sdk
+
+from ..constant.authentication_const import ACCESS_KEY, ACCESS_TOKEN, REGION_NAME, SECRET_KEY, URL
+from ..model.provider.aws_braket_provider import AwsBraketProvider
+from ..model.provider.oqc_cloud_provider import OqcCloudProvider
+from ..model.provider.qapp_braket_provider import QuappBraketProvider
+from ..util.braket_utils import verify_credentials
+
+logger = logger.bind(context='BraketProviderFactory')
+
+
+def create_provider(provider_type: ProviderTag, sdk: Sdk, authentication: dict):
+    logger.info("create_provider()")
+
+    if ProviderTag.QUAO_QUANTUM_SIMULATOR.__eq__(provider_type) and Sdk.BRAKET.__eq__(sdk):
+        logger.debug("Create QuappBraketProvider")
+
+        return QuappBraketProvider()
+
+    if ProviderTag.AWS_BRAKET.__eq__(provider_type):
+        logger.debug(f"Create AwsBraketProvider with authentication keys: "
+                     f"ACCESS_KEY={'present' if ACCESS_KEY in authentication else 'missing'}, "
+                     f"SECRET_KEY={'present' if SECRET_KEY in authentication else 'missing'}, "
+                     f"REGION_NAME={authentication.get(REGION_NAME)}")
+
+        verify_credentials(authentication)
+        return AwsBraketProvider(authentication.get(ACCESS_KEY), authentication.get(SECRET_KEY),
+                                 authentication.get(REGION_NAME), )
+
+    if ProviderTag.OQC_CLOUD.__eq__(provider_type):
+        logger.debug(f"Create OqcCloudProvider with URL={authentication.get(URL)}, "
+                     f"ACCESS_TOKEN={'present' if ACCESS_TOKEN in authentication else 'missing'}")
+        return OqcCloudProvider(
+            authentication.get(URL),
+            authentication.get(ACCESS_TOKEN)
+        )
+
+    logger.error(f"Unsupported provider: {provider_type}")
+    raise ValueError("Unsupported provider!")

quapp_braket-0.0.11.dev4/quapp_braket/handler/invocation_handler.py

@@ -0,0 +1,32 @@
+#  Quapp Platform Project
+#  invocation_handler.py
+#  Copyright © CITYNOW Co. Ltd.All rights reserved.
+
+from quapp_common.config.logging_config import logger
+from quapp_common.data.request.invocation_request import InvocationRequest
+from quapp_common.handler.handler import Handler
+
+from ..component.backend.braket_invocation import BraketInvocation
+
+logger = logger.bind(context='InvocationHandler')
+
+
+class InvocationHandler(Handler):
+
+    def __init__(self, request_data: dict,
+                 circuit_preparation_fn,
+                 post_processing_fn):
+        super().__init__(request_data, post_processing_fn)
+        self.circuit_preparation_fn = circuit_preparation_fn
+
+    def handle(self):
+        logger.debug(f"Creating InvocationRequest with data: {self.request_data.keys()}")
+        invocation_request = InvocationRequest(self.request_data)
+
+        logger.debug("Initializing BraketInvocation backend")
+        backend = BraketInvocation(invocation_request)
+
+        logger.debug(f"Submitting job with circuit_preparation_fn={self.circuit_preparation_fn}, "
+                     f"post_processing_fn={self.post_processing_fn}")
+        backend.submit_job(circuit_preparation_fn=self.circuit_preparation_fn,
+                           post_processing_fn=self.post_processing_fn)

{quapp_braket-0.0.11.dev2/qapp_braket → quapp_braket-0.0.11.dev4/quapp_braket}/model/device/aws_braket_device.py

@@ -1,13 +1,17 @@
-"""
-    QuaO Project aws_braket_device.py Copyright © CITYNOW Co. Ltd. All rights reserved.
-"""
+#  Quapp Platform Project
+#  aws_braket_device.py
+#  Copyright © CITYNOW Co. Ltd.All rights reserved.
+
 from dateutil.parser import parse
+from quapp_common.config.logging_config import logger
+from quapp_common.data.device.circuit_running_option import CircuitRunningOption
+from quapp_common.enum.status.job_status import JobStatus
+from quapp_common.model.device.custom_device import CustomDevice
+from quapp_common.model.provider.provider import Provider
+
+from quapp_braket.constant.job_result_const import CREATED_AT, ENDED_AT, SHOTS, TASK_METADATA
 
-from qapp_common.config.logging_config import logger
-from qapp_common.data.device.circuit_running_option import CircuitRunningOption
-from qapp_common.enum.status.job_status import JobStatus
-from qapp_common.model.device.custom_device import CustomDevice
-from qapp_common.model.provider.provider import Provider
+logger = logger.bind(context='AwsBraketDevice')
 
 
 class AwsBraketDevice(CustomDevice):
@@ -20,41 +24,41 @@ class AwsBraketDevice(CustomDevice):
         self.s3_folder = (s3_bucket_name, s3_prefix)
 
     def _produce_histogram_data(self, job_result) -> dict | None:
-        logger.debug("[AwsBraketDevice] _produce_histogram_data()")
+        logger.debug("_produce_histogram_data()")
 
         return dict(job_result.measurement_counts)
 
     def _get_provider_job_id(self, job) -> str:
-        logger.debug("[AwsBraketDevice] _get_provider_job_id()")
+        logger.debug("_get_provider_job_id()")
 
         return job.id
 
     def _get_job_status(self, job) -> str:
-        logger.debug("[AwsBraketDevice] _get_job_status()")
+        logger.debug("_get_job_status()")
 
         job_state = job.state()
-        logger.debug("[AwsBraketDevice] job status: {0} ".format(job_state))
+        logger.debug(f"job status: {job_state}")
 
         if JobStatus.COMPLETED.value.__eq__(job_state):
             job_state = JobStatus.DONE.value
         return job_state
 
     def _calculate_execution_time(self, job_result):
-        logger.debug("[AwsBraketDevice] _calculate_execution_time()")
+        logger.debug("_calculate_execution_time()")
 
-        if "task_metadata" not in job_result:
+        if TASK_METADATA not in job_result:
             return
 
-        task_metadata = job_result["task_metadata"]
+        task_metadata = job_result[TASK_METADATA]
 
         if task_metadata is None \
                 or not bool(task_metadata) \
-                or "createdAt" not in task_metadata \
-                or "endedAt" not in task_metadata:
+                or CREATED_AT not in task_metadata \
+                or ENDED_AT not in task_metadata:
             return
 
-        created_at = task_metadata["createdAt"]
-        ended_at = task_metadata["endedAt"]
+        created_at = task_metadata[CREATED_AT]
+        ended_at = task_metadata[ENDED_AT]
 
         if created_at is None or ended_at is None:
             return
@@ -66,16 +70,15 @@ class AwsBraketDevice(CustomDevice):
 
         self.execution_time = offset.total_seconds()
 
-        logger.debug("[AwsBraketDevice] Execution time calculation was: {0} seconds"
-                     .format(self.execution_time))
+        logger.debug(f"Execution time calculation was: {self.execution_time} seconds")
 
     def _get_job_result(self, job):
-        logger.debug("[AwsBraketDevice] _get_job_result()")
+        logger.debug("_get_job_result()")
 
         return job.result()
 
     def _create_job(self, circuit, options: CircuitRunningOption):
-        logger.debug("[AwsBraketDevice] _create_job()")
+        logger.debug("_create_job()")
 
         job = self.device.run(task_specification=circuit,
                               s3_destination_folder=self.s3_folder,
@@ -83,7 +86,7 @@ class AwsBraketDevice(CustomDevice):
         return job
 
     def _is_simulator(self) -> bool:
-        logger.debug("[AwsBraketDevice] _is_simulator()")
+        logger.debug("_is_simulator()")
 
         return True
 
@@ -103,7 +106,7 @@ class AwsBraketDevice(CustomDevice):
         Returns:
             int | None: The number of shots if available; otherwise, None.
         """
-        logger.debug("[AwsBraketDevice] _get_shots()")
+        logger.debug("_get_shots()")
 
-        return job_result.task_metadata.shots if hasattr(job_result, 'task_metadata') and hasattr(
-            job_result.task_metadata, 'shots') else None
+        return job_result.task_metadata.shots if hasattr(job_result, TASK_METADATA) and hasattr(
+            job_result.task_metadata, SHOTS) else None