luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

luna_quantum/solve/default_token.py

@@ -0,0 +1,304 @@
+from typing import ClassVar
+
+from luna_quantum.client.schemas import QpuToken, QpuTokenSource
+
+
+class DefaultToken:
+    """
+    Set default tokens for various quantum computing providers.
+
+    This class is used to set, retrieve, and remove the default QPU tokens for different
+    quantum computing providers. It supports providers such as D-Wave, IBM,
+    Fujitsu, Q-CTRL, and AWS. The purpose is to centralize token management
+    for seamless integration with quantum computing platforms.
+    """
+
+    _dwave: ClassVar[QpuToken | None] = None
+    _ibm: ClassVar[QpuToken | None] = None
+    _fujitsu: ClassVar[QpuToken | None] = None
+    _qctrl: ClassVar[QpuToken | None] = None
+    _aws_access_key: ClassVar[QpuToken | None] = None
+    _aws_secret_access_key: ClassVar[QpuToken | None] = None
+    _aws_session_token: ClassVar[QpuToken | None] = None
+
+    @classmethod
+    def set_token(cls, provider: str, token: QpuToken | str) -> None:
+        """
+        Set the token for a specific provider.
+
+        This method associates a token with a given provider, allowing for
+        authenticated interactions with the provider's services.
+
+        Parameters
+        ----------
+        provider : str
+            The name or identifier of the provider.
+        token : Union[QpuToken, str]
+            The token object or string to authenticate with the provider.
+        """
+        if isinstance(token, str):
+            token = QpuToken(token=token, source=QpuTokenSource.INLINE)
+        cls._set_token(provider, token)
+
+    @classmethod
+    def set_dwave_token(cls, token: QpuToken | str) -> None:
+        """
+        Set the token for the D-Wave platform.
+
+        Allow users to set a default token for accessing the D-Wave platform by
+        specifying it as a parameter.
+
+        Parameters
+        ----------
+        token : Union[QpuToken, str]
+            The token to use for D-Wave access.
+
+        Returns
+        -------
+        None
+
+        """
+        cls.set_token("dwave", token)
+
+    @classmethod
+    def set_ibm_token(cls, token: QpuToken | str) -> None:
+        """
+        Set the token for the IBM platform.
+
+        Allow users to set a default token for accessing the IBM platform by
+        specifying it as a parameter.
+
+        Parameters
+        ----------
+        token : Union[QpuToken, str]
+            The token to use for IBM access.
+
+        Returns
+        -------
+        None
+
+        """
+        cls.set_token("ibm", token)
+
+    @classmethod
+    def set_fujitsu_token(cls, token: QpuToken | str) -> None:
+        """
+        Set the token for the Fujitsu platform.
+
+        Allow users to set a default token for accessing the Fujitsu platform by
+        specifying it as a parameter.
+
+        Parameters
+        ----------
+        token : Union[QpuToken, str]
+            The token to use for Fujitsu access.
+
+        Returns
+        -------
+        None
+
+        """
+        cls.set_token("fujitsu", token)
+
+    @classmethod
+    def set_qctrl_token(cls, token: QpuToken | str) -> None:
+        """
+        Set the token for the QCTRL platform.
+
+        Allow users to set a default token for accessing the QCTRL platform by
+        specifying it as a parameter.
+
+        Parameters
+        ----------
+        token : Union[QpuToken, str]
+            The token to use for QCTRL access.
+
+        Returns
+        -------
+        None
+
+        """
+        cls.set_token("qctrl", token)
+
+    @classmethod
+    def set_aws_access_token(
+        cls,
+        access_key: QpuToken | str,
+        secret_access_key: QpuToken | str,
+        aws_session_token: QpuToken | str,
+    ) -> None:
+        """
+        Set the tokens for the AWS platform.
+
+        Allow users to set a default token for accessing the AWS platform by
+        specifying it as a parameter.
+
+        Parameters
+        ----------
+        access_key : Union[QpuToken, str]
+            The access key to use for AWS.
+        secret_access_key : Union[QpuToken, str]
+            The secret access key to use for AWS.
+
+        Returns
+        -------
+        None
+
+        """
+        cls.set_token("aws_access_key", access_key)
+        cls.set_token("aws_secret_access_key", secret_access_key)
+        cls.set_token("aws_session_token", aws_session_token)
+
+    @classmethod
+    def remove_token(cls, provider: str) -> None:
+        """
+        Remove a token for a specific provider.
+
+        This method removes the token associated with a particular provider by setting
+        its value to None.
+
+        Parameters
+        ----------
+        provider : str
+            The identifier for the provider whose token is to be removed.
+
+        Returns
+        -------
+        None
+            This method does not return a value.
+        """
+        cls._set_token(provider, None)
+
+    @classmethod
+    def remove_dwave_token(cls) -> None:
+        """
+        Remove the D-Wave token from the default token provider.
+
+        Returns
+        -------
+        None
+            This method does not return anything.
+        """
+        cls.remove_token("dwave")
+
+    @classmethod
+    def remove_ibm_token(cls) -> None:
+        """
+        Remove the IBM token from the default token provider.
+
+        Returns
+        -------
+        None
+            This method does not return anything.
+        """
+        cls.remove_token("ibm")
+
+    @classmethod
+    def remove_fujitsu_token(cls) -> None:
+        """
+        Remove the Fujitsu token from the default token provider.
+
+        Returns
+        -------
+        None
+            This method does not return anything.
+        """
+        cls.remove_token("fujitsu")
+
+    @classmethod
+    def remove_qctrl_token(cls) -> None:
+        """
+        Remove the QCTRl token from the default token provider.
+
+        Returns
+        -------
+        None
+            This method does not return anything.
+        """
+        cls.remove_token("qctrl")
+
+    @classmethod
+    def remove_aws_token(cls) -> None:
+        """
+        Remove the AWS tokens from the default token provider.
+
+        Returns
+        -------
+        None
+            This method does not return anything.
+        """
+        cls.remove_token("aws_access_key")
+        cls.remove_token("aws_secret_access_key")
+        cls.remove_token("aws_session_token")
+
+    @classmethod
+    def get_token(cls, provider: str) -> QpuToken | None:
+        """
+        Get the token for a specified quantum computing provider.
+
+        This method returns the token associated with the given provider name. If the
+        provider is not recognized, it returns None.
+
+        Parameters
+        ----------
+        provider : str
+            The name of the quantum computing provider.
+
+        Returns
+        -------
+        Union[QpuToken, None]
+            The token associated with the specified provider, or None if the provider is
+        """
+        to_return: QpuToken | None = None
+        if provider == "dwave":
+            to_return = cls._dwave
+        elif provider == "ibm":
+            to_return = cls._ibm
+        elif provider == "fujitsu":
+            to_return = cls._fujitsu
+        elif provider == "qctrl":
+            to_return = cls._qctrl
+        elif provider == "aws_access_key":
+            to_return = cls._aws_access_key
+        elif provider == "aws_secret_access_key":
+            to_return = cls._aws_secret_access_key
+        elif provider == "aws_session_token":
+            to_return = cls._aws_session_token
+        else:
+            to_return = None
+        return to_return
+
+    @classmethod
+    def _set_token(cls, provider: str, token: QpuToken | None) -> None:
+        """
+        Set token for the specified quantum provider.
+
+        The method updates the corresponding class-level attribute for the given
+        quantum provider with the token provided.
+
+        Parameters
+        ----------
+        provider : str
+            The name of the quantum provider to set the token for.
+        token : Union[QpuToken, None]
+            The token to associate with the given provider.
+
+        Raises
+        ------
+        KeyError
+            If the provider name does not match any supported providers.
+        """
+        if provider == "dwave":
+            cls._dwave = token
+        elif provider == "ibm":
+            cls._ibm = token
+        elif provider == "fujitsu":
+            cls._fujitsu = token
+        elif provider == "qctrl":
+            cls._qctrl = token
+        elif provider == "aws_access_key":
+            cls._aws_access_key = token
+        elif provider == "aws_secret_access_key":
+            cls._aws_secret_access_key = token
+        elif provider == "aws_session_token":
+            cls._aws_session_token = token

