luna-quantum 0.0.16__py3-none-any.whl

luna_sdk/schemas/optimization.py

@@ -0,0 +1,75 @@
+from datetime import datetime
+from typing import Any, Dict, Generic, List, Optional, TypeVar
+
+from pydantic import BaseModel, Extra
+
+from luna_sdk.schemas.enums.optimization import InputType
+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.pretty_base import PrettyBase
+
+
+class Optimization(PrettyBase):
+    """
+    Pydantic model for optimization going OUT.
+        Attributes
+    ----------
+    id: str
+        Id of the optimization
+    created_date: Optional[datetime]
+        Date when optimization was created
+    created_by: Optional[str]
+        Id of the user who created optimization
+    modified_date: Optional[datetime]
+        Date when optimization was modified
+    modified_by: Optional[str]
+        Id of the user who modified optimization
+    """
+
+    id: str
+    name: Optional[str] = None
+    created_date: datetime
+    created_by: str
+    modified_date: Optional[datetime] = None
+    modified_by: Optional[str] = None
+    input_type: Optional[InputType] = None
+    use_case_name: Optional[str] = None
+    params: Optional[Dict[str, Any]] = None
+
+    class Config:
+        extra = Extra.ignore
+        from_attributes = False
+
+
+class OptimizationQubo(BaseModel):
+    id: str
+    name: Optional[str] = None
+    created_date: datetime
+    created_by: str
+    modified_date: Optional[datetime] = None
+    modified_by: Optional[str] = None
+
+    matrix: List[List[float]]
+
+
+class OptimizationBQM(Optimization, BQMSchema): ...
+
+
+class OptimizationCQM(Optimization, CQMSchema): ...
+
+
+class OptimizationLP(Optimization, LPSchema): ...
+
+
+class OptimizationUseCase(Optimization, BQMSchema):
+    use_case: Dict[str, Any]
+
+
+T = TypeVar("T")
+
+
+class OptimizationCreate(BaseModel, Generic[T]):
+    """Pydantic model for optimization coming IN."""
+
+    instance: T

luna_sdk/schemas/optimization_formats/bqm.py

@@ -0,0 +1,34 @@
+from enum import Enum
+from typing import Optional
+
+from dimod import BinaryQuadraticModel
+
+from luna_sdk.schemas.optimization_formats.qm import QMSchema
+
+
+class BQMVarType(str, Enum):
+    SPIN = "SPIN"
+    BINARY = "BINARY"
+
+
+class BQMSchema(QMSchema):
+    vartype: BQMVarType
+    offset: Optional[float] = None
+
+    @classmethod
+    def from_bqm(cls, bqm: BinaryQuadraticModel) -> "BQMSchema":
+        return cls(
+            vartype=BQMVarType(bqm.vartype.name),
+            quadratic={k: v for k, v in bqm.quadratic.items()},
+            linear={k: v for k, v in bqm.linear.items()},
+            offset=float(bqm.offset) if bqm.offset is not None else None,
+        )
+
+    def to_bqm(self) -> BinaryQuadraticModel:
+        bqm = BinaryQuadraticModel(
+            self.linear,
+            self._parsed_quadratic,
+            offset=self.offset,
+            vartype=self.vartype,
+        )
+        return bqm

luna_sdk/schemas/optimization_formats/cqm.py

