quapp-dwave-ocean 0.0.1.dev2__py3-none-any.whl

quapp_dwave_ocean/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.4.9"
+
+from .factory.d_wave_handler_factory import DWaveHandlerFactory

quapp_dwave_ocean/async_tasks/d_wave_ocean_circuit_export_task.py

@@ -0,0 +1,228 @@
+#  Quapp Platform Project
+#  d_wave_ocean_circuit_export_task.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+from io import BytesIO
+
+import numpy as np
+import requests
+from dimod import BinaryQuadraticModel
+from matplotlib import pyplot as plt
+from quapp_common.async_tasks.export_circuit_task import CircuitExportTask
+from quapp_common.config.logging_config import job_logger
+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.response.custom_header import CustomHeader
+from quapp_common.enum.media_type import MediaType
+from quapp_common.util.file_utils import FileUtils
+from quapp_common.util.http_utils import create_bearer_header, \
+    get_job_id_from_url
+
+
+class DWaveOceanCircuitExportTask:
+    MAX_CIRCUIT_IMAGE_SIZE = 5 * (1024 ** 2)
+
+    def __init__(self, circuit_data_holder: CircuitDataHolder,
+                 backend_data_holder: BackendDataHolder,
+                 project_header: CustomHeader, workspace_header: CustomHeader):
+        super().__init__()
+        self.project_header = project_header
+        self.workspace_header = workspace_header
+        self.circuit_data_holder = circuit_data_holder
+        self.backend_data_holder = backend_data_holder
+        self.logger = job_logger(
+                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._render_circuit_svg(self._transpile_circuit())
+        except Exception as e:
+            self.logger.exception("Error converting circuit to SVG: %s", e,
+                                  exc_info=True)
+            return
+
+        try:
+            self.logger.debug('Determining if circuit SVG should be zipped')
+            # Use protected helpers from base class (single underscore), not name-mangled privates
+            io_buffer_value, content_type = self.__determine_zip(
+                    figure_buffer=figure_buffer)
+            size_bytes = (
+                io_buffer_value.getbuffer().nbytes
+                if isinstance(io_buffer_value, BytesIO)
+                else len(io_buffer_value)
+            )
+            self.logger.debug("Content type: %s", content_type)
+            self.logger.debug("Buffer size: %s bytes", size_bytes)
+        except Exception as e:
+            self.logger.exception(
+                    "Error determining if circuit SVG should be zipped: %s", 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.")
+            return
+        except Exception as e:
+            self.logger.exception(
+                    "Error sending exported circuit to backend: %s", e,
+                    exc_info=True)
+            return
+
+    def _render_circuit_svg(self,
+                            transpiled_circuit: BinaryQuadraticModel) -> BytesIO:
+        """
+        Render a BinaryQuadraticModel as an SVG figure and return it as a BytesIO buffer.
+
+        This matches the transpile output type (BinaryQuadraticModel) from _transpile_circuit.
+        """
+        self.logger.info("Rendering BinaryQuadraticModel to SVG")
+        try:
+            linear_items = list(transpiled_circuit.linear.items())
+            quadratic_items = list(transpiled_circuit.quadratic.items())
+
+            # Prepare figure
+            fig, axes = plt.subplots(1, 2, figsize=(10, 4))
+            fig.suptitle("D-Wave Ocean BQM Visualization", fontsize=12)
+
+            # Left: Linear biases (bar chart)
+            ax0 = axes[0]
+            if linear_items:
+                vars_, lin_vals = zip(*linear_items)
+                x = np.arange(len(vars_))
+                ax0.bar(x, lin_vals, color="#1f77b4")
+                ax0.set_xticks(x)
+                ax0.set_xticklabels([str(v) for v in vars_], rotation=45,
+                                    ha="right", fontsize=8)
+                ax0.set_title("Linear biases")
+                ax0.set_ylabel("bias")
+            else:
+                ax0.text(0.5, 0.5, "No linear biases", ha="center", va="center",
+                         transform=ax0.transAxes)
+                ax0.set_axis_off()
+
+            # Right: Quadratic couplers (scatter)
+            ax1 = axes[1]
+            if quadratic_items:
+                uvs = [f"{u}-{v}" for (u, v), _ in quadratic_items]
+                q_vals = [b for _, b in quadratic_items]
+                x = np.arange(len(uvs))
+                ax1.scatter(x, q_vals, c=np.sign(q_vals), cmap="bwr",
+                            edgecolor="k")
+                ax1.set_xticks(x)
+                ax1.set_xticklabels(uvs, rotation=45, ha="right", fontsize=8)
+                ax1.set_title("Quadratic couplers")
+                ax1.set_ylabel("coupling")
+                ax1.axhline(0, color="gray", linewidth=0.8)
+            else:
+                ax1.text(0.5, 0.5, "No quadratic couplers", ha="center",
+                         va="center", transform=ax1.transAxes)
+                ax1.set_axis_off()
+
+            fig.tight_layout(rect=[0, 0.03, 1, 0.95])
+
+            self.logger.debug("Converting rendered figure to SVG buffer")
+            figure_buffer = BytesIO()
+            try:
+                fig.savefig(figure_buffer, format="svg", bbox_inches="tight")
+                figure_buffer.seek(0)
+                self.logger.debug("SVG export complete. Size: %s bytes",
+                                  figure_buffer.getbuffer().nbytes)
+            except Exception as exception:
+                self.logger.exception("Error saving BQM figure to SVG: %s",
+                                      exception, exc_info=True)
+                raise
+            finally:
+                plt.close(fig)
+
+            return figure_buffer
+
+        except Exception as exception:
+            self.logger.exception(
+                    "Error rendering BinaryQuadraticModel to SVG: %s",
+                    exception,
+                    exc_info=True)
+            raise
+
+    def _transpile_circuit(self) -> BinaryQuadraticModel:
+        self.logger.info('Transpiling D-Wave Ocean circuit')
+        circuit = self.circuit_data_holder.circuit
+        self.logger.debug('Fetched circuit from holder: %s', circuit)
+
+        if circuit is None:
+            self.logger.error('Circuit must not be None')
+            raise ValueError('Circuit must not be None')
+
+        if isinstance(circuit, BinaryQuadraticModel):
+            self.logger.debug(
+                    'Circuit is BinaryQuadraticModel; no transpilation needed')
+            return circuit
+
+        self.logger.error('Expected BinaryQuadraticModel, got %s',
+                          type(circuit))
+        raise ValueError(f'Expected BinaryQuadraticModel, got {type(circuit)}')
+
+    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, self.project_header,
+                    self.workspace_header), files=payload)
+        except Exception as exception:
+            self.logger.exception(f"HTTP request failed: {exception}",
+                                  exc_info=True)
+            raise
+
+        if response.ok:
+            self.logger.info("Request sent to QuaO backend successfully.")
+        else:
+            self.logger.exception(
+                    f"Sending request to QuaO backend failed with status {response.status_code}! Response: {response.content}")
+
+        self.logger.debug("HTTP request complete.")