luna_quantum/solve/domain/abstract/__init__.py

@@ -0,0 +1,4 @@
+from .luna_algorithm import LunaAlgorithm
+from .qpu_token_backend import QpuTokenBackend
+
+__all__ = ["LunaAlgorithm", "QpuTokenBackend"]

luna_quantum/solve/domain/abstract/luna_algorithm.py

@@ -0,0 +1,205 @@
+from abc import abstractmethod
+from logging import Logger
+from typing import TYPE_CHECKING, Any, ClassVar, Generic
+
+from pydantic import ConfigDict, Field, field_validator
+
+from luna_quantum.aqm_overwrites.model import Model
+from luna_quantum.client.controllers.luna_solve import LunaSolve
+from luna_quantum.factories.luna_solve_client_factory import LunaSolveClientFactory
+from luna_quantum.solve.domain.solve_job import SolveJob
+from luna_quantum.solve.errors.incompatible_backend_error import (
+    IncompatibleBackendError,
+)
+from luna_quantum.solve.interfaces.algorithm_i import BACKEND_TYPE, IAlgorithm
+from luna_quantum.util.log_utils import Logging
+
+if TYPE_CHECKING:
+    from luna_quantum.solve.interfaces.usecases import ISolveJobCreateUseCase
+
+
+class LunaAlgorithm(IAlgorithm[BACKEND_TYPE], Generic[BACKEND_TYPE]):
+    """
+    Class representing a solver for Luna model problems.
+
+    This class serves as a base model combining functionality for model
+    solvers, client management, and configurations needed for integrating with
+    Luna's solving capabilities.
+    """
+
+    _logger: ClassVar[Logger] = Logging.get_logger(__name__)
+    backend: BACKEND_TYPE | None = Field(
+        default=None,
+        exclude=True,
+        repr=False,
+    )
+
+    @field_validator("backend", mode="before")
+    @classmethod
+    def backend_validator(cls, v: Any) -> BACKEND_TYPE | None:  # noqa: ANN401 # Ignore ANN401 here because the type for validation could be every type.
+        """
+        Validate and ensure the compatibility of the backend.
+
+        Convert or validate the backend input to ensure compatibility with
+        the expected backend type. This method is called before assigning a
+        value to the backend attribute.
+
+        Parameters
+        ----------
+        v : Any
+            The value to be validated or converted into the compatible backend type.
+
+        Returns
+        -------
+        Optional[BACKEND_TYPE]
+            The validated or converted backend type. It returns None if the validation
+            fails and no compatible backend type can be determined.
+
+        Raises
+        ------
+        IncompatibleBackendError
+            Raised if the value cannot be ensured to meet the backend compatibility
+            requirements.
+        """
+        return cls._ensure_backend_compatibility(v)
+
+    @classmethod
+    def _ensure_backend_compatibility(cls, backend: Any) -> BACKEND_TYPE | None:  # noqa: ANN401 Disabled since we want to check every possible input if its valid
+        """
+        Ensure the compatibility of the provided backend.
+
+        Check if the given backend is compatible with the current algorithm. If not,
+        log an error and raise an exception. Return without any action if the
+        backend is None.
+
+        Parameters
+        ----------
+        backend : Optional[BACKEND_TYPE]
+            Backend instance to be verified for compatibility.
+
+        Raises
+        ------
+        IncompatibleBackendError
+            If the backend is not compatible with the algorithm.
+        """
+        if backend is None:
+            return None
+
+        if not isinstance(backend, cls.get_compatible_backends()):
+            cls._logger.error(
+                f"Backend of type {type(backend)}"
+                f" is not compatible with the '{cls.__name__}' Algorithm. "
+                f"Use one of the following: {cls.get_compatible_backends()}",
+            )
+            raise IncompatibleBackendError(backend, cls)
+
+        # We checked before if its a instance of BACKEND_TYPE
+        # so we know here that this is correct,
+        # unless we implement cls.get_compatible_backends() wrong.
+        return backend
+
+    def run(
+        self,
+        model: Model | str,
+        name: str | None = None,
+        backend: BACKEND_TYPE | None = None,
+        client: LunaSolve | str | None = None,
+        *args: Any,  # noqa: ARG002 its set here in case a child needs more set parameters
+        **kwargs: Any,  # noqa: ARG002 its set here in case a child needs more set parameters
+    ) -> SolveJob:
+        """
+        Run the configured solver.
+
+        Parameters
+        ----------
+        model : Model or str
+            The model to be optimized or solved. It could be an Model instance or
+            a string identifier representing the model id.
+        name: Optional[str]
+            If provided, the name of the job. Defaults to None.
+        backend: Optional[BACKEND_TYPE]
+            Backend to use for the solver. If not provided, the default backend is
+            used.
+        client : LunaSolve or str, optional
+            The client interface used to interact with the backend services. If
+            not provided, a default client will be used.
+        *args : Any
+            Additional arguments that will be passed to the solver or client.
+        **kwargs : Any
+            Additional keyword parameters for configuration or customization.
+
+        Returns
+        -------
+        SolveJob
+            The job object containing the information about the solve process.
+        """
+        from luna_quantum.factories.usecase_factory import (  # noqa: PLC0415
+            UseCaseFactory,
+        )
+
+        b: BACKEND_TYPE
+        if backend is not None:
+            b = backend
+        elif self.backend is not None:
+            b = self.backend
+        else:
+            b = self.get_default_backend()
+
+        self._ensure_backend_compatibility(b)
+
+        c = LunaSolveClientFactory.get_client(client=client)
+
+        uc: ISolveJobCreateUseCase = UseCaseFactory.solve_job_create(client=c)
+
+        return uc(model=model, luna_solver=self, backend=b, name=name)
+
+    @property
+    @abstractmethod
+    def algorithm_name(self) -> str:
+        """
+        Returns the name of the algorithm.
+
+        This abstract property method is intended to be overridden by subclasses.
+        It should provide the name of the algorithm being implemented.
+
+        Returns
+        -------
+        str
+            The name of the algorithm.
+        """
+
+    @classmethod
+    @abstractmethod
+    def get_default_backend(cls) -> BACKEND_TYPE:
+        """
+        Return the default backend implementation.
+
+        This property must be implemented by subclasses to provide
+        the default backend instance to use when no specific backend
+        is specified.
+
+        Returns
+        -------
+            BACKEND_TYPE
+                An instance of a class implementing the IBackend interface that serves
+                as the default backend.
+        """
+
+    @classmethod
+    @abstractmethod
+    def get_compatible_backends(cls) -> tuple[type[BACKEND_TYPE], ...]:
+        """
+        Check at runtime if the used backend is compatible with the solver.
+
+        Returns
+        -------
+        tuple[type[IBackend], ...]
+            True if the backend is compatible with the solver, False otherwise.
+
+        """
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="allow",
+        validate_assignment=True,
+    )

