luna-quantum 1.0.0__cp311-cp311-win_amd64.whl

luna_quantum/aqm_overwrites/__init__.py

@@ -0,0 +1,3 @@
+from .model import Model
+
+__all__ = ["Model"]

luna_quantum/aqm_overwrites/model.py

@@ -0,0 +1,184 @@
+from luna_quantum._core import Model, Solution
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.factories.luna_solve_client_factory import LunaSolveClientFactory
+from luna_quantum.factories.usecase_factory import UseCaseFactory
+from luna_quantum.solve.domain.model_metadata import ModelMetadata
+from luna_quantum.solve.domain.solve_job import SolveJob
+from luna_quantum.util.class_patcher import (
+    patch_instance,
+    patch_property,
+    patch_static,
+)
+
+
+@patch_property(Model)
+def metadata(self: Model) -> ModelMetadata | None:
+    """
+    Return metadata for the current Model instance.
+
+    If metadata is cached and corresponds to the current hash, returns the cached
+    metadata. Otherwise, retrieves metadata via a client and updates the cache.
+
+    Parameters
+    ----------
+    self
+        Instance of Model.
+
+    Returns
+    -------
+    Optional[ModelMetadata]
+        Metadata for the current Model instance, or None if an error occurs or
+        metadata cannot be retrieved.
+    """
+    _hash = self.__hash__()
+    if (
+        "metadata" in self._metadata  # type: ignore[attr-defined]
+        and "hash" in self._metadata  # type: ignore[attr-defined]
+        and self._metadata["hash"] == _hash  # type: ignore[attr-defined]
+    ):
+        return self._metadata["metadata"]  # type: ignore  # noqa: PGH003 # Patched Model
+    client = LunaSolveClientFactory.get_client(
+        None
+    )  # TODO(Llewellyn): is there a way to let the user overwrite # noqa: FIX002
+    #  set the client here
+    try:
+        _metadata = UseCaseFactory.model_load_metadata_by_hash(client=client).__call__(
+            model_hash=_hash
+        )
+    except Exception:
+        _metadata = None
+    self._metadata["metadata"] = _metadata  # type: ignore  # noqa: PGH003 # Patched Model
+    self._metadata["hash"] = _hash  # type: ignore  # noqa: PGH003 # Patched Model
+
+    return _metadata
+
+
+@patch_static(Model)
+def load_luna(model_id: str, client: ILunaSolve | str | None = None) -> Model:
+    """
+    Load an AQ model using a specific model ID.
+
+    This function retrieves an AQ model from a client obj. The client can either be
+    provided directly or created dynamically if not specified.
+
+    Parameters
+    ----------
+    model_id : str
+        The identifier of the model that needs to be loaded.
+    client : Optional[Union[ILunaSolve, str]]
+        The client to use for loading the model. If not provided, a client
+        will be created automatically.
+
+    Returns
+    -------
+    Model
+        The AQ model that was successfully loaded.
+    """
+    client = LunaSolveClientFactory.get_client(client=client)
+    return UseCaseFactory.model_load_by_id(client=client).__call__(model_id=model_id)
+
+
+@patch_instance(Model)
+def save_luna(self: Model, client: ILunaSolve | str | None = None) -> None:
+    """
+    Save the model and update its metadata and hash.
+
+    This function saves the current state of the model using the provided client or
+    default client obtained from `ClientFactory`. It also updates the local `metadata`
+    attributes of the model after saving.
+
+    Parameters
+    ----------
+    self : Model
+        The instance of the Model class.
+    client : Optional[Union[ILunaSolve, str]], default=None
+        The client to facilitate saving the model. Can be an instance of `ILunaSolve`,
+        a string representing the client, or left as None to use the default client.
+
+    Returns
+    -------
+    None
+        This function does not return any values.
+
+    """
+    client = LunaSolveClientFactory.get_client(client=client)
+    self._metadata["metadata"] = UseCaseFactory.model_save(client=client).__call__(self)  # type: ignore  # noqa: PGH003 # Patched Model
+    self._metadata["hash"] = self.__hash__()  # type: ignore[attr-defined]
+
+
+@patch_instance(Model)
+def delete_luna(self: Model, client: ILunaSolve | str | None = None) -> None:
+    """
+    Delete the Luna instance of the Model.
+
+    Ensure the Model instance is removed properly using the provided client or the
+    default client.
+
+    Parameters
+    ----------
+    self : Model
+        The instance of the model to be deleted.
+    client : Optional[Union[ILunaSolve, str]], optional
+        The client used to connect to the service. If not provided, the default
+        client is used.
+
+    Returns
+    -------
+    None
+    """
+    client = LunaSolveClientFactory.get_client(client=client)
+    UseCaseFactory.model_delete(client=client).__call__(self)
+
+
+@patch_instance(Model)
+def load_solutions(
+    self: Model, client: ILunaSolve | str | None = None
+) -> list[Solution]:
+    """
+    Load solutions for an Model.
+
+    Fetch and return the list of all solutions for the patched Model
+    using the provided client or the default client.
+
+    Parameters
+    ----------
+    self : Model
+        The Model for which solutions are to be loaded.
+    client : Optional[Union[ILunaSolve, str]], optional
+        The client used to interact and retrieve model solutions. If not provided,
+        a default client will be created using the `ClientFactory`.
+
+    Returns
+    -------
+    List[IAqSolution]
+        A list of IAqSolution instances containing the solutions.
+
+    """
+    client = LunaSolveClientFactory.get_client(client=client)
+    return UseCaseFactory.model_get_solution(client=client).__call__(self)
+
+
+@patch_instance(Model)
+def load_solve_jobs(
+    self: Model, client: ILunaSolve | str | None = None
+) -> list[SolveJob]:
+    """
+    Load and return a list of SolveJob objects for the Model instance.
+
+    Parameters
+    ----------
+    self : Model
+        The instance of the Model for which solve jobs need to be loaded.
+    client : Optional[Union[ILunaSolve, str]], optional
+        The client object or client type for fetching solve jobs, by default None.
+
+    Returns
+    -------
+    List[SolveJob]
+        A list of SolveJob objects related to the Model instance.
+    """
+    client = LunaSolveClientFactory.get_client(client=client)
+    return UseCaseFactory.model_get_solve_job(client=client).__call__(self)
+
+
+__all__ = ["Model"]

