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

luna_sdk/interfaces/solutions_repo_i.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
@@ -22,6 +22,7 @@ class ISolutionsRepo(IRepository, ABC):
         limit: int = 50,
         offset: int = 0,
         optimization_id: Optional[str] = None,
+        **kwargs,
     ) -> List[Solution]:
         """
         Get list of available optimizations.
@@ -36,6 +37,8 @@ class ISolutionsRepo(IRepository, ABC):
             Offset the list of solutions by this amount. Default value 0.
         optimization_id: Optional[str]
             Show solutions for only this optimization id. Default None.
+        **kwargs
+            Parameters to pass to `httpx.request`.
 
         Returns
         -------
@@ -45,14 +48,16 @@ class ISolutionsRepo(IRepository, ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def get(self, solution_id: str) -> Solution:
+    def get(self, solution_id: str, **kwargs) -> Solution:
         """
         Retrieve one optimization by id.
 
         Parameters
         ----------
         solution_id: str
-            Id of the solution that should be retrieved
+            Id of the solution that should be retrieved.
+        **kwargs
+            Parameters to pass to `httpx.request`.
 
         Returns
         -------
@@ -62,14 +67,18 @@ class ISolutionsRepo(IRepository, ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def get_use_case_representation(self, solution_id: str) -> UseCaseRepresentation:
+    def get_use_case_representation(
+        self, solution_id: str, **kwargs
+    ) -> UseCaseRepresentation:
         """
         Get the use-case-specific representation of a solution.
 
         Parameters
         ----------
         solution_id: str
-            Id of the solution that should be retrieved
+            Id of the solution that should be retrieved.
+        **kwargs
+            Parameters to pass to `httpx.request`.
 
         Returns
         -------
@@ -78,17 +87,16 @@ class ISolutionsRepo(IRepository, ABC):
         """
 
     @abstractmethod
-    def delete(self, solution_id: str) -> None:
+    def delete(self, solution_id: str, **kwargs) -> None:
         """
         Delete one optimization by id.
 
         Parameters
         ----------
         solution_id: str
-            Id of the optimization that should be deleted
-
-        Returns
-        -------
+            Id of the optimization that should be deleted.
+        **kwargs
+            Parameters to pass to `httpx.request`.
         """
         raise NotImplementedError
 
@@ -99,34 +107,40 @@ class ISolutionsRepo(IRepository, ABC):
         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 optimization
+        Create a solution for optimization.
 
         Parameters
         ----------
         optimization_id: str
-            The id of the optimization for which solution should be created
+            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]
             The tokens to be used for the QPU.
-        solver_parameters: Optional[Union[Dict, BaseModel]]
+        solver_parameters: Optional[Union[Dict[str, Any], BaseModel]]
             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.
+        fail_on_invalid_params: bool
+            Default: true. Disable the local solver parameter validation.
+        **kwargs
+            Parameters to pass to `httpx.request`.
 
         Returns
         -------
         SolutionOut
-            Returns the location where the solution can be found once solving is complete.
+            The location where the solution can be found once solving is complete.
         """
         raise NotImplementedError
 
@@ -137,12 +151,14 @@ class ISolutionsRepo(IRepository, ABC):
         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.
@@ -151,16 +167,15 @@ class ISolutionsRepo(IRepository, ABC):
         Parameters
         ----------
         optimization_id: str
-            The id of the optimization for which solution should be created
+            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[Union[Dict, BaseModel]]
+        solver_parameters: Optional[Union[Dict[str, Any], BaseModel]]
             Parameters to be passed to the solver.
-
         sleep_time_max: float
             Maximum time to sleep between requests.
         sleep_time_increment: float
@@ -171,10 +186,15 @@ class ISolutionsRepo(IRepository, ABC):
             Encryption key to be used for encryption of QPU tokens.
         name: Optional[str]
             Default: None, The name of the solution to create.
+        fail_on_invalid_params: bool
+            Default: true. Disable the local solver parameter validation.
+        **kwargs
+            Parameters to pass to `httpx.request`.
+
         Returns
         -------
         SolutionOut
-            Returns the location where the solution can be found once solving is complete.
+            The location where the solution can be found once solving is complete.
         """
         raise NotImplementedError
 