quapp_dwave_ocean/component/backend/d_wave_ocean_invocation.py

@@ -0,0 +1,157 @@
+#  Quapp Platform Project
+#  d_wave_ocean_invocation.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from dimod import BinaryQuadraticModel
+from quapp_common.component.backend.invocation import Invocation
+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 quapp_dwave_ocean.async_tasks.d_wave_ocean_circuit_export_task import \
+    DWaveOceanCircuitExportTask
+from quapp_dwave_ocean.factory.d_wave_device_factory import DWaveDeviceFactory
+from quapp_dwave_ocean.factory.d_wave_provider_factory import \
+    DWaveProviderFactory
+
+
+class DWaveOceanInvocation(Invocation):
+    def __init__(self, request_data: InvocationRequest):
+        """
+        Initialize DWaveOceanInvocation object
+
+        Args:
+             request_data: InvocationRequest object
+        """
+        super().__init__(request_data)
+        try:
+            provider_tag = getattr(self.backend_information, "provider_tag",
+                                   None)
+            device_name = getattr(self.backend_information, "device_name", None)
+            self.logger.info("[DWaveOceanInvocation] Initialized")
+            self.logger.debug(
+                    "[DWaveOceanInvocation] init details: provider_tag=%s, device_name=%s, sdk=%s, export_url_present=%s",
+                    provider_tag, device_name, getattr(self, "sdk", None),
+                    bool(getattr(self, "circuit_export_url", None)), )
+        except Exception as e:
+            self.logger.exception(
+                    "[DWaveOceanInvocation] Initialization logging failed: %s",
+                    e)
+
+    def _export_circuit(self, circuit):
+        """
+        Export circuit to svg file then send to QuaO server for saving
+
+        @param circuit: Circuit was exported
+        """
+        self.logger.info("[DWaveOceanInvocation] _export_circuit() started")
+        try:
+            circuit_export_task = DWaveOceanCircuitExportTask(
+                    circuit_data_holder=CircuitDataHolder(circuit,
+                                                          self.circuit_export_url),
+                    backend_data_holder=BackendDataHolder(
+                            self.backend_information,
+                            self.authentication.user_token),
+                    project_header=self.project_header,
+                    workspace_header=self.workspace_header, )
+            self.logger.debug(
+                    "[DWaveOceanInvocation] Prepared CircuitExportTask: export_url_present=%s, project_header=%s, workspace_header=%s",
+                    bool(self.circuit_export_url),
+                    bool(getattr(self, "project_header", None)),
+                    bool(getattr(self, "workspace_header", None)), )
+
+            future = circuit_exporting_pool.submit(circuit_export_task.do)
+            self.logger.info(
+                    "[DWaveOceanInvocation] Circuit export task submitted to thread pool")
+
+            def _done_callback(fut):
+                try:
+                    fut.result()
+                    self.logger.info(
+                            "[DWaveOceanInvocation] Circuit export task completed successfully")
+                except Exception as export_err:
+                    self.logger.exception(
+                            "[DWaveOceanInvocation] Circuit export task failed: %s",
+                            export_err)
+
+            future.add_done_callback(_done_callback)
+        except Exception as e:
+            self.logger.exception(
+                    "[DWaveOceanInvocation] Failed to export circuit: %s", e)
+            raise
+
+    def _create_provider(self):
+        """
+        Create a provider based on the provider type and SDK
+
+        Return: Provider object
+        """
+        self.logger.info("[DWaveOceanInvocation] _create_provider()")
+        try:
+            self.logger.debug(
+                    "[DWaveOceanInvocation] Creating provider with provider_tag=%s, sdk=%s",
+                    getattr(self.backend_information, "provider_tag", None),
+                    getattr(self, "sdk", None), )
+            return DWaveProviderFactory.create_provider(
+                    provider_type=self.backend_information.provider_tag,
+                    sdk=self.sdk,
+                    authentication=self.backend_information.authentication, )
+        except Exception as e:
+            self.logger.exception(
+                    "[DWaveOceanInvocation] _create_provider failed: %s", e)
+            raise
+
+    def _create_device(self, provider: Provider):
+        """
+        Create a device based on the provider and device specification
+
+        Args:
+            provider: Provider instance that this device belongs to
+        Return:
+            A device instance corresponding to the specified provider and device type
+        """
+        try:
+            self.logger.debug(
+                    f"[DWaveOceanInvocation] Creating device device_name="
+                    f"{getattr(self.backend_information, 'device_name', None)}"
+                    f", sdk={getattr(self, 'sdk', None)}")
+            return DWaveDeviceFactory.create_device(provider=provider,
+                                                    device_specification=self.backend_information.device_name,
+                                                    authentication=self.backend_information.authentication,
+                                                    sdk=self.sdk, )
+        except Exception as exception:
+            self.logger.exception(
+                    f"[DWaveOceanInvocation] _create_device failed: {exception}")
+            raise
+
+    def _get_qubit_amount(self, circuit):
+        """
+        Get the number of qubits in the given circuit.
+
+        Args:
+            circuit: The quantum circuit for which the qubit count is needed.
+        Returns:
+            int: The number of qubits in the circuit.
+        """
+        try:
+            if isinstance(circuit, BinaryQuadraticModel):
+                qubit_amount = circuit.binary.num_variables
+                self.logger.info(
+                        f"[DWaveOceanInvocation] Circuit is a BinaryQuadraticModel with {qubit_amount} qubits.")
+                return qubit_amount
+            else:
+                qubit_amount = getattr(circuit, "num_qubits", None)
+                if qubit_amount is None:
+                    raise AttributeError(
+                            "circuit object has no attribute 'num_qubits'")
+                self.logger.info(f"[DWaveOceanInvocation] Circuit is not a "
+                                 f"BinaryQuadraticModel; it has {qubit_amount} qubits.")
+                return qubit_amount
+        except Exception as exception:
+            self.logger.exception(
+                    f"[DWaveOceanInvocation] Failed to get qubit amount: {exception}")
+            raise