luna_quantum/client/controllers/__init__.py

@@ -0,0 +1,4 @@
+from luna_quantum.client.controllers.luna_q import LunaQ
+from luna_quantum.client.controllers.luna_solve import LunaSolve
+
+__all__ = ["LunaQ", "LunaSolve"]

luna_quantum/client/controllers/luna_http_client.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from importlib.metadata import version
+from typing import Any
+
+import httpx
+from httpx import Client, Response
+
+from luna_quantum.client.error.timeout_error import LunaTimeoutError
+from luna_quantum.client.error.utils.http_error_utils import HttpErrorUtils
+
+
+class LunaHTTPClient(Client):
+    """
+    Luna HTTP client.
+
+    Mainly used to set custom headers.
+    """
+
+    _version: str = version("luna-quantum")
+
+    _user_agent: str = f"LunaSDK/{_version}"
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.headers["User-Agent"] = self._user_agent
+
+    def request(self, *args: Any, **kwargs: Any) -> Response:
+        """Send request to Luna platform."""
+        try:
+            response: Response = super().request(*args, **kwargs)
+        except httpx.TimeoutException:
+            # Handle all possible in httpx timeout exceptions
+            raise LunaTimeoutError from None
+        HttpErrorUtils.check_for_error(response)
+        return response

luna_quantum/client/controllers/luna_platform_client.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import os
+from contextlib import suppress
+from enum import Enum
+from http import HTTPStatus
+from typing import TYPE_CHECKING, ClassVar
+
+import httpx
+from httpx import HTTPStatusError, Request, Response
+
+from luna_quantum.client.controllers.luna_http_client import LunaHTTPClient
+from luna_quantum.client.error.luna_api_key_invalid_error import LunaApiKeyInvalidError
+from luna_quantum.client.error.luna_api_key_missing_error import LunaApiKeyMissingError
+from luna_quantum.client.error.utils.http_error_utils import HttpErrorUtils
+from luna_quantum.client.interfaces.services.service_i import IService
+from luna_quantum.client.rest_client.users_rest_client import UsersRestClient
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+
+class LunaPrefixEnum(str, Enum):
+    """Enumeration of Luna services."""
+
+    LUNA_SOLVE = "luna-solve"
+    LUNA_Q = "luna-q"
+
+
+def check_httpx_exceptions(response: Response) -> None:
+    """
+    Check if response contains errors from the server.
+
+    This function examines the HTTP response and raises appropriate SDK exceptions
+    if error conditions are detected.
+
+    Parameters
+    ----------
+    response: Response
+        The HTTP response object to be examined for error conditions.
+    """
+    HttpErrorUtils.check_for_error(response)
+
+
+class APIKeyAuth(httpx.Auth):
+    """API key authentication method for luna platform."""
+
+    def __init__(self, token: str) -> None:
+        self.token = token
+
+    def auth_flow(self, request: Request) -> Generator[Request, Response, None]:
+        """
+        Authenticate a request to Luna platform.
+
+        Parameters
+        ----------
+        request: Request
+            Request that needs to be authenticated.
+        """
+        request.headers["Luna-API-Key"] = self.token
+
+        dev_header_value = os.getenv("LUNA_DEV_EXTRA_HEADER_VALUE", None)
+        dev_header_name = os.getenv("LUNA_DEV_EXTRA_HEADER_NAME", None)
+        if dev_header_name and dev_header_value:
+            request.headers[dev_header_name] = dev_header_value
+        yield request
+
+
+class LunaPlatformClient(IService):
+    """Luna platform REST client."""
+
+    _base_url: str = ""
+
+    _httpx_client: httpx.Client
+    _api_key: ClassVar[str | None] = None
+
+    @property
+    def client(self) -> httpx.Client:
+        """
+        Return httpx client.
+
+        Returns
+        -------
+        httpx.Client
+        """
+        return self._httpx_client
+
+    def __init__(
+        self,
+        api: LunaPrefixEnum,
+        api_key: str | None = None,
+        base_url: str = os.getenv("LUNA_BASE_URL", "https://api.aqarios.com"),
+        timeout: float | None = 240.0,
+    ) -> None:
+        """
+        LunaPlatformClient is a main entrypoint of the SDK.
+
+        All the operations with entities should be processed using an instance of
+        LunaPlatformClient.
+
+        Parameters
+        ----------
+        api: LunaPrefixEnum
+            Current API with which luna client is working. Can be luna-solve or luna-q.
+        api_key: Optional[str]
+            Api key to be used to authorize. Default none.
+            If its none then the key set by the `authorize` method will be used.
+        base_url:
+            Base API URL.
+            If you want to use API not on your local PC then change it.
+            You can do that by setting the environment variable LUNA_BASE_URL.
+            Default value https://api.aqarios.com.
+        timeout:
+            Default timeout in seconds for the requests via the LunaQ client. `None`
+            means that the SDK uses no timeouts. Note that either way the Luna platform
+            itself will time out after 240 seconds.
+            Default: 240.0
+        """
+        if os.getenv("LUNA_DISABLE_SUFFIX", "false").lower() == "true":
+            self._base_url = f"{base_url}/api/v1"
+        else:
+            self._base_url = f"{base_url}/{api.value}/api/v1"
+        if api_key:
+            auth_key = api_key
+        elif self.__class__._api_key:  # noqa: SLF001 Use here self.__class__ so that LunaSolve and LunaQ can have different api keys set
+            auth_key = self.__class__._api_key  # noqa: SLF001 Use here self.__class__ so that LunaSolve and LunaQ can have different api keys set
+        elif key := os.getenv("LUNA_API_KEY", None):
+            auth_key = key
+        else:
+            raise LunaApiKeyMissingError
+
+        self._httpx_client = LunaHTTPClient(
+            auth=APIKeyAuth(auth_key),
+            base_url=self._base_url,
+            follow_redirects=True,
+            timeout=timeout,
+            event_hooks={"response": [check_httpx_exceptions]},
+        )
+
+        self._authenticate()
+
+    def __del__(self) -> None:  # noqa: D105
+        if hasattr(self, "_httpx_client"):
+            with suppress(Exception):
+                self._httpx_client.close()
+
+    def _authenticate(self) -> None:
+        try:
+            UsersRestClient(service=self).get_me()
+        except HTTPStatusError as exception:
+            if exception.response.status_code == HTTPStatus.UNAUTHORIZED:
+                raise LunaApiKeyInvalidError from exception
+            raise

