luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

luna_quantum/client/interfaces/services/luna_solve_i.py

@@ -0,0 +1,72 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+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,
+)
+from luna_quantum.client.interfaces.clients.solve_job_rest_client_i import (
+    ISolveJobRestClient,
+)
+from luna_quantum.client.interfaces.services.service_i import IService
+
+
+class ILunaSolve(IService, ABC):
+    """Inteface for luna solve service."""
+
+    @abstractmethod
+    def __init__(self, api_key: str | None = None, *args: Any, **kwargs: Any) -> None:
+        pass
+
+    @property
+    @abstractmethod
+    def model(self) -> IModelRestClient:
+        """
+        Returns a model rest client.
+
+        Returns
+        -------
+            IModelRestClient
+
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def solve_job(self) -> ISolveJobRestClient:
+        """
+        Returns a solve job rest client.
+
+        Returns
+        -------
+            ISolveJobRestClient
+
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def qpu_token(self) -> IQpuTokenRestClient:
+        """
+        Returns a qpu token rest client.
+
+        Returns
+        -------
+           IQpuTokenRestClient
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def info(self) -> IInfoRestClient:
+        """
+        Returns an info rest client.
+
+        Returns
+        -------
+           IInfoRestClient
+        """
+        raise NotImplementedError

luna_quantum/client/interfaces/services/service_i.py

@@ -0,0 +1,56 @@
+from abc import ABC, abstractmethod
+
+from httpx import Client
+
+
+class IService(ABC):
+    """Interface for luna services."""
+
+    @property
+    @abstractmethod
+    def client(self) -> Client:
+        """
+        Return the httpx client.
+
+        Returns
+        -------
+        Client
+            A httpx client.
+        """
+
+    @classmethod
+    @abstractmethod
+    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.
+        """
+
+    @abstractmethod
+    def is_same(
+        self,
+        api_key: str | None = None,
+    ) -> bool:
+        """
+        Whether the service is created with the current environment variables.
+
+        Parameters
+        ----------
+        api_key: str
+            User's API key
+
+        Returns
+        -------
+        bool:
+            True if the service is created with the current environment variables.
+            False otherwise.
+        """

luna_quantum/client/rest_client/__init__.py

@@ -0,0 +1,15 @@
+from luna_quantum.client.rest_client.circuit_rest_client import CircuitRestClient
+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
+
+__all__ = [
+    "CircuitRestClient",
+    "InfoRestClient",
+    "ModelRestClient",
+    "QpuTokenRestClient",
+    "SolveJobRestClient",
+]

