luna-quantum 0.0.16__py3-none-any.whl

luna_sdk/repositories/circuit_repo.py

@@ -0,0 +1,104 @@
+import os
+from typing import Any, Dict, Optional
+
+from luna_sdk.exceptions.encryption_exception import EncryptionNotSetException
+from luna_sdk.interfaces.circuit_repo_i import ICircuitRepo
+from luna_sdk.schemas.circuit import CircuitJob, CircuitResult
+from luna_sdk.schemas.create.circuit import CircuitIn
+from luna_sdk.schemas.enums.circuit import CircuitProviderEnum
+from luna_sdk.schemas.qpu_token import TokenProvider, QpuToken, QpuTokenSource
+from luna_sdk.schemas.rest.qpu_token.token_provider import RestAPITokenProvider
+from luna_sdk.utils.qpu_tokens import extract_qpu_tokens_from_env
+
+
+class CircuitRepo(ICircuitRepo):
+    _endpoint = "/circuits"
+
+    def create(
+        self,
+        circuit: str,
+        provider: CircuitProviderEnum,
+        params: Dict[str, Any] = {},
+        qpu_tokens: Optional[TokenProvider] = None,
+        timeout: Optional[float] = 10800.0,
+        encryption_key: Optional[str] = None,
+    ) -> CircuitJob:
+        """
+        Create a circuit solution.
+
+        Parameters
+        ----------
+        circuit: str
+            The circuit which to create a solution for.
+        provider: CircuitProviderEnum
+            Which provider to use to solve the circuit.
+        params: Dict[str, Any]
+            Additional parameters of the circuit.
+        qpu_tokens: Optional[TokenProvider]
+            The tokens to be used for the QPU.
+        timeout: Optional[float]
+            Default = 10800.0. Timeout for the api request. If set to None,
+            there won't be any timeout. Increase or disable the timeout if you face
+            issues uploading big Problems.
+        encryption_key: Optional[str]
+            Encryption key to be used for encryption of QPU tokens.
+        Returns
+        -------
+        CircuitJob
+            The created circuit job.
+        """
+        if qpu_tokens is not None:
+            rest_qpu_tokens = RestAPITokenProvider.from_sdk_token_provider(qpu_tokens)
+        else:
+            rest_qpu_tokens = None
+
+        # try to retrieve qpu tokens from env variables
+        if rest_qpu_tokens is None:
+            rest_qpu_tokens = extract_qpu_tokens_from_env()
+
+        encryption_key = encryption_key or os.environ.get("LUNA_ENCRYPTION_KEY")
+        if encryption_key is None:
+            raise EncryptionNotSetException
+        circuit_in: CircuitIn = CircuitIn(
+            provider=provider,
+            circuit=circuit,
+            params=params,
+            qpu_tokens=rest_qpu_tokens,
+            encryption_key=encryption_key,
+        )
+
+        response = self._client.post(
+            self._endpoint, content=circuit_in.model_dump_json(), timeout=timeout
+        )
+
+        response.raise_for_status()
+        return CircuitJob(id=response.json(), provider=provider, params=params)
+
+    def get(
+        self, job: CircuitJob, encryption_key: Optional[str] = None
+    ) -> CircuitResult:
+        """
+        Retrieve a circuit result from a job.
+
+        Parameters
+        ----------
+        job: CircuitJob
+            The job received upon circuit creation.
+        encryption_key: Optional[str]
+            The encryption key to be used for the QPU.
+        Returns
+        -------
+        CircuitResult
+            The result of solving the circuit.
+        """
+        url = f"{self._endpoint}/{job.id}/{job.provider.value}"
+        encryption_key = encryption_key or os.environ.get("LUNA_ENCRYPTION_KEY")
+        if encryption_key is None:
+            raise EncryptionNotSetException
+        if job.params is None:
+            job.params = {}
+        job.params["encryption_key"] = encryption_key
+        response = self._client.get(url, params=job.params, timeout=60)
+
+        response.raise_for_status()
+        return CircuitResult.model_validate(response.json())

luna_sdk/repositories/cplex_repo.py