quapp_dwave_ocean/component/backend/d_wave_ocean_job_fetching.py

@@ -0,0 +1,28 @@
+from quapp_common.component.backend.job_fetcher import JobFetcher
+from quapp_common.data.request.job_fetching_request import JobFetchingRequest
+
+
+class DWaveOceanJobFetching(JobFetcher):
+    def __init__(self, request: JobFetchingRequest, ):
+        super().__init__(request)
+
+    def _collect_provider(self):
+        pass
+
+    def _retrieve_job(self, provider):
+        pass
+
+    def _get_job_status(self, job):
+        pass
+
+    def _get_job_result(self, job):
+        pass
+
+    def _produce_histogram_data(self, job_result) -> dict | None:
+        pass
+
+    def _get_execution_time(self, job_result):
+        pass
+
+    def _get_shots(self, job_result):
+        pass

quapp_dwave_ocean/factory/d_wave_device_factory.py

@@ -0,0 +1,73 @@
+#  Quapp Platform Project
+#  d_wave_device_factory.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from quapp_common.config.logging_config import job_logger
+from quapp_common.enum.provider_tag import ProviderTag
+from quapp_common.enum.sdk import Sdk
+from quapp_common.factory.device_factory import DeviceFactory
+from quapp_common.model.provider.provider import Provider
+
+from ..model.device.d_wave_hybrid_device import DWaveHybridDevice
+from ..model.device.d_wave_system_device import DWaveSystemDevice
+from ..model.device.quapp_d_wave_device import QuappDWaveOceanDevice
+from ..model.provider.d_wave_system_provider import (system_devices,
+                                                     hybrid_devices)
+
+logger = job_logger(__name__)
+
+
+class DWaveDeviceFactory(DeviceFactory):
+    @staticmethod
+    def create_device(provider: Provider, device_specification: str,
+            authentication: dict, sdk: Sdk, ):
+        """
+        Creates a D-Wave device based on the provided specification and SDK.
+
+        This method selects and returns an appropriate D-Wave device instance
+        based on the provider type and device specification. It supports both
+        quantum simulators and actual D-Wave devices, either system or hybrid
+        devices.
+
+        Args:
+            provider (Provider): The provider instance to create the device from.
+            device_specification (str): The specification of the device to be created.
+            authentication (dict): Authentication details required for the provider.
+            sdk (Sdk): The software development kit being used.
+
+        Returns:
+            A device instance corresponding to the specified provider and device type.
+
+        Raises:
+            Exception: If the device specification or provider type is unsupported.
+        """
+        provider_type = ProviderTag.resolve(provider.get_provider_type().value)
+        logger.debug(
+                f"[DWaveDeviceFactory] create_device called with provider_type={provider_type}, "
+                f"device_specification={device_specification}, sdk={sdk}")
+
+        if ProviderTag.QUAO_QUANTUM_SIMULATOR.__eq__(provider_type):
+            logger.debug(
+                    f"[DWaveDeviceFactory] Detected QUAO_QUANTUM_SIMULATOR with sdk={sdk}")
+            if Sdk.D_WAVE_OCEAN.__eq__(sdk):
+                logger.info(
+                        f"[DWaveDeviceFactory] Creating QuappDWaveOceanDevice for spec={device_specification}")
+                return QuappDWaveOceanDevice(provider, device_specification)
+
+        if ProviderTag.D_WAVE.__eq__(provider_type):
+            logger.debug(
+                    f"[DWaveDeviceFactory] Detected D_WAVE provider; resolving device for spec={device_specification}")
+            if device_specification in system_devices:
+                logger.info(
+                        f"[DWaveDeviceFactory] Creating DWaveSystemDevice for spec={device_specification}")
+                return DWaveSystemDevice(provider, device_specification)
+
+            if device_specification in hybrid_devices:
+                logger.info(
+                        f"[DWaveDeviceFactory] Creating DWaveHybridDevice for spec={device_specification}")
+                return DWaveHybridDevice(provider, device_specification)
+
+        logger.error(
+                f"[DWaveDeviceFactory] Unsupported device: provider_type={provider_type}, "
+                f"device_specification={device_specification}, sdk={sdk}")
+        raise ValueError("Unsupported device!")

