luna-quantum 0.0.16__py3-none-any.whl → 0.0.33__py3-none-any.whl

luna_sdk/schemas/solver_parameters/fujitsu/base.py

@@ -1,11 +1,12 @@
 from typing import Literal, Optional, Tuple, Union
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import ConfigDict, Field
 
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.fujitsu.partial_config import PartialConfig
 
 
-class CommonParams(BaseModel):
+class CommonParams(BaseParameter):
     auto_tuning: Literal[
         "NOTHING",
         "SCALING",
@@ -24,7 +25,7 @@ class CommonParams(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
-class V2Params(BaseModel):
+class V2Params(BaseParameter):
     optimization_method: Literal["annealing", "parallel_tempering"] = "annealing"
     temperature_start: float = Field(default=1_000.0, ge=0.0, le=1e20)
     temperature_end: float = Field(default=1.0, ge=0.0, le=1e20)
@@ -37,7 +38,7 @@ class V2Params(BaseModel):
     sampling_runs: int = 100
 
 
-class ConnectionParams(BaseModel):
+class ConnectionParams(BaseParameter):
     annealer_protocol: Literal["http", "https"] = "https"
     annealer_address: str = "cloud.ts.fujitsu.com"
     annealer_port: int = Field(default=443, ge=0, le=2**16)

luna_sdk/schemas/solver_parameters/fujitsu/partial_config.py

@@ -1,13 +1,15 @@
 from typing import Any, List, Literal, Optional, Tuple, Union
 
 from numpy.typing import NDArray
-from pydantic import BaseModel, ConfigDict, Field, field_serializer
+from pydantic import ConfigDict, Field, field_serializer
 from typing_extensions import Annotated
 
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
+
 OneHot = Literal["no_way", "one_way", "two_way"]
 
 
-class VarShapeBase(BaseModel):
+class VarShapeBase(BaseParameter):
     name: str
     one_hot: OneHot = "no_way"
 
@@ -110,7 +112,7 @@ VarDef = Annotated[
 ]
 
 
-class OneHotGroup(BaseModel):
+class OneHotGroup(BaseParameter):
     """O:class:`dadk.BinPol.OneHotGroup` is used to define a one-way-one-hot group within a set of bit variables.
     In particular, the entries of the one-way-one-hot group are specified as tuples including the name of the variable
     specified in a BitArrayShape and (optionally) the indices of the variable in every dimension. Here, a single number
@@ -129,7 +131,7 @@ class OneHotGroup(BaseModel):
     entries: List[Union[List, Tuple]] = []
 
 
-class VarShapeSet(BaseModel):
+class VarShapeSet(BaseParameter):
     """:class:`dadk.BinPol.VarShapeSet` defines an indexing structure for the bits of a BinPol polynomial. Plain BinPol
     polynomials are defined on a set of bits indexed by a ``range(N)`` for some integer ``N``. The ``VarShapeSet`` lays
     a sequence of disjoint named sections over this linear structure. Bits within a section can be addressed by the
@@ -150,7 +152,7 @@ class VarShapeSet(BaseModel):
     one_hot_groups: Optional[List[OneHotGroup]] = None
 
 
-class PartialConfig(BaseModel):
+class PartialConfig(BaseParameter):
     """:class:`PartialConfig` produces a dictionary that can be used to initialize bits for the annealing algorithm.
 
     The start state for an annealing or parallel tempering optimization can be specified.

luna_sdk/schemas/solver_parameters/ibm/standard_parameters.py

@@ -1,9 +1,104 @@
 from typing import Any, Dict, Literal, Optional, Union
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import Field
 
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
+
+
+class Simulator(BaseParameter):
+    """Use a simulator as backend. The QAOA is executed completely on our server, and
+    no IBM token is required.
+
+    Parameters
+    ----------
+    backend_name: Literal['aer', 'statevector']
+        Which simulator to use. Currently, `AerSimulator` from `qiskit_aer` and the statevector simulator from `qiskit.primitives` are available.
+    """
+
+    backend_type: Literal["simulator"] = "simulator"
+    backend_name: Literal["aer", "statevector"] = "aer"
+
+
+class FakeProvider(BaseParameter):
+    """Use a V2 fake backend from `qiskit_ibm_runtime.fake_provider`. The QAOA is
+    executed entirely on our server, and no IBM token is required.
+
+    Parameters
+    ----------
+    backend_name: str
+        Which backend to use
+    """
+
+    backend_type: Literal["fake_provider"] = "fake_provider"
+    backend_name: str
+
+
+class IbmBackend(BaseParameter):
+    """Use an online backend from `ibm_quantum` or `ibm_cloud`. As IBM hardware is used,
+    this method requires an IBM token.
+
+    Parameters
+    ----------
+    backend_name: str
+        Which backend to use.
+    """
+
+    backend_type: Literal["ibm_backend"] = "ibm_backend"
+    backend_name: str
+
+
+class LeastBusyQuery(BaseParameter):
+    """Filter parameters when querying the least busy backend.
+
+    Parameters
+    ----------
+    min_num_qubits: Optional[int]
+        Minimum number of qubits the backend has to have.
+    instance: Optional[str]
+        This is only supported for `ibm_quantum` runtime and is in the hub/group/project format.
+    filters: Dict[str, Any]
+        Simple filters that require a specific value for an attribute in backend configuration or status. Example: `{'operational': True}`"""
+
+    min_num_qubits: Optional[int] = None
+    instance: Optional[str] = None
+    filters: Dict[str, Any] = {}
+
+
+class LeastBusy(BaseParameter):
+    """Use the least busy online backend from `ibm_quantum` or `ibm_cloud`. As IBM
+    hardware is used, this method requires an IBM token.
+
+    Parameters
+    ----------
+    query_params: LeastBusyQuery
+        Filter parameters when querying the least busy backend.
+    """
+
+    backend_type: Literal["least_busy"] = "least_busy"
+    query_params: LeastBusyQuery = LeastBusyQuery()
+
+
+class ServiceConfig(BaseParameter):
+    """Parameters to be passed to the `QiskitRuntimeService` object
+
+    Parameters
+    ----------
+    channel: Optional[Literal['ibm_cloud', 'ibm_quantum']]
+        The channel type for the service
+    url: Optional[str]
+        The URL of the service
+    name: Optional[str]
+        The name of the service
+    instance: Optional[str]
+        The instance identifier
+    proxies: Optional[dict]
+        Proxy settings for the service
+    verify: Optional[bool]
+        SSL verification setting
+    channel_strategy: Optional[str]
+        The strategy for the channel
+    """
 
-class ServiceConfig(BaseModel):
     channel: Optional[Literal["ibm_cloud", "ibm_quantum"]] = "ibm_quantum"
     url: Optional[str] = None
     name: Optional[str] = None
@@ -12,16 +107,35 @@ class ServiceConfig(BaseModel):
     verify: Optional[bool] = None
     channel_strategy: Optional[str] = None
 
-    model_config = ConfigDict(extra="forbid")
 
+class StandardParameters(BaseParameter):
+    """
+    Standard parameters for the optimizer.
+
+    Parameters
+    ----------
+    backend: Union[Simulator, FakeProvider, IbmBackend, LeastBusy]
+        Which backend to use. If None, will use no backend and StatevectorSampler and StatevectorEstimator. If dict, will call `runtime_service.least_busy` with the params given in the dict. If str: If 'AerSimulator', use AerSimulator. If string starts with 'Fake', will use the corresponding fake backend from qiskit_ibm_runtime.fake_provider. Otherwise, will try to use a real backend with this name.
+    shots: int
+        Shots for the optimizer
+    dynamical_decoupling: Dict[str, Any]
+        Dynamical decoupling options for the optimizer
+    optimizer: str
+        Name of the optimizer to use in scipy minimize
+    maxiter: int
+        Maximum number of iterations for the algorithm
+    optimization_level: int
+        Optimization level for the pass manager
+    service_config: ServiceConfig
+        Parameters to be passed to the `QiskitRuntimeService` object
+    """
 
-class StandardParameters(BaseModel):
-    backend: Optional[Union[str, Dict[str, Any]]] = "AerSimulator"
+    backend: Union[Simulator, FakeProvider, IbmBackend, LeastBusy] = Field(
+        default=Simulator(), discriminator="backend_type"
+    )
     shots: int = 1024
     dynamical_decoupling: Dict[str, Any] = {}
     optimizer: str = "COBYLA"
     maxiter: int = 10
     optimization_level: int = 2
     service_config: ServiceConfig = ServiceConfig()
-
-    model_config = ConfigDict(extra="forbid")

luna_sdk/schemas/solver_parameters/qctrl/qaoa.py

@@ -1,9 +1,9 @@
 from typing import Any, Optional
 
-from pydantic import BaseModel
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 
 
-class QaoaParameters(BaseModel):
+class QaoaParameters(BaseParameter):
     """
     QAOA is a popular algorithm that can be applied to a wide range of optimization problems that are out of reach today
     like portfolio optimization, efficient logistics routing, and asset liability management.

luna_sdk/schemas/wrappers/__init__.py

@@ -0,0 +1 @@
+from .datetime_wrapper import PydanticDatetimeWrapper

luna_sdk/schemas/wrappers/datetime_wrapper.py

@@ -0,0 +1,31 @@
+from datetime import datetime
+from typing import Union
+
+from dateutil.parser import parse
+from pydantic import BeforeValidator
+from typing_extensions import Annotated
+
+
+def validate_datetime(date_string: Union[str, datetime]) -> datetime:
+    """Validate an ISO date string and return the resulting datetime in the local timezone.
+
+    Parameters
+    ----------
+    date_string : str
+        The ISO date string
+
+    Returns
+    -------
+    datetime
+        The datetime in the user's local timezone
+
+    Raises
+    ------
+    ValueError
+        If `date_string` does not have a valid format.
+    """
+    dt = date_string if isinstance(date_string, datetime) else parse(date_string)
+    return dt.astimezone()
+
+
+PydanticDatetimeWrapper = Annotated[datetime, BeforeValidator(validate_datetime)]

luna_sdk/utils/parameter_finder.py

@@ -0,0 +1,90 @@
+from typing import Dict, Optional, Type
+
+from pydantic import BaseModel
+
+from luna_sdk.schemas.solver_parameters.aws import QaoaParameters as AwsQaoaParameters
+from luna_sdk.schemas.solver_parameters.dwave import (
+    DialecticSearchParameters,
+    KerberosParameters,
+    LeapHybridBqmParameters,
+    LeapHybridCqmParameters,
+    ParallelTemperingParameters,
+    ParallelTemperingQpuParameters,
+    PopulationAnnealingParameters,
+    PopulationAnnealingQpuParameters,
+    QAGAParameters,
+    QbSolvLikeQpuParameters,
+    QbSolvLikeSimulatedAnnealingParameters,
+    QbSolvLikeTabuSearchParameters,
+    QuantumAnnealingParameters,
+    RepeatedReverseQuantumAnnealingParameters,
+    RepeatedReverseSimulatedAnnealingParameters,
+    SAGAParameters,
+    SimulatedAnnealingParameters,
+    TabuSearchParameters,
+)
+from luna_sdk.schemas.solver_parameters.fujitsu import (
+    DigitalAnnealerCPUParameters,
+    DigitalAnnealerV2Parameters,
+    DigitalAnnealerV3Parameters,
+)
+from luna_sdk.schemas.solver_parameters.ibm import VqeParameters
+from luna_sdk.schemas.solver_parameters.ibm import QaoaParameters as IbmQaoaParameters
+from luna_sdk.schemas.solver_parameters.qctrl import (
+    QaoaParameters as QctrlQaoaParameters,
+)
+
+_provider_solver_param_dict: Dict[str, Dict[str, Optional[Type[BaseModel]]]] = {
+    "aws": {
+        "QAOA": AwsQaoaParameters,
+    },
+    "dwave": {
+        "BF": None,
+        "DS": DialecticSearchParameters,
+        "K": KerberosParameters,
+        "LBQM": LeapHybridBqmParameters,
+        "LCQM": LeapHybridCqmParameters,
+        "PT": ParallelTemperingParameters,
+        "PTQ": ParallelTemperingQpuParameters,
+        "PA": PopulationAnnealingParameters,
+        "PAQ": PopulationAnnealingQpuParameters,
+        "QLQ": QbSolvLikeQpuParameters,
+        "QLSA": QbSolvLikeSimulatedAnnealingParameters,
+        "QLTS": QbSolvLikeTabuSearchParameters,
+        "QA": QuantumAnnealingParameters,
+        "RRQA": RepeatedReverseQuantumAnnealingParameters,
+        "RRSA": RepeatedReverseSimulatedAnnealingParameters,
+        "SA": SimulatedAnnealingParameters,
+        "TS": TabuSearchParameters,
+        "SAGA": SAGAParameters,
+        "SAGAPW": None,
+        "SAGAMP": None,
+        "QAGA": QAGAParameters,
+        "QAGAPW": None,
+        "QAGAMP": None,
+    },
+    "fujitsu": {
+        "DACPU": DigitalAnnealerCPUParameters,
+        "DAV3": DigitalAnnealerV3Parameters,
+        "DAV2": DigitalAnnealerV2Parameters,
+    },
+    "ibm": {
+        "QAOA": IbmQaoaParameters,
+        "VQE": VqeParameters,
+    },
+    "qctrl": {
+        "QCTRLQAOA": QctrlQaoaParameters,
+    },
+    "zib": {
+        "SCIP": None,
+    },
+}
+
+
+def get_parameter_by_solver(solver: str, provider: str) -> Optional[Type[BaseModel]]:
+    if provider not in _provider_solver_param_dict:
+        return None
+
+    if solver not in _provider_solver_param_dict[provider]:
+        return None
+    return _provider_solver_param_dict[provider][solver]

luna_sdk/utils/qpu_tokens.py

@@ -1,9 +1,10 @@
 import os
 
-from luna_sdk.schemas import QpuToken, QpuTokenSource
+from luna_sdk.schemas.rest.qpu_token.qpu_token_source import _RESTQpuTokenSource
 from luna_sdk.schemas.rest.qpu_token.token_provider import (
     RestAPITokenProvider,
     AWSQpuTokens,
+    _RestQpuToken,
 )
 
 
@@ -15,37 +16,37 @@ def extract_qpu_tokens_from_env() -> RestAPITokenProvider:
     aws_access_key = os.environ.get("LUNA_AWS_ACCESS_KEY")
     aws_access_secret_key = os.environ.get("LUNA_AWS_SECRET_ACCESS_KEY")
     return RestAPITokenProvider(
-        ibm=QpuToken(
-            source=QpuTokenSource.INLINE,
+        ibm=_RestQpuToken(
+            source=_RESTQpuTokenSource.INLINE,
             token=ibm_token,
         )
         if ibm_token
         else None,
-        dwave=QpuToken(
-            source=QpuTokenSource.INLINE,
+        dwave=_RestQpuToken(
+            source=_RESTQpuTokenSource.INLINE,
             token=dwave_token,
         )
         if dwave_token
         else None,
-        qctrl=QpuToken(
-            source=QpuTokenSource.INLINE,
+        qctrl=_RestQpuToken(
+            source=_RESTQpuTokenSource.INLINE,
             token=qctrl_token,
         )
         if qctrl_token
         else None,
-        fujitsu=QpuToken(
-            source=QpuTokenSource.INLINE,
+        fujitsu=_RestQpuToken(
+            source=_RESTQpuTokenSource.INLINE,
             token=fujitsu_token,
         )
         if fujitsu_token
         else None,
         aws=AWSQpuTokens(
-            aws_access_key=QpuToken(
-                source=QpuTokenSource.INLINE,
+            aws_access_key=_RestQpuToken(
+                source=_RESTQpuTokenSource.INLINE,
                 token=aws_access_key,
             ),
-            aws_secret_access_key=QpuToken(
-                source=QpuTokenSource.INLINE,
+            aws_secret_access_key=_RestQpuToken(
+                source=_RESTQpuTokenSource.INLINE,
                 token=aws_access_secret_key,
             ),
         ),

luna_sdk/constants.py

@@ -1 +0,0 @@
-LUNA_SDK_VERSION: str = "0.0.11"

luna_sdk/controllers/custom_login_client.py

@@ -1,61 +0,0 @@
-import logging
-from http.client import UNAUTHORIZED
-
-from httpx import Client, ReadTimeout, Response
-
-from luna_sdk.constants import LUNA_SDK_VERSION
-from luna_sdk.error.http_error_utils import HttpErrorUtils
-from luna_sdk.exceptions.timeout_exception import TimeoutException
-
-
-class CustomLoginClient(Client):
-    _login_url: str
-    _email: str
-    _password: str
-    _bearer_token: str
-
-    _user_agent: str = f"LunaSDK/{LUNA_SDK_VERSION}"
-
-    def __init__(self, email: str, password: str, login_url: str, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._email = email
-        self._password = password
-        self._login_url = login_url
-
-        self.headers["User-Agent"] = self._user_agent
-
-    def login(self, email: str, password: str):
-        with Client() as client:
-            headers = {
-                "accept": "application/json",
-                "Content-Type": "application/x-www-form-urlencoded",
-                "User-Agent": self._user_agent,
-            }
-
-            response: Response = client.post(
-                self._login_url,
-                data={"username": email, "password": password},
-                headers=headers,
-            )
-            HttpErrorUtils.check_for_error(response)
-
-            self._bearer_token = response.json()["access_token"]
-
-    def request(self, *args, **kwargs) -> Response:
-        try:
-            response: Response = super().request(*args, **kwargs)
-            if response.status_code == UNAUTHORIZED:
-                logging.info("Unauthorized - trying to login")
-
-                self.login(self._email, self._password)
-
-                logging.info("Re-login successful")
-                self.headers.update(
-                    headers={"authorization": f"Bearer {self._bearer_token}"}
-                )
-                logging.info("Trying request again")
-                response = super().request(*args, **kwargs)
-        except ReadTimeout as e:
-            raise TimeoutException()
-        HttpErrorUtils.check_for_error(response)
-        return response