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

luna_sdk/schemas/solution.py

@@ -1,7 +1,9 @@
+from datetime import datetime
 from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
+from luna_sdk.schemas.enums.optimization import OptFormat
 from luna_sdk.schemas.enums.solution import SenseEnum
 from luna_sdk.schemas.enums.status import StatusEnum
 from luna_sdk.schemas.optimization import Optimization
@@ -105,45 +107,17 @@ class Solution(PrettyBase):
     solver: str
     provider: str
     status: StatusEnum
+    status_timeline: Dict[StatusEnum, datetime] = {}
+    used_format: Optional[OptFormat] = None
     optimization: Union[Optimization, str]
     representation: Optional[Any] = None
 
-    def __str__(self):
-        """Overwrite the default object string representation to use the custom pretty print console representation"""
-        data = self.model_dump()
-        results = data.pop("results")  # Extract and remove results from data
-        metadata = data.pop("metadata")  # Extract and remove metadata from data
-        provider = data["provider"]
+    verbose: bool = False
 
-        divider = "--------------------------------------------------------------------------------\n"
-
-        # Build Meta Data section
-        output = f"{divider}META DATA:\n{divider}"
-        output += self._pretty_print(data)
-
-        # Build Results section
-        if results:
-            output += f"\n\n{divider}RESULTS:\n{divider}"
-            for i, result in enumerate(results, start=1):
-                r = f"Result {i}:\n"
-                r += f"    {result}\n"
-                output += r
-        else:
-            output += f"\n\n{divider}RESULTS:\n{divider}"
-            output += "    No results..\n"
-            output += "    Solution has status: " + str(self.status.value) + "\n"
-            if self.error_message:
-                output += "    Error message: " + str(self.error_message) + "\n"
-
-        # Build Provider Meta Data section
-        output += f"\n\n{divider}{provider.upper()} META DATA:\n{divider}"
-        output += (
-            self._pretty_print(metadata)
-            if metadata
-            else "    No metadata from provider..\n"
-        )
-
-        return output
+    def __str__(self):
+        if self.verbose:
+            return self.details()
+        return self.subset()
 
     @property
     def head(self):
@@ -216,6 +190,86 @@ class Solution(PrettyBase):
 
         return output
 
+    def details(self):
+        """Overwrite the default object string representation to use the custom pretty print console representation"""
+        data = self.model_dump()
+        results = data.pop("results")  # Extract and remove results from data
+        metadata = data.pop("metadata")  # Extract and remove metadata from data
+        provider = data["provider"]
+
+        divider = "--------------------------------------------------------------------------------\n"
+
+        # Build Meta Data section
+        output = f"{divider}META DATA:\n{divider}"
+        output += self._pretty_print(data)
+
+        # Build Results section
+        if results:
+            output += f"\n\n{divider}RESULTS:\n{divider}"
+            for i, result in enumerate(results, start=1):
+                r = f"Result {i}:\n"
+                r += f"    {result}\n"
+                output += r
+        else:
+            output += f"\n\n{divider}RESULTS:\n{divider}"
+            output += "    No results..\n"
+            output += "    Solution has status: " + str(self.status.value) + "\n"
+            if self.error_message:
+                output += "    Error message: " + str(self.error_message) + "\n"
+
+        # Build Provider Meta Data section
+        output += f"\n\n{divider}{provider.upper()} META DATA:\n{divider}"
+        output += (
+            self._pretty_print(metadata)
+            if metadata
+            else "    No metadata from provider..\n"
+        )
+        return output
+
+    def subset(self):
+        limit = 5
+        subset_keys = [
+            "id",
+            "name",
+            "status",
+            "solver",
+            "provider",
+            "runtime",
+            "optimization_name",
+            "created_date",
+        ]
+        data = self.model_dump()
+        data["optimization_name"] = data["optimization"]["original_format"]
+        output = ""
+        data_subset = {key: data.get(key) for key in subset_keys if key in data}
+        output += self._pretty_print(data_subset)
+
+        # Build Results section
+        results = data.pop("results")
+        if results:
+            output += "results:\n"
+            output += (
+                f"{len(results)} results found. Displaying first {limit} results.\n"
+            )
+            for i, result in enumerate(results, start=1):
+                if i > limit:
+                    output += "....\n"
+                    break
+                r = f"Result {i}:\n"
+                r += (
+                    f"    {str(result)[:150]}   ....\n"
+                    if len(str(result)) > 150
+                    else f"    {result}\n"
+                )
+                output += r
+        else:
+            output += "results:\n"
+            output += "    No results..\n"
+            output += "    Solution has status: " + str(self.status.value) + "\n"
+            if self.error_message:
+                output += "    Error message: " + str(self.error_message) + "\n"
+        return output
+
 
 class UseCaseResult(BaseModel):
     representation: Any