@@ -0,0 +1,127 @@
+from enum import Enum
+from typing import Dict, Tuple, List, Union, Optional
+
+from dimod import ConstrainedQuadraticModel, QuadraticModel
+from pydantic import BaseModel
+
+from luna_sdk.exceptions.transformation import WeightedConstraintException
+from luna_sdk.schemas.optimization_formats.qm import QMSchema
+
+
+class CQMVarType(str, Enum):
+    SPIN = "SPIN"
+    BINARY = "BINARY"
+    INTEGER = "INTEGER"
+    REAL = "REAL"
+
+
+class QuadraticModelSchema(QMSchema):
+    offset: Union[float, int]
+    var_types: Dict[str, CQMVarType]
+
+
+class CQMSense(str, Enum):
+    Le = "<="
+    Ge = ">="
+    Eq = "=="
+
+
+class CQMPenaltyEnum(str, Enum):
+    linear = "linear"
+    quadratic = "quadratic"
+
+
+class CQMConstraintsSchema(BaseModel):
+    qm: QuadraticModelSchema
+    sense: CQMSense
+    rhs: Union[float, int]
+    label: str
+    penalty: CQMPenaltyEnum
+
+
+class CQMVariableSchema(BaseModel):
+    var_type: CQMVarType
+    name: str
+    lower_bound: Optional[float]
+    upper_bound: Optional[float]
+
+
+class CQMSchema(BaseModel):
+    constraints: Dict[str, CQMConstraintsSchema]
+    objective: QuadraticModelSchema
+    variables: List[CQMVariableSchema]
+
+    @classmethod
+    def from_cqm(cls, cqm: ConstrainedQuadraticModel) -> "CQMSchema":
+        var_types = {v: CQMVarType[cqm.vartype(v).name] for v in cqm.variables}
+        constraints = {}
+        for name, constraint in cqm.constraints.items():
+            if constraint.lhs.is_soft():
+                raise WeightedConstraintException
+            constr = CQMConstraintsSchema(
+                qm=QuadraticModelSchema(
+                    linear=constraint.lhs.linear,
+                    quadratic=constraint.lhs.quadratic,
+                    offset=constraint.lhs.offset,
+                    var_types=var_types,
+                ),
+                sense=CQMSense[constraint.sense.name],
+                rhs=constraint.rhs,
+                label=name,
+                penalty=CQMPenaltyEnum.linear,
+            )
+            constraints[name] = constr
+        objective = QuadraticModelSchema(
+            linear=cqm.objective.linear,
+            quadratic=cqm.objective.quadratic,
+            offset=cqm.objective.offset,
+            var_types=var_types,
+        )
+        variables = []
+        for var in cqm.variables:
+            variables.append(
+                CQMVariableSchema(
+                    name=var,
+                    var_type=var_types[var],
+                    lower_bound=cqm.lower_bound(var),
+                    upper_bound=cqm.upper_bound(var),
+                )
+            )
+        return cls(
+            constraints=constraints,
+            objective=objective,
+            variables=variables,
+        )
+
+    def to_cqm(self) -> ConstrainedQuadraticModel:
+        cqm = ConstrainedQuadraticModel()
+        for variable in self.variables:
+            cqm.add_variable(vartype=variable.var_type, v=variable.name)
+        for name, constraint in self.constraints.items():
+            qm = QuadraticModel(
+                linear=constraint.qm.linear,  # type: ignore[arg-type]
+                quadratic=constraint.qm._parsed_quadratic,  # type: ignore[arg-type]
+                offset=constraint.qm.offset,
+                vartypes=constraint.qm.var_types,  # type: ignore[arg-type]
+            )
+            cqm.add_constraint_from_model(
+                qm=qm,
+                sense=constraint.sense,
+                rhs=constraint.rhs,
+                label=constraint.label,
+                penalty=constraint.penalty,
+            )
+        objective = QuadraticModel(
+            linear=self.objective.linear,  # type: ignore[arg-type]
+            quadratic=self.objective._parsed_quadratic,  # type: ignore[arg-type]
+            offset=self.objective.offset,
+            vartypes=self.objective.var_types,  # type: ignore[arg-type]
+        )
+        cqm.set_objective(objective)
+        for variable in self.variables:
+            if variable.var_type not in (CQMVarType.BINARY, CQMVarType.SPIN):
+                if variable.upper_bound is not None:
+                    cqm.set_upper_bound(variable.name, variable.upper_bound)
+                if variable.lower_bound is not None:
+                    cqm.set_lower_bound(variable.name, variable.lower_bound)
+        return cqm

luna_sdk/schemas/optimization_formats/lp.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+
+class LPSchema(BaseModel):
+    lp_string: str
+
+    @classmethod
+    def from_lp(cls, lp: str) -> "LPSchema":
+        return cls(lp_string=lp)

luna_sdk/schemas/optimization_formats/qm.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, Tuple
+
+from pydantic import BaseModel, field_validator
+
+
+class QMSchema(BaseModel):
+    quadratic: Dict[str, float]
+    linear: Dict[str, float]
+
+    @property
+    def _parsed_quadratic(self) -> Dict[Tuple[str, ...], float]:
+        q = {}
+        for k, v in self.quadratic.items():
+            parsed_key = eval(k) if isinstance(k, str) else k
+            formatted_key = tuple(
+                str(x) if not isinstance(x, str) else x for x in parsed_key
+            )
+            q[formatted_key] = v
+        return q
+
+    @field_validator("quadratic", mode="before")
+    @classmethod
+    def transform_quadratic(cls, quadratic: Dict[Any, Any]) -> Dict[str, Any]:
+        if quadratic:
+            q = {}
+            for k, v in quadratic.items():
+                k = str(k) if not isinstance(k, str) else k
+                q[k] = v
+            return q
+        return quadratic