luna_quantum/solve/domain/abstract/qpu_token_backend.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+
+from luna_quantum.client.schemas.qpu_token.qpu_token import TokenProvider
+from luna_quantum.client.utils.qpu_token_utils import QpuTokenUtils
+from luna_quantum.solve.interfaces.backend_i import IBackend
+
+
+class QpuTokenBackend(IBackend, ABC):
+    """Abstract base class for backend providers that require QPU tokens."""
+
+    @abstractmethod
+    def _get_token(self) -> TokenProvider | None:
+        pass
+
+    def get_qpu_tokens(self) -> TokenProvider | None:
+        """
+        Retrieve a QPU token.
+
+        This method is intended to be implemented by subclasses to provide the
+        mechanism for fetching the required Quantum Processing Unit (QPU) tokens, if
+        they are required by the solver implementation. The tokens may either be
+        sourced from a `TokenProvider` object or result in a `None` if unavailable.
+
+        Returns
+        -------
+        TokenProvider | None:
+            An object implementing the `TokenProvider` interface if tokens are
+            available/needed, otherwise `None`.
+        """
+        token = self._get_token()
+        if token is None:
+            token = TokenProvider()
+
+        return QpuTokenUtils.patch_qpu_tokens_from_env(token)

luna_quantum/solve/domain/model_metadata.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+from luna_quantum.client.schemas.wrappers import (
+    PydanticDatetimeWrapper,  # noqa: TC001 Otherwise Pydantic will break
+)
+from luna_quantum.factories.luna_solve_client_factory import LunaSolveClientFactory
+
+if TYPE_CHECKING:
+    from luna_quantum.aqm_overwrites import Model
+    from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+
+
+class ModelMetadata(BaseModel):
+    """Metadata of an AQ model."""
+
+    id: str
+
+    created_date: PydanticDatetimeWrapper
+    created_by: str
+
+    modified_date: PydanticDatetimeWrapper | None = None
+    modified_by: str | None = None
+
+    def fetch_model(self, client: ILunaSolve | str | None = None) -> Model:
+        """
+        Fetch a Model instance using the provided client input.
+
+        The method uses the client input, which can be an instance of ILunaSolve or a
+        string, to create a client. It then loads the Model instance based on the
+        metadata tied to the client.
+
+        Parameters
+        ----------
+        client : Optional[Union[ILunaSolve, str]]
+            The client object or identifier used to retrieve model metadata.
+
+        Returns
+        -------
+        Model
+            An Model instance loaded based on provided client metadata.
+        """
+        c = LunaSolveClientFactory.get_client(client=client)
+
+        from luna_quantum.factories.usecase_factory import (  # noqa: PLC0415
+            UseCaseFactory,
+        )
+
+        aq_model: Model = UseCaseFactory.model_load_by_metadata(client=c).__call__(
+            model_metadata=self
+        )
+
+        return aq_model