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

luna_sdk/repositories/circuit_repo.py

@@ -1,7 +1,6 @@
 import os
 from typing import Any, Dict, Optional
 
-from luna_sdk.exceptions.encryption_exception import EncryptionNotSetException
 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
@@ -20,7 +19,6 @@ class CircuitRepo(ICircuitRepo):
         provider: CircuitProviderEnum,
         params: Dict[str, Any] = {},
         qpu_tokens: Optional[TokenProvider] = None,
-        encryption_key: Optional[str] = None,
         **kwargs,
     ) -> CircuitJob:
         if qpu_tokens is not None:
@@ -34,15 +32,11 @@ class CircuitRepo(ICircuitRepo):
         if rest_qpu_tokens is None:
             rest_qpu_tokens = extract_qpu_tokens_from_env()
 
-        encryption_key = encryption_key or os.environ.get("LUNA_ENCRYPTION_KEY")
-        if encryption_key is None:
-            raise EncryptionNotSetException
         circuit_in: CircuitIn = CircuitIn(
             provider=provider,
             circuit=circuit,
             params=params,
             qpu_tokens=rest_qpu_tokens,
-            encryption_key=encryption_key,
         )
 
         response = self._client.post(
@@ -55,16 +49,11 @@ class CircuitRepo(ICircuitRepo):
     def get(
         self,
         job: CircuitJob,
-        encryption_key: Optional[str] = None,
         **kwargs,
     ) -> CircuitResult:
         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:
-            raise EncryptionNotSetException
         if job.params is None:
             job.params = {}
-        job.params["encryption_key"] = encryption_key
         response = self._client.get(url, params=job.params, **kwargs)
 
         response.raise_for_status()

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,7 +31,7 @@ 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,
@@ -40,7 +41,7 @@ class OptimizationRepo(IOptimizationRepo):
             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
@@ -63,21 +64,21 @@ 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)
 

luna_sdk/repositories/qpu_token_repo.py

@@ -3,14 +3,18 @@ import os
 from typing import Dict, List, Optional
 
 from httpx import Response
+from pydantic import TypeAdapter
 
-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
 
 
+_ORGANIZATION_QPU_TOKENS_BACKEND = "shared"
+_PERSONAL_QPU_TOKENS_BACKEND = "private"
+
+
 class QpuTokenRepo(IQpuTokenRepo):
     @property
     def _endpoint(self) -> str:
@@ -22,15 +26,15 @@ 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}/{_PERSONAL_QPU_TOKENS_BACKEND}"
         else:
-            return f"{self._endpoint}/organization"
+            return f"{self._endpoint}/{_ORGANIZATION_QPU_TOKENS_BACKEND}"
 
     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}", **kwargs
+            f"{self._get_endpoint_by_type(token_type)}/{name}", **kwargs
         )
         response.raise_for_status()
 
@@ -44,17 +48,12 @@ class QpuTokenRepo(IQpuTokenRepo):
         provider: str,
         token: str,
         token_type: QpuTokenTypeEnum,
-        encryption_key: Optional[str] = None,
         **kwargs,
     ) -> QpuTokenOut:
-        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(
@@ -70,30 +69,42 @@ class QpuTokenRepo(IQpuTokenRepo):
     def get_all(
         self,
         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]]:
         params = {}
         if filter_provider:
             params["filter_provider"] = filter_provider
 
-        if name:
-            params["name"] = name
+        if limit is not None:
+            params["limit"] = str(limit)
+        if offset is not None:
+            params["offset"] = str(offset)
+        if token_type == QpuTokenTypeEnum.PERSONAL:
+            params["token_type"] = _PERSONAL_QPU_TOKENS_BACKEND
+        if token_type == QpuTokenTypeEnum.GROUP:
+            params["token_type"] = _ORGANIZATION_QPU_TOKENS_BACKEND
 
         response = self._client.get(
-            self._get_endpoint_by_type(), params=params, **kwargs
+            self._endpoint,
+            params=params,
+            **kwargs,
         )
-        response.raise_for_status()
-
+        ta = TypeAdapter(List[QpuTokenOut])
         to_return: Dict[QpuTokenTypeEnum, List[QpuTokenOut]] = {}