quapp_dwave_ocean/factory/d_wave_handler_factory.py

@@ -0,0 +1,45 @@
+#  Quapp Platform Project
+#  d_wave_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
+
+
+class DWaveHandlerFactory(HandlerFactory):
+    @staticmethod
+    def create_handler(
+            event,
+            circuit_preparation_fn,
+            post_processing_fn,
+    ) -> Handler:
+        """
+        Create a handler based on event and functions.
+
+        Args:
+            event (dict): Input event. Should contain "providerJobId" key.
+            circuit_preparation_fn (function): Function for preparing circuit.
+            post_processing_fn (function): Function for post-processing the result.
+
+        Returns:
+            Handler: Handler based on event and functions.
+        """
+        request_data = event.json()
+        provider_job_id = request_data.get("providerJobId")
+
+        if provider_job_id is None:
+            logger.debug("Create InvocationHandler")
+            return InvocationHandler(
+                    request_data=request_data,
+                    circuit_preparation_fn=circuit_preparation_fn,
+                    post_processing_fn=post_processing_fn,
+            )
+
+        logger.debug("Create JobFetchingHandler")
+        return JobFetchingHandler(
+                request_data=request_data, post_processing_fn=post_processing_fn
+        )

quapp_dwave_ocean/factory/d_wave_provider_factory.py

@@ -0,0 +1,74 @@
+#  Quapp Platform Project
+#  d_wave_provider_factory.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+from quapp_common.config.logging_config import job_logger
+from quapp_common.enum.provider_tag import ProviderTag
+from quapp_common.enum.sdk import Sdk
+from quapp_common.factory.provider_factory import ProviderFactory
+
+from ..model.provider.d_wave_system_provider import DWaveSystemProvider
+from ..model.provider.quapp_d_wave_provider import QuappDWaveProvider
+
+logger = job_logger(__name__)
+
+
+class DWaveProviderFactory(ProviderFactory):
+    @staticmethod
+    def create_provider(provider_type: ProviderTag, sdk: Sdk,
+                        authentication: dict):
+        """
+        Creates and returns a provider based on the specified provider type and SDK.
+
+        Args:
+            provider_type: The type of provider to create, identified by a ProviderTag.
+            sdk: The SDK to use for the provider, identified by a Sdk.
+            authentication: A dictionary containing authentication details such as token and endpoint.
+
+        Returns:
+            An instance of DWaveSystemProvider or QuappDWaveProvider based on the matching criteria.
+
+        Raises:
+            Exception: If the provider type or SDK is not supported.
+        """
+        logger.debug(
+                "[DWaveProviderFactory] create_provider called with provider_type=%s, sdk=%s, auth_provided=%s",
+                provider_type, sdk, authentication is not None
+        )
+
+        if ProviderTag.QUAO_QUANTUM_SIMULATOR.__eq__(provider_type):
+            logger.debug(
+                    "[DWaveProviderFactory] Detected QUAO_QUANTUM_SIMULATOR")
+            if Sdk.D_WAVE_OCEAN.__eq__(sdk):
+                logger.info(
+                        "[DWaveProviderFactory] Creating QuappDWaveProvider")
+                return QuappDWaveProvider()
+
+        if ProviderTag.D_WAVE.__eq__(provider_type):
+            logger.debug("[DWaveProviderFactory] Detected D_WAVE provider")
+            if authentication is None:
+                logger.error(
+                        "[DWaveProviderFactory] Missing authentication for D-Wave provider")
+                raise ValueError(
+                        "Authentication details are required for D-Wave provider.")
+
+            token = authentication.get("token")
+            endpoint = authentication.get("endpoint")
+            if token is None or endpoint is None:
+                missing_details = []
+                if token is None:
+                    missing_details.append("token")
+                if endpoint is None:
+                    missing_details.append("endpoint")
+                error_message = "Missing authentication details: {0}".format(
+                        ", ".join(missing_details))
+                logger.error("[DWaveProviderFactory] %s", error_message)
+                raise ValueError(error_message)
+
+            logger.info(
+                    "[DWaveProviderFactory] Creating DWaveSystemProvider with provided endpoint")
+            return DWaveSystemProvider(token, endpoint)
+
+        logger.error(
+                "[DWaveProviderFactory] Unsupported provider: provider_type=%s, sdk=%s",
+                provider_type, sdk)
+        raise ValueError("Unsupported provider!")

quapp_dwave_ocean/handler/invocation_handler.py