luna_sdk/schemas/solver_parameters/dwave/base.py

@@ -376,6 +376,8 @@ class Loop(BaseParameter):
         Energy level that the algorithm tries to reach.
     rtol: float
         Relative tolerance for convergence.
+    rtol: float
+        Relative tolerance for convergence.
     atol: float
         Absolute tolerance for convergence.
     """
@@ -383,7 +385,8 @@ class Loop(BaseParameter):
     max_iter: Optional[int] = 100
     max_time: int = 5
     convergence: int = 3
-    target: Optional[float] = DEFAULT_RTOL
+    target: Optional[float] = None
+    rtol: float = DEFAULT_RTOL
     atol: float = DEFAULT_ATOL
 
 

luna_sdk/schemas/solver_parameters/dwave/quantum_annealing.py

@@ -1,5 +1,13 @@
 from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 from luna_sdk.schemas.solver_parameters.dwave import Embedding, SamplingParams
+from pydantic import StringConstraints
+
+import sys
+
+if sys.version_info >= (3, 9):
+    from typing import Annotated
+else:
+    from typing_extensions import Annotated
 
 
 class QuantumAnnealingParameters(BaseParameter):
@@ -13,7 +21,12 @@ class QuantumAnnealingParameters(BaseParameter):
     sampling_params: SamplingParams
         Parameters for the sampling. See https://docs.dwavesys.com/docs/latest/c_solver_parameters.html
         for more details.
+    qpu_backend: str
+        Specific D-Wave quantum processing unit (QPU) for your optimization
     """
 
     embedding: Embedding = Embedding()
     sampling_params: SamplingParams = SamplingParams()
+    qpu_backend: Annotated[
+        str, StringConstraints(strip_whitespace=True, min_length=1)
+    ] = "default"

luna_sdk/schemas/solver_parameters/dwave/repeated_reverse_quantum_annealing.py

@@ -1,9 +1,16 @@
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import Field, StringConstraints
 
 from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 