@@ -186,14 +206,14 @@ class ISolutionsRepo(IRepository, ABC):
         Parameters
         ----------
         solution : Solution
-            The solution received via a `solutions.get` or `solutions.get_all`.
+            The solution received via `solutions.get` or `solutions.get_all`.
 
         Returns
         -------
-        Result | None
+        Optional[Result]
             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, return `None`.
+            not (yet) available or the solution sense is `None`, `None` is returned.
         """
         raise NotImplementedError
 
@@ -214,6 +234,6 @@ class ISolutionsRepo(IRepository, ABC):
         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`.
+            not (yet) available or the solution sense is `None`, `None` is returned.
         """
         raise NotImplementedError

luna_sdk/repositories/circuit_repo.py

@@ -6,7 +6,7 @@ from luna_sdk.interfaces.circuit_repo_i import ICircuitRepo
 from luna_sdk.schemas.circuit import CircuitJob, CircuitResult
 from luna_sdk.schemas.create.circuit import CircuitIn
 from luna_sdk.schemas.enums.circuit import CircuitProviderEnum
-from luna_sdk.schemas.qpu_token import TokenProvider, QpuToken, QpuTokenSource
+from luna_sdk.schemas.qpu_token import TokenProvider
 from luna_sdk.schemas.rest.qpu_token.token_provider import RestAPITokenProvider
 from luna_sdk.utils.qpu_tokens import extract_qpu_tokens_from_env
 
@@ -20,35 +20,13 @@ class CircuitRepo(ICircuitRepo):
         provider: CircuitProviderEnum,
         params: Dict[str, Any] = {},
         qpu_tokens: Optional[TokenProvider] = None,
-        timeout: Optional[float] = 10800.0,
         encryption_key: Optional[str] = None,
+        **kwargs,
     ) -> CircuitJob:
-        """
-        Create a circuit solution.
-
-        Parameters
-        ----------
-        circuit: str
-            The circuit which to create a solution for.
-        provider: CircuitProviderEnum
-            Which provider to use to solve the circuit.
-        params: Dict[str, Any]
-            Additional parameters of the circuit.
-        qpu_tokens: Optional[TokenProvider]
-            The tokens to be used for the QPU.
-        timeout: Optional[float]
-            Default = 10800.0. Timeout for the api request. If set to None,
-            there won't be any timeout. Increase or disable the timeout if you face
-            issues uploading big Problems.
-        encryption_key: Optional[str]
-            Encryption key to be used for encryption of QPU tokens.
-        Returns
-        -------
-        CircuitJob
-            The created circuit job.
-        """
         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
 
@@ -68,29 +46,18 @@ class CircuitRepo(ICircuitRepo):
         )
 
         response = self._client.post(
-            self._endpoint, content=circuit_in.model_dump_json(), timeout=timeout
+            self._endpoint, content=circuit_in.model_dump_json(), **kwargs
         )
 
         response.raise_for_status()
         return CircuitJob(id=response.json(), provider=provider, params=params)
 
     def get(
-        self, job: CircuitJob, encryption_key: Optional[str] = None
+        self,
+        job: CircuitJob,
+        encryption_key: Optional[str] = None,
+        **kwargs,
     ) -> CircuitResult:
-        """
-        Retrieve a circuit result from a job.
-
-        Parameters
-        ----------
-        job: CircuitJob
-            The job received upon circuit creation.
-        encryption_key: Optional[str]
-            The encryption key to be used for the QPU.
-        Returns
-        -------
-        CircuitResult
-            The result of solving the circuit.
-        """
         url = f"{self._endpoint}/{job.id}/{job.provider.value}"
         encryption_key = encryption_key or os.environ.get("LUNA_ENCRYPTION_KEY")
         if encryption_key is None:
@@ -98,7 +65,7 @@ class CircuitRepo(ICircuitRepo):
         if job.params is None:
             job.params = {}
         job.params["encryption_key"] = encryption_key
-        response = self._client.get(url, params=job.params, timeout=60)
+        response = self._client.get(url, params=job.params, **kwargs)
 
         response.raise_for_status()
         return CircuitResult.model_validate(response.json())

luna_sdk/repositories/cplex_repo.py

@@ -2,7 +2,7 @@ import os
 import pickle
 import tempfile
 from functools import partial
