luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

luna_quantum/client/interfaces/clients/qpu_token_rest_client_i.py

@@ -0,0 +1,364 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+from luna_quantum.client.interfaces.clients.rest_client_i import IRestClient
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+    from luna_quantum.client.schemas import QpuTokenOut
+    from luna_quantum.client.schemas.enums.qpu_token_type import QpuTokenTypeEnum
+    from luna_quantum.client.schemas.qpu_token.qpu_token_time_quota import (
+        QpuTokenTimeQuotaOut,
+    )
+
+
+class IQpuTokenRestClient(IRestClient, ABC):
+    """Inteface of a solve job REST client."""
+
+    @abstractmethod
+    def create(
+        self,
+        name: str,
+        provider: str,
+        token: str,
+        token_type: QpuTokenTypeEnum,
+        **kwargs: dict[str, Any],
+    ) -> QpuTokenOut:
+        """
+        Create QPU token.
+
+        Parameters
+        ----------
+        name: str
+            Name of the QPU token
+        provider: str
+            Name of provider
+        token: str
+            Token
+        token_type: QpuTokenTypeEnum
+            There are two types of QPU tokens: PERSONAL and GROUP.
+            All users of a group can use group QPU tokens.
+            User QPU tokens can only be used by the user who created them.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        QpuTokenOut
+            QpuToken instances.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_all(
+        self,
+        filter_provider: str | None = None,
+        token_type: QpuTokenTypeEnum | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
+        **kwargs: dict[str, Any],
+    ) -> dict[QpuTokenTypeEnum, list[QpuTokenOut]]:
+        """
+        Retrieve a list of QPU tokens.
+
+        Parameters
+        ----------
+        filter_provider: Optional[str]
+            The provider for which qpu tokens should be retrieved
+        token_type: Optional[QpuTokenTypeEnum]
+            If you want to retrieve only user or group QPU tokens
+            otherwise all QPU tokens will be retrieved
+        limit: Optional[int]
+            Number of items to fetch. Default is 10.
+        offset: Optional[int]
+            Optional. Number of items to skip. Default is 0.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        Dict[QpuTokenTypeEnum, List[QpuTokenOut]]
+            List of QpuTokenOut instances.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get(
+        self, name: str, token_type: QpuTokenTypeEnum, **kwargs: dict[str, Any]
+    ) -> QpuTokenOut:
+        """
+        Retrieve user QPU token by id.
+
+        Parameters
+        ----------
+        name: str
+            Name of the QPU token that should be retrieved
+        token_type: QpuTokenTypeEnum
+            There are two types of QPU tokens: PERSONAL and GROUP.
+            All users of a group can use group QPU tokens.
+            User QPU tokens can only be used by the user who created them.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        QpuTokenOut
+            QpuToken instance.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def rename(
+        self,
+        name: str,
+        new_name: str,
+        token_type: QpuTokenTypeEnum,
+        **kwargs: dict[str, Any],
+    ) -> QpuTokenOut:
+        """
+        Update QPU token by id.
+
+        Parameters
+        ----------
+        name: str
+            Current name of the QPU token that should be updated
+        new_name: str
+            The new name
+        token_type: QpuTokenTypeEnum
+            There are two types of QPU tokens: PERSONAL and GROUP.
+            All users of a group can use group QPU tokens.
+            User QPU tokens can only be used by the user who created them.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        QpuTokenOut
+            QpuToken instance.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(
+        self, name: str, token_type: QpuTokenTypeEnum, **kwargs: dict[str, Any]
+    ) -> None:
+        """
+        Delete QPU token by name.
+
+        Parameters
+        ----------
+        name: str
+            Name of the QPU token that should be deleted
+        token_type: QpuTokenTypeEnum
+            There are two types of QPU tokens: PERSONAL and GROUP.
+            All users of a group can use organization QPU tokens.
+            User QPU tokens can only be used by the user who created them.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_group_time_quota(
+        self,
+        qpu_token_name: str,
+        quota: int,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        **kwargs: dict[str, Any],
+    ) -> None:
+        """Create a time quota policy for a shared QPU token.
+
+        This affects every user of the group.
+
+        Parameters
+        ----------
+        qpu_token_name : str
+            The name of the qpu token. Currently, only DWave tokens are supported.
+        quota : int
+        quota : int
+            The amount of quota to add. For DWave Quantum Annealing, which is currently
+            the only algorithm that supports time quota, this is the qpu access time in
+            nanoseconds.
+        start : Optional[datetime], optional
+            The date and time from which the policy is active. If None, the current date
+            and time will be used. If the policy is currently not effective, the token
+            cannot be used at all.
+            Default: None
+        end : Optional[datetime], optional
+            The date and time until which the policy is active. If None, the policy if
+            effective until 265 days after the start date. If the policy is currently
+            not effective, the token cannot be used at all.
+            Default: None
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_group_time_quota(
+        self, qpu_token_name: str, **kwargs: dict[str, Any]
+    ) -> QpuTokenTimeQuotaOut | None:
+        """Get the group time quota policy for a qpu token.
+
+        Parameters
+        ----------
+        qpu_token_name : str
+            The name of the qpu token.
+
+        Returns
+        -------
+        Optional[QpuTokenTimeQuotaOut]
+            The token policy. None, if no group policy is set on this token.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_group_time_quota(
+        self,
+        qpu_token_name: str,
+        quota: int | None = None,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        **kwargs: dict[str, Any],
+    ) -> None:
+        """Update the details on a group qpu time quota policy.
+
+        Parameters
+        ----------
+        qpu_token_name : str
+            The name of the qpu token.
+        quota : Optional[int], optional
+            The amount of quota. For DWave Quantum Annealing, which is currently the
+            only supported solver, this is the qpu access time in nanoseconds. If None,
+            the available quota won't be updated.
+            Default: None
+        start : Optional[datetime], optional
+            The date and time from which the policy is active. If None, the start date
+            won't be updated.
+            Default: None
+        end : Optional[datetime], optional
+            The date and time until which the policy is active. If None, the end date
+            won't be updated.
+            Default: None
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_group_time_quota(
+        self, qpu_token_name: str, **kwargs: dict[str, Any]
+    ) -> None:
+        """Delete the group policy set on a qpu token.
+
+        Parameters
+        ----------
+        qpu_token_name : str
+            The name of the qpu token.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_user_time_quota(
+        self,
+        qpu_token_name: str,
+        user_email: str,
+        quota: int,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        **kwargs: dict[str, Any],
+    ) -> None:
+        """Create a time quota policy for a shared QPU token.
+
+        This affects a single user of the group.
+
+        Parameters
+        ----------
+        qpu_token_name : str
+            The name of the qpu token. Currently, only DWave tokens are supported.
+        user_email : str
+            Email of the user for whom to add the policy.
+        quota : int
+            The amount of quota to add. For DWave Quantum Annealing, which is currently
+            the only algorithm that supports time quota, this is the qpu access time in
+            nanoseconds.
+        start : Optional[datetime], optional
+            The date and time from which the policy is active. If None, the current date
+            and time will be used. If the policy is currently not effective, the token
+            cannot be used at all.
+            Default: None
+        end : Optional[datetime], optional
+            The date and time until which the policy is active. If None, the policy if
+            effective until 265 days after the start date. If the policy is currently
+            not effective, the token cannot be used at all.
+            Default: None
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_user_time_quota(
+        self, qpu_token_name: str, user_email: str, **kwargs: dict[str, Any]
+    ) -> QpuTokenTimeQuotaOut | None:
+        """Get a user-specific time quota policy for a qpu token.
+
+        Parameters
+        ----------
+        qpu_token_name : str
+            The name of the qpu token.
+        user_email : str
+            Email of the user for whom to get the policy.
+
+        Returns
+        -------
+        Optional[QpuTokenTimeQuotaOut]
+            The token policy. None, if no policy is set on this token for the specified
+            user.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_user_time_quota(
+        self,
+        qpu_token_name: str,
+        user_email: str,
+        quota: int | None = None,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        **kwargs: dict[str, Any],
+    ) -> None:
+        """Update the details on a user-specific qpu time quota policy.
+
+        Parameters
+        ----------
+        qpu_token_name : str
+            The name of the qpu token.
+        user_email : str
+            Email of the user for whom to update the policy.
+        quota : Optional[int], optional
+            The amount of quota. For DWave Quantum Annealing, which is currently the
+            only supported solver, this is the qpu access time in nanoseconds. If None,
+            the available quota won't be updated.
+            Default: None
+        start : Optional[datetime], optional
+            The date and time from which the policy is active. If None, the start date
+            won't be updated.
+            Default: None
+        end : Optional[datetime], optional
+            The date and time until which the policy is active. If None, the end date
+            won't be updated.
+            Default: None
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_user_time_quota(
+        self, qpu_token_name: str, user_email: str, **kwargs: dict[str, Any]
+    ) -> None:
+        """Delete a user-specific policy set on a qpu token.
+
+        Parameters
+        ----------
+        qpu_token_name : str
+            The name of the qpu token.
+        """
+        raise NotImplementedError