luna_quantum/client/controllers/luna_q.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from luna_quantum.client.controllers.luna_platform_client import (
+    LunaPlatformClient,
+    LunaPrefixEnum,
+)
+from luna_quantum.client.interfaces.services.luna_q_i import ILunaQ
+from luna_quantum.client.rest_client import CircuitRestClient, QpuTokenRestClient
+
+if TYPE_CHECKING:
+    from luna_quantum.client.interfaces.clients import ICircuitRestClient
+    from luna_quantum.client.interfaces.clients.qpu_token_rest_client_i import (
+        IQpuTokenRestClient,
+    )
+
+
+class LunaQ(LunaPlatformClient, ILunaQ):
+    """Implementation of LunaQ service."""
+
+    qpu_token: IQpuTokenRestClient = None  # type: ignore[assignment]
+    circuit: ICircuitRestClient = None  # type: ignore[assignment]
+
+    def __init__(
+        self, api_key: str | None = None, timeout: float | None = 240.0
+    ) -> None:
+        """
+        LunaQ is the main entrypoint for all LunaQ related tasks.
+
+        Parameters
+        ----------
+        api_key: str
+            User's API key
+        timeout: float
+            Default timeout in seconds for the requests via the LunaQ client. `None`
+            means that the SDK uses no timeouts. Note that either way the Luna platform
+            itself will time out after 240 seconds.
+            Default: 240.0
+        """
+        super().__init__(api_key=api_key, api=LunaPrefixEnum.LUNA_Q, timeout=timeout)
+
+        self.circuit = CircuitRestClient(self)
+        self.qpu_token = QpuTokenRestClient(self)
+
+    @classmethod
+    def authenticate(cls, api_key: str) -> None:
+        """
+        Authenticate the client with the given API key.
+
+        Parameters
+        ----------
+        api_key : str
+            The API key used to authenticate the client.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+        """
+        cls(api_key=api_key)
+        cls._api_key = api_key