@@ -0,0 +1,42 @@
+#  Quapp Platform Project
+#  invocation_handler.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from quapp_common.data.request.invocation_request import InvocationRequest
+from quapp_common.handler.handler import Handler
+
+from ..component.backend.d_wave_ocean_invocation import DWaveOceanInvocation
+
+
+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):
+        """
+        Handles the invocation and submission of a quantum job request to the
+        DWaveOceanInvocation backend. This method creates an invocation request
+        with the provided data, logs relevant debug information, and submits
+        the job to the backend using the specified preparation and post-processing
+        functions.
+        """
+        self.logger.debug('Creating InvocationRequest')
+        try:
+            invocation_request = InvocationRequest(self.request_data)
+            self.logger.debug(
+                f'Invocation request keys: {list(invocation_request.__dict__.keys())}')
+
+            backend = DWaveOceanInvocation(invocation_request)
+            self.logger.debug('DWaveOceanInvocation backend instantiated')
+
+            self.logger.debug('Submitting job to backend')
+            backend.submit_job(
+                    circuit_preparation_fn=self.circuit_preparation_fn,
+                    post_processing_fn=self.post_processing_fn)
+            self.logger.info('Job submitted to backend')
+        except Exception as exception:
+            self.logger.exception(
+                    f'Error submitting job to backend: {exception}')
+            raise ValueError(f'Error submitting job to backend: {exception}')

quapp_dwave_ocean/handler/job_fetching_handler.py

@@ -0,0 +1,42 @@
+#  Quapp Platform Project
+#  job_fetching_handler.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from quapp_common.config.logging_config import logger
+from quapp_common.data.request.job_fetching_request import JobFetchingRequest
+from quapp_common.handler.handler import Handler
+
+from ..component.backend.d_wave_ocean_job_fetching import DWaveOceanJobFetching
+
+
+class JobFetchingHandler(Handler):
+    def __init__(self,
+                 request_data: dict,
+                 post_processing_fn):
+        super().__init__(request_data, post_processing_fn)
+
+    def handle(self):
+        """
+        Handles the job fetching request.
+
+        This method creates a JobFetchingRequest object using the provided
+        request data, then creates a JobFetching object to fetch the job.
+        The job fetching process uses a post-processing function
+        to process the fetched result.
+
+        Returns:
+            The result of the job fetching process after applying
+            post-processing.
+        """
+        self.logger.debug("[JobFetchingHandler] Creating JobFetchingRequest with data: {0}".format(
+            self.request_data))
+        request = JobFetchingRequest(self.request_data)
+
+        self.logger.debug("[JobFetchingHandler] Initializing JobFetching with request.")
+        job_fetching = DWaveOceanJobFetching(request)
+
+        self.logger.debug("[JobFetchingHandler] Starting job fetching process.")
+        fetching_result = job_fetching.fetch(post_processing_fn=self.post_processing_fn)
+
+        self.logger.debug("[JobFetchingHandler] Job fetching result: {0}".format(fetching_result))
+        return fetching_result

quapp_dwave_ocean/model/device/d_wave_device.py

@@ -0,0 +1,31 @@
+#  Quapp Platform Project
+#  d_wave_device.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from abc import ABC
+
+from quapp_common.enum.status.job_status import JobStatus
+from quapp_common.model.device.custom_device import CustomDevice
+
+
+class DWaveDevice(CustomDevice, ABC):
+
+    def _is_simulator(self) -> bool:
+        self.logger.debug("[DWave Device] Get device type")
+
+        return True
+
+    def _produce_histogram_data(self, job_result) -> dict | None:
+        self.logger.debug("[DWave Device] Produce histogram")
+
+        return None
+
+    def _get_job_status(self, job) -> str:
+        self.logger.debug("[DWave Device] Get job status")
+
+        return JobStatus.DONE.value
+
+    def _get_shots(self, job_result) -> int | None:
+        self.logger.debug('[DWave Device] Get shots')
+        self.logger.debug(f'[DWave Device] Job result: {job_result}')
+        return None

quapp_dwave_ocean/model/device/d_wave_hybrid_device.py

@@ -0,0 +1,38 @@
+#  Quapp Platform Project
+#  d_wave_hybrid_device.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from quapp_common.data.device.circuit_running_option import CircuitRunningOption
+
+from ..device.d_wave_device import DWaveDevice
+
+
+class DWaveHybridDevice(DWaveDevice):
+
+    def _create_job(self, circuit, options: CircuitRunningOption):
+        self.logger.debug("[DWave System] Create job")
+
+        return self.device.sample_bqm(circuit, time_limit=10)
+
+    def _get_provider_job_id(self, job) -> str:
+        self.logger.debug("[DWave System] Get provider job id")
+
+        return job.id
+
+    def _get_job_result(self, job):
+        self.logger.debug('[DWave System] Get job result')
+
+        return job.result().get('sampleset')
+
+    def _calculate_execution_time(self, job_result) -> None:
+        self.logger.debug("[DWave System] Calculate execution time")
+
+        self.execution_time = (
+                job_result.get("_info").get('run_time') / 1000
+        )
+
+        self.logger.debug(
+                "[DWave System] Execution time calculation was: {0} seconds".format(
+                        self.execution_time
+                )
+        )

quapp_dwave_ocean/model/device/d_wave_system_device.py

@@ -0,0 +1,34 @@
+#  Quapp Platform Project
+#  d_wave_system_device.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from quapp_common.data.device.circuit_running_option import CircuitRunningOption
+
+from ..device.d_wave_device import DWaveDevice
+
+
+class DWaveSystemDevice(DWaveDevice):
+
+    def _create_job(self, circuit, options: CircuitRunningOption):
+        self.logger.debug("[DWave System] Create job")
+
+        return self.device.sample(circuit)
+
+    def _get_provider_job_id(self, job) -> str:
+        self.logger.debug("[DWave System] Get provider job id")
+
+        return job.info.get("problem_id")
+
+    def _calculate_execution_time(self, job_result) -> None:
+        self.logger.debug("[DWave System] Calculate execution time")
+
+        self.execution_time = (job_result.get("_info").get("timing").get(
+                "qpu_access_time") / 1000)
+
+        self.logger.debug(
+                f"[DWave System] Execution time calculation was: {self.execution_time} seconds")
+
+    def _get_job_result(self, job):
+        self.logger.debug('[DWave System] Get job result')
+
+        return job

