luna-quantum 0.0.16__py3-none-any.whl

luna_sdk/repositories/optimization_repo.py

@@ -0,0 +1,358 @@
+import json
+from io import BufferedReader
+from typing import Any, Dict, List, Optional, Type
+
+from dimod import BinaryQuadraticModel, ConstrainedQuadraticModel
+from httpx import Response
+
+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.timeframe import TimeframeEnum
+from luna_sdk.schemas.optimization import (
+    Optimization,
+    OptimizationBQM,
+    OptimizationCQM,
+    OptimizationLP,
+    OptimizationUseCase,
+)
+from luna_sdk.schemas.optimization_formats.bqm import BQMSchema
+from luna_sdk.schemas.optimization_formats.cqm import CQMSchema
+
+
+class OptimizationRepo(IOptimizationRepo):
+    @property
+    def _endpoint(self) -> str:
+        return "/optimizations"
+
+    def get_all(
+        self,
+        timeframe: Optional[TimeframeEnum] = None,
+        input_type: Optional[InputType] = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> 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
+
+        if limit < 1:
+            # set the minimum limit to 1
+            limit = 1
+
+        params["limit"] = str(limit)
+        params["offset"] = str(offset)
+        response: Response = self._client.get(self._endpoint, params=params)
+        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}")
+        response.raise_for_status()
+        response_data = response.json()
+
+        model: Type[Optimization] = Optimization
+
+        optimization_data = response_data.pop("optimization_data", None)
+        if optimization_data:
+            input_type = response_data["input_type"]
+
+            if input_type in (InputType.bqm_spin, InputType.bqm_binary):
+                model = OptimizationBQM
+            elif input_type == InputType.cqm:
+                model = OptimizationCQM
+            elif input_type == InputType.lp:
+                model = OptimizationLP
+            elif input_type == InputType.qubo:
+                if response_data.get("use_case_name"):
+                    model = OptimizationUseCase
+                else:
+                    model = OptimizationBQM
+            else:
+                model = OptimizationBQM
+
+            response_data.update(optimization_data)
+
+        return model.validate(response_data)
+
+    def create_from_qubo(
+        self,
+        name: str,
+        matrix: List[List[float]],
+        timeout: Optional[float] = 10800.0,
+    ) -> 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,
+        )
+
+        response.raise_for_status()
+
+        return Optimization.model_validate_json(response.text)
+
+    def create_from_use_case(
+        self,
+        name: str,
+        use_case: UseCase,
+        timeout: Optional[float] = 10800.0,
+    ) -> 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
+        )
+
+        response: Response = self._client.post(
+            f"{self._endpoint}/use_case",
+            content=optimization_in.model_dump_json(),
+            timeout=timeout,
+        )
+
+        response.raise_for_status()
+
+        return Optimization.model_validate_json(response.text)
+
+    def create_from_bqm(
+        self,
+        name: str,
+        bqm: BinaryQuadraticModel,
+        timeout: Optional[float] = 10800.0,
+    ) -> 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,
+        )
+
+        response.raise_for_status()
+
+        return Optimization.model_validate_json(response.text)
+
+    def create_from_cqm(
+        self,
+        name: str,
+        cqm: ConstrainedQuadraticModel,
+        timeout: Optional[float] = 10800.0,
+    ) -> 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,
+        )
+
+        response.raise_for_status()
+
+        return Optimization.model_validate_json(response.text)
+
+    def create_from_lp_file(
+        self,
+        name: str,
+        lp_file: BufferedReader,
+        timeout: Optional[float] = 10800.0,
+    ) -> 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,
+        )
+
+        response.raise_for_status()
+
+        return Optimization.model_validate_json(response.text)
+
+    def create_from_lp_string(
+        self,
+        name: str,
+        lp_string: str,
+        timeout: Optional[float] = 10800.0,
+    ) -> 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,
+        )
+
+        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.
+        """
+        data: Dict[str, str] = {"name": name}
+
+        response: Response = self._client.put(
+            f"{self._endpoint}/{optimization_id}",
+            content=json.dumps(data),
+        )
+        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}")
+        response.raise_for_status()

luna_sdk/repositories/qpu_token_repo.py

@@ -0,0 +1,226 @@
+import json
+import os
+from typing import Dict, List, Optional
+
+from httpx import Response
+
+from luna_sdk.exceptions.encryption_exception import EncryptionNotSetException
+from luna_sdk.interfaces.qpu_token_repo_i import IQpuTokenRepo
+from luna_sdk.schemas import QpuTokenOut
+from luna_sdk.schemas.create import QpuTokenIn
+from luna_sdk.schemas.enums.qpu_token_type import QpuTokenTypeEnum
+
+
+class QpuTokenRepo(IQpuTokenRepo):
+    @property
+    def _endpoint(self) -> str:
+        return "/qpu-tokens"
+
+    def _get_endpoint_by_type(
+        self, token_type: Optional[QpuTokenTypeEnum] = None
+    ) -> str:
+        if token_type is None:
+            return f"{self._endpoint}"
+        elif token_type == QpuTokenTypeEnum.PERSONAL:
+            return f"{self._endpoint}/users"
+        else:
+            return f"{self._endpoint}/organization"
+
+    def _get_by_name(self, name: str, token_type: QpuTokenTypeEnum) -> QpuTokenOut:
+        response: Response = self._client.get(
+            f"{self._get_endpoint_by_type(token_type)}/by_name/{name}"
+        )
+        response.raise_for_status()
+
+        qpu_token_data = response.json()
+        return QpuTokenOut.model_validate(qpu_token_data)
+
+    def create(
+        self,
+        name: str,
+        provider: str,
+        token: str,
+        token_type: QpuTokenTypeEnum = QpuTokenTypeEnum.PERSONAL,
+        encryption_key: Optional[str] = None,
+    ) -> 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
+        qpu_token = QpuTokenIn(
+            name=name,
+            provider=provider,
+            token=token,
+            encryption_key=encryption_key,
+        )
+
+        response: Response = self._client.post(
+            self._get_endpoint_by_type(token_type), content=qpu_token.model_dump_json()
+        )
+        response.raise_for_status()
+        qpu_token_data = response.json()
+        return QpuTokenOut.model_validate(qpu_token_data)
+
+    def get_all(
+        self,
+        filter_provider: Optional[str] = None,
+        name: Optional[str] = None,
+        token_type: Optional[QpuTokenTypeEnum] = None,
+    ) -> 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()
+
+        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
+            ]
+
+        return to_return
+
+    def get(
+        self,
+        name: str,
+        token_type: QpuTokenTypeEnum = QpuTokenTypeEnum.PERSONAL,
+    ) -> 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)
+
+        return qpu_token
+
+    def rename(
+        self,
+        name: str,
+        new_name: str,
+        token_type: QpuTokenTypeEnum = QpuTokenTypeEnum.PERSONAL,
+    ) -> 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}",
+            content=json.dumps(qpu_token_update_data),
+        )
+        response.raise_for_status()
+
+        qpu_token_data = response.json()
+        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)
+
+        response = self._client.delete(
+            f"{self._get_endpoint_by_type(token_type)}/{token.id}"
+        )
+        response.raise_for_status()