luna_quantum/client/controllers/luna_solve.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from luna_quantum.client.controllers.luna_platform_client import (
+    LunaPlatformClient,
+    LunaPrefixEnum,
+)
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.client.rest_client.info_rest_client import InfoRestClient
+from luna_quantum.client.rest_client.model_rest_client import (
+    ModelRestClient,
+)
+from luna_quantum.client.rest_client.qpu_token_rest_client import QpuTokenRestClient
+from luna_quantum.client.rest_client.solve_job_rest_client import SolveJobRestClient
+
+if TYPE_CHECKING:
+    from luna_quantum.client.interfaces.clients import ISolveJobRestClient
+    from luna_quantum.client.interfaces.clients.info_rest_client_i import (
+        IInfoRestClient,
+    )
+    from luna_quantum.client.interfaces.clients.model_rest_client_i import (
+        IModelRestClient,
+    )
+    from luna_quantum.client.interfaces.clients.qpu_token_rest_client_i import (
+        IQpuTokenRestClient,
+    )
+
+
+class LunaSolve(LunaPlatformClient, ILunaSolve):
+    """Implementation of LunaSolve service."""
+
+    _model: IModelRestClient
+    _solve_job: ISolveJobRestClient
+    _qpu_token: IQpuTokenRestClient
+    _info: IInfoRestClient
+
+    def __init__(
+        self, api_key: str | None = None, timeout: float | None = 240.0
+    ) -> None:
+        """
+        LunaSolve is the main entrypoint for all LunaSolve related tasks.
+
+        Parameters
+        ----------
+        api_key: str
+            User's API key
+        timeout: float
+            Default timeout in seconds for the requests via the LunaQ client. `None`
+            means that the SDK uses no timeouts. Note that either way the Luna platform
+            itself will time out after 240 seconds.
+            Default: 240.0
+        """
+        super().__init__(
+            api_key=api_key,
+            api=LunaPrefixEnum.LUNA_SOLVE,
+            timeout=timeout,
+        )
+
+        self._model = ModelRestClient(self)
+        self._solve_job = SolveJobRestClient(self)
+        self._qpu_token = QpuTokenRestClient(self)
+        self._info = InfoRestClient(self)
+
+    @classmethod
+    def authenticate(cls, api_key: str) -> None:
+        """
+        Authenticate the client with the given API key.
+
+        Parameters
+        ----------
+        api_key : str
+            The API key used to authenticate the client.
+
+        Returns
+        -------
+        None
+            This method does not return any value.
+        """
+        cls(api_key=api_key)
+        cls._api_key = api_key
+
+    @property
+    def model(self) -> IModelRestClient:
+        """
+        Returns a model rest client.
+
+        Returns
+        -------
+        IModelRestClient
+        """
+        return self._model
+
+    @property
+    def solve_job(self) -> ISolveJobRestClient:
+        """
+        Returns a solve job rest client.
+
+        Returns
+        -------
+        ISolveJobRestClient
+        """
+        return self._solve_job
+
+    @property
+    def qpu_token(self) -> IQpuTokenRestClient:
+        """
+        Returns a qpu token rest client.
+
+        Returns
+        -------
+        IQpuTokenRestClient
+        """
+        return self._qpu_token
+
+    @property
+    def info(self) -> IInfoRestClient:
+        """
+        Returns an info rest client.
+
+        Returns
+        -------
+        IInfoRestClient
+        """
+        return self._info