quapp_dwave_ocean/model/device/quapp_d_wave_device.py

@@ -0,0 +1,191 @@
+#  Quapp Platform Project
+#  quapp_d_wave_device.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+import time
+import uuid
+from abc import ABC
+
+import numpy as np
+from dimod import SampleSet
+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
+
+
+class QuappDWaveOceanDevice(CustomDevice, ABC):
+    def __init__(self, provider: Provider, device_specification: str):
+        super().__init__(provider, device_specification)
+
+    def _create_job(self, circuit, options: CircuitRunningOption):
+        """
+        Creates a D-Wave job for the provided BQM (Binary Quadratic Model) circuit.
+
+        This method creates a job by sampling the provided BQM circuit and records
+        the execution time for the job creation. The job is then returned.
+
+        Args:
+            circuit (dimod.BinaryQuadraticModel): The BQM circuit to sample.
+            options (CircuitRunningOption): The options for running the circuit.
+
+        Returns:
+            dimod.SampleSet: The created job as a SampleSet.
+        """
+        self.logger.debug(
+                '[QuappDWaveOceanDevice] Creating job with {0} shots'.format(
+                        options.shots))
+
+        # Record the start time for execution time measurement
+        start_time = time.time()
+
+        # Create a job by sampling the provided BQM (Binary Quadratic Model) circuit
+        job = self.device.sample(bqm=circuit, num_reads=options.shots)
+
+        # Calculate the execution time by subtracting the start time from the current time
+        self.execution_time = time.time() - start_time
+
+        # Log the execution time for the job creation
+        self.logger.debug(
+                '[QuappDWaveOceanDevice] Job created in {0:.2f} seconds'.format(
+                        self.execution_time))
+
+        # Return the created job
+        return job
+
+    def _produce_histogram_data(self, job_result) -> dict | None:
+        """
+        Converts the samples of a SampleSet into a histogram data.
+
+        Args:
+            job_result (SampleSet): The SampleSet object returned by the D-Wave Ocean Solver.
+
+        Returns:
+            dict | None: A dictionary containing the histogram data in the format {'0': int, '1': int}.
+        """
+        self.logger.debug('[QuappDWaveOceanDevice] Produce histogram data')
+
+        # Check if job_result is an instance of SampleSet
+        if isinstance(job_result, SampleSet):
+            try:
+                # Retrieve the sample from the job_result
+                sample = job_result.record.sample
+                # Convert the first sample to a NumPy array
+                sample = np.array(sample[0])
+
+                # Count the occurrences of each value (0 and 1) in the sample
+                counts = np.bincount(sample, minlength=2)
+
+                # Return a dictionary with the counts of values 0 and 1
+                return {"0": int(counts[0]), "1": int(counts[1]), }
+            except Exception as e:
+                self.logger.error(
+                        f"[QuappDWaveOceanDevice] Error producing histogram data: {e}")
+                return None
+
+        self.logger.debug(
+                '[QuappDWaveOceanDevice] Job result is not an instance of SampleSet. Returning None.')
+        return None
+
+    def _get_provider_job_id(self, job) -> str:
+        self.logger.debug('[QuappDWaveOceanDevice] Get provider job id')
+
+        provider_job_id = str(uuid.uuid4())
+        self.logger.debug(f'[QuappDWaveOceanDevice] Provider job ID:'
+                          f' {provider_job_id}')
+        return provider_job_id
+
+    def _get_job_status(self, job) -> str:
+        self.logger.debug('[QuappDWaveOceanDevice] Get job status')
+
+        return JobStatus.DONE.value
+
+    def _get_job_result(self, job):
+        """
+        Retrieves the result of the job from the provider.
+
+        If the job is a SampleSet, it is returned directly. Otherwise, the result of the job is retrieved by calling `job.result()`.
+
+        Args:
+            job (SampleSet or Job): The job to retrieve the result from.
+
+        Returns:
+            SampleSet or Any: The result of the job if it is a SampleSet, otherwise the result of calling `job.result()`.
+        """
+        self.logger.debug('[QuappDWaveOceanDevice] Get job result')
+
+        # Check if the job is an instance of SampleSet
+        if isinstance(job, SampleSet):
+            # Log that the job is a SampleSet and will be returned directly
+            self.logger.debug(
+                    f'[QuappDWaveOceanDevice] Job is a SampleSet. Returning the job directly: {job}')
+            return job
+
+        # Log that the job is not a SampleSet and will return the result of the job
+        self.logger.debug(
+                f'[QuappDWaveOceanDevice] Job is not a SampleSet. Returning job.result(): {job.result()}')
+        return job.result()
+
+    def _get_shots(self, job_result) -> int | None:
+        """
+        Get the number of shots of a job.
+
+        Args:
+            job_result (SampleSet): The SampleSet object returned by the D-Wave Ocean Solver.
+
+        Returns:
+            int | None: The number of shots if the job_result is a SampleSet, otherwise None.
+        """
+        self.logger.debug('[QuappDWaveOceanDevice] Get shots')
+        if isinstance(job_result, SampleSet):
+            # Log the size of the 'num_occurrences' data vector
+            occurrences_size = job_result.data_vectors['num_occurrences'].size
+            self.logger.debug(
+                    f'[QuappDWaveOceanDevice] Number of occurrences size: {occurrences_size}')
+            return occurrences_size
+
+        # Log a warning if job_result is not a SampleSet
+        self.logger.warning(
+                f'[QuappDWaveOceanDevice] Job result is not a SampleSet, is {type(job_result)}. Returning None.')
+        return None
+
+    def _is_simulator(self) -> bool:
+        self.logger.info('[QuappDWaveOceanDevice] Is simulator')
+        return True
+
+    def _calculate_execution_time(self, job_result) -> None:
+        """
+        Calculate the execution time of a job in seconds.
+
+        The execution time is calculated from the timing information in the job info,
+        which is extracted and summed directly. The result is stored in the
+        `execution_time` attribute.
+
+        If the `job_result` is not a SampleSet, the extract timing information from the job info skipped.
+
+        Parameters
+        ----------
+        job_result : SampleSet
+            The result of the job.
+
+        Returns
+        -------
+        None
+        """
+        timing = None
+        # Extract timing information from the job information
+        if isinstance(job_result, SampleSet):
+            timing = job_result.info.get('timing', {})
+        else:
+            if isinstance(job_result, dict) and '_info' in job_result:
+                timing = job_result['_info'].get('timing', {})
+        if timing is not None:
+            # Calculate total time in seconds by summing the values directly
+            self.execution_time = sum(timing.values()) / 1_000_000_000
+
+            # Log the execution time calculation
+            self.logger.debug(
+                    f'[QuappDWaveOceanDevice] Execution time calculation was: {self.execution_time} seconds')
+        else:
+            self.logger.warning(
+                    '[QuappDWaveOceanDevice] Extract timing information from the job info skipped.')

