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

luna_sdk/schemas/rest/qpu_token/token_provider.py

@@ -1,20 +1,48 @@
-from typing import Optional
+from typing import Optional, Union
 
 from pydantic import BaseModel, Extra
 
-from luna_sdk.schemas import QpuToken, TokenProvider
+from luna_sdk.schemas import QpuToken, TokenProvider, QpuTokenSource
+from luna_sdk.schemas.rest.qpu_token.qpu_token_source import _RESTQpuTokenSource
+
+
+class _RestQpuToken(BaseModel):
+    source: _RESTQpuTokenSource
+    # A unique name for a stored token
+    name: Optional[str] = None
+    # This could be a QPU token, an API key or any token key for a QPU provider.
+    # If the token is not passed from this API call, one stored in the user's
+    # account will be used.
+    token: Optional[str] = None
+
+    @classmethod
+    def from_qpu_token(cls, qpu_token: Optional[QpuToken]) -> Optional["_RestQpuToken"]:
+        if qpu_token is None:
+            return None
+        # Organizational tokens were renamed to group in #1851
+        # For smoother transition we only change naming in the SDK,
+        # and therefore we need a mapping between Group and Organization here.
+        # However, in backend for now QPU tokens still has source organization
+        # TODO: Remove it when backend I/O schema is changed
+        if qpu_token.source == QpuTokenSource.GROUP:
+            return cls(
+                source=_RESTQpuTokenSource.ORGANIZATION,
+                name=qpu_token.name,
+                token=qpu_token.token,
+            )
+        return cls.model_validate(qpu_token, from_attributes=True)
 
 
 class AWSQpuTokens(BaseModel):
-    aws_access_key: QpuToken
-    aws_secret_access_key: QpuToken
+    aws_access_key: _RestQpuToken
+    aws_secret_access_key: _RestQpuToken
 
 
 class RestAPITokenProvider(BaseModel):
-    dwave: Optional[QpuToken] = None
-    ibm: Optional[QpuToken] = None
-    fujitsu: Optional[QpuToken] = None
-    qctrl: Optional[QpuToken] = None
+    dwave: Optional[_RestQpuToken] = None
+    ibm: Optional[_RestQpuToken] = None
+    fujitsu: Optional[_RestQpuToken] = None
+    qctrl: Optional[_RestQpuToken] = None
     aws: Optional[AWSQpuTokens] = None
 
     @classmethod
@@ -28,16 +56,20 @@ class RestAPITokenProvider(BaseModel):
         ):
             # Ignoring mypy here to receive validation error, because we always need 2 tokens for aws
             aws = AWSQpuTokens(
-                aws_access_key=getattr(token_provider, "aws_access_key", None),  # type: ignore[arg-type]
-                aws_secret_access_key=getattr(  # type: ignore[arg-type]
-                    token_provider, "aws_secret_access_key", None
+                aws_access_key=_RestQpuToken.from_qpu_token(
+                    getattr(token_provider, "aws_access_key", None)
+                ),  # type: ignore[arg-type]
+                aws_secret_access_key=_RestQpuToken.from_qpu_token(
+                    getattr(  # type: ignore[arg-type]
+                        token_provider, "aws_secret_access_key", None
+                    )
                 ),
             )
         return cls(
-            dwave=token_provider.dwave,
-            ibm=token_provider.ibm,
-            fujitsu=token_provider.fujitsu,
-            qctrl=token_provider.qctrl,
+            dwave=_RestQpuToken.from_qpu_token(token_provider.dwave),
+            ibm=_RestQpuToken.from_qpu_token(token_provider.ibm),
+            fujitsu=_RestQpuToken.from_qpu_token(token_provider.fujitsu),
+            qctrl=_RestQpuToken.from_qpu_token(token_provider.qctrl),
             aws=aws,
         )
 

luna_sdk/schemas/solution.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
@@ -7,6 +6,7 @@ from luna_sdk.schemas.enums.solution import SenseEnum
 from luna_sdk.schemas.enums.status import StatusEnum
 from luna_sdk.schemas.optimization import Optimization
 from luna_sdk.schemas.pretty_base import PrettyBase
+from luna_sdk.schemas.wrappers import PydanticDatetimeWrapper
 
 Numeric = Union[float, int]
 Sample = Dict[str, Numeric]
@@ -20,14 +20,11 @@ class Runtime(BaseModel):
     ----------
     total: float
         Total time of solution processing
-    overhead: Optional[float]
-        Time of the classical computing processes
     qpu: Optional[float]
         Total time of the quantum computing processes
     """
 
     total: float
-    overhead: Optional[float]
     qpu: Optional[float]
     # ...
 
@@ -79,6 +76,8 @@ class Solution(PrettyBase):
         Optimization sense, can be 'min' or 'max'.
     metadata: Optional[Dict]
         Solution's metadata
+    solver: str
+        Solver's name
     provider: str
         The solver provider
 
@@ -90,18 +89,20 @@ class Solution(PrettyBase):
 
     id: str
     name: Optional[str] = None
-    created_date: datetime
+    created_date: PydanticDatetimeWrapper
     created_by: str
-    modified_date: Optional[datetime] = None
+    modified_date: Optional[PydanticDatetimeWrapper] = None
     modified_by: Optional[str] = None
 
     error_message: Optional[str] = None
+    solver_job_info: Optional[str] = None
 
     results: Optional[List[Result]]
     params: Dict[str, Any]
     runtime: Optional[Runtime]
     sense: Optional[SenseEnum]
     metadata: Optional[Dict[str, Any]]
+    solver: str
     provider: str
     status: StatusEnum
     optimization: Union[Optimization, str]

luna_sdk/schemas/solver_info.py

@@ -1,11 +1,41 @@
-from typing import Optional
+from enum import Enum
+from typing import List, Optional
 
 from pydantic import BaseModel
 
 
+class OptimizationSense(str, Enum):
+    Max = "max"
+    Min = "min"
+
+
+class VariableTypes(str, Enum):
+    Binary = "B"
+    Integer = "I"
+    Float = "F"
+
+
+class ConstraintTypes(str, Enum):
+    OneHot = "one-hot"
+    Arithmetic = "arithemtic"
+    Soft = "soft"
+
+
+class ModelSpecs(BaseModel):
+    """Serialized Model specs"""
+
+    max_degree: int
+    min_degree: int
+    needed_constraints: List[ConstraintTypes]
+    can_handle_constraints: List[ConstraintTypes]
+    can_handle_vtype: List[VariableTypes]
+    can_handle_sense: List[OptimizationSense]
+
+
 class SolverInfo(BaseModel):
     full_name: str
     short_name: str
     available: bool
     params: dict
     description: Optional[str]
+    specs: ModelSpecs

luna_sdk/schemas/solver_parameters/aws/optimizer_params.py

@@ -0,0 +1,40 @@
+from typing import Any, Optional, List, Tuple, Dict, Literal
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
+
+
+class OptimizerParams(BaseParameter):
+    """
+    Parameters for scipy optimizer
+
+    Attributes
+    ----------
+    method: Literal
+        Type of solver. Currently available methods:
+        Nelder-Mead, Powell, CG, BFGS, L-BFGS-B, TNC, COBYLA, COBYQA, SLSQP, trust-constr
+    bounds: Optional[list[[tuple[float, float]]]]
+        Bounds on variables for Nelder-Mead, L-BFGS-B, TNC, SLSQP, Powell, trust-constr,
+        and COBYLA methods. Sequence of (min, max) pairs for each element in x.
+        None is used to specify no bound.
+    tol: Optional[float]
+        Tolerance for termination. When tol is specified, the selected minimization
+        algorithm sets some relevant solver-specific tolerance(s) equal to tol.
+        For detailed control, use solver-specific options.
+    options: Optional[dict[str, Any]]
+        A dictionary of solver options.
+    """
+
+    method: Literal[
+        "Nelder-Mead",
+        "Powell",
+        "CG",
+        "BFGS",
+        "L-BFGS-B",
+        "TNC",
+        "COBYLA",
+        "COBYQA",
+        "SLSQP",
+        "trust-constr",
+    ] = "COBYLA"
+    bounds: Optional[List[Tuple[float, float]]] = None
+    tol: Optional[float] = None
+    options: Optional[Dict[str, Any]] = {"maxiter": 20}

luna_sdk/schemas/solver_parameters/aws/qaoa.py

@@ -1,9 +1,12 @@
-from typing import Optional, List
+from typing import List, Optional
 
-from pydantic import BaseModel
+from pydantic import Field
 
+from luna_sdk.schemas.solver_parameters.aws.optimizer_params import OptimizerParams
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 
-class QaoaParameters(BaseModel):
+
+class QaoaParameters(BaseParameter):
     """
     The Quantum Approximate Optimization Algorithm ([QAOA](https://arxiv.org/abs/1411.4028))
     solves combinatorial optimization problems by approximating the solution.
@@ -13,6 +16,35 @@ class QaoaParameters(BaseModel):
     for the current NISQ (noisy intermediate-scale quantum) era. In this NISQ era QAOA is also an emerging
     approach for benchmarking quantum devices and is a prime candidate for demonstrating a practical
     quantum speed-up on near-term NISQ device.
+
+    Parameters
+    ----------
+    aws_provider: str
+        QPU provider name from Amazon Braket.
+        Available providers and devices can be found
+        [here](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/devices).
+
+    aws_device: str
+       QPU device name from Amazon Braket.
+       Available providers and devices can be found
+       [here](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/devices).
+
+    seed: Optional[int]
+        Seed for the random number generator. Default: 385920.
+
+    reps: Optional[int]
+        The number of repetitions in the QAOA circuit. Default: 1.
+
+    initial_values: Optional[List[float]]
+        Initial values for the QAOA parameters. Default: None.
+
+    shots: int
+        The number of shots to run on the quantum device. Default: 1024.
+
+    optimizer_params: Optional[dict]
+        Parameters for the optimizer. Default: None.
+
+    All possible optimizer parameters can be found in the [scipy.optimize.minimize documentation](https://docs.scipy.org/doc/scipy-1.13.1/reference/generated/scipy.optimize.minimize.html).
     """
 
     aws_provider: str = ""
@@ -21,4 +53,4 @@ class QaoaParameters(BaseModel):
     reps: Optional[int] = 1
     initial_values: Optional[List[float]] = None
     shots: Optional[int] = 1024
-    optimizer_params: Optional[dict] = None
+    optimizer_params: OptimizerParams = OptimizerParams()

luna_sdk/schemas/solver_parameters/base_parameter.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel, ConfigDict
+
+
+class BaseParameter(BaseModel):
+    model_config = ConfigDict(extra="forbid")

luna_sdk/schemas/solver_parameters/dwave/base.py

@@ -1,9 +1,11 @@
 import multiprocessing as mp
 from typing import Any, List, Mapping, Optional, Tuple, Union
 
-from pydantic import BaseModel, Field
+from pydantic import Field
 from typing_extensions import Literal
 
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
+
 # The default absolute tolerance that should be used for `numpy.isclose(...)`
 # calls. Equal to the default used in `numpy.isclose(..)`.
 DEFAULT_ATOL: float = 1.0e-8
@@ -16,7 +18,6 @@ DEFAULT_RTOL: float = 1.0e-5
 # Number of seconds before routine halts. Default is 2592000 for dimod.qbsolv.
 DEFAULT_TIMEOUT: int = 10
 
-
 # The number of processes that should be used for parallel solving.
 # Default is `mp.cpu_count()`.
 DEFAULT_MULTIPROCESSING_CPU_COUNT: int = mp.cpu_count()
@@ -26,11 +27,11 @@ DEFAULT_MULTIPROCESSING_CPU_COUNT: int = mp.cpu_count()
 DRAMATIQ_ACTOR_MAX_RETRIES: int = 0
 
 
-class BaseSolver(BaseModel):
+class BaseSolver(BaseParameter):
     timeout: Optional[Any] = None
 
 
-class Tabu(BaseModel):
+class Tabu(BaseParameter):
     """
     Parameters
     ----------
@@ -62,7 +63,7 @@ class Tabu(BaseModel):
     initial_states_generator: Literal["none", "tile", "random"] = "random"
 
 
-class SimulatedAnnealing(BaseModel):
+class SimulatedAnnealing(BaseParameter):
     """
     Parameters
     ----------
@@ -98,7 +99,7 @@ class SimulatedAnnealing(BaseModel):
     initial_states_generator: Literal["none", "tile", "random"] = "random"
 
 
-class Decomposer(BaseModel):
+class Decomposer(BaseParameter):
     """
     Parameters
     ----------
@@ -139,7 +140,7 @@ class Decomposer(BaseModel):
     traversal: Literal["energy", "bfs", "pfs"] = "energy"
 
 
-class FixedTemperatureSampler(BaseModel):
+class FixedTemperatureSampler(BaseParameter):
     """
     Parameters
     ----------
@@ -153,7 +154,7 @@ class FixedTemperatureSampler(BaseModel):
     num_reads: Optional[int] = None
 
 
-class EmbeddingParameters(BaseModel):
+class EmbeddingParameters(BaseParameter):
     """
     Parameters
     ----------
@@ -253,7 +254,7 @@ class EmbeddingParameters(BaseModel):
     suspend_chains: Any = ()
 
 
-class AutoEmbeddingParams(BaseModel):
+class AutoEmbeddingParams(BaseParameter):
     """
     Parameters
     ----------
@@ -264,7 +265,7 @@ class AutoEmbeddingParams(BaseModel):
     embedding_parameters: EmbeddingParameters = EmbeddingParameters()
 
 
-class Embedding(BaseModel):
+class Embedding(BaseParameter):
     """
     Parameters
     ----------
@@ -285,7 +286,7 @@ class Embedding(BaseModel):
     embedding_parameters: EmbeddingParameters = EmbeddingParameters()
 
 
-class SamplingParams(BaseModel):
+class SamplingParams(BaseParameter):
     """
     Parameters
     ----------
@@ -339,7 +340,7 @@ class SamplingParams(BaseModel):
     reinitialize_state: Optional[bool] = None
 
 
-class Qpu(BaseModel):
+class Qpu(BaseParameter):
     """
     Parameters
     ----------
@@ -361,7 +362,7 @@ class Qpu(BaseModel):
     auto_embedding_params: AutoEmbeddingParams = AutoEmbeddingParams()
 
 
-class Loop(BaseModel):
+class Loop(BaseParameter):
     """
     Parameters
     ----------
@@ -386,7 +387,7 @@ class Loop(BaseModel):
     atol: float = DEFAULT_ATOL
 
 
-class QBSOLVLike(BaseModel):
+class QBSOLVLike(BaseParameter):
     """
     Parameters
     ----------

luna_sdk/schemas/solver_parameters/dwave/dialectic_search.py

@@ -1,11 +1,12 @@
 from typing import Optional
 
-from pydantic import BaseModel, Field
+from pydantic import Field
 
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import Decomposer, Loop, Tabu
 
 
-class DialecticSearchParameters(BaseModel):
+class DialecticSearchParameters(BaseParameter):
     """
     The Dialectic Search Solver uses a path search between two states representing the thesis and antithesis.
     A greedy search is used to reduce the energy by applying bit flips in an attempt to find the solution.

luna_sdk/schemas/solver_parameters/dwave/kerberos.py

@@ -1,7 +1,6 @@
 from typing import Optional
 
-from pydantic import BaseModel
-
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import (
     Decomposer,
     Loop,
@@ -41,7 +40,7 @@ class TabuKerberos(Tabu):
     max_time: Optional[float] = None
 
 
-class KerberosParameters(BaseModel):
+class KerberosParameters(BaseParameter):
     """
     Kerberos divides the problem into subproblems and solves them using Tabu Search, Simulated Annealing and QPU Subproblem Sampling.
     These algorithms are executed in parallel and afterwards the best solutions are combined.

luna_sdk/schemas/solver_parameters/dwave/leap_hybrid_bqm.py

@@ -1,9 +1,9 @@
 from typing import Optional, Union
 
-from pydantic import BaseModel
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 
 
-class LeapHybridBqmParameters(BaseModel):
+class LeapHybridBqmParameters(BaseParameter):
     """
     Leap's quantum-classical hybrid solvers are intended to solve arbitrary application
     problems formulated as quadratic models.

luna_sdk/schemas/solver_parameters/dwave/leap_hybrid_cqm.py

@@ -1,9 +1,9 @@
 from typing import List, Optional, Union
 
-from pydantic import BaseModel
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 
 
-class LeapHybridCqmParameters(BaseModel):
+class LeapHybridCqmParameters(BaseParameter):
     """
     Leap's quantum-classical hybrid solvers are intended to solve arbitrary application
     problems formulated as quadratic models.

luna_sdk/schemas/solver_parameters/dwave/parallel_tempering.py

@@ -1,9 +1,8 @@
-from pydantic import BaseModel
-
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import FixedTemperatureSampler, Loop
 
 
-class ParallelTemperingParameters(BaseModel):
+class ParallelTemperingParameters(BaseParameter):
     """
     Parallel Tempering uses multiple optimization procedures per temperature.
     During the cooling process, an exchange of replicas can take place between the parallel procedures,

luna_sdk/schemas/solver_parameters/dwave/parallel_tempering_qpu.py

@@ -1,5 +1,4 @@
-from pydantic import BaseModel
-
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import (
     Decomposer,
     FixedTemperatureSampler,
@@ -8,7 +7,7 @@ from luna_sdk.schemas.solver_parameters.dwave import (
 )
 
 
-class ParallelTemperingQpuParameters(BaseModel):
+class ParallelTemperingQpuParameters(BaseParameter):
     """
     Parallel Tempering uses multiple optimization procedures per temperature. During the cooling process,
     an exchange of replicas can take place between the parallel procedures, thus enabling higher energy mountains to be overcome.

luna_sdk/schemas/solver_parameters/dwave/population_annealing.py

@@ -1,9 +1,8 @@
-from pydantic import BaseModel
-
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import FixedTemperatureSampler
 
 
-class PopulationAnnealingParameters(BaseModel):
+class PopulationAnnealingParameters(BaseParameter):
     """
     Population Annealing uses a sequential Monte Carlo method to minimize the energy of a population.
     The population consists of walkers that can explore their neighborhood during the cooling process.

luna_sdk/schemas/solver_parameters/dwave/population_annealing_qpu.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel
 
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import (
     Decomposer,
     FixedTemperatureSampler,
@@ -7,7 +8,7 @@ from luna_sdk.schemas.solver_parameters.dwave import (
 )
 
 
-class PopulationAnnealingQpuParameters(BaseModel):
+class PopulationAnnealingQpuParameters(BaseParameter):
     """
     Population Annealing uses a sequential Monte Carlo method to minimize the energy of a population.
     The population consists of walkers that can explore their neighborhood during the cooling process.

luna_sdk/schemas/solver_parameters/dwave/qaga.py

@@ -1,10 +1,12 @@
 from typing import Optional
 
-from pydantic import BaseModel, Field
+from pydantic import Field
 from typing_extensions import Literal
 
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 
-class QAGAParameters(BaseModel):
+
+class QAGAParameters(BaseParameter):
     """
     Parameters for the Quantum Assisted Genetic Algorithm (QAGA).
     QAGA combines the principles of genetic algorithms and quantum annealing to solve optimization problems.

luna_sdk/schemas/solver_parameters/dwave/qbsolv_like_qpu.py

@@ -1,9 +1,8 @@
-from pydantic import BaseModel
-
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import QBSOLVLike, Qpu
 
 
-class QbSolvLikeQpuParameters(BaseModel):
+class QbSolvLikeQpuParameters(BaseParameter):
     """
     QBSolv QPU splits the problem into parts and solves them using the Tabu Search algorithm. For this purpose, the DWaveSampler is used.
 

luna_sdk/schemas/solver_parameters/dwave/qbsolv_like_simulated_annealing.py

@@ -1,9 +1,8 @@
-from pydantic import BaseModel
-
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import QBSOLVLike, SimulatedAnnealing
 
 
-class QbSolvLikeSimulatedAnnealingParameters(BaseModel):
+class QbSolvLikeSimulatedAnnealingParameters(BaseParameter):
     """
     QBSolv Like Simulated Annealing breaks down the problem and solves the parts individually using a classic solver that uses Simulated Annealing.
     This particular implementation uses hybrid.SimulatedAnnealingSubproblemSampler

luna_sdk/schemas/solver_parameters/dwave/qbsolv_like_tabu_search.py

@@ -1,9 +1,8 @@
-from pydantic import BaseModel
-
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import QBSOLVLike, Tabu
 
 
-class QbSolvLikeTabuSearchParameters(BaseModel):
+class QbSolvLikeTabuSearchParameters(BaseParameter):
     """
     QBSolv Like Tabu Search breaks down the problem and solves the parts individually using a classic solver that uses Tabu Search.
     This particular implementation uses hybrid.TabuSubproblemSampler (https://docs.ocean.dwavesys.com/projects/hybrid/en/stable/reference/samplers.html#tabusubproblemsampler)

luna_sdk/schemas/solver_parameters/dwave/quantum_annealing.py

@@ -1,9 +1,8 @@
-from pydantic import BaseModel
-
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import Embedding, SamplingParams
 
 
-class QuantumAnnealingParameters(BaseModel):
+class QuantumAnnealingParameters(BaseParameter):
     """
     Parameters for the Quantum Annealing solver.
 

luna_sdk/schemas/solver_parameters/dwave/repeated_reverse_quantum_annealing.py

@@ -2,8 +2,10 @@ from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field
 
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 
-class RRQuantumAnnealingSamplingParams(BaseModel):
+
+class RRQuantumAnnealingSamplingParams(BaseParameter):
     """
     Parameters
     ----------
@@ -41,7 +43,7 @@ class RRQuantumAnnealingSamplingParams(BaseModel):
     reduce_intersample_correlation: bool = False
 
 
-class RepeatedReverseQuantumAnnealingParameters(BaseModel):
+class RepeatedReverseQuantumAnnealingParameters(BaseParameter):
     """
     Repeated Reverse Quantum Annealing begins the annealing process from a previously initialized state and increases the temperature from there.
     Afterwards, the temperature is decreased again until the solution is found.

luna_sdk/schemas/solver_parameters/dwave/repeated_reverse_simulated_annealing.py

@@ -1,8 +1,9 @@
 from typing import Any, List, Optional, Sequence
 
-from pydantic import BaseModel, Field
+from pydantic import Field
 from typing_extensions import Literal
 
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import SimulatedAnnealing
 
 
@@ -61,7 +62,7 @@ class RRSimulatedAnnealing(SimulatedAnnealing):
     proposal_acceptance_criteria: Literal["Gibbs", "Metropolis"] = "Metropolis"
 
 
-class RepeatedReverseSimulatedAnnealingParameters(BaseModel):
+class RepeatedReverseSimulatedAnnealingParameters(BaseParameter):
     """
     Parameters for the Repeated Reverse Simulated Annealing solver.
 

luna_sdk/schemas/solver_parameters/dwave/saga.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, Optional, Tuple
+from typing import Literal, Optional, Tuple
 
 from pydantic import Field
 

luna_sdk/schemas/solver_parameters/dwave/tabu_search.py

@@ -2,8 +2,10 @@ from typing import Any, Optional
 
 from pydantic import BaseModel
 
+from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 
-class TabuSearchParameters(BaseModel):
+
+class TabuSearchParameters(BaseParameter):
     """
     Tabu Search is a heuristic optimization method that works with the help of a tabu list.
     Initially, random states are chosen in the solution landscape.