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

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/constants.py

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