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

luna_sdk/repositories/qpu_token_repo.py

@@ -26,13 +26,16 @@ class QpuTokenRepo(IQpuTokenRepo):
         else:
             return f"{self._endpoint}/organization"
 
-    def _get_by_name(self, name: str, token_type: QpuTokenTypeEnum) -> QpuTokenOut:
+    def _get_by_name(
+        self, name: str, token_type: QpuTokenTypeEnum, **kwargs
+    ) -> QpuTokenOut:
         response: Response = self._client.get(
-            f"{self._get_endpoint_by_type(token_type)}/by_name/{name}"
+            f"{self._get_endpoint_by_type(token_type)}/by_name/{name}", **kwargs
         )
         response.raise_for_status()
 
         qpu_token_data = response.json()
+        qpu_token_data["token_type"] = token_type
         return QpuTokenOut.model_validate(qpu_token_data)
 
     def create(
@@ -40,32 +43,10 @@ class QpuTokenRepo(IQpuTokenRepo):
         name: str,
         provider: str,
         token: str,
-        token_type: QpuTokenTypeEnum = QpuTokenTypeEnum.PERSONAL,
+        token_type: QpuTokenTypeEnum,
         encryption_key: Optional[str] = None,
+        **kwargs,
     ) -> QpuTokenOut:
-        """
-        Create user 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 ORGANIZATION.
-            The default value is PERSONAL.
-            All users of an organization can use organization QPU tokens.
-            User QPU tokens can only be used by the user who created them.
-        encryption_key: Optional[str]
-            Encryption key to be used for encryption of QPU tokens.
-        Returns
-        -------
-        QpuTokenOut
-            QpuTokenOut instances.
-        """
         encryption_key = encryption_key or os.environ.get("LUNA_ENCRYPTION_KEY")
         if encryption_key is None:
             raise EncryptionNotSetException
@@ -77,10 +58,13 @@ class QpuTokenRepo(IQpuTokenRepo):
         )
 
         response: Response = self._client.post(
-            self._get_endpoint_by_type(token_type), content=qpu_token.model_dump_json()
+            self._get_endpoint_by_type(token_type),
+            content=qpu_token.model_dump_json(),
+            **kwargs,
         )
         response.raise_for_status()
         qpu_token_data = response.json()
+        qpu_token_data["token_type"] = token_type
         return QpuTokenOut.model_validate(qpu_token_data)
 
     def get_all(
@@ -88,30 +72,8 @@ class QpuTokenRepo(IQpuTokenRepo):
         filter_provider: Optional[str] = None,
         name: Optional[str] = None,
         token_type: Optional[QpuTokenTypeEnum] = None,
+        **kwargs,
     ) -> Dict[QpuTokenTypeEnum, List[QpuTokenOut]]:
-        """
-        Retrieve list of user QPU tokens.
-
-        Parameters
-        ----------
-        filter_provider: Optional[str]
-            The provider for which qpu tokens should be retrieved
-        name: Optional[str]
-            Name of the QPU token that should be retrieved
-        token_type: Optional[QpuTokenTypeEnum]
-            If you want to retrieve only user or organization QPU tokens
-            otherwise all QPU tokens will be retrieved
-        token_type: QpuTokenTypeEnum
-            There are two types of QPU tokens: PERSONAL and ORGANIZATION.
-            The default value is PERSONAL.
-            All users of an organization can use organization QPU tokens.
-            User QPU tokens can only be used by the user who created them.
-
-        Returns
-        -------
-        Dict[QpuTokenTypeEnum, List[QpuTokenOut]]
-            List of QpuTokenOut instances.
-        """
         params = {}
         if filter_provider:
             params["filter_provider"] = filter_provider
@@ -119,14 +81,19 @@ class QpuTokenRepo(IQpuTokenRepo):
         if name:
             params["name"] = name
 
-        response = self._client.get(self._get_endpoint_by_type(), params=params)
+        response = self._client.get(
+            self._get_endpoint_by_type(), params=params, **kwargs
+        )
         response.raise_for_status()
 
         to_return: Dict[QpuTokenTypeEnum, List[QpuTokenOut]] = {}
         for key, value in response.json().items():