luna_quantum/client/error/luna_api_key_invalid_error.py

@@ -0,0 +1,10 @@
+from luna_quantum.client.error.luna_error import LunaError
+
+
+class LunaApiKeyInvalidError(LunaError):
+    """Raised when the Luna API key is invalid."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            "Luna API key is invalid. Please provide a valid Luna API key."
+        )

luna_quantum/client/error/luna_api_key_missing_error.py

@@ -0,0 +1,10 @@
+from luna_quantum.client.error.luna_error import LunaError
+
+
+class LunaApiKeyMissingError(LunaError):
+    """Raised when the Luna API key is missing."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            "Luna API key is missing. Please set the LUNA_API_KEY environment variable."
+        )

luna_quantum/client/error/luna_error.py

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

luna_quantum/client/error/luna_server_error.py

@@ -0,0 +1,20 @@
+from luna_quantum.client.error.luna_error import LunaError
+from luna_quantum.client.schemas.error_message import ErrorMessage
+
+
+class LunaServerError(LunaError):
+    """Luna HTTP server error."""
+
+    http_status_code: int
+    error_message: ErrorMessage
+
+    def __init__(self, http_status_code: int, error_message: ErrorMessage) -> None:
+        self.http_status_code = http_status_code
+        self.error_message = error_message
+        super().__init__(error_message.message)
+
+    def __str__(self) -> str:  # noqa: D105
+        return (
+            f"The Luna-Server reported the error '{self.error_message.internal_code}' "
+            f"with the message:\n {self.error_message.message}"
+        )

luna_quantum/client/error/timeout_error.py

@@ -0,0 +1,12 @@
+from luna_quantum.client.error.luna_error import LunaError
+
+
+class LunaTimeoutError(LunaError):
+    """Luna timeout error."""
+
+    def __init__(self) -> None:
+        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_quantum/client/error/transformation_error.py

@@ -0,0 +1,18 @@
+from luna_quantum.client.error.luna_error import LunaError
+
+
+class TransformationError(LunaError):
+    """Luna transformation error."""
+
+    def __str__(self) -> str:  # noqa: D105
+        return (
+            "An unexpected error occurred during transformation,"
+            " please contact support or open an issue."
+        )
+
+
+class WeightedConstraintError(LunaError):
+    """Error if weighted constraints provided in CQM."""
+
+    def __str__(self) -> str:  # noqa: D105
+        return "Weighted constraints for CQM are not supported"