+import sys
+
+if sys.version_info >= (3, 9):
+    from typing import Annotated
+else:
+    from typing_extensions import Annotated
+
 
 class RRQuantumAnnealingSamplingParams(BaseParameter):
     """
@@ -69,6 +76,8 @@ class RepeatedReverseQuantumAnnealingParameters(BaseParameter):
         The target energy for the solving process.
     check_trivial: bool
         Whether to check for trivial variables. Checking for trivial variables means an overhead. On the other hand, when set to `False`, trivial variables, i.e., variables without interactions, will lead to a runtime error.
+    qpu_backend: str
+        Specific D-Wave quantum processing unit (QPU) for your optimization
     """
 
     sampling_params: RRQuantumAnnealingSamplingParams = (
@@ -82,3 +91,6 @@ class RepeatedReverseQuantumAnnealingParameters(BaseParameter):
     max_iter: int = 10
     target: Optional[Any] = None
     check_trivial: bool = True
+    qpu_backend: Annotated[
+        str, StringConstraints(strip_whitespace=True, min_length=1)
+    ] = "default"

luna_sdk/schemas/solver_parameters/dwave/tabu_search.py

@@ -1,11 +1,9 @@
 from typing import Any, Optional
 
-from pydantic import BaseModel
+from .base import Tabu
 
-from luna_sdk.schemas.solver_parameters.base_parameter import BaseParameter
 
-
-class TabuSearchParameters(BaseParameter):
+class TabuSearchParameters(Tabu):
     """
     Tabu Search is a heuristic optimization method that works with the help of a tabu list.
     Initially, random states are chosen in the solution landscape.

luna_sdk/utils/qpu_tokens.py

@@ -1,9 +1,10 @@
 import os
 
-from luna_sdk.schemas import QpuToken, QpuTokenSource
+from luna_sdk.schemas.rest.qpu_token.qpu_token_source import _RESTQpuTokenSource
 from luna_sdk.schemas.rest.qpu_token.token_provider import (
     RestAPITokenProvider,
     AWSQpuTokens,
+    _RestQpuToken,
 )
 
 
@@ -15,37 +16,37 @@ def extract_qpu_tokens_from_env() -> RestAPITokenProvider:
     aws_access_key = os.environ.get("LUNA_AWS_ACCESS_KEY")
     aws_access_secret_key = os.environ.get("LUNA_AWS_SECRET_ACCESS_KEY")
     return RestAPITokenProvider(
-        ibm=QpuToken(
-            source=QpuTokenSource.INLINE,
+        ibm=_RestQpuToken(
+            source=_RESTQpuTokenSource.INLINE,
             token=ibm_token,
         )
         if ibm_token
         else None,
-        dwave=QpuToken(
-            source=QpuTokenSource.INLINE,
+        dwave=_RestQpuToken(
+            source=_RESTQpuTokenSource.INLINE,
             token=dwave_token,
         )
         if dwave_token
         else None,
-        qctrl=QpuToken(
-            source=QpuTokenSource.INLINE,
+        qctrl=_RestQpuToken(
+            source=_RESTQpuTokenSource.INLINE,
             token=qctrl_token,
         )
         if qctrl_token
         else None,
-        fujitsu=QpuToken(
-            source=QpuTokenSource.INLINE,
+        fujitsu=_RestQpuToken(
+            source=_RESTQpuTokenSource.INLINE,
             token=fujitsu_token,
         )
         if fujitsu_token
         else None,
         aws=AWSQpuTokens(
-            aws_access_key=QpuToken(
-                source=QpuTokenSource.INLINE,
+            aws_access_key=_RestQpuToken(
+                source=_RESTQpuTokenSource.INLINE,
                 token=aws_access_key,
             ),
-            aws_secret_access_key=QpuToken(
-                source=QpuTokenSource.INLINE,
+            aws_secret_access_key=_RestQpuToken(
+                source=_RESTQpuTokenSource.INLINE,
                 token=aws_access_secret_key,
             ),
         ),

luna_sdk/controllers/custom_login_client.py

@@ -1,66 +0,0 @@
-import logging
-from http.client import UNAUTHORIZED
-from importlib.metadata import version
-
-from httpx import Client, ReadTimeout, Response
-
-from luna_sdk.error.http_error_utils import HttpErrorUtils
-from luna_sdk.exceptions.timeout_exception import TimeoutException
-
-
-class CustomLoginClient(Client):
-    _login_url: str
-    _email: str
-    _password: str
-    _bearer_token: str
-
-    _version: str = version("luna-quantum")
-
-    _user_agent: str = f"LunaSDK/{_version}"
-
-    def __init__(self, email: str, password: str, login_url: str, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._email = email
-        self._password = password
-        self._login_url = login_url
-
-        self.headers["User-Agent"] = self._user_agent
-
-    def login(self, email: str, password: str):
-        with Client() as client:
-            headers = {
-                "accept": "application/json",
-                "Content-Type": "application/x-www-form-urlencoded",
-                "User-Agent": self._user_agent,
-            }
-
-            response: Response = client.post(
-                self._login_url,
-                data={"username": email, "password": password},
-                headers=headers,
-                # Ensure timeout is high enough. CustomLoginClient will be deleted in
-                # near future anyway.
-                timeout=None,
-            )
-            HttpErrorUtils.check_for_error(response)
-
-            self._bearer_token = response.json()["access_token"]
-
-    def request(self, *args, **kwargs) -> Response:
-        try:
-            response: Response = super().request(*args, **kwargs)
-            if response.status_code == UNAUTHORIZED:
-                logging.info("Unauthorized - trying to login")
-
-                self.login(self._email, self._password)
-
-                logging.info("Re-login successful")
-                self.headers.update(
-                    headers={"authorization": f"Bearer {self._bearer_token}"}
-                )
-                logging.info("Trying request again")
-                response = super().request(*args, **kwargs)
-        except ReadTimeout:
-            raise TimeoutException()
-        HttpErrorUtils.check_for_error(response)
-        return response