luna_sdk/schemas/pretty_base.py

@@ -0,0 +1,49 @@
+from pydantic import BaseModel
+
+
+class PrettyBase(BaseModel):
+    def _pretty_print(self, data: dict, indent: int = 0) -> str:
+        """Helper function to pretty print nested dictionaries in a readable yaml inspired format"""
+        output = ""
+        for key, value in data.items():
+            output += "    " * indent + str(key) + ":"
+            if isinstance(value, dict):
+                output += "\n"
+                output += self._pretty_print(value, indent + 1)
+            else:
+                output += " " + str(value) + "\n"
+        return output
+
+    def __str__(self):
+        """Overwrite the default object string representation to use the custom pretty print console representation"""
+        data = self.model_dump()
+
+        return self._pretty_print(data)
+
+    @property
+    def head(self):
+        """Print a truncated version of the pretty print console representation"""
+        limit = 20
+
+        def truncate(data, limit):
+            if data is None:
+                return None, False
+
+            if isinstance(data, dict):
+                d = {
+                    k: truncate(v, limit)[0]
+                    for i, (k, v) in enumerate(data.items())
+                    if i < limit
+                }
+                return d, len(data) > limit
+            elif isinstance(data, list):
+                d = data[:limit]
+                return d, len(data) > limit
+            else:
+                return data, False
+
+        data = self.model_dump()
+
+        data_truncated, is_truncated = truncate(data, limit)
+
+        return self._pretty_print(data_truncated)

luna_sdk/schemas/qpu_token.py