-            to_return[QpuTokenTypeEnum(key)] = [
-                QpuTokenOut.model_validate(item) for item in value
-            ]
+            tokens = []
+            for item in value:
+                if token_type is None or token_type.value == key:
+                    item["token_type"] = QpuTokenTypeEnum(key)
+                    tokens.append(QpuTokenOut.model_validate(item))
+            to_return[QpuTokenTypeEnum(key)] = tokens
 
         return to_return
 
@@ -134,56 +101,15 @@ class QpuTokenRepo(IQpuTokenRepo):
         self,
         name: str,
         token_type: QpuTokenTypeEnum = QpuTokenTypeEnum.PERSONAL,
+        **kwargs,
     ) -> 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 ORGANIZATION.
-            The default value is PERSONAL.
-            All users of an organization can use organization QPU tokens.
-            User QPU tokens can only be used by the user who created them.
-
-        Returns
-        -------
-        QpuTokenOut
-            QpuTokenOut instance.
-        """
-
-        qpu_token: QpuTokenOut = self._get_by_name(name, token_type)
+        qpu_token: QpuTokenOut = self._get_by_name(name, token_type, **kwargs)
 
         return qpu_token
 
     def rename(
-        self,
-        name: str,
-        new_name: str,
-        token_type: QpuTokenTypeEnum = QpuTokenTypeEnum.PERSONAL,
+        self, name: str, new_name: str, token_type: QpuTokenTypeEnum, **kwargs
     ) -> QpuTokenOut:
-        """
-        Update user QPU token by id
-
-        Parameters
-        ----------
-        name: str
-            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 ORGANIZATION.
-            The default value is PERSONAL.
-            All users of an organization can use organization QPU tokens.
-            User QPU tokens can only be used by the user who created them.
-
-        Returns
-        -------
-        QpuTokenOut
-            QpuTokenOut instance.
-        """
         qpu_token_update_data = {"name": new_name}
 
         token: QpuTokenOut = self.get(name, token_type)
@@ -191,36 +117,18 @@ class QpuTokenRepo(IQpuTokenRepo):
         response = self._client.put(
             f"{self._get_endpoint_by_type(token_type)}/{token.id}",
             content=json.dumps(qpu_token_update_data),
+            **kwargs,
         )
         response.raise_for_status()
 
         qpu_token_data = response.json()
+        qpu_token_data["token_type"] = token_type
         return QpuTokenOut.model_validate(qpu_token_data)
 
-    def delete(
-        self,
-        name: str,
-        token_type: QpuTokenTypeEnum = QpuTokenTypeEnum.PERSONAL,
-    ) -> None:
-        """
-        Delete organization 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 ORGANIZATION.
-            The default value is PERSONAL.
-            All users of an organization can use organization QPU tokens.
-            User QPU tokens can only be used by the user who created them.
-
-        Returns
-        -------
-        """
+    def delete(self, name: str, token_type: QpuTokenTypeEnum, **kwargs) -> None:
         token: QpuTokenOut = self.get(name, token_type)
 
         response = self._client.delete(
-            f"{self._get_endpoint_by_type(token_type)}/{token.id}"
+            f"{self._get_endpoint_by_type(token_type)}/{token.id}", **kwargs
         )
         response.raise_for_status()

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

@@ -1,13 +1,13 @@
-from datetime import datetime
 from typing import Any, Dict, Generic, List, Optional, TypeVar
 
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, ConfigDict
 
 from luna_sdk.schemas.enums.optimization import InputType
 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.pretty_base import PrettyBase
+from luna_sdk.schemas.wrappers import PydanticDatetimeWrapper
 
 
 class Optimization(PrettyBase):
@@ -17,11 +17,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,25 +29,23 @@ 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
     use_case_name: Optional[str] = None
     params: Optional[Dict[str, Any]] = None
 
-    class Config:
-        extra = Extra.ignore
-        from_attributes = False
+    model_config = ConfigDict(extra="ignore", from_attributes=False)
 
 
 class OptimizationQubo(BaseModel):
     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
 
     matrix: List[List[float]]