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

luna_sdk/repositories/optimization_repo.py

@@ -9,7 +9,7 @@ from luna_sdk.interfaces.optimization_repo_i import IOptimizationRepo
 from luna_sdk.schemas import UseCase
 from luna_sdk.schemas.create import QUBOIn
 from luna_sdk.schemas.create.optimization import OptimizationUseCaseIn
-from luna_sdk.schemas.enums.optimization import InputType
+from luna_sdk.schemas.enums.optimization import OptFormat
 from luna_sdk.schemas.enums.timeframe import TimeframeEnum
 from luna_sdk.schemas.optimization import (
     Optimization,
@@ -17,6 +17,7 @@ from luna_sdk.schemas.optimization import (
     OptimizationCQM,
     OptimizationLP,
     OptimizationUseCase,
+    OptimizationQubo,
 )
 from luna_sdk.schemas.optimization_formats.bqm import BQMSchema
 from luna_sdk.schemas.optimization_formats.cqm import CQMSchema
@@ -30,35 +31,17 @@ class OptimizationRepo(IOptimizationRepo):
     def get_all(
         self,
         timeframe: Optional[TimeframeEnum] = None,
-        input_type: Optional[InputType] = None,
+        input_type: Optional[OptFormat] = 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
 
         if input_type:
-            params["input_type"] = input_type.value
+            params["original_format"] = input_type.value
 
         if limit < 1:
             # set the minimum limit to 1
@@ -66,12 +49,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()
 
@@ -79,57 +64,33 @@ class OptimizationRepo(IOptimizationRepo):
 
         optimization_data = response_data.pop("optimization_data", None)
         if optimization_data:
-            input_type = response_data["input_type"]
+            original_format = response_data["original_format"]
 
-            if input_type in (InputType.bqm_spin, InputType.bqm_binary):
+            if original_format == OptFormat.BQM:
                 model = OptimizationBQM
-            elif input_type == InputType.cqm:
+            elif original_format == OptFormat.CQM:
                 model = OptimizationCQM
-            elif input_type == InputType.lp:
+            elif original_format == OptFormat.LP:
                 model = OptimizationLP
-            elif input_type == InputType.qubo:
+            elif original_format == OptFormat.QUBO:
                 if response_data.get("use_case_name"):
                     model = OptimizationUseCase
                 else:
-                    model = OptimizationBQM
+                    model = OptimizationQubo
             else:
-                model = OptimizationBQM
+                raise ValueError("Unknown optimization format")
 
             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 +98,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 +107,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 +115,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 +128,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 +141,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 +155,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()

luna_sdk/repositories/qpu_token_repo.py

@@ -22,17 +22,20 @@ class QpuTokenRepo(IQpuTokenRepo):
         if token_type is None:
             return f"{self._endpoint}"
         elif token_type == QpuTokenTypeEnum.PERSONAL:
-            return f"{self._endpoint}/users"
+            return f"{self._endpoint}/private"
         else:
-            return f"{self._endpoint}/organization"
+            return f"{self._endpoint}/shared"
 
-    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)}/{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,44 +72,45 @@ class QpuTokenRepo(IQpuTokenRepo):
         filter_provider: Optional[str] = None,
         name: Optional[str] = None,
         token_type: Optional[QpuTokenTypeEnum] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = 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
 
         if name:
             params["name"] = name
-
-        response = self._client.get(self._get_endpoint_by_type(), params=params)
-        response.raise_for_status()
+        if limit is not None:
+            params["limit"] = str(limit)
+        if offset is not None:
+            params["offset"] = str(offset)
 
         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
+        if token_type is None or token_type == QpuTokenTypeEnum.PERSONAL:
+            response = self._client.get(
+                self._get_endpoint_by_type(QpuTokenTypeEnum.PERSONAL),
+                params=params,
+                **kwargs,
+            )
+            response.raise_for_status()
+            personal_qpu_tokens = response.json()
+            to_return[QpuTokenTypeEnum.PERSONAL] = [
+                QpuTokenOut(**qpu_token, token_type=QpuTokenTypeEnum.PERSONAL)
+                for qpu_token in personal_qpu_tokens
+            ]
+        if token_type is None or token_type == QpuTokenTypeEnum.GROUP:
+            response = self._client.get(
+                self._get_endpoint_by_type(QpuTokenTypeEnum.GROUP),
+                params=params,
+                **kwargs,
+            )
+            response.raise_for_status()
+            shared_qpu_tokens = response.json()
+            to_return[QpuTokenTypeEnum.GROUP] = [
+                QpuTokenOut(**qpu_token, token_type=QpuTokenTypeEnum.GROUP)
+                for qpu_token in shared_qpu_tokens
             ]
 
         return to_return
@@ -134,93 +119,32 @@ 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)
 
-        response = self._client.put(
-            f"{self._get_endpoint_by_type(token_type)}/{token.id}",
+        response = self._client.patch(
+            f"{self._get_endpoint_by_type(token_type)}/{token.name}",
             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
-        -------
-        """
-        token: QpuTokenOut = self.get(name, token_type)
-
+    def delete(self, name: str, token_type: QpuTokenTypeEnum, **kwargs) -> None:
         response = self._client.delete(
-            f"{self._get_endpoint_by_type(token_type)}/{token.id}"
+            f"{self._get_endpoint_by_type(token_type)}/{name}", **kwargs
         )
         response.raise_for_status()