-from typing import Tuple, List, Dict
+from typing import Dict, List, Tuple
 
 import dimod
 from dimod import ConstrainedQuadraticModel
@@ -12,7 +12,7 @@ from qiskit_optimization import QuadraticProgram
 
 from luna_sdk.exceptions.transformation import TransformationException
 from luna_sdk.interfaces.cplex_repo_i import ICplexRepo
-from luna_sdk.schemas.transformations.bqm import BQMResultSchema, BQMSchema
+from luna_sdk.schemas.transformations.bqm import BQMResultSchema
 from luna_sdk.schemas.transformations.matrix import MatrixSchema
 
 
@@ -20,12 +20,14 @@ class CplexRepo(ICplexRepo):
     _endpoint = "/transformations/docplex"
 
     def _send_request_with_pickle_file_response(
-        self, docplex_model: DOCplexModel, endpoint: str
+        self, docplex_model: DOCplexModel, endpoint: str, **kwargs
     ):
         file = tempfile.NamedTemporaryFile(delete=False)
         with open(file.name, "wb") as tmp:
             pickle.dump(docplex_model, tmp)
-        response = self._client.post(endpoint, files={"file": (file.name, file.file)})
+        response = self._client.post(
+            endpoint, files={"file": (file.name, file.file)}, **kwargs
+        )
         os.remove(file.name)
         try:
             parsed_model = pickle.loads(response.content)
@@ -33,9 +35,9 @@ class CplexRepo(ICplexRepo):
             raise TransformationException()
         return parsed_model
 
-    def to_qubo_qiskit(self, docplex_model: DOCplexModel) -> QuadraticProgram:
+    def to_qubo_qiskit(self, docplex_model: DOCplexModel, **kwargs) -> QuadraticProgram:
         qubo_qiskit_model = self._send_request_with_pickle_file_response(
-            docplex_model, f"{self._endpoint}/to-qubo-qiskit"
+            docplex_model, f"{self._endpoint}/to-qubo-qiskit", **kwargs
         )
         try:
             assert isinstance(qubo_qiskit_model, QuadraticProgram)
@@ -43,51 +45,59 @@ class CplexRepo(ICplexRepo):
             raise TransformationException()
         return qubo_qiskit_model
 
-    def to_lp_file(self, docplex_model: DOCplexModel, filepath: str) -> None:
+    def to_lp_file(self, docplex_model: DOCplexModel, filepath: str, **kwargs) -> None:
         file = tempfile.NamedTemporaryFile(delete=False)
         with open(file.name, "wb") as tmp:
             pickle.dump(docplex_model, tmp)
         response = self._client.post(
-            f"{self._endpoint}/to-lp-file", files={"file": (file.name, file.file)}
+            f"{self._endpoint}/to-lp-file",
+            files={"file": (file.name, file.file)},
+            **kwargs,
         )
         with open(filepath, "w") as file:  # type: ignore
             file.write(response.content.decode("utf-8"))  # type: ignore
 
-    def to_lp_string(self, docplex_model: DOCplexModel) -> str:
+    def to_lp_string(self, docplex_model: DOCplexModel, **kwargs) -> str:
         file = tempfile.NamedTemporaryFile(delete=False)
         with open(file.name, "wb") as tmp:
             pickle.dump(docplex_model, tmp)
         response = self._client.post(
-            f"{self._endpoint}/to-lp-file", files={"file": (file.name, file.file)}
+            f"{self._endpoint}/to-lp-file",
+            files={"file": (file.name, file.file)},
+            **kwargs,
         )
         return response.content.decode("utf-8")
 
     def to_qubo_matrix(
-        self, docplex_model: DOCplexModel
+        self, docplex_model: DOCplexModel, **kwargs
     ) -> Tuple[List[List[float]], partial]:
         file = tempfile.NamedTemporaryFile(delete=False)
         with open(file.name, "wb") as tmp:
             pickle.dump(docplex_model, tmp)
         response = self._client.post(
-            f"{self._endpoint}/to-qubo-matrix", files={"file": (file.name, file.file)}
+            f"{self._endpoint}/to-qubo-matrix",
+            files={"file": (file.name, file.file)},
+            **kwargs,
         )