quapp_dwave_ocean/model/provider/d_wave_system_provider.py

@@ -0,0 +1,49 @@
+#  Quapp Platform Project
+#  d_wave_system_provider.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from dwave.cloud import Client
+from dwave.system import DWaveSampler, AutoEmbeddingComposite
+
+from quapp_common.config.logging_config import job_logger
+from quapp_common.enum.provider_tag import ProviderTag
+from quapp_common.model.provider.provider import Provider
+
+system_devices = ["Advantage_system4.1"]
+hybrid_devices = ["hybrid_binary_quadratic_model_version2"]
+
+logger = job_logger(__name__)
+
+
+class DWaveSystemProvider(Provider):
+
+    def __init__(self, api_token, endpoint):
+        super().__init__(ProviderTag.D_WAVE)
+        self.api_token = api_token
+        self.endpoint = endpoint
+
+    def get_backend(self, device_specification: str):
+        logger.debug("[DWave system] Get backend")
+
+        if device_specification in system_devices:
+            provider = self.collect_provider()
+            logger.debug("[DWave system] Get auto embedding composite")
+            return AutoEmbeddingComposite(provider)
+
+        if device_specification in hybrid_devices:
+            client = Client(endpoint=self.endpoint, token=self.api_token)
+            logger.debug("[DWave system] Get solver")
+            return client.get_solver(device_specification)
+
+        raise ValueError(
+                "Unsupported DWave device: {0}".format(device_specification))
+
+    def collect_provider(self):
+        logger.debug("[DWave system] Connect to provider")
+        try:
+            return DWaveSampler(endpoint=self.endpoint, token=self.api_token)
+        except Exception as exception:
+            logger.exception(
+                f"Failed to connect to DWave provider: {exception}")
+            raise ValueError(
+                f"Failed to connect to DWave provider: {exception}")

quapp_dwave_ocean/model/provider/quapp_d_wave_provider.py

@@ -0,0 +1,26 @@
+#  Quapp Platform Project
+#  quapp_d_wave_provider.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from dwave.samplers import SimulatedAnnealingSampler
+
+from quapp_common.config.logging_config import job_logger
+from quapp_common.enum.provider_tag import ProviderTag
+from quapp_common.model.provider.provider import Provider
+
+logger = job_logger(__name__)
+
+
+class QuappDWaveProvider(Provider):
+
+    def __init__(self):
+        logger.debug('[Quapp D-Wave] Initiate QuappDWaveProvider')
+        super().__init__(ProviderTag.QUAO_QUANTUM_SIMULATOR)
+
+    def get_backend(self, device_specification):
+        logger.debug('[Quapp D-Wave] Get backend')
+
+        return SimulatedAnnealingSampler()
+
+    def collect_provider(self):
+        return None