luna_quantum/client/rest_client/circuit_rest_client.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from luna_quantum.client.interfaces.clients.circuit_rest_client_i import (
+    ICircuitRestClient,
+)
+from luna_quantum.client.schemas.circuit import CircuitJob, CircuitResult
+from luna_quantum.client.schemas.create.circuit import CircuitIn
+from luna_quantum.client.schemas.qpu_token.qpu_token import TokenProvider
+from luna_quantum.client.schemas.qpu_token.token_provider import RestAPITokenProvider
+from luna_quantum.client.utils.qpu_token_utils import QpuTokenUtils
+
+if TYPE_CHECKING:
+    from luna_quantum.client.schemas.enums.circuit import CircuitProviderEnum
+
+
+class CircuitRestClient(ICircuitRestClient):
+    """Implementation for circuit rest client."""
+
+    _endpoint = "/circuits"
+
+    def create(
+        self,
+        circuit: str,
+        provider: CircuitProviderEnum,
+        params: dict[str, Any] | None = None,
+        qpu_tokens: TokenProvider | None = None,
+        **kwargs: Any,
+    ) -> 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.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        CircuitJob
+            The created circuit job.
+        """
+        if params is None:
+            params = {}
+        if qpu_tokens is not None:
+            rest_qpu_tokens = RestAPITokenProvider.from_sdk_token_provider(
+                TokenProvider.model_validate(qpu_tokens)
+            )
+        else:
+            rest_qpu_tokens = None
+
+        # try to retrieve qpu tokens from env variables
+        if rest_qpu_tokens is None:
+            qpu_tokens = QpuTokenUtils.patch_qpu_tokens_from_env()
+            if qpu_tokens is not None:
+                rest_qpu_tokens = RestAPITokenProvider.from_sdk_token_provider(
+                    qpu_tokens
+                )
+
+        circuit_in: CircuitIn = CircuitIn(
+            provider=provider,
+            circuit=circuit,
+            params=params,
+            qpu_tokens=rest_qpu_tokens,
+        )
+
+        response = self._client.post(
+            self._endpoint, content=circuit_in.model_dump_json(), **kwargs
+        )
+
+        response.raise_for_status()
+        return CircuitJob(id=response.json(), provider=provider, params=params)
+
+    def get(
+        self,
+        job: CircuitJob,
+        **kwargs: Any,
+    ) -> CircuitResult:
+        """
+        Get the result of a circuit.
+
+        Parameters
+        ----------
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        CircuitResult
+            The result of solving the circuit.
+        """
+        url = f"{self._endpoint}/{job.id}/{job.provider.value}"
+        if job.params is None:
+            job.params = {}
+        response = self._client.get(url, params=job.params, **kwargs)
+
+        response.raise_for_status()
+        return CircuitResult.model_validate(response.json())

luna_quantum/client/rest_client/info_rest_client.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Any
+
+from luna_quantum.client.interfaces.clients.info_rest_client_i import IInfoRestClient
+from luna_quantum.client.schemas.solver_info import SolverInfo
+
+
+class InfoRestClient(IInfoRestClient):
+    """Implementation of the info rest client."""
+
+    _endpoint = "/"
+
+    _endpoint_solvers = "/solvers"
+    _endpoint_providers = "/providers"
+
+    def solvers_available(
+        self, solver_name: str | None = None, **kwargs: Any
+    ) -> 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.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        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.
+        """
+        params = {}
+        if solver_name:
+            params["solver_name"] = solver_name
+
+        response = self._client.get(
+            f"{self._endpoint_solvers}/available", params=params, **kwargs
+        )
+
+        response.raise_for_status()
+
+        json: dict[str, dict[str, Any]] = response.json()
+        to_return: dict[str, dict[str, SolverInfo]] = {}
+        for provider, solvers in json.items():
+            to_return[provider] = {}
+            for solver in solvers:
+                to_return[provider][solver] = SolverInfo.model_validate(solvers[solver])
+
+        return to_return
+
+    def providers_available(self, **kwargs: Any) -> list[str]:
+        """
+        Get list of available providers.
+
+        Parameters
+        ----------
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        List[str]
+            List of available QPU providers.
+        """
+        response = self._client.get(f"{self._endpoint_providers}/available", **kwargs)
+
+        response.raise_for_status()
+
+        return list(response.json())