-        retrieved_matrix = MatrixSchema.validate(response.json())
+        retrieved_matrix = MatrixSchema.model_validate(response.json())
         return retrieved_matrix.matrix, partial(
             self.inverter,
             var_indices=retrieved_matrix.variable_indices,
-            inverter_bqm=CQMToBQMInverter.from_dict(retrieved_matrix.inverter.dict()),
+            inverter_bqm=CQMToBQMInverter.from_dict(
+                retrieved_matrix.inverter.model_dump()
+            ),
         )
 
     def to_bqm(
-        self, docplex_model: DOCplexModel
+        self, docplex_model: DOCplexModel, **kwargs
     ) -> Tuple[dimod.BinaryQuadraticModel, CQMToBQMInverter]:
         file = tempfile.NamedTemporaryFile(delete=False)
         with open(file.name, "wb") as tmp:
             pickle.dump(docplex_model, tmp)
         response = self._client.post(
-            f"{self._endpoint}/to-bqm", files={"file": (file.name, file.file)}
+            f"{self._endpoint}/to-bqm", files={"file": (file.name, file.file)}, **kwargs
         )
-        retrieved_bqm = BQMResultSchema.validate(response.json())
+        retrieved_bqm = BQMResultSchema.model_validate(response.json())
 
         quadratic: Dict[Tuple[str, str], float] = {}
         for key, value in retrieved_bqm.bqm.quadratic.items():
@@ -104,15 +114,17 @@ class CplexRepo(ICplexRepo):
             )
         except Exception:
             raise TransformationException()
-        inverter = CQMToBQMInverter.from_dict(retrieved_bqm.inverter.dict())
+        inverter = CQMToBQMInverter.from_dict(retrieved_bqm.inverter.model_dump())
         return bqm, inverter
 
-    def to_cqm(self, docplex_model: DOCplexModel) -> ConstrainedQuadraticModel:
+    def to_cqm(
+        self, docplex_model: DOCplexModel, **kwargs
+    ) -> ConstrainedQuadraticModel:
         file = tempfile.NamedTemporaryFile(delete=False)
         with open(file.name, "wb") as tmp:
             pickle.dump(docplex_model, tmp)
         response = self._client.post(
-            f"{self._endpoint}/to-cqm", files={"file": (file.name, file.file)}
+            f"{self._endpoint}/to-cqm", files={"file": (file.name, file.file)}, **kwargs
         )
         cqm = ConstrainedQuadraticModel.from_file(response.content)
         return cqm

luna_sdk/repositories/info_repo.py

@@ -11,15 +11,14 @@ class InfoRepo(IInfoRepo):
     _endpoint_providers = "/providers"
 
     def solvers_available(
-        self, solver_name: Optional[str] = None
+        self, solver_name: Optional[str] = None, **kwargs
     ) -> Dict[str, Dict[str, SolverInfo]]:
         params = {}
         if solver_name:
             params["solver_name"] = solver_name
 
         response = self._client.get(
-            f"{self._endpoint_solvers}/available",
-            params=params,
+            f"{self._endpoint_solvers}/available", params=params, **kwargs
         )
 
         response.raise_for_status()
@@ -35,10 +34,8 @@ class InfoRepo(IInfoRepo):
 
         return to_return
 
-    def providers_available(self) -> List[str]:
-        response = self._client.get(
-            f"{self._endpoint_providers}/available",
-        )
+    def providers_available(self, **kwargs) -> List[str]:
+        response = self._client.get(f"{self._endpoint_providers}/available", **kwargs)
 
         response.raise_for_status()
 

luna_sdk/repositories/lp_repo.py

@@ -2,7 +2,7 @@ import os
 import pickle
 import tempfile
 from functools import partial
-from typing import Tuple, List, Dict
+from typing import Dict, List, Tuple
 
 import dimod
 from dimod import ConstrainedQuadraticModel
@@ -12,7 +12,7 @@ from qiskit_optimization import QuadraticProgram
 
 from luna_sdk.exceptions.transformation import TransformationException
 from luna_sdk.interfaces.lp_repo_i import ILPRepo
-from luna_sdk.schemas.transformations.bqm import BQMResultSchema, BQMSchema
+from luna_sdk.schemas.transformations.bqm import BQMResultSchema
 from luna_sdk.schemas.transformations.matrix import MatrixSchema
 
 
