luna-quantum 0.0.16__py3-none-any.whl

luna_sdk/controllers/luna_transform.py

@@ -0,0 +1,41 @@
+from luna_sdk.controllers.luna_platform_client import LunaPlatformClient
+from luna_sdk.interfaces.clients.luna_transform_i import ILunaTransform
+from luna_sdk.interfaces.cplex_repo_i import ICplexRepo
+from luna_sdk.interfaces.lp_repo_i import ILPRepo
+from luna_sdk.repositories.cplex_repo import CplexRepo
+from luna_sdk.repositories.lp_repo import LPRepo
+
+
+class LunaTransform(LunaPlatformClient, ILunaTransform):
+    cplex: ICplexRepo = None  # type: ignore
+    lp: ILPRepo = None  # type: ignore
+
+    def __init__(
+        self,
+        email: str,
+        password: str,
+        timeout: float = 10.0,
+    ):
+        """
+        LunaSolve is the main entrypoint for all LunaSolve related tasks.
+
+        Parameters
+        ----------
+        email: str
+            User's email
+        password: str
+            User's password
+        timeout: float
+            Timeout for the requests. Default value 10.
+
+        Returns
+        -------
+        """
+        super().__init__(
+            email=email,
+            password=password,
+            timeout=timeout,
+        )
+
+        self.cplex = CplexRepo(self._client)
+        self.lp = LPRepo(self._client)

luna_sdk/error/http_error_utils.py

@@ -0,0 +1,100 @@
+import logging
+from typing import Optional
+
+from httpx import HTTPStatusError, RequestError, Response
+
+from luna_sdk.exceptions.luna_server_exception import LunaServerException
+from luna_sdk.schemas.error_message import ErrorMessage
+
+
+class HttpErrorUtils:
+    @staticmethod
+    def __sdk_custom_request_errors(
+        response: Response,
+    ) -> Optional[LunaServerException]:
+        """
+        Check if the response needs a custom error message from the SDK.
+
+        This is the place to add other custom error messages.
+        This is helpful then the default http error messages are not enough for the user.
+
+        Parameters
+        ----------
+        response:
+            Response object from the request
+
+        Returns
+        -------
+        Optional[LunaServerException]
+            If the response needs a custom error message, return the exception.
+            Otherwise, return None.
+        """
+        exception: Optional[LunaServerException] = None
+
+        def create_error_message(
+            internal_code: str, message: str
+        ) -> LunaServerException:
+            return LunaServerException(
+                response.status_code,
+                ErrorMessage(
+                    internal_code=f"SDK-{internal_code}",
+                    message=message,
+                ),
+            )
+
+        if response.status_code == 502:
+            # Catch error when upload was too long
+            exception = create_error_message(
+                "LUNA_GATEWAY_TIMEOUT",
+                "The Luna server did not respond within time,"
+                " leading to a timeout. Try reducing the size of the optimization.",
+            )
+
+        return exception
+
+    @staticmethod
+    def check_for_error(response: Response) -> None:
+        """
+        Check if an error occurred and rais the error if so.
+
+        Parameters
+        ----------
+        response: Response
+            Response object from the request
+
+        Raises
+        ------
+        LunaServerException
+            If an error occurred with the request. The error message is in the exception.
+        RequestError
+            If an error occurred with the request outside the http status codes 4xx and 5xx.
+        """
+        try:
+            response.raise_for_status()
+        except HTTPStatusError as e:
+            exception: Optional[LunaServerException]
+
+            try:
+                error_msg: ErrorMessage = ErrorMessage.model_validate_json(
+                    response.text
+                )
+
+                # Convert the error message to the correct exception
+                exception = LunaServerException(response.status_code, error_msg)
+
+            except ValueError:
+                # The server can generate errors that are in a different format, and we
+                # have less to no control how they look like.
+                # In this case, we will try to create a custom error messages.
+                exception = HttpErrorUtils.__sdk_custom_request_errors(response)
+
+            if exception:
+                logging.error(exception, exc_info=False)
+                raise exception
+            else:
+                logging.error(exception, exc_info=True)
+                raise e
+
+        except RequestError as e:
+            logging.error(e, exc_info=True)
+            raise e

luna_sdk/exceptions/__init__.py

@@ -0,0 +1 @@
+from .transformation import TransformationException