luna_quantum/client/rest_client/model_rest_client.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from luna_quantum.aqm_overwrites.model import Model
+from luna_quantum.client.interfaces.clients.model_rest_client_i import (
+    IModelRestClient,
+)
+from luna_quantum.client.schemas.create.optimization import OptimizationUseCaseIn
+from luna_quantum.client.schemas.enums.timeframe import TimeframeEnum
+from luna_quantum.client.schemas.model_metadata import ModelMetadataSchema
+
+if TYPE_CHECKING:
+    from httpx import Response
+
+    from luna_quantum.solve.use_cases import UseCase
+
+
+class ModelRestClient(IModelRestClient):
+    """Implementation of the model rest client."""
+
+    @property
+    def _endpoint(self) -> str:
+        return "/models"
+
+    def get_all(
+        self,
+        timeframe: TimeframeEnum | None = None,
+        limit: int = 50,
+        offset: int = 0,
+        **kwargs: Any,
+    ) -> list[ModelMetadataSchema]:
+        """
+        Retrieve a list of model metadata.
+
+        Parameters
+        ----------
+        timeframe: Optional[TimeframeEnum]
+            Only return optimizations created within a specified timeframe.
+            Default None.
+        limit:
+            Limit the number of optimizations to be returned. Default value 50.
+        offset:
+            Offset the list of optimizations by this amount. Default value 0.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        List[ModelMetadataSchema]:
+            List of model metadata.
+        """
+        params = {}
+        if timeframe and timeframe != TimeframeEnum.all_time:  # no value == all_time
+            params["timeframe"] = timeframe.value
+
+        limit = max(limit, 1)
+
+        params["limit"] = str(limit)
+        params["offset"] = str(offset)
+        response: Response = self._client.get(
+            f"{self._endpoint}/metadata", params=params, **kwargs
+        )
+        response.raise_for_status()
+        return [ModelMetadataSchema.model_validate(item) for item in response.json()]
+
+    def get_model(self, model_id: str, **kwargs: Any) -> Model:
+        """
+        Retrieve a model by the id.
+
+        Parameters
+        ----------
+        model_id: str
+            Id of the model to be retrieved.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        Model:
+            The model.
+
+        """
+        response: Response = self._client.get(
+            f"{self._endpoint}/data/{model_id}", **kwargs
+        )
+        response.raise_for_status()
+
+        return Model.deserialize(response.content)
+
+    def get_metadata_by_hash(
+        self, model_hash: int, **kwargs: Any
+    ) -> ModelMetadataSchema:
+        """
+        Retrieve metadata for a model using its hash.
+
+        This method fetches metadata associated with a given model hash.
+
+        Parameters
+        ----------
+        model_hash : int
+            The hash identifier of the model.
+
+        Returns
+        -------
+        ModelMetadataSchema
+            Metadata information of the model.
+        """
+        params = {}
+        params["model_hash"] = model_hash
+        response: Response = self._client.get(
+            f"{self._endpoint}/metadata", params=params, **kwargs
+        )
+        response.raise_for_status()
+        models = [ModelMetadataSchema.model_validate(item) for item in response.json()]
+        if len(models) != 1:
+            raise ValueError(  # TODO(@Llewellyn) better error here  # noqa: E501, FIX002, TD004, TRY003
+                f"Expected exactly one model with hash {model_hash}, got {len(models)}"
+            )
+        return models[0]
+
+    def create(self, model: Model, **kwargs: Any) -> ModelMetadataSchema:  # noqa: ARG002
+        """
+        Create a model based on the provided Model instance.
+
+        This function saves the model and returns metadata about it.
+
+        Parameters
+        ----------
+        model : Model
+            Instance of the Model which should be saved.
+
+        Returns
+        -------
+        ModelMetadataSchema
+            Metadata of the created model containing information about its
+            configuration and properties.
+
+        """
+        response: Response = self._client.post(
+            f"{self._endpoint}",
+            content=model.serialize(),  # Send raw bytes directly
+            headers={"Content-Type": "application/octet-stream"},
+        )
+
+        response.raise_for_status()
+
+        return ModelMetadataSchema.model_validate(response.json())
+
+    def get(self, model_id: str, **kwargs: Any) -> ModelMetadataSchema:
+        """
+        Retrieve the model metadata by its id.
+
+        Parameters
+        ----------
+        model_id: str
+            Id of the model to be retrieved.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        ModelMetadataSchema:
+            Metadata of the model.
+        """
+        response: Response = self._client.get(
+            f"{self._endpoint}/metadata/{model_id}", **kwargs
+        )
+        response.raise_for_status()
+
+        return ModelMetadataSchema.model_validate(response.json())
+
+    def create_from_use_case(
+        self, name: str, use_case: UseCase, **kwargs: Any
+    ) -> ModelMetadataSchema:
+        """
+        Create a model from a use case.
+
+        Parameters
+        ----------
+        name: str
+            Name of the use case to be created.
+        use_case: UseCase
+            A use case instance that defines the optimization problem.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+        """
+        optimization_in = OptimizationUseCaseIn(
+            name=name, use_case=use_case, params=None
+        )
+
+        response: Response = self._client.post(
+            f"{self._endpoint}/use-case",
+            content=optimization_in.model_dump_json(),
+            **kwargs,
+        )
+
+        response.raise_for_status()
+
+        return ModelMetadataSchema.model_validate(response.json())
+
+    def delete(self, model_id: str, **kwargs: Any) -> None:
+        """
+        Delete a model and the model metadata by its id.
+
+        Parameters
+        ----------
+        model_id: str
+            Id of the model to be deleted.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+        """
+        response: Response = self._client.delete(
+            f"{self._endpoint}/{model_id}", **kwargs
+        )
+        response.raise_for_status()