quapp-dwave-ocean 0.0.1.dev2__tar.gz

quapp_dwave_ocean-0.0.1.dev2/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,53 @@
+# 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/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel==0.45.1"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quapp-dwave-ocean"
+version = "0.0.1.dev2"
+description = "Quapp D-Wave Ocean 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-dwave-ocean", "dwave-ocean", "quantum"]
+dependencies = [
+    "quapp-common==0.0.11.dev6",
+    "dwave-cloud-client==0.13.4",
+    "dwave-system==1.30.0",
+    "dwave-samplers==1.5.0",
+    "dimod==0.12.20",
+    "numpy==2.2.4"
+]
+requires-python = ">=3.7"
+
+[project.optional-dependencies]
+dev = ["black", "bumpver", "isort", "pip-tools", "pytest"]
+
+[project.urls]
+Homepage = "https://citynow.asia/"

quapp_dwave_ocean-0.0.1.dev2/quapp_dwave_ocean/__init__.py

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

quapp_dwave_ocean-0.0.1.dev2/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-0.0.1.dev2/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-0.0.1.dev2/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