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

luna_sdk/repositories/solutions_repo.py

@@ -1,9 +1,9 @@
 import logging
 import os
 from time import sleep
-from typing import Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 
 from luna_sdk.exceptions.encryption_exception import EncryptionNotSetException
 from luna_sdk.interfaces.solutions_repo_i import ISolutionsRepo
@@ -19,32 +19,15 @@ from luna_sdk.schemas.solution import (
     UseCaseRepresentation,
     UseCaseResult,
 )
+from luna_sdk.utils.parameter_finder import get_parameter_by_solver
 from luna_sdk.utils.qpu_tokens import extract_qpu_tokens_from_env
 
 
 class SolutionsRepo(ISolutionsRepo):
     _endpoint = "/solutions"
 
-    def get(
-        self,
-        solution_id: str,
-    ) -> Solution:
-        """
-        Retrieve one solution by id.
-
-        Parameters
-        ----------
-        solution_id: str
-            Id of the solution that should be retrieved
-
-        Returns
-        -------
-        Solution
-            Solution instance
-        """
-        response = self._client.get(
-            f"{self._endpoint}/{solution_id}",
-        )
+    def get(self, solution_id: str, **kwargs) -> Solution:
+        response = self._client.get(f"{self._endpoint}/{solution_id}", **kwargs)
 
         response.raise_for_status()
 
@@ -56,26 +39,8 @@ class SolutionsRepo(ISolutionsRepo):
         limit: int = 50,
         offset: int = 0,
         optimization_id: Optional[str] = None,
+        **kwargs,
     ) -> List[Solution]:
-        """
-        Get list of available optimizations.
-
-        Parameters
-        ----------
-        timeframe: Optional[TimeframeEnum]
-            Only return Solutions created within a specified timeframe. Default None.
-        limit:
-            Limit the number of Optimizations to be returned. Default value 10.
-        offset:
-            Offset the list of solutions by this amount. Default value 0.
-        optimization_id: Optional[str]
-            Show solutions for only this optimization id. Default None.
-
-        Returns
-        -------
-        List[SolutionOut]
-            List of SolutionOut instances.
-        """
         params = {}
         if timeframe and timeframe != TimeframeEnum.all_time:  # no value == all_time
             params["timeframe"] = timeframe.value
@@ -89,30 +54,14 @@ class SolutionsRepo(ISolutionsRepo):
 
         params["limit"] = str(limit)
         params["offset"] = str(offset)
-        response = self._client.get(
-            self._endpoint,
-            params=params,
-        )
+        response = self._client.get(self._endpoint, params=params, **kwargs)
 
         response.raise_for_status()
 
         return [Solution.model_validate(i) for i in response.json()]
 
-    def delete(self, solution_id: str) -> None:
-        """
-        Delete one optimization by id.
-
-        Parameters
-        ----------
-        solution_id: str
-            Id of the optimization that should be deleted
-
-        Returns
-        -------
-        """
-        self._client.delete(
-            f"{self._endpoint}/{solution_id}",
-        )
+    def delete(self, solution_id: str, **kwargs) -> None:
+        self._client.delete(f"{self._endpoint}/{solution_id}", **kwargs)
 
     def create(
         self,
@@ -120,39 +69,16 @@ class SolutionsRepo(ISolutionsRepo):
         solver_name: str,
         provider: str,
         qpu_tokens: Optional[TokenProvider] = None,
-        solver_parameters: Optional[Union[Dict, BaseModel]] = None,
+        solver_parameters: Optional[Union[Dict[str, Any], BaseModel]] = None,
         encryption_key: Optional[str] = None,
         name: Optional[str] = None,
+        fail_on_invalid_params: bool = True,
+        **kwargs,
     ) -> Solution:
-        """
-        Create a solution for an optimization
-
-        Parameters
-        ----------
-        optimization_id: str
-            The id of the optimization for which solution should be created
-        solver_name: str
-            The name of the solver to use.
-        provider: str
-            The name of the QPU provider to use.
-        qpu_tokens: Optional[TokenProvider]
-            The tokens to be used for the QPU.
-        solver_parameters: Optional[Dict]
-            Parameters to be passed to the solver.
-        encryption_key: Optional[str]
-            Encryption key to be used for encryption of QPU tokens.
-        name: Optional[str]
-            Default: None, The name of the solution to create.
-
-        Returns
-        -------
-        SolutionOut
-            Returns the location where the solution can be found once solving is complete.
-        """
-        if solver_parameters is None:
-            solver_parameters = {}
         if qpu_tokens is not None:
-            rest_qpu_tokens = RestAPITokenProvider.from_sdk_token_provider(qpu_tokens)
+            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
@@ -162,21 +88,21 @@ class SolutionsRepo(ISolutionsRepo):
         encryption_key = encryption_key or os.environ.get("LUNA_ENCRYPTION_KEY")
         if encryption_key is None:
             raise EncryptionNotSetException
