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

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

luna_sdk/repositories/optimization_repo.py

@@ -33,26 +33,8 @@ class OptimizationRepo(IOptimizationRepo):
         input_type: Optional[InputType] = None,
         limit: int = 50,
         offset: int = 0,
+        **kwargs,
     ) -> List[Optimization]:
-        """
-        Get a list of all available Models.
-
-        Parameters
-        ----------
-        timeframe: Optional[TimeframeEnum]
-            Only return QUBOs created within a specified timeframe. Default None.
-        input_type: Optional[InputType]
-            Only return optimizations of a specified input type. Default None.
-        limit: int
-            Limit the number of Optimizations to be returned. Default value 50.
-        offset: int
-            Offset the list of optimizations by this amount. Default value 0.
-
-        Returns
-        -------
-        List[Model]
-            List of Model instances.
-        """
         params = {}
         if timeframe and timeframe != TimeframeEnum.all_time:  # no value == all_time
             params["timeframe"] = timeframe.value
@@ -66,12 +48,14 @@ class OptimizationRepo(IOptimizationRepo):
 
         params["limit"] = str(limit)
         params["offset"] = str(offset)
-        response: Response = self._client.get(self._endpoint, params=params)
+        response: Response = self._client.get(self._endpoint, params=params, **kwargs)
         response.raise_for_status()
         return [Optimization.model_validate(item) for item in response.json()]
 
-    def get(self, optimization_id: str) -> Optimization:
-        response: Response = self._client.get(f"{self._endpoint}/{optimization_id}")
+    def get(self, optimization_id: str, **kwargs) -> Optimization:
+        response: Response = self._client.get(
+            f"{self._endpoint}/{optimization_id}", **kwargs
+        )
         response.raise_for_status()
         response_data = response.json()
 
@@ -97,39 +81,15 @@ class OptimizationRepo(IOptimizationRepo):
 
             response_data.update(optimization_data)
 
-        return model.validate(response_data)
+        return model.model_validate(response_data)
 
     def create_from_qubo(
-        self,
-        name: str,
-        matrix: List[List[float]],
-        timeout: Optional[float] = 10800.0,
+        self, name: str, matrix: List[List[float]], **kwargs
     ) -> Optimization:
-        """
-        Create an optimization from a QUBO matrix.
-
-        Parameters
-        ----------
-        name: str
-            Name of the optimization to be created.
-        matrix: List[List[float]]
-            QUBO matrix.
-        timeout: Optional[float]
-            Default = 10800. 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 QUBO matrices.
-
-        Returns
-        -------
-        Optimization:
-            Created optimization.
-        """
         data_in: Dict[str, Any] = QUBOIn(name=name, matrix=matrix).model_dump()
 
         response: Response = self._client.post(
-            f"{self._endpoint}/qubo",
-            json=data_in,
-            timeout=timeout,
+            f"{self._endpoint}/qubo", json=data_in, **kwargs
         )
 
         response.raise_for_status()
@@ -137,30 +97,8 @@ class OptimizationRepo(IOptimizationRepo):
         return Optimization.model_validate_json(response.text)
 
     def create_from_use_case(
-        self,
-        name: str,
-        use_case: UseCase,
-        timeout: Optional[float] = 10800.0,
+        self, name: str, use_case: UseCase, **kwargs
     ) -> Optimization:
-        """
-        Create an optimization from a use case.
-
-        Parameters
-        ----------
-        name: str
-            Name of the optimization to be created.
-        use_case: UseCase
-            Use case.
-        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.
-
-        Returns
-        -------
-        Optimization:
-            Created optimization.
-        """
         optimization_in = OptimizationUseCaseIn(
             name=name, use_case=use_case, params=None
         )
@@ -168,7 +106,7 @@ class OptimizationRepo(IOptimizationRepo):
         response: Response = self._client.post(
             f"{self._endpoint}/use_case",
             content=optimization_in.model_dump_json(),
-            timeout=timeout,
+            **kwargs,
         )
 
         response.raise_for_status()
@@ -176,33 +114,12 @@ class OptimizationRepo(IOptimizationRepo):
         return Optimization.model_validate_json(response.text)
 
     def create_from_bqm(
-        self,
-        name: str,
-        bqm: BinaryQuadraticModel,
-        timeout: Optional[float] = 10800.0,
+        self, name: str, bqm: BinaryQuadraticModel, **kwargs
     ) -> Optimization:
-        """
-        Create an optimization from BQM.
-
-        Parameters
-        ----------
-        name: str
-            Name of the optimization to be created.
-        bqm: BinaryQuadraticModel
-            QUBO in dimod BQM format.
-        timeout: Optional[float]
-
-        Returns
-        -------
-        Optimization:
-            Created optimization.
-        """
         data_in = {"name": name, **BQMSchema.from_bqm(bqm).model_dump()}
 
         response: Response = self._client.post(
-            f"{self._endpoint}/bqm",
-            json=data_in,
-            timeout=timeout,
+            f"{self._endpoint}/bqm", json=data_in, **kwargs
         )
 
         response.raise_for_status()