luna_sdk/exceptions/encryption_exception.py

@@ -0,0 +1,6 @@
+class EncryptionNotSetException(Exception):
+    def __str__(self):
+        return (
+            "Encryption not set. Please refer to our encryption documentation  "
+            "https://docs.aqarios.com/get-started#luna-encryption for more information."
+        )

luna_sdk/exceptions/luna_exception.py

@@ -0,0 +1,7 @@
+class LunaException(Exception):
+    """
+    Base exception for all exceptions in the Luna SDK.
+
+    """
+
+    pass

luna_sdk/exceptions/luna_server_exception.py

@@ -0,0 +1,18 @@
+from luna_sdk.exceptions.luna_exception import LunaException
+from luna_sdk.schemas.error_message import ErrorMessage
+
+
+class LunaServerException(LunaException):
+    http_status_code: int
+    error_message: ErrorMessage
+
+    def __init__(self, http_status_code: int, error_message: ErrorMessage):
+        self.http_status_code = http_status_code
+        self.error_message = error_message
+        super().__init__(error_message.message)
+
+    def __str__(self):
+        return (
+            f"The Luna-Server reported the error '{self.error_message.internal_code}' "
+            f"with the message:\n {self.error_message.message}"
+        )

luna_sdk/exceptions/timeout_exception.py

@@ -0,0 +1,10 @@
+from luna_sdk.exceptions.luna_exception import LunaException
+
+
+class TimeoutException(LunaException):
+    def __init__(self):
+        super().__init__(
+            "Luna Timeout. The request took too long to complete."
+            " Please increase timeout value or try again later."
+            " If the problem persists, please contact our support team."
+        )

luna_sdk/exceptions/transformation.py

@@ -0,0 +1,11 @@
+from luna_sdk.exceptions.luna_exception import LunaException
+
+
+class TransformationException(LunaException):
+    def __str__(self):
+        return "An unexpected error occurred during transformation, please contact support or open an issue."
+
+
+class WeightedConstraintException(LunaException):
+    def __str__(self):
+        return "Weighted constraints for CQM are not supported"

luna_sdk/interfaces/__init__.py

@@ -0,0 +1,5 @@
+from .circuit_repo_i import ICircuitRepo
+from .optimization_repo_i import IOptimizationRepo
+from .clients.client_i import IClient
+from .solutions_repo_i import ISolutionsRepo
+from .repository_i import IRepository

luna_sdk/interfaces/circuit_repo_i.py

@@ -0,0 +1,62 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+from luna_sdk.interfaces.repository_i import IRepository
+from luna_sdk.schemas.circuit import CircuitJob, CircuitResult
+from luna_sdk.schemas.enums.circuit import CircuitProviderEnum
+from luna_sdk.schemas.qpu_token import TokenProvider
+
+
+class ICircuitRepo(IRepository, ABC):
+    @abstractmethod
+    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.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get(
+        self, job: CircuitJob, encryption_key: Optional[str] = None
+    ) -> CircuitResult:
+        """
+        Attributes:
+        choices: A list containing a string or `AliasPath`.
+        encryption_key: Optional[str]
+            Encryption key to be used for encryption of QPU tokens.
+
+        This is equivalent to Python ``sum`` of :meth:`time.time`.
+        :time.time: 1.0
+        `CircuitResult`
+        Some sections are omitted here for simplicity.
+        """
+        raise NotImplementedError

luna_sdk/interfaces/clients/client_i.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+from httpx import Client
+
+
+class IClient(ABC):
+    @property
+    @abstractmethod
+    def _client(self) -> Client:
+        raise NotImplementedError

luna_sdk/interfaces/clients/luna_q_i.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+
+from luna_sdk.interfaces import ICircuitRepo
+from luna_sdk.interfaces.clients.client_i import IClient
+from luna_sdk.interfaces.qpu_token_repo_i import IQpuTokenRepo
+
+
+class ILunaQ(IClient, ABC):
+    """
+    Interface for the LunaQ client
+
+
+    """
+
+    @property
+    @abstractmethod
+    def qpu_token(self) -> IQpuTokenRepo:
+        """
+        Returns a QPU token repository
+
+        Examples
+        --------
+            >>> add(4.0, 2.0)
+            6.0
+            >>> add(4, 2)
+            6.0
+
+
+        """
+
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def circuit(self) -> ICircuitRepo:
+        """
+        Returns a circuit :py:class: repository
+        """
+        raise NotImplementedError