@@ -31,9 +31,9 @@ class LPRepo(ILPRepo):
             raise TransformationException()
         return parsed_model
 
-    def to_qubo_qiskit(self, lp_string: str) -> QuadraticProgram:
+    def to_qubo_qiskit(self, lp_string: str, **kwargs) -> QuadraticProgram:
         qubo_qiskit_model = self._send_request_with_pickle_file_response(
-            lp_string, f"{self._endpoint}/to-qubo-qiskit"
+            lp_string, f"{self._endpoint}/to-qubo-qiskit", **kwargs
         )
         try:
             assert isinstance(qubo_qiskit_model, QuadraticProgram)
@@ -41,9 +41,9 @@ class LPRepo(ILPRepo):
             raise TransformationException()
         return qubo_qiskit_model
 
-    def to_docplex(self, lp_string: str) -> DOCplexModel:
+    def to_docplex(self, lp_string: str, **kwargs) -> DOCplexModel:
         docplex_model = self._send_request_with_pickle_file_response(
-            lp_string, f"{self._endpoint}/to-docplex"
+            lp_string, f"{self._endpoint}/to-docplex", **kwargs
         )
         try:
             assert isinstance(docplex_model, DOCplexModel)
@@ -51,30 +51,36 @@ class LPRepo(ILPRepo):
             raise TransformationException()
         return docplex_model
 
-    def to_qubo_matrix(self, lp_string: str) -> Tuple[List[List[float]], partial]:
+    def to_qubo_matrix(
+        self, lp_string: str, **kwargs
+    ) -> Tuple[List[List[float]], partial]:
         file = tempfile.NamedTemporaryFile(delete=False, suffix=".lp")
         with open(file.name, "w") as tmp:
             tmp.write(lp_string)
         response = self._client.post(
-            f"{self._endpoint}/to-qubo-matrix", files={"file": (file.name, file.file)}
+            f"{self._endpoint}/to-qubo-matrix",
+            files={"file": (file.name, file.file)},
+            **kwargs,
         )
-        retrieved_matrix = MatrixSchema.validate(response.json())
+        retrieved_matrix = MatrixSchema.model_validate(response.json())
         return retrieved_matrix.matrix, partial(
             self.inverter,
             var_indices=retrieved_matrix.variable_indices,
-            inverter_bqm=CQMToBQMInverter.from_dict(retrieved_matrix.inverter.dict()),
+            inverter_bqm=CQMToBQMInverter.from_dict(
+                retrieved_matrix.inverter.model_dump()
+            ),
         )
 
     def to_bqm(
-        self, lp_string: str
+        self, lp_string: str, **kwargs
     ) -> Tuple[dimod.BinaryQuadraticModel, CQMToBQMInverter]:
         file = tempfile.NamedTemporaryFile(delete=False, suffix=".lp")
         with open(file.name, "w") as tmp:
             tmp.write(lp_string)
         response = self._client.post(
-            f"{self._endpoint}/to-bqm", files={"file": (file.name, file.file)}
+            f"{self._endpoint}/to-bqm", files={"file": (file.name, file.file)}, **kwargs
         )
-        retrieved_bqm = BQMResultSchema.validate(response.json())
+        retrieved_bqm = BQMResultSchema.model_validate(response.json())
 
         quadratic: Dict[Tuple[str, str], float] = {}
         for key, value in retrieved_bqm.bqm.quadratic.items():
@@ -94,12 +100,12 @@ class LPRepo(ILPRepo):
         inverter = CQMToBQMInverter.from_dict(retrieved_bqm.inverter.dict())
         return bqm, inverter
 
-    def to_cqm(self, lp_string: str) -> ConstrainedQuadraticModel:
+    def to_cqm(self, lp_string: str, **kwargs) -> ConstrainedQuadraticModel:
         file = tempfile.NamedTemporaryFile(delete=False, suffix=".lp")
         with open(file.name, "w") as tmp:
             tmp.write(lp_string)
         response = self._client.post(
-            f"{self._endpoint}/to-cqm", files={"file": (file.name, file.file)}
+            f"{self._endpoint}/to-cqm", files={"file": (file.name, file.file)}, **kwargs
         )
         cqm = ConstrainedQuadraticModel.from_file(response.content)
         return cqm