@@ -210,34 +127,12 @@ class OptimizationRepo(IOptimizationRepo):
         return Optimization.model_validate_json(response.text)
 
     def create_from_cqm(
-        self,
-        name: str,
-        cqm: ConstrainedQuadraticModel,
-        timeout: Optional[float] = 10800.0,
+        self, name: str, cqm: ConstrainedQuadraticModel, **kwargs
     ) -> Optimization:
-        """
-        Create an optimization from CQM.
-
-        Parameters
-        ----------
-        name: str
-            Name of the optimization to be created.
-        cqm: ConstrainedQuadraticModel
-            in dimod CQM format.
-        timeout: Optional[float]
-
-        Returns
-        -------
-        Optimization:
-            Created optimization.
-        """
-
         data_in = {"name": name, **CQMSchema.from_cqm(cqm).model_dump()}
 
         response: Response = self._client.post(
-            f"{self._endpoint}/cqm",
-            json=data_in,
-            timeout=timeout,
+            f"{self._endpoint}/cqm", json=data_in, **kwargs
         )
 
         response.raise_for_status()
@@ -245,35 +140,13 @@ class OptimizationRepo(IOptimizationRepo):
         return Optimization.model_validate_json(response.text)
 
     def create_from_lp_file(
-        self,
-        name: str,
-        lp_file: BufferedReader,
-        timeout: Optional[float] = 10800.0,
+        self, name: str, lp_file: BufferedReader, **kwargs
     ) -> Optimization:
-        """
-        Create an optimization from LP file.
-
-        Parameters
-        ----------
-        name: str
-            Name of the optimization to be created.
-        lp_file: buffer reader.
-        timeout: Optional[float]
-            Default = 10800. 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 QUBO matrices.
-
-        Returns
-        -------
-        Optimization:
-            Created optimization.
-        """
-
         response: Response = self._client.post(
             f"{self._endpoint}/lp-file",
             data={"optimization_in": json.dumps({"name": name})},
             files={"lp_file": lp_file},
-            timeout=timeout,
+            **kwargs,
         )
 
         response.raise_for_status()
@@ -281,78 +154,30 @@ class OptimizationRepo(IOptimizationRepo):
         return Optimization.model_validate_json(response.text)
 
     def create_from_lp_string(
-        self,
-        name: str,
-        lp_string: str,
-        timeout: Optional[float] = 10800.0,
+        self, name: str, lp_string: str, **kwargs
     ) -> Optimization:
-        """
-        Create an optimization from LP string.
-
-        Parameters
-        ----------
-        name: str
-            Name of the optimization to be created.
-        lp_string: string.
-        timeout: Optional[float]
-            Default = 10800. 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 QUBO matrices.
-
-        Returns
-        -------
-        Optimization:
-            Created optimization.
-        """
         data_in = {"name": name, "lp_string": lp_string}
 
         response: Response = self._client.post(
-            f"{self._endpoint}/lp-string",
-            json=data_in,
-            timeout=timeout,
+            f"{self._endpoint}/lp-string", json=data_in, **kwargs
         )
 
         response.raise_for_status()
 
         return Optimization.model_validate_json(response.text)
 
-    def rename(self, optimization_id: str, name: str) -> Optimization:
-        """
-        Update the name of the optimization
-
-        Parameters
-        ----------
-        optimization_id: str
-            Id of the optimization to be updated.
-        name: str
-            New name of the optimization
-
-        Returns
-        -------
-        Optimization:
-            Updated optimization.
-        """
+    def rename(self, optimization_id: str, name: str, **kwargs) -> Optimization:
         data: Dict[str, str] = {"name": name}
 
         response: Response = self._client.put(
-            f"{self._endpoint}/{optimization_id}",
-            content=json.dumps(data),
+            f"{self._endpoint}/{optimization_id}", content=json.dumps(data), **kwargs
         )
         response.raise_for_status()
 
         return Optimization.model_validate_json(response.text)
 
-    def delete(self, optimization_id: str) -> None:
-        """
-        Delete one QUBO by id.
-
-        Parameters
-        ----------
-        optimization_id: str
-            Id of the Model that should be deleted
-
-        Returns
-        -------
-        """
-        response: Response = self._client.delete(f"{self._endpoint}/{optimization_id}")
+    def delete(self, optimization_id: str, **kwargs) -> None:
+        response: Response = self._client.delete(
+            f"{self._endpoint}/{optimization_id}", **kwargs
+        )
         response.raise_for_status()