-        for key, value in response.json().items():
-            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
+        resp = response.json()
+
+        shared_tokens = resp.get(_ORGANIZATION_QPU_TOKENS_BACKEND, [])
+        for qpu_token in shared_tokens:
+            qpu_token["token_type"] = QpuTokenTypeEnum.GROUP
+        to_return[QpuTokenTypeEnum.GROUP] = ta.validate_python(shared_tokens)
+
+        personal_tokens = resp.get(_PERSONAL_QPU_TOKENS_BACKEND, [])
+        for qpu_token in personal_tokens:
+            qpu_token["token_type"] = QpuTokenTypeEnum.PERSONAL
+        to_return[QpuTokenTypeEnum.PERSONAL] = ta.validate_python(personal_tokens)
 
         return to_return
 
@@ -114,8 +125,8 @@ class QpuTokenRepo(IQpuTokenRepo):
 
         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,
         )
@@ -126,9 +137,7 @@ class QpuTokenRepo(IQpuTokenRepo):
         return QpuTokenOut.model_validate(qpu_token_data)
 
     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}", **kwargs
+            f"{self._get_endpoint_by_type(token_type)}/{name}", **kwargs
         )
         response.raise_for_status()

luna_sdk/repositories/solutions_repo.py

@@ -5,7 +5,6 @@ from typing import Any, Dict, List, Optional, Type, Union
 
 from pydantic import BaseModel, ValidationError
 
-from luna_sdk.exceptions.encryption_exception import EncryptionNotSetException
 from luna_sdk.interfaces.solutions_repo_i import ISolutionsRepo
 from luna_sdk.schemas.create.solution import SolutionIn
 from luna_sdk.schemas.enums.solution import SenseEnum
@@ -70,7 +69,6 @@ class SolutionsRepo(ISolutionsRepo):
         provider: str,
         qpu_tokens: Optional[TokenProvider] = 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,
@@ -85,9 +83,6 @@ class SolutionsRepo(ISolutionsRepo):
         if rest_qpu_tokens is None:
             rest_qpu_tokens = extract_qpu_tokens_from_env()
 
-        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
         )
@@ -98,7 +93,6 @@ class SolutionsRepo(ISolutionsRepo):
             provider=provider,
             parameters=params,
             qpu_tokens=rest_qpu_tokens,
-            encryption_key=encryption_key,
             name=name,
         )
         response = self._client.post(
@@ -118,7 +112,6 @@ class SolutionsRepo(ISolutionsRepo):
         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,
@@ -134,7 +127,6 @@ class SolutionsRepo(ISolutionsRepo):
             provider=provider,
             solver_parameters=params,
             qpu_tokens=qpu_tokens,
-            encryption_key=encryption_key,
             name=name,
             **kwargs,
         )

luna_sdk/schemas/create/circuit.py

@@ -18,12 +18,9 @@ class CircuitIn(BaseModel):
         The QASM circuit
     params: Dict[str, Any]
         Additional parameters
-    encryption_key: str
-        Encryption key to be used for encryption of QPU tokens.
     """
 
     provider: CircuitProviderEnum
     circuit: str
     params: Dict[str, Any] = {}
     qpu_tokens: Optional[RestAPITokenProvider] = None
-    encryption_key: str

luna_sdk/schemas/create/qpu_token.py

@@ -13,14 +13,11 @@ class QpuTokenIn(BaseModel):
         Name of provider
     token: str
         Token
-    encryption_key: str
-        Encryption key to be used for encryption of QPU tokens.
     """
 
     name: str
     provider: str
     token: str
-    encryption_key: str
 
     class Config:
         extra = Extra.forbid

luna_sdk/schemas/create/solution.py

@@ -11,5 +11,4 @@ class SolutionIn(BaseModel):
     provider: str
     parameters: Dict[str, Any]
     qpu_tokens: Optional[RestAPITokenProvider] = None
-    encryption_key: str
     name: Optional[str] = None

luna_sdk/schemas/enums/optimization.py

@@ -1,10 +1,11 @@
 from enum import Enum
 
 
-class InputType(str, Enum):
-    bqm_spin = "bqm_spin"
-    bqm_binary = "bqm_binary"
-    cqm = "cqm"
-    lp = "lp"
-    aq = "aq"
-    qubo = "qubo"
+class OptFormat(str, Enum):
+    """Enumeration of all supported formats."""
+
+    AQ_MODEL = "AQ_MODEL"
+    LP = "LP"
+    QUBO = "QUBO_MATRIX"
+    CQM = "CQM"
+    BQM = "BQM"

luna_sdk/schemas/enums/qpu_token_type.py