@@ -0,0 +1,60 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Extra
+
+
+class QpuTokenSource(str, Enum):
+    # 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"
+
+
+class QpuToken(BaseModel):
+    source: QpuTokenSource
+    # 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
+
+
+class TokenProvider(BaseModel):
+    dwave: Optional[QpuToken] = None
+    ibm: Optional[QpuToken] = None
+    fujitsu: Optional[QpuToken] = None
+    qctrl: Optional[QpuToken] = None
+    aws_access_key: Optional[QpuToken] = None
+    aws_secret_access_key: Optional[QpuToken] = None
+
+    class Config:
+        extra = Extra.forbid
+
+
+class QpuTokenOut(BaseModel):
+    """
+    Pydantic model for QPU token OUT.
+    It contains the data received from the API call.
+
+    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
+
+    class Config:
+        extra = Extra.ignore
+        from_attributes = True

luna_sdk/schemas/representation.py

@@ -0,0 +1,19 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class Representation(BaseModel):
+    """
+    Pydantic model for representation of a solution sample.
+
+    Attributes
+    ----------
+    description: str
+        Description of the representation
+    solution: Any
+        matrix of the solution representation
+    """
+
+    description: str
+    solution: Any

luna_sdk/schemas/rest/qpu_token/token_provider.py

@@ -0,0 +1,45 @@
+from typing import Optional
+
+from pydantic import BaseModel, Extra
+
+from luna_sdk.schemas import QpuToken, TokenProvider
+
+
+class AWSQpuTokens(BaseModel):
+    aws_access_key: QpuToken
+    aws_secret_access_key: QpuToken
+
+
+class RestAPITokenProvider(BaseModel):
+    dwave: Optional[QpuToken] = None
+    ibm: Optional[QpuToken] = None
+    fujitsu: Optional[QpuToken] = None
+    qctrl: Optional[QpuToken] = None
+    aws: Optional[AWSQpuTokens] = None
+
+    @classmethod
+    def from_sdk_token_provider(
+        cls, token_provider: TokenProvider
+    ) -> "RestAPITokenProvider":
+        aws: Optional[AWSQpuTokens] = None
+        if (
+            token_provider.aws_access_key is not None
+            or token_provider.aws_secret_access_key is not None
+        ):
+            # 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
+                ),
+            )
+        return cls(
+            dwave=token_provider.dwave,
+            ibm=token_provider.ibm,
+            fujitsu=token_provider.fujitsu,
+            qctrl=token_provider.qctrl,
+            aws=aws,
+        )
+
+    class Config:
+        extra = Extra.forbid

luna_sdk/schemas/solution.py

@@ -0,0 +1,227 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+from luna_sdk.schemas.enums.solution import SenseEnum
+from luna_sdk.schemas.enums.status import StatusEnum
+from luna_sdk.schemas.optimization import Optimization
+from luna_sdk.schemas.pretty_base import PrettyBase
+
+Numeric = Union[float, int]
+Sample = Dict[str, Numeric]
+
+
+class Runtime(BaseModel):
+    """
+    Pydantic model for runtime of a solution.
+
+    Attributes
+    ----------
+    total: float
+        Total time of solution processing
+    overhead: Optional[float]
+        Time of the classical computing processes
+    qpu: Optional[float]
+        Total time of the quantum computing processes
+    """
+
+    total: float
+    overhead: Optional[float]
+    qpu: Optional[float]
+    # ...
+
+
+class ConstraintResult(BaseModel):
+    satisfied: bool
+    extra: Optional[Dict[str, Any]]
+
+
+class Result(PrettyBase):
+    """
+    A single result of a solution
+
+    Attributes
+    ----------
+    sample: List[List[bool]]
+        Binary solutions vectors
+    energies: List[float]
+        Energy corresponding to binary solution vector
+    solver: str
+        Solver's name
+    params: Dict
+        Solver params
+    runtime: Runtime
+        Solution runtime information
+    metadata: Optional[Dict]
+        Solution's metadata
+    """
+
+    sample: Sample
+    obj_value: float
+    feasible: bool
+    constraints: Dict[str, ConstraintResult]
+
+
+class Solution(PrettyBase):
+    """
+    The solution class for Solver return values
+
+    Attributes
+    ----------
+    results: List[List[bool]]
+        List of binary solutions vectors
+    params: Dict
+        Solver params
+    runtime: Runtime
+        Solution runtime information
+    sense: SenseEnum
+        Optimization sense, can be 'min' or 'max'.
+    metadata: Optional[Dict]
+        Solution's metadata
+    provider: str
+        The solver provider
+
+    error_message: Optional[str]
+        Default is none.
+        If an error occurs during the solution process,
+        the error message is stored here.
+    """
+
+    id: str
+    name: Optional[str] = None
+    created_date: datetime
+    created_by: str
+    modified_date: Optional[datetime] = None
+    modified_by: Optional[str] = None
+
+    error_message: Optional[str] = None
+
+    results: Optional[List[Result]]
+    params: Dict[str, Any]
+    runtime: Optional[Runtime]
+    sense: Optional[SenseEnum]
+    metadata: Optional[Dict[str, Any]]
+    provider: str
+    status: StatusEnum
+    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"]
+
+        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
+
+    @property
+    def head(self):
+        """Print a truncated version of the pretty print console representation"""
+        limit = 5
+
+        def truncate(data, limit):
+            if data is None:
+                return None, False
+
+            if isinstance(data, dict):
+                d = {
+                    k: truncate(v, limit)[0]
+                    for i, (k, v) in enumerate(data.items())
+                    if i < limit
+                }
+                return d, len(data) > limit
+            elif isinstance(data, list):
+                d = data[:limit]
+                return d, len(data) > limit
+            else:
+                return data, False
+
+        data = self.model_dump()
+        results = data.pop("results")  # remove results from data
+        metadata = data.pop("metadata")  # 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}"
+            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 += 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
+        metadata_truncated, is_truncated = truncate(metadata, limit)
+        output += f"\n\n{divider}{provider.upper()} META DATA"
+        output += " (truncated)" if is_truncated else ""
+        output += f":\n{divider}"
+        output += (
+            self._pretty_print(metadata_truncated)
+            if metadata
+            else "    No metadata from provider..\n"
+        )
+        output += "...." if is_truncated else ""
+
+        return output
+
+
+class UseCaseResult(BaseModel):
+    representation: Any
+    obj_value: float
+
+
+class UseCaseRepresentation(PrettyBase):
+    sense: Optional[SenseEnum]
+    results: List[UseCaseResult]
+    description: str

luna_sdk/schemas/solver_info.py

@@ -0,0 +1,11 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class SolverInfo(BaseModel):
+    full_name: str
+    short_name: str
+    available: bool
+    params: dict
+    description: Optional[str]