luna_quantum/client/interfaces/clients/rest_client_i.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+from httpx import Client
+
+from luna_quantum.client.interfaces.services.service_i import IService
+
+
+class IRestClient(ABC):
+    """Inteface for rest client."""
+
+    _lc_client: IService
+    _client: Client
+
+    def __init__(self, service: IService) -> None:
+        self._lc_client = service
+        self._client = service.client
+
+    @property
+    @abstractmethod
+    def _endpoint(self) -> str:
+        raise NotImplementedError

luna_quantum/client/interfaces/clients/solve_job_rest_client_i.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+from luna_quantum.client.interfaces.clients.rest_client_i import IRestClient
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+    from luna_quantum import Solution
+    from luna_quantum.client.schemas.enums.timeframe import TimeframeEnum
+    from luna_quantum.client.schemas.qpu_token.qpu_token import TokenProvider
+    from luna_quantum.client.schemas.solution import (
+        UseCaseRepresentation,
+        UseCaseResult,
+    )
+    from luna_quantum.client.schemas.solve_job import SolveJobSchema
+
+
+class ISolveJobRestClient(IRestClient, ABC):
+    """Interface for a solve job REST client."""
+
+    @abstractmethod
+    def get_all(
+        self,
+        timeframe: TimeframeEnum | None = None,
+        limit: int = 50,
+        offset: int = 0,
+        model_id: str | None = None,
+        **kwargs: Any,
+    ) -> list[SolveJobSchema]:
+        """
+        Get list of available SolveJobs.
+
+        Parameters
+        ----------
+        timeframe: Optional[TimeframeEnum]
+            Only return SolveJobs created within a specified timeframe. Default None.
+        limit:
+            Limit the number of SolveJobs to be returned. Default value 10.
+        offset:
+            Offset the list of solve job by this amount. Default value 0.
+        model_id: Optional[str]
+            Show solve job for only this model id. Default None.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        List[SolveJobSchema]
+            List of SolveJob instances.
+        """
+
+    @abstractmethod
+    def get(self, solve_job_id: str, **kwargs: Any) -> SolveJobSchema:
+        """
+        Retrieve one SolveJob by id.
+
+        Parameters
+        ----------
+        solve_job_id: str
+            Id of the solve job that should be retrieved.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        SolveJobSchema
+            Instance of SolveJob.
+        """
+
+    @abstractmethod
+    def get_solution(self, solve_job_id: str, **kwargs: Any) -> Solution:
+        """
+        Retrieve one solution by id.
+
+        Parameters
+        ----------
+        solve_job_id: str
+            Id of the solve job for which a solution should be retrieved.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        Solution
+            Solution instance
+        """
+
+    @abstractmethod
+    def get_use_case_representation(
+        self, solve_job_id: str, **kwargs: Any
+    ) -> UseCaseRepresentation:
+        """
+        Get the use-case-specific representation of a solution.
+
+        Parameters
+        ----------
+        solve_job_id: str
+            Id of the solve job that should be retrieved.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        UseCaseRepresentation
+            The use-case-specific representation
+        """
+
+    @abstractmethod
+    def delete(self, solve_job_id: str, **kwargs: Any) -> None:
+        """
+        Delete one solution by id.
+
+        Parameters
+        ----------
+        solve_job_id: str
+            Id of the solve job that should be deleted.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+        """
+
+    @abstractmethod
+    def create(  # noqa: PLR0913
+        self,
+        model_id: str,
+        solver_name: str,
+        provider: str,
+        qpu_tokens: TokenProvider | None = None,
+        solver_parameters: dict[str, Any] | BaseModel | None = None,
+        name: str | None = None,
+        **kwargs: Any,
+    ) -> SolveJobSchema:
+        """
+        Create a solution for a model.
+
+        Parameters
+        ----------
+        model_id: str
+            The id of the model for which solution should be created.
+        solver_name: str
+            The name of the solver to use.
+        provider: str
+            The name of the provider to use.
+        qpu_tokens: Optional[TokenProvider]
+            The tokens to be used for the QPU.
+        solver_parameters: Optional[Union[Dict[str, Any], BaseModel]]
+            Parameters to be passed to the solver.
+        name: Optional[str]
+            Default: None, The name of the solution to create.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        SolveJobSchema
+            The created solve job, which can be used to retrieve the solution later.
+        """
+
+    @abstractmethod
+    def get_best_use_case_result(
+        self, use_case_representation: UseCaseRepresentation
+    ) -> UseCaseResult | None:
+        """
+        Retrieve the best result from a solution's use case representation.
+
+        Parameters
+        ----------
+        use_case_representation : UseCaseRepresentation
+            A solution's use case representation.
+
+        Returns
+        -------
+        Optional[UseCaseResult]
+            The best result of the solution. If there are several best solve job with
+            the same objective value, return only the first. If the solution results are
+            not (yet) available or the solution sense is `None`, `None` is returned.
+        """
+
+    @abstractmethod
+    def cancel(
+        self,
+        solve_job_id: str,
+        **kwargs: Any,
+    ) -> SolveJobSchema:
+        """
+        Cancel a solve job for an id.
+
+        Parameters
+        ----------
+        solve_job_id: str
+            The id of the solve job which should be canceled.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        SolveJobSchema
+            The updated solve job, which can be used to retrieve the solution later.
+        """

luna_quantum/client/interfaces/clients/users_rest_client_i.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+from luna_quantum.client.interfaces.clients.rest_client_i import IRestClient
+
+if TYPE_CHECKING:
+    from luna_quantum.client.schemas.user import User
+
+
+class IUsersRestClient(IRestClient, ABC):
+    """Inteface for user rest client."""
+
+    @abstractmethod
+    def get_me(self, **kwargs: dict[str, Any]) -> User:
+        """
+        Retrieve information about user.
+
+        Parameters
+        ----------
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
+        Returns
+        -------
+        User:
+            User data.
+        """

luna_quantum/client/interfaces/services/luna_q_i.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+
+from luna_quantum.client.interfaces.clients import ICircuitRestClient
+from luna_quantum.client.interfaces.clients.qpu_token_rest_client_i import (
+    IQpuTokenRestClient,
+)
+from luna_quantum.client.interfaces.services.service_i import IService
+
+
+class ILunaQ(IService, ABC):
+    """Interface for the LunaQ client."""
+
+    @property
+    @abstractmethod
+    def qpu_token(self) -> IQpuTokenRestClient:
+        """
+        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) -> ICircuitRestClient:
+        """Returns a circuit :py:class: repository."""
+        raise NotImplementedError