@@ -2,5 +2,5 @@ from enum import Enum
 
 
 class QpuTokenTypeEnum(str, Enum):
-    ORGANIZATION = "organization"
+    GROUP = "group"
     PERSONAL = "personal"

luna_sdk/schemas/optimization.py

@@ -1,11 +1,12 @@
-from typing import Any, Dict, Generic, List, Optional, TypeVar
+from typing import Any, Dict, Generic, Optional, TypeVar
 
 from pydantic import BaseModel, ConfigDict
 
-from luna_sdk.schemas.enums.optimization import InputType
+from luna_sdk.schemas.enums.optimization import OptFormat
 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.optimization_formats.qubo import QuboSchema
 from luna_sdk.schemas.pretty_base import PrettyBase
 from luna_sdk.schemas.wrappers import PydanticDatetimeWrapper
 
@@ -33,22 +34,56 @@ class Optimization(PrettyBase):
     created_by: str
     modified_date: Optional[PydanticDatetimeWrapper] = None
     modified_by: Optional[str] = None
-    input_type: Optional[InputType] = None
+    original_format: Optional[OptFormat] = None
     use_case_name: Optional[str] = None
     params: Optional[Dict[str, Any]] = None
 
-    model_config = ConfigDict(extra="ignore", from_attributes=False)
-
-
-class OptimizationQubo(BaseModel):
-    id: str
-    name: Optional[str] = None
-    created_date: PydanticDatetimeWrapper
-    created_by: str
-    modified_date: Optional[PydanticDatetimeWrapper] = None
-    modified_by: Optional[str] = None
+    verbose: bool = False
+
+    def __str__(self):
+        if self.verbose:
+            return self.details()
+        return self.subset()
+
+    def details(self):
+        trimmed_keys = [
+            "verbose",
+        ]
+        data = self.model_dump()
+        output = ""
+        data_subset = {key: data[key] for key in data if key not in trimmed_keys}
+        ordered_subset = {
+            "id": data_subset.pop("id"),
+            "name": data_subset.pop("name"),
+            "original_format": data_subset.pop("original_format"),
+            **data_subset,
+        }
+        output += self._pretty_print(ordered_subset)
+        return output
+
+    def subset(self):
+        trimmed_keys = [
+            "created_by",
+            "modified_date",
+            "modified_by",
+            "use_case_name",
+            "params",
+            "verbose",
+        ]
+        data = self.model_dump()
+        output = ""
+        data_subset = {key: data[key] for key in data if key not in trimmed_keys}
+
+        ordered_subset = {
+            "id": data_subset.pop("id"),
+            "name": data_subset.pop("name"),
+            "original_format": data_subset.pop("original_format"),
+            **data_subset,
+        }
+        output += self._pretty_print(ordered_subset)
+        return output
 
-    matrix: List[List[float]]
+    model_config = ConfigDict(extra="ignore", from_attributes=False)
 
 
 class OptimizationBQM(Optimization, BQMSchema): ...
@@ -60,10 +95,13 @@ class OptimizationCQM(Optimization, CQMSchema): ...
 class OptimizationLP(Optimization, LPSchema): ...
 
 
-class OptimizationUseCase(Optimization, BQMSchema):
+class OptimizationUseCase(Optimization, QuboSchema):
     use_case: Dict[str, Any]
 
 
+class OptimizationQubo(Optimization, QuboSchema): ...
+
+
 T = TypeVar("T")
 
 

luna_sdk/schemas/optimization_formats/qubo.py

@@ -0,0 +1,8 @@
+from typing import List
+
+from pydantic import BaseModel
+
+
+class QuboSchema(BaseModel):
+    matrix: List[List[float]]
+    offset: float

luna_sdk/schemas/qpu_token.py

@@ -12,7 +12,7 @@ class QpuTokenSource(str, Enum):
     # stored token in user account
     PERSONAL = "personal"
     # stored token in group account
-    ORGANIZATION = "organization"
+    GROUP = "group"
 
 
 class QpuToken(BaseModel):
@@ -44,16 +44,12 @@ class QpuTokenOut(BaseModel):
 
     Attributes
     ----------