luna_sdk/interfaces/clients/luna_solve_i.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+
+from luna_sdk.interfaces.clients.client_i import IClient
+from luna_sdk.interfaces.info_repo_i import IInfoRepo
+from luna_sdk.interfaces.optimization_repo_i import IOptimizationRepo
+from luna_sdk.interfaces.qpu_token_repo_i import IQpuTokenRepo
+from luna_sdk.interfaces.solutions_repo_i import ISolutionsRepo
+
+
+class ILunaSolve(IClient, ABC):
+    @property
+    @abstractmethod
+    def optimization(self) -> IOptimizationRepo:
+        """
+        Returns an optimization repository
+
+        Returns
+        ----------
+            IOptimizationRepo]
+
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def solution(self) -> ISolutionsRepo:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def qpu_token(self) -> IQpuTokenRepo:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def info(self) -> IInfoRepo:
+        raise NotImplementedError

luna_sdk/interfaces/clients/luna_transform_i.py

@@ -0,0 +1,33 @@
+from abc import abstractmethod, ABC
+
+from luna_sdk.interfaces import IClient, IOptimizationRepo
+from luna_sdk.interfaces.cplex_repo_i import ICplexRepo
+from luna_sdk.interfaces.lp_repo_i import ILPRepo
+
+
+class ILunaTransform(IClient, ABC):
+    @property
+    @abstractmethod
+    def cplex(self) -> ICplexRepo:
+        """
+        Returns an docplex repository
+
+        Returns
+        ----------
+            ICplexRepo
+
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def lp(self) -> ILPRepo:
+        """
+        Returns a lp repository
+
+        Returns
+        ----------
+            ILPRepo
+
+        """
+        raise NotImplementedError

luna_sdk/interfaces/cplex_repo_i.py

@@ -0,0 +1,121 @@
+from abc import ABC, abstractmethod
+from functools import partial
+from typing import Tuple, List
+
+import dimod
+from dimod import ConstrainedQuadraticModel
+from docplex.mp.model import Model as DOCplexModel  # type: ignore
+from qiskit_optimization import QuadraticProgram
+
+from luna_sdk.interfaces import IRepository  # type: ignore
+from dimod.constrained.constrained import CQMToBQMInverter
+
+
+class ICplexRepo(IRepository, ABC):
+    @staticmethod
+    def inverter(sample, var_indices, inverter_bqm) -> CQMToBQMInverter:
+        sample_list = list(sample.values())
+        var_sample = {name: sample_list[index] for name, index in var_indices.items()}
+        return inverter_bqm(var_sample)
+
+    @abstractmethod
+    def to_qubo_qiskit(self, docplex_model: DOCplexModel) -> QuadraticProgram:
+        """
+        Transform DOCplex model to QUBO Qiskit
+
+        Parameters
+        ----------
+        docplex_model: docplex.mp.model.Model
+            DOCplex problem description
+
+        Returns
+        -------
+        QuadraticProgram
+            QUBO Qiskit representation
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_lp_file(self, docplex_model: DOCplexModel, filepath: str) -> None:
+        """
+        Transform DOCplex to LP representation
+
+        Parameters
+        ----------
+        docplex_model: docplex.mp.model.Model
+            DOCplex problem description
+        filepath: str
+            .lp file path where result should be stored
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_lp_string(self, docplex_model: DOCplexModel) -> str:
+        """
+        Transform DOCplex to LP representation
+
+        Parameters
+        ----------
+        docplex_model: docplex.mp.model.Model
+            DOCplex problem description
+        Returns
+        -------
+        str
+            LP representation
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_qubo_matrix(
+        self, docplex_model: DOCplexModel
+    ) -> Tuple[List[List[float]], partial]:
+        """
+        Transform DOCplex model to QUBO matrix
+
+        Parameters
+        ----------
+        docplex_model: docplex.mp.model.Model
+            DOCplex problem description
+
+        Returns
+        -------
+        Tuple[List[List[float]], partial]
+            QUBO matrix representation and inverter
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_bqm(
+        self, docplex_model: DOCplexModel
+    ) -> Tuple[dimod.BinaryQuadraticModel, CQMToBQMInverter]:
+        """
+        Transform DOCplex model to BQM model
+
+        Parameters
+        ----------
+        docplex_model: docplex.mp.model.Model
+            DOCplex problem description
+
+        Returns
+        -------
+        Tuple[dimod.BinaryQuadraticModel, CQMToBQMInverter]
+            BQM representation and inverter
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_cqm(self, docplex_model: DOCplexModel) -> ConstrainedQuadraticModel:
+        """
+        Transform DOCplex model to CQM model
+
+        Parameters
+        ----------
+        docplex_model: docplex.mp.model.Model
+            DOCplex problem description
+
+        Returns
+        -------
+        ConstrainedQuadraticModel
+            CQM representation
+        """
+        raise NotImplementedError

luna_sdk/interfaces/info_repo_i.py

@@ -0,0 +1,40 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional
+
+from luna_sdk.interfaces.repository_i import IRepository
+from luna_sdk.schemas.solver_info import SolverInfo
+
+
+class IInfoRepo(IRepository, ABC):
+    @abstractmethod
+    def solvers_available(
+        self, solver_name: Optional[str] = None
+    ) -> Dict[str, Dict[str, SolverInfo]]:
+        """
+        Get list of available solvers.
+
+        Parameters
+        ----------
+        solver_name: Optional[str]
+            Name of the solver that should be retrieved. If not specified, all solvers
+            will be returned.
+
+        Returns
+        -------
+        Dict[str, Dict[str, SolverInfo]]
+            Dictionary containing the provider name as the key, and a dictionary of
+            the solver name and solver-specific information as the value.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def providers_available(self) -> List[str]:
+        """
+        Get list of available providers.
+
+        Returns
+        -------
+        List[str]
+            List of available QPU providers.
+        """
+        raise NotImplementedError