quapp_dwave_ocean-0.0.1.dev2.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: quapp-dwave-ocean
+Version: 0.0.1.dev2
+Summary: Quapp D-Wave Ocean 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-dwave-ocean,dwave-ocean,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: quapp-common==0.0.11.dev6
+Requires-Dist: dwave-cloud-client==0.13.4
+Requires-Dist: dwave-system==1.30.0
+Requires-Dist: dwave-samplers==1.5.0
+Requires-Dist: dimod==0.12.20
+Requires-Dist: numpy==2.2.4
+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
+
+# quapp-dwave-ocean
+
+Quapp D-Wave Ocean library supporting Quapp Platform for Quantum Computing.
+
+## Overview
+
+`quapp-dwave-ocean` provides providers, devices, factories, and async tasks to
+run
+Binary Quadratic Models (BQMs) via D-Wave Ocean within the Quapp Platform. It
+supports
+D-Wave system and hybrid devices as well as a QuaO quantum simulator, featuring
+consistent context-rich logging, robust error handling, and standardized
+project/workspace
+headers for clean integration with backend services.
+
+## Features
+
+- Provider and device factories for:
+    - D-Wave System devices
+    - D-Wave Hybrid devices
+    - Quapp D-Wave Ocean simulator
+- Asynchronous circuit export to SVG (BQM visualization) with optional
+  compression and upload.
+- Consistent, instance-level logging across provider/device creation, job
+  invocation, export, and fetching.
+- Standardized project/workspace header handling for backend invocations.
+- Improved error handling and diagnostics in critical paths (export,
+  provider/device creation, job processing).
+- Job fetching workflow encapsulated for clarity and maintainability.
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install quapp-dwave-ocean
+```
+
+## Recently Changes Highlights
+
+- chore: Bump a version to `0.0.1.dev2` and update `quapp-common` dependency to
+  `0.0.11.dev6`
+- refactor: Replace global logger usage with instance-level logging and enhance
+  debug information across D-Wave Ocean modules
+- feature: Create `DWaveOceanJobFetching` class for managing job fetching logic in
+  D-Wave Ocean backend
+- feature: Add `DWaveOceanCircuitExportTask` for exporting and processing D-Wave
+  Ocean circuit visualizations
+- refactor: Update import paths from `qapp_common` to `quapp_common` for consistency
+  across modules
+
+For detailed usage and API references, please refer to the in-code documentation
+or contact the maintainers.

quapp_dwave_ocean-0.0.1.dev2.dist-info/RECORD

@@ -0,0 +1,28 @@
+quapp_dwave_ocean/__init__.py,sha256=_0M_dDraklXjKk4RYnaWPUvefKf7AtD6-5F4X8wolFo,87
+quapp_dwave_ocean/async_tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quapp_dwave_ocean/async_tasks/d_wave_ocean_circuit_export_task.py,sha256=UJMcxWsYchhzS7h_BfKCholYrEcwjhhMDJ2baWfpniM,9442
+quapp_dwave_ocean/component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quapp_dwave_ocean/component/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quapp_dwave_ocean/component/backend/d_wave_ocean_invocation.py,sha256=6N3SvCxKKr84USwaPWGTo2ZOp7o8bAfyrAwM2uPN5f8,7130
+quapp_dwave_ocean/component/backend/d_wave_ocean_job_fetching.py,sha256=A6z2Z8_a0nU-4-aguVIV7tMSwVu7I2vJqgjVp0qhuLI,669
+quapp_dwave_ocean/factory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quapp_dwave_ocean/factory/d_wave_device_factory.py,sha256=mK5P3V_FlwsP3sccU74IwNj7asJ2NlVm1wEICFxpOrE,3515
+quapp_dwave_ocean/factory/d_wave_handler_factory.py,sha256=hBkLw--fJh8rSH7KIs3Yx9kroZRIIkoLLKb-dXwH2a8,1588
+quapp_dwave_ocean/factory/d_wave_provider_factory.py,sha256=LPFfbNdtnt7s2PWCoQzt-N3H4gimbMzE9Mq2UE9u-CM,3251
+quapp_dwave_ocean/handler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quapp_dwave_ocean/handler/invocation_handler.py,sha256=-MElH0kHBjBwCYtykNaDnSML-jdrpBU7E6EUr0yQYIg,1856
+quapp_dwave_ocean/handler/job_fetching_handler.py,sha256=yscOF2K1EIIJ65j2h2cZbsRZgTnzF4GPtqKSRvZ6ze0,1654
+quapp_dwave_ocean/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quapp_dwave_ocean/model/device/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quapp_dwave_ocean/model/device/d_wave_device.py,sha256=8jWvArw3gEgB7M0kptfJ2cfomLIgB5_mQSmHfenn8kM,891
+quapp_dwave_ocean/model/device/d_wave_hybrid_device.py,sha256=UM0PLDKnrZurNktCRLPH4AIJ69FmHTjqmv3wQ0hNTiQ,1163
+quapp_dwave_ocean/model/device/d_wave_system_device.py,sha256=7S9C4ahXyIt9oqBlcikcFa2u4t2UI-zd4mJYbHvzqH4,1090
+quapp_dwave_ocean/model/device/quapp_d_wave_device.py,sha256=dSnubgpLZMLlFMygn_AP_3F9Vu8C3XYaSc5vdvh1RIU,7589
+quapp_dwave_ocean/model/provider/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quapp_dwave_ocean/model/provider/d_wave_system_provider.py,sha256=Z91-fwJpuIIQyFZSRrKo8uRGSMbdKJAju2oFcmdse2c,1799
+quapp_dwave_ocean/model/provider/quapp_d_wave_provider.py,sha256=1JJhUaf_zdF_PUqkg2haUseZvl-9--aS8uvENyk5kVo,754
+quapp_dwave_ocean-0.0.1.dev2.dist-info/licenses/LICENSE,sha256=LZ_WtCo2GQZm4PAl_QaQKdS37Pevj736S9jfCvzL8IA,1104
+quapp_dwave_ocean-0.0.1.dev2.dist-info/METADATA,sha256=dJeOiM7xXaTxjNpE3rkQSauJ-txNtnD4ZIn3YYXzmhY,4024
+quapp_dwave_ocean-0.0.1.dev2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+quapp_dwave_ocean-0.0.1.dev2.dist-info/top_level.txt,sha256=BSySVmOYNPU1vwej2xEUgP4_e0oup5GyEwRIu-4jHi8,18
+quapp_dwave_ocean-0.0.1.dev2.dist-info/RECORD,,

quapp_dwave_ocean-0.0.1.dev2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

quapp_dwave_ocean-0.0.1.dev2.dist-info/licenses/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_dwave_ocean-0.0.1.dev2.dist-info/top_level.txt

@@ -0,0 +1 @@
+quapp_dwave_ocean