-    id: str
-        Id of the QPU token
     name: Optional[str]
         Name of the QPU token
     provider: ProviderEnum
         Name of provider: dwave | ibm
     """
 
-    id: str
-
     name: str
     provider: str
     token_type: QpuTokenTypeEnum

luna_sdk/schemas/rest/qpu_token/qpu_token_source.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class _RESTQpuTokenSource(str, Enum):
+    """
+    This schema allow us not to change entire backend,
+    but just sync SDK and everything else in terms of qpu token source.
+    Currently, the difference is that
+    SDK has group qpu token source
+    and backend has organization qpu token source which are mapped to each other.
+    """
+
+    # token currently passed in from the API call (not stored by us)
+    INLINE = "inline"
+    # stored token in user account
+    PERSONAL = "personal"
+    # stored token in group account
+    ORGANIZATION = "organization"

luna_sdk/schemas/rest/qpu_token/token_provider.py

@@ -1,20 +1,48 @@
-from typing import Optional
+from typing import Optional, Union
 
 from pydantic import BaseModel, Extra
 
-from luna_sdk.schemas import QpuToken, TokenProvider
+from luna_sdk.schemas import QpuToken, TokenProvider, QpuTokenSource
+from luna_sdk.schemas.rest.qpu_token.qpu_token_source import _RESTQpuTokenSource
+
+
+class _RestQpuToken(BaseModel):
+    source: _RESTQpuTokenSource
+    # A unique name for a stored token
+    name: Optional[str] = None
+    # This could be a QPU token, an API key or any token key for a QPU provider.
+    # If the token is not passed from this API call, one stored in the user's
+    # account will be used.
+    token: Optional[str] = None
+
+    @classmethod
+    def from_qpu_token(cls, qpu_token: Optional[QpuToken]) -> Optional["_RestQpuToken"]:
+        if qpu_token is None:
+            return None
+        # Organizational tokens were renamed to group in #1851
+        # For smoother transition we only change naming in the SDK,
+        # and therefore we need a mapping between Group and Organization here.
+        # However, in backend for now QPU tokens still has source organization
+        # TODO: Remove it when backend I/O schema is changed
+        if qpu_token.source == QpuTokenSource.GROUP:
+            return cls(
+                source=_RESTQpuTokenSource.ORGANIZATION,
+                name=qpu_token.name,
+                token=qpu_token.token,
+            )
+        return cls.model_validate(qpu_token, from_attributes=True)
 
 
 class AWSQpuTokens(BaseModel):
-    aws_access_key: QpuToken
-    aws_secret_access_key: QpuToken
+    aws_access_key: _RestQpuToken
+    aws_secret_access_key: _RestQpuToken
 
 
 class RestAPITokenProvider(BaseModel):
-    dwave: Optional[QpuToken] = None
-    ibm: Optional[QpuToken] = None
-    fujitsu: Optional[QpuToken] = None
-    qctrl: Optional[QpuToken] = None
+    dwave: Optional[_RestQpuToken] = None
+    ibm: Optional[_RestQpuToken] = None
+    fujitsu: Optional[_RestQpuToken] = None
+    qctrl: Optional[_RestQpuToken] = None
     aws: Optional[AWSQpuTokens] = None
 
     @classmethod
@@ -28,16 +56,20 @@ class RestAPITokenProvider(BaseModel):
         ):
             # Ignoring mypy here to receive validation error, because we always need 2 tokens for aws
             aws = AWSQpuTokens(
-                aws_access_key=getattr(token_provider, "aws_access_key", None),  # type: ignore[arg-type]
-                aws_secret_access_key=getattr(  # type: ignore[arg-type]
-                    token_provider, "aws_secret_access_key", None
+                aws_access_key=_RestQpuToken.from_qpu_token(
+                    getattr(token_provider, "aws_access_key", None)
+                ),  # type: ignore[arg-type]
+                aws_secret_access_key=_RestQpuToken.from_qpu_token(
+                    getattr(  # type: ignore[arg-type]
+                        token_provider, "aws_secret_access_key", None
+                    )
                 ),
             )
         return cls(
-            dwave=token_provider.dwave,
-            ibm=token_provider.ibm,
-            fujitsu=token_provider.fujitsu,
-            qctrl=token_provider.qctrl,
+            dwave=_RestQpuToken.from_qpu_token(token_provider.dwave),
+            ibm=_RestQpuToken.from_qpu_token(token_provider.ibm),
+            fujitsu=_RestQpuToken.from_qpu_token(token_provider.fujitsu),
+            qctrl=_RestQpuToken.from_qpu_token(token_provider.qctrl),
             aws=aws,
         )