luna_sdk/interfaces/lp_repo_i.py

@@ -0,0 +1,106 @@
+from abc import ABC, abstractmethod
+from functools import partial
+from typing import Tuple, List
+
+import dimod
+from dimod import ConstrainedQuadraticModel
+from dimod.constrained.constrained import CQMToBQMInverter
+from docplex.mp.model import Model as DOCplexModel  # type: ignore
+from qiskit_optimization import QuadraticProgram
+
+from luna_sdk.interfaces import IRepository  # type: ignore
+
+
+class ILPRepo(IRepository, ABC):
+    @staticmethod
+    def inverter(sample, var_indices, inverter_bqm) -> CQMToBQMInverter:
+        sample_list = list(sample.values())
+        var_sample = {name: sample_list[index] for name, index in var_indices.items()}
+        return inverter_bqm(var_sample)
+
+    @abstractmethod
+    def to_qubo_qiskit(self, lp_string: str) -> QuadraticProgram:
+        """
+        Transform LP to QUBO Qiskit
+
+        Parameters
+        ----------
+        lp_string: str
+            LP problem description
+
+        Returns
+        -------
+        QuadraticProgram
+            QUBO Qiskit representation
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_docplex(self, lp_string: str) -> DOCplexModel:
+        """
+        Transform LP to DOCplex
+
+        Parameters
+        ----------
+        lp_string: str
+            LP problem description
+
+        Returns
+        -------
+        DOCplexModel
+            DOCplex representation
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_qubo_matrix(self, lp_string: str) -> Tuple[List[List[float]], partial]:
+        """
+        Transform LP to QUBO matrix
+
+        Parameters
+        ----------
+        lp_string: str
+            LP problem description
+
+        Returns
+        -------
+        Tuple[List[List[float]], partial]
+            QUBO matrix representation and inverter
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_bqm(
+        self, lp_string: str
+    ) -> Tuple[dimod.BinaryQuadraticModel, CQMToBQMInverter]:
+        """
+        Transform LP to BQM model
+
+        Parameters
+        ----------
+        lp_string: str
+            LP problem description
+
+        Returns
+        -------
+        Tuple[dimod.BinaryQuadraticModel, CQMToBQMInverter]
+            BQM representation and inverter
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def to_cqm(self, lp_string: str) -> ConstrainedQuadraticModel:
+        """
+        Transform LP to CQM model
+
+        Parameters
+        ----------
+        lp_string: str
+            LP problem description
+
+        Returns
+        -------
+        ConstrainedQuadraticModel
+            CQM representation
+        """
+        raise NotImplementedError