@@ -0,0 +1,118 @@
+import os
+import pickle
+import tempfile
+from functools import partial
+from typing import Tuple, List, Dict
+
+import dimod
+from dimod import ConstrainedQuadraticModel
+from dimod.constrained.constrained import CQMToBQMInverter
+from docplex.mp.model import Model as DOCplexModel
+from qiskit_optimization import QuadraticProgram
+
+from luna_sdk.exceptions.transformation import TransformationException
+from luna_sdk.interfaces.cplex_repo_i import ICplexRepo
+from luna_sdk.schemas.transformations.bqm import BQMResultSchema, BQMSchema
+from luna_sdk.schemas.transformations.matrix import MatrixSchema
+
+
+class CplexRepo(ICplexRepo):
+    _endpoint = "/transformations/docplex"
+
+    def _send_request_with_pickle_file_response(
+        self, docplex_model: DOCplexModel, endpoint: str
+    ):
+        file = tempfile.NamedTemporaryFile(delete=False)
+        with open(file.name, "wb") as tmp:
+            pickle.dump(docplex_model, tmp)
+        response = self._client.post(endpoint, files={"file": (file.name, file.file)})
+        os.remove(file.name)
+        try:
+            parsed_model = pickle.loads(response.content)
+        except Exception:
+            raise TransformationException()
+        return parsed_model
+
+    def to_qubo_qiskit(self, docplex_model: DOCplexModel) -> QuadraticProgram:
+        qubo_qiskit_model = self._send_request_with_pickle_file_response(
+            docplex_model, f"{self._endpoint}/to-qubo-qiskit"
+        )
+        try:
+            assert isinstance(qubo_qiskit_model, QuadraticProgram)
+        except AssertionError:
+            raise TransformationException()
+        return qubo_qiskit_model
+
+    def to_lp_file(self, docplex_model: DOCplexModel, filepath: str) -> None:
+        file = tempfile.NamedTemporaryFile(delete=False)
+        with open(file.name, "wb") as tmp:
+            pickle.dump(docplex_model, tmp)
+        response = self._client.post(
+            f"{self._endpoint}/to-lp-file", files={"file": (file.name, file.file)}
+        )
+        with open(filepath, "w") as file:  # type: ignore
+            file.write(response.content.decode("utf-8"))  # type: ignore
+
+    def to_lp_string(self, docplex_model: DOCplexModel) -> str:
+        file = tempfile.NamedTemporaryFile(delete=False)
+        with open(file.name, "wb") as tmp:
+            pickle.dump(docplex_model, tmp)
+        response = self._client.post(
+            f"{self._endpoint}/to-lp-file", files={"file": (file.name, file.file)}
+        )
+        return response.content.decode("utf-8")
+
+    def to_qubo_matrix(
+        self, docplex_model: DOCplexModel
+    ) -> Tuple[List[List[float]], partial]:
+        file = tempfile.NamedTemporaryFile(delete=False)
+        with open(file.name, "wb") as tmp:
+            pickle.dump(docplex_model, tmp)
+        response = self._client.post(
+            f"{self._endpoint}/to-qubo-matrix", files={"file": (file.name, file.file)}
+        )
+        retrieved_matrix = MatrixSchema.validate(response.json())
+        return retrieved_matrix.matrix, partial(
+            self.inverter,
+            var_indices=retrieved_matrix.variable_indices,
+            inverter_bqm=CQMToBQMInverter.from_dict(retrieved_matrix.inverter.dict()),
+        )
+
+    def to_bqm(
+        self, docplex_model: DOCplexModel
+    ) -> Tuple[dimod.BinaryQuadraticModel, CQMToBQMInverter]:
+        file = tempfile.NamedTemporaryFile(delete=False)
+        with open(file.name, "wb") as tmp:
+            pickle.dump(docplex_model, tmp)
+        response = self._client.post(
+            f"{self._endpoint}/to-bqm", files={"file": (file.name, file.file)}
+        )
+        retrieved_bqm = BQMResultSchema.validate(response.json())
+
+        quadratic: Dict[Tuple[str, str], float] = {}
+        for key, value in retrieved_bqm.bqm.quadratic.items():
+            split_key = tuple(key.split(","))
+            if len(split_key) != 2:
+                raise TransformationException
+            quadratic[split_key[0], split_key[1]] = value
+        try:
+            bqm = dimod.BinaryQuadraticModel(
+                retrieved_bqm.bqm.linear,
+                quadratic,
+                offset=retrieved_bqm.bqm.offset,
+                vartype=retrieved_bqm.bqm.var_type,
+            )
+        except Exception:
+            raise TransformationException()
+        inverter = CQMToBQMInverter.from_dict(retrieved_bqm.inverter.dict())
+        return bqm, inverter
+
+    def to_cqm(self, docplex_model: DOCplexModel) -> ConstrainedQuadraticModel:
+        file = tempfile.NamedTemporaryFile(delete=False)
+        with open(file.name, "wb") as tmp:
+            pickle.dump(docplex_model, tmp)
+        response = self._client.post(
+            f"{self._endpoint}/to-cqm", files={"file": (file.name, file.file)}
+        )
+        cqm = ConstrainedQuadraticModel.from_file(response.content)
+        return cqm

luna_sdk/repositories/info_repo.py

@@ -0,0 +1,45 @@
+from typing import Any, Dict, List, Optional
+
+from luna_sdk.interfaces.info_repo_i import IInfoRepo
+from luna_sdk.schemas.solver_info import SolverInfo
+
+
+class InfoRepo(IInfoRepo):
+    _endpoint = "/"
+
+    _endpoint_solvers = "/solvers"
+    _endpoint_providers = "/providers"
+
+    def solvers_available(
+        self, solver_name: Optional[str] = None
+    ) -> Dict[str, Dict[str, SolverInfo]]:
+        params = {}
+        if solver_name:
+            params["solver_name"] = solver_name
+
+        response = self._client.get(
+            f"{self._endpoint_solvers}/available",
+            params=params,
+        )
+
+        response.raise_for_status()
+
+        json: Dict[str, Dict[str, Any]] = response.json()
+        to_return: Dict[str, Dict[str, SolverInfo]] = {}
+        for provider in json:
+            to_return[provider] = {}
+            for solver in json[provider]:
+                to_return[provider][solver] = SolverInfo.model_validate(
+                    json[provider][solver]
+                )
+
+        return to_return
+
+    def providers_available(self) -> List[str]:
+        response = self._client.get(
+            f"{self._endpoint_providers}/available",
+        )
+
+        response.raise_for_status()
+
+        return [i for i in response.json()]

luna_sdk/repositories/lp_repo.py

@@ -0,0 +1,105 @@
+import os
+import pickle
+import tempfile
+from functools import partial
+from typing import Tuple, List, Dict
+
+import dimod
+from dimod import ConstrainedQuadraticModel
+from dimod.constrained.constrained import CQMToBQMInverter
+from docplex.mp.model import Model as DOCplexModel
+from qiskit_optimization import QuadraticProgram
+
+from luna_sdk.exceptions.transformation import TransformationException
+from luna_sdk.interfaces.lp_repo_i import ILPRepo
+from luna_sdk.schemas.transformations.bqm import BQMResultSchema, BQMSchema
+from luna_sdk.schemas.transformations.matrix import MatrixSchema
+
+
+class LPRepo(ILPRepo):
+    _endpoint = "/transformations/lp"
+
+    def _send_request_with_pickle_file_response(self, lp_string: str, endpoint: str):
+        file = tempfile.NamedTemporaryFile(delete=False, suffix=".lp")
+        with open(file.name, "w") as tmp:
+            tmp.write(lp_string)
+        response = self._client.post(endpoint, files={"file": (file.name, file.file)})
+        os.remove(file.name)
+        try:
+            parsed_model = pickle.loads(response.content)
+        except Exception:
+            raise TransformationException()
+        return parsed_model
+
+    def to_qubo_qiskit(self, lp_string: str) -> QuadraticProgram:
+        qubo_qiskit_model = self._send_request_with_pickle_file_response(
+            lp_string, f"{self._endpoint}/to-qubo-qiskit"
+        )
+        try:
+            assert isinstance(qubo_qiskit_model, QuadraticProgram)
+        except AssertionError:
+            raise TransformationException()
+        return qubo_qiskit_model
+
+    def to_docplex(self, lp_string: str) -> DOCplexModel:
+        docplex_model = self._send_request_with_pickle_file_response(
+            lp_string, f"{self._endpoint}/to-docplex"
+        )
+        try:
+            assert isinstance(docplex_model, DOCplexModel)
+        except AssertionError:
+            raise TransformationException()
+        return docplex_model
+
+    def to_qubo_matrix(self, lp_string: str) -> Tuple[List[List[float]], partial]:
+        file = tempfile.NamedTemporaryFile(delete=False, suffix=".lp")
+        with open(file.name, "w") as tmp:
+            tmp.write(lp_string)
+        response = self._client.post(
+            f"{self._endpoint}/to-qubo-matrix", files={"file": (file.name, file.file)}
+        )
+        retrieved_matrix = MatrixSchema.validate(response.json())
+        return retrieved_matrix.matrix, partial(
+            self.inverter,
+            var_indices=retrieved_matrix.variable_indices,
+            inverter_bqm=CQMToBQMInverter.from_dict(retrieved_matrix.inverter.dict()),
+        )
+
+    def to_bqm(
+        self, lp_string: str
+    ) -> Tuple[dimod.BinaryQuadraticModel, CQMToBQMInverter]:
+        file = tempfile.NamedTemporaryFile(delete=False, suffix=".lp")
+        with open(file.name, "w") as tmp:
+            tmp.write(lp_string)
+        response = self._client.post(
+            f"{self._endpoint}/to-bqm", files={"file": (file.name, file.file)}
+        )
+        retrieved_bqm = BQMResultSchema.validate(response.json())
+
+        quadratic: Dict[Tuple[str, str], float] = {}
+        for key, value in retrieved_bqm.bqm.quadratic.items():
+            split_key = tuple(key.split(","))
+            if len(split_key) != 2:
+                raise TransformationException
+            quadratic[split_key[0], split_key[1]] = value
+        try:
+            bqm = dimod.BinaryQuadraticModel(
+                retrieved_bqm.bqm.linear,
+                quadratic,
+                offset=retrieved_bqm.bqm.offset,
+                vartype=retrieved_bqm.bqm.var_type,
+            )
+        except Exception:
+            raise TransformationException()
+        inverter = CQMToBQMInverter.from_dict(retrieved_bqm.inverter.dict())
+        return bqm, inverter
+
+    def to_cqm(self, lp_string: str) -> ConstrainedQuadraticModel:
+        file = tempfile.NamedTemporaryFile(delete=False, suffix=".lp")
+        with open(file.name, "w") as tmp:
+            tmp.write(lp_string)
+        response = self._client.post(
+            f"{self._endpoint}/to-cqm", files={"file": (file.name, file.file)}
+        )
+        cqm = ConstrainedQuadraticModel.from_file(response.content)
+        return cqm