+        params = SolutionsRepo.validate_solver_params(
+            solver_name, provider, solver_parameters, fail_on_invalid_params
+        )
+
         solution_in = SolutionIn(
             optimization=optimization_id,
             solver_name=solver_name,
             provider=provider,
-            parameters=(
-                solver_parameters.model_dump()
-                if isinstance(solver_parameters, BaseModel)
-                else solver_parameters
-            ),
+            parameters=params,
             qpu_tokens=rest_qpu_tokens,
             encryption_key=encryption_key,
             name=name,
         )
         response = self._client.post(
-            self._endpoint, content=solution_in.model_dump_json()
+            self._endpoint, content=solution_in.model_dump_json(), **kwargs
         )
         response.raise_for_status()
 
@@ -188,53 +114,19 @@ class SolutionsRepo(ISolutionsRepo):
         solver_name: str,
         provider: str,
         qpu_tokens: Optional[TokenProvider] = None,
-        solver_parameters: Optional[Union[Dict, BaseModel]] = None,
+        solver_parameters: Optional[Union[Dict[str, Any], BaseModel]] = None,
         sleep_time_max: float = 60.0,
         sleep_time_increment: float = 5.0,
         sleep_time_initial: float = 5.0,
         encryption_key: Optional[str] = None,
         name: Optional[str] = None,
+        fail_on_invalid_params: bool = True,
+        **kwargs,
     ) -> Solution:
-        """
-        Create a solution for optimization. This method will block your code until the solution is ready.
-        Depending on the problem size, this can take a long time.
-
-        Parameters
-        ----------
-        optimization_id: str
-            The id of the optimization 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] = None
-            The tokens to be used for the QPU.
-        solver_parameters: Optional[Dict]
-            Parameters to be passed to the solver.
-
-        sleep_time_max: float
-            Maximum time to sleep between requests.
-        sleep_time_increment: float
-            Increment of sleep time between requests. Initial sleep time will be
-        sleep_time_initial: float
-            Initial sleep time.
-        encryption_key: Optional[str]
-            Encryption key to be used for encryption of QPU tokens.
-        name: Optional[str]
-            Default: None, The name of the solution to create.
-        Returns
-        -------
-        SolutionOut
-            Returns the location where the solution can be found once solving is complete.
-        """
         # First create the solution
-
-        params: Optional[Union[Dict, BaseModel]] = None
-        if solver_parameters is not None:
-            params = solver_parameters
-        if isinstance(solver_parameters, BaseModel):
-            params = solver_parameters.dict()
+        params = SolutionsRepo.validate_solver_params(
+            solver_name, provider, solver_parameters, fail_on_invalid_params
+        )
 
         solution: Solution = self.create(
             optimization_id=optimization_id,
@@ -244,6 +136,7 @@ class SolutionsRepo(ISolutionsRepo):
             qpu_tokens=qpu_tokens,
             encryption_key=encryption_key,
             name=name,
+            **kwargs,
         )
         # times are in sec
 
@@ -271,44 +164,20 @@ class SolutionsRepo(ISolutionsRepo):
             if cur_sleep_time > sleep_time_max:
                 cur_sleep_time = sleep_time_max
 
-            solution = self.get(solution_id=solution.id)
+            solution = self.get(solution_id=solution.id, **kwargs)
 
         return solution
 
-    def get_use_case_representation(self, solution_id: str) -> UseCaseRepresentation:
-        """
-        Get the use-case-specific representation of a solution.
-
-        Parameters
-        ----------
-        solution_id: str
-            Id of the solution that should be retrieved
-
-        Returns
-        -------
-        UseCaseRepresentation
-            The use-case-specific representation
-        """
-        response = self._client.get(f"{self._endpoint}/{solution_id}/representation")
+    def get_use_case_representation(
+        self, solution_id: str, **kwargs
+    ) -> UseCaseRepresentation:
+        response = self._client.get(
+            f"{self._endpoint}/{solution_id}/representation", **kwargs
+        )
         response.raise_for_status()
         return UseCaseRepresentation.model_validate_json(response.text)
 
     def get_best_result(self, solution: Solution) -> Optional[Result]:
-        """
-        Retrieves the best result from a solution.
-
-        Parameters
-        ----------
-        solution : Solution
-            The solution received via `solutions.get` or `solutions.get_all`.
-
-        Returns
-        -------
-        Result | None
-            The best result of the solution. If there are several best solutions with
-            the same objective value, return only the first. If the solution results are
-            not (yet) available or no the solution sense is `None`, return `None`.
-        """
         if solution.results is None or solution.sense is None:
             return None
 
@@ -320,21 +189,6 @@ class SolutionsRepo(ISolutionsRepo):
     def get_best_use_case_result(
         self, use_case_representation: UseCaseRepresentation
     ) -> Optional[UseCaseResult]:
-        """
-        Retrieves the best result from a solution's use case representation.
-
-        Parameters
-        ----------
-        use_case_representation : UseCaseRepresentation
-            A solution's use case representation.
-
-        Returns
-        -------
-        UseCaseResult | None
-            The best result of the solution. If there are several best solutions with
-            the same objective value, return only the first. If the solution results are
-            not (yet) available or no the solution sense is `None`, return `None`.
-        """
         if (
             use_case_representation.results is None
             or use_case_representation.sense is None
@@ -345,3 +199,77 @@ class SolutionsRepo(ISolutionsRepo):
         best_result = agg(use_case_representation.results, key=lambda x: x.obj_value)
 
         return best_result
+
+    @staticmethod
+    def validate_solver_params(
+        solver: str,
+        provider: str,
+        solver_parameter: Optional[Union[Dict[str, Any], BaseModel]],
+        fail_on_invalid_params: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        This function checks if the params provided are valid for the provided solver
+        and provider.
+        If no parameter class was found, there will be no check.
+
+        Parameters
+        ----------
+        solver: str
+            The solver
+        provider: str
+            The provider
+        solver_parameter: Optional[Union[Dict[str, Any], BaseModel]]
+            The solver parameter
+        fail_on_invalid_params: bool
+            Default true.
+            If True, a ValueError will be raised, if the solver_parameter are invalid.
+            Otherwise, there will only a warning.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Validated solver params
+
+        Raises
+        -------
+        ValidationError
+            If the object could not be validated.
+
+        """
+        if solver_parameter is None:
+            logging.info(
+                "You didn't provide any specific solver parameters, so we chose the "
+                "default ones for this solver."
+            )
+            return {}
+
+        params: Dict[str, Any]
+        if isinstance(solver_parameter, BaseModel):
+            params = solver_parameter.dict()
+        else:
+            params = solver_parameter
+
+        parameter_class: Optional[Type[BaseModel]] = get_parameter_by_solver(
+            solver, provider
+        )
+
+        if parameter_class is None:
+            logging.info(
+                f"SDK was not able to find a parameter for solver {solver} "
+                f"and provider {provider}."
+            )
+            return params
+
+        try:
+            parameter_class.model_validate(params)
+
+        except ValidationError as e:
+            if fail_on_invalid_params:
+                raise e
+            logging.warning(
+                "The validation for the provided solver parameter failed.\n"
+                f"Detected error:\n{e}\n"
+                "Since continue on error is enabled, no error was raised.\n"
+                "Solving with Luna can still fail due to the parameters."
+            )
+        return params

luna_sdk/schemas/create/solution.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional
+from typing import Dict, Optional, Any
 
 from pydantic import BaseModel
 
@@ -9,7 +9,7 @@ class SolutionIn(BaseModel):
     optimization: str  # id of the optimization
     solver_name: str
     provider: str
-    parameters: Dict
+    parameters: Dict[str, Any]
     qpu_tokens: Optional[RestAPITokenProvider] = None
     encryption_key: str
     name: Optional[str] = None

luna_sdk/schemas/enums/optimization.py

@@ -1,10 +1,11 @@
 from enum import Enum
 
 
-class InputType(str, Enum):
-    bqm_spin = "bqm_spin"
-    bqm_binary = "bqm_binary"
-    cqm = "cqm"
-    lp = "lp"
-    aq = "aq"
-    qubo = "qubo"
+class OptFormat(str, Enum):
+    """Enumeration of all supported formats."""
+
+    AQ_MODEL = "AQ_MODEL"
+    LP = "LP"
+    QUBO = "QUBO_MATRIX"
+    CQM = "CQM"
+    BQM = "BQM"

luna_sdk/schemas/enums/qpu_token_type.py

@@ -2,5 +2,5 @@ from enum import Enum
 
 
 class QpuTokenTypeEnum(str, Enum):
-    ORGANIZATION = "organization"
+    GROUP = "group"
     PERSONAL = "personal"

luna_sdk/schemas/optimization.py

@@ -1,13 +1,14 @@
-from datetime import datetime
-from typing import Any, Dict, Generic, List, Optional, TypeVar
+from typing import Any, Dict, Generic, Optional, TypeVar
 
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, ConfigDict
 
-from luna_sdk.schemas.enums.optimization import InputType
+from luna_sdk.schemas.enums.optimization import OptFormat
 from luna_sdk.schemas.optimization_formats.bqm import BQMSchema
 from luna_sdk.schemas.optimization_formats.cqm import CQMSchema
 from luna_sdk.schemas.optimization_formats.lp import LPSchema
+from luna_sdk.schemas.optimization_formats.qubo import QuboSchema
 from luna_sdk.schemas.pretty_base import PrettyBase
+from luna_sdk.schemas.wrappers import PydanticDatetimeWrapper
 
 
 class Optimization(PrettyBase):
@@ -17,11 +18,11 @@ class Optimization(PrettyBase):
     ----------
     id: str
         Id of the optimization
-    created_date: Optional[datetime]
+    created_date: Optional[DatetimeWrapper]
         Date when optimization was created
     created_by: Optional[str]
         Id of the user who created optimization
-    modified_date: Optional[datetime]
+    modified_date: Optional[DatetimeWrapper]
         Date when optimization was modified
     modified_by: Optional[str]
         Id of the user who modified optimization
@@ -29,28 +30,15 @@ class Optimization(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
-    input_type: Optional[InputType] = None
+    original_format: Optional[OptFormat] = None
     use_case_name: Optional[str] = None
     params: Optional[Dict[str, Any]] = None
 
-    class Config:
-        extra = Extra.ignore
-        from_attributes = False
-
-
-class OptimizationQubo(BaseModel):
-    id: str
-    name: Optional[str] = None
-    created_date: datetime
-    created_by: str
-    modified_date: Optional[datetime] = None
-    modified_by: Optional[str] = None
-
-    matrix: List[List[float]]
+    model_config = ConfigDict(extra="ignore", from_attributes=False)
 
 
 class OptimizationBQM(Optimization, BQMSchema): ...
@@ -62,10 +50,13 @@ class OptimizationCQM(Optimization, CQMSchema): ...
 class OptimizationLP(Optimization, LPSchema): ...
 
 
-class OptimizationUseCase(Optimization, BQMSchema):
+class OptimizationUseCase(Optimization, QuboSchema):
     use_case: Dict[str, Any]
 
 
+class OptimizationQubo(Optimization, QuboSchema): ...
+
+
 T = TypeVar("T")
 
 

luna_sdk/schemas/optimization_formats/qubo.py

@@ -0,0 +1,8 @@
+from typing import List
+
+from pydantic import BaseModel
+
+
+class QuboSchema(BaseModel):
+    matrix: List[List[float]]
+    offset: float

luna_sdk/schemas/pretty_base.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from pydantic import BaseModel
 
 
@@ -8,10 +10,15 @@ class PrettyBase(BaseModel):
         for key, value in data.items():
             output += "    " * indent + str(key) + ":"
             if isinstance(value, dict):
-                output += "\n"
-                output += self._pretty_print(value, indent + 1)
+                if value == {}:
+                    output += " {}\n"
+                else:
+                    output += "\n"
+                    output += self._pretty_print(value, indent + 1)
+            elif isinstance(value, datetime):
+                output += f" {value.strftime('%Y-%m-%d %H:%M:%S (%Z)')}\n"
             else:
-                output += " " + str(value) + "\n"
+                output += f" {value}\n"
         return output
 
     def __str__(self):

luna_sdk/schemas/qpu_token.py

@@ -3,6 +3,8 @@ from typing import Optional
 
 from pydantic import BaseModel, Extra
 
+from luna_sdk.schemas.enums.qpu_token_type import QpuTokenTypeEnum
+
 
 class QpuTokenSource(str, Enum):
     # token currently passed in from the API call (not stored by us)
@@ -10,7 +12,7 @@ class QpuTokenSource(str, Enum):
     # stored token in user account
     PERSONAL = "personal"
     # stored token in group account
-    ORGANIZATION = "organization"
+    GROUP = "group"
 
 
 class QpuToken(BaseModel):
@@ -42,18 +44,15 @@ class QpuTokenOut(BaseModel):
 
     Attributes
     ----------
-    id: str
-        Id of the QPU token
     name: Optional[str]
         Name of the QPU token
     provider: ProviderEnum
         Name of provider: dwave | ibm
     """
 
-    id: str
-
     name: str
     provider: str
+    token_type: QpuTokenTypeEnum
 
     class Config:
         extra = Extra.ignore

luna_sdk/schemas/rest/qpu_token/qpu_token_source.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class _RESTQpuTokenSource(str, Enum):
+    """
+    This schema allow us not to change entire backend,
+    but just sync SDK and everything else in terms of qpu token source.
+    Currently, the difference is that
+    SDK has group qpu token source
+    and backend has organization qpu token source which are mapped to each other.
+    """
+
+    # token currently passed in from the API call (not stored by us)
+    INLINE = "inline"
+    # stored token in user account
+    PERSONAL = "personal"
+    # stored token in group account
+    ORGANIZATION = "organization"