luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

luna_quantum/client/schemas/enums/model_format.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class ModelFormat(str, Enum):
+    """Enumeration of all supported formats."""
+
+    AQ_MODEL = "AQ_MODEL"
+    LP = "LP"
+    QUBO = "QUBO_MATRIX"
+    CQM = "CQM"
+    BQM = "BQM"

luna_quantum/client/schemas/enums/problem.py

@@ -0,0 +1,50 @@
+from enum import Enum
+
+
+class UseCaseEnum(str, Enum):
+    """Use case enum."""
+
+    AEB = "AEB"
+    ANB = "ANB"
+    BIP = "BIP"
+    BPSP = "BPSP"
+    CSFS = "CSFS"
+    DPO = "DPO"
+    EC = "EC"
+    FGO = "FGO"
+    GC = "GC"
+    GI = "GI"
+    GP = "GP"
+    HC = "HC"
+    ISGI = "ISGI"
+    JSS = "JSS"
+    KMC = "KMC"
+    KIW = "KIW"
+    LR = "LR"
+    LMWCS = "LMWCS"
+    LP = "LP"
+    MGC = "MGC"
+    M2SAT = "M2SAT"
+    M3SAT = "M3SAT"
+    MCQ = "MCQ"
+    MC = "MC"
+    MIS = "MIS"
+    MMM = "MMM"
+    MST = "MST"
+    MVC = "MVC"
+    NP = "NP"
+    PO = "PO"
+    POIBTV = "POIBTV"
+    QA = "QA"
+    QK = "QK"
+    SSC = "SSC"
+    SPL = "SPL"
+    SC = "SC"
+    SP = "SP"
+    SPP = "SPP"
+    SGI = "SGI"
+    SSP = "SSP"
+    SVM = "SVM"
+    TFO = "TFO"
+    TSP = "TSP"
+    WMC = "WMC"

luna_quantum/client/schemas/enums/qpu_token_type.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+
+class QpuTokenTypeEnum(str, Enum):
+    """
+    Enumeration of possible types for QPU tokens.
+
+    This enum defines the scope or ownership category of QPU tokens.
+
+    Attributes
+    ----------
+    GROUP : str
+        Indicates that the QPU token is shared among a group of users.
+
+    PERSONAL : str
+        Indicates that the QPU token belongs to an individual user.
+    """
+
+    GROUP = "group"
+    PERSONAL = "personal"

luna_quantum/client/schemas/enums/sense.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class SenseEnum(str, Enum):
+    """Optimization Sense."""
+
+    MAX = "max"
+    MIN = "min"

luna_quantum/client/schemas/enums/status.py

@@ -0,0 +1,40 @@
+from enum import Enum
+
+
+class StatusEnum(str, Enum):
+    """
+    Enumeration of possible status states for a solve job.
+
+    This enum defines the standard lifecycle states of a solve job.
+
+    Enum Values
+    -----------
+    REQUESTED
+        The job has been requested but not yet initialized by the system.
+        This is the initial state when a job is submitted.
+
+    CREATED
+        The job has been created and initialized in the system, but execution
+        has not yet begun.
+
+    IN_PROGRESS
+        The job is currently being executed. Processing has started but
+        is not yet complete.
+
+    DONE
+        The job has completed successfully with a valid result.
+
+    FAILED
+        The solve job has terminated abnormally or
+        encountered an error during execution.
+
+    CANCELED
+        The job was explicitly canceled by a user before completion.
+    """
+
+    REQUESTED = "REQUESTED"
+    CREATED = "CREATED"
+    IN_PROGRESS = "IN_PROGRESS"
+    DONE = "DONE"
+    FAILED = "FAILED"
+    CANCELED = "CANCELED"

luna_quantum/client/schemas/enums/timeframe.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class TimeframeEnum(str, Enum):
+    """Enum class for query filter timeframes."""
+
+    today = "today"
+    this_week = "last_week"
+    this_month = "last_month"
+    this_year = "last_year"
+    all_time = "all_time"

luna_quantum/client/schemas/error_message.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+
+
+class ErrorMessage(BaseModel):
+    """
+    Error message model.
+
+    If an error occurs, this model is used to return error messages
+    to the client. It contains the internal code and the message that describes
+    the error.
+    """
+
+    internal_code: str
+    message: str

luna_quantum/client/schemas/model_metadata.py

@@ -0,0 +1,35 @@
+from pydantic import BaseModel
+
+from luna_quantum.client.schemas.wrappers import PydanticDatetimeWrapper
+
+
+class ModelMetadataSchema(BaseModel):
+    """
+    Model metadata schema.
+
+    Attributes
+    ----------
+    id: str
+        Unique identifier for the model.
+
+    created_date: PydanticDatetimeWrapper
+        The timestamp when the model was initially created.
+
+    created_by: str
+        Identifier of the user that created the model.
+
+    modified_date: PydanticDatetimeWrapper | None
+        The timestamp when the model was last modified.
+        None if the model has never been modified after creation.
+
+    modified_by: str | None
+        Identifierof the user that last modified the model.
+        None if the model has never been modified after creation.
+    """
+
+    id: str
+    created_date: PydanticDatetimeWrapper
+    created_by: str
+
+    modified_date: PydanticDatetimeWrapper | None = None
+    modified_by: str | None = None

luna_quantum/client/schemas/qpu_token/qpu_token.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from luna_quantum.client.schemas.enums.qpu_token_type import (
+    QpuTokenTypeEnum,
+)
+
+
+class QpuTokenSource(str, Enum):
+    """
+    Enumeration of possible sources for QPU tokens.
+
+    This enum defines the different strategies for providing or retrieving
+    QPU tokens.
+    """
+
+    # token currently passed in from the API call
+    INLINE = "inline"
+    # stored token in user account
+    PERSONAL = "personal"
+    # stored token in group account
+    GROUP = "group"
+
+
+class QpuToken(BaseModel):
+    """
+    Schema for QPU token.
+
+    Attributes
+    ----------
+    source: QpuTokenSource
+        Specifies the source location of the QPU token, determining how the
+        token is retrieved.
+    name: str | None
+        The identifier name of the stored QPU token. Required when
+        source is QpuTokenSource.PERSONAL or QpuTokenSource.GROUP.
+    token: str | None
+        The actual QPU token value to be used for authentication.
+        Required when source is QpuTokenSource.INLINE.
+    """
+
+    source: QpuTokenSource
+    # A unique name for a stored token
+    name: str | None = 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: str | None = None
+
+
+class PersonalQpuToken(QpuToken):
+    """
+    Schema for stored personal qpu token.
+
+    Attributes
+    ----------
+    name: str
+        Name of qpu token.
+    source: QpuTokenSource
+        Source of the qpu token.
+        In this case should be always set to QpuTokenSource.PERSONAL
+    """
+
+    name: str
+    source: QpuTokenSource = Field(
+        init=False, default=QpuTokenSource.PERSONAL, frozen=True
+    )
+
+
+class GroupQpuToken(QpuToken):
+    """
+    Schema for stored group qpu token.
+
+    Attributes
+    ----------
+    name: str
+        Name of qpu token.
+    source: QpuTokenSource
+        Source of the qpu token.
+        In this case should be always set to QpuTokenSource.GROUP
+    """
+
+    name: str
+    source: QpuTokenSource = Field(
+        init=False, default=QpuTokenSource.GROUP, frozen=True
+    )
+
+
+class TokenProvider(BaseModel):
+    """
+    Schema for QPU tokens.
+
+    Attributes
+    ----------
+    dwave: QpuToken | None
+        Authentication token for D-Wave quantum computing services.
+        None if no D-Wave token is provided.
+
+    ibm: QpuToken | None
+        Authentication token for IBM Quantum services.
+        None if no IBM token is provided.
+
+    fujitsu: QpuToken | None
+        Authentication token for Fujitsu quantum computing services.
+        None if no Fujitsu token is provided.
+
+    qctrl: QpuToken | None
+        Authentication token for Q-CTRL quantum computing services.
+        None if no Q-CTRL token is provided.
+
+    aws_access_key: QpuToken
+        The AWS access key ID token used to identify the AWS account.
+
+    aws_secret_access_key: _RestQpuToken
+        The AWS secret access key token used to verify the identity.
+
+    aws_session_token: _RestQpuToken
+        The AWS session token.
+    """
+
+    dwave: QpuToken | None = None
+    ibm: QpuToken | None = None
+    fujitsu: QpuToken | None = None
+    qctrl: QpuToken | None = None
+    aws_access_key: QpuToken | None = None
+    aws_secret_access_key: QpuToken | None = None
+    aws_session_token: QpuToken | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QpuTokenOut(BaseModel):
+    """
+    pydantic model for qpu token out.
+
+    it contains the data received from the api call.
+
+    Attributes
+    ----------
+    name: optional[str]
+        name of the qpu token.
+    provider: str
+        name of provider.
+
+    """
+
+    name: str
+    provider: str
+    token_type: QpuTokenTypeEnum
+
+    model_config = ConfigDict(extra="forbid", from_attributes=True)

luna_quantum/client/schemas/qpu_token/qpu_token_source.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class _RESTQpuTokenSource(str, Enum):
+    """_RESTQpuTokenSource.
+
+    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_quantum/client/schemas/qpu_token/qpu_token_time_quota.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel
+
+from luna_quantum.client.schemas.wrappers.datetime_wrapper import (
+    PydanticDatetimeWrapper,
+)
+
+
+class QpuTokenTimeQuotaOut(BaseModel):
+    """
+    Pydantic model for QPU token time quota OUT.
+
+    It contains the data received from the API call.
+
+    Attributes
+    ----------
+    quota: int
+        The total amount of quota available on a qpu token.
+    start: datetime
+        Effective start date of the time quota policy.
+    end: datetime
+        Effective end date of the time quota policy.
+    quota_used: int
+        How much quota has already been used from
+        the totally available amount of quota.
+    """
+
+    quota: int
+    start: PydanticDatetimeWrapper
+    end: PydanticDatetimeWrapper
+    quota_used: int

luna_quantum/client/schemas/qpu_token/token_provider.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+from luna_quantum.client.schemas.qpu_token.qpu_token import (
+    QpuToken,
+    QpuTokenSource,
+    TokenProvider,
+)
+from luna_quantum.client.schemas.qpu_token.qpu_token_source import _RESTQpuTokenSource
+
+
+class _RestQpuToken(BaseModel):
+    source: _RESTQpuTokenSource
+    # A unique name for a stored token
+    name: str | None = 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: str | None = None
+
+    @classmethod
+    def from_qpu_token(cls, qpu_token: QpuToken | None) -> _RestQpuToken | None:
+        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 # noqa: FIX002, TD002
+        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):
+    """
+    Container for AWS authentication tokens.
+
+    Attributes
+    ----------
+    aws_access_key: _RestQpuToken
+        The AWS access key ID token used to identify the AWS account.
+
+    aws_secret_access_key: _RestQpuToken
+        The AWS secret access key token used to verify the identity.
+
+    aws_session_token: _RestQpuToken
+        The AWS secret access key token used to verify the identity.
+    """
+
+    aws_access_key: _RestQpuToken
+    aws_secret_access_key: _RestQpuToken
+    aws_session_token: _RestQpuToken
+
+
+class RestAPITokenProvider(BaseModel):
+    """
+    Internal schema for QPU tokens.
+
+    Attributes
+    ----------
+    dwave: _RestQpuToken | None
+        Authentication token for D-Wave quantum computing services.
+        None if no D-Wave token is provided.
+
+    ibm: _RestQpuToken | None
+        Authentication token for IBM Quantum services.
+        None if no IBM token is provided.
+
+    fujitsu: _RestQpuToken | None
+        Authentication token for Fujitsu quantum computing services.
+        None if no Fujitsu token is provided.
+
+    qctrl: _RestQpuToken | None
+        Authentication token for Q-CTRL quantum computing services.
+        None if no Q-CTRL token is provided.
+
+    aws: AWSQpuTokens | None
+        Authentication tokens for AWS quantum computing services.
+        Uses a specialized structure for AWS authentication.
+        None if no AWS tokens are provided.
+    """
+
+    dwave: _RestQpuToken | None = None
+    ibm: _RestQpuToken | None = None
+    fujitsu: _RestQpuToken | None = None
+    qctrl: _RestQpuToken | None = None
+    aws: AWSQpuTokens | None = None
+
+    model_config = ConfigDict(extra="forbid")
+
+    @classmethod
+    def from_sdk_token_provider(
+        cls, token_provider: TokenProvider
+    ) -> RestAPITokenProvider:
+        """
+        Create RestAPITokenProvider from TokenProvider.
+
+        Parameters
+        ----------
+        token_provider: TokenProvider
+            TokenProvider datastructure containing QPU tokens.
+        """
+        aws: AWSQpuTokens | None = None
+        if (
+            token_provider.aws_access_key is not None
+            or token_provider.aws_secret_access_key is not None
+            or token_provider.aws_session_token is not None
+        ):
+            aws = AWSQpuTokens(
+                aws_access_key=_RestQpuToken.from_qpu_token(  # type: ignore[arg-type]
+                    token_provider.aws_access_key
+                ),
+                aws_secret_access_key=_RestQpuToken.from_qpu_token(  # type: ignore[arg-type]
+                    token_provider.aws_secret_access_key
+                ),
+                aws_session_token=_RestQpuToken.from_qpu_token(  # type: ignore[arg-type]
+                    token_provider.aws_session_token
+                ),
+            )
+        return cls(
+            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,
+        )

luna_quantum/client/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_quantum/client/schemas/solution.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from luna_quantum.util.pretty_base import PrettyBase
+
+Numeric = float | int
+Sample = dict[str, Numeric]
+
+
+class Runtime(BaseModel):
+    """
+    Pydantic model for runtime of a solution.
+
+    Attributes
+    ----------
+    total: float
+        Total time of solution processing
+    qpu: Optional[float]
+        Total time of the quantum computing processes
+    """
+
+    total: float
+    qpu: float | None
+    # ...
+
+
+class ConstraintResult(BaseModel):
+    """
+    Represents the evaluation result of a constraint in an optimization.
+
+    Attributes
+    ----------
+    satisfied: bool
+        Indicates whether the constraint is satisfied by the solution.
+    extra: dict[str, Any] | None
+        Additional information related to the constraint evaluation.
+    """
+
+    satisfied: bool
+    extra: dict[str, Any] | None
+
+
+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 UseCaseResult(BaseModel):
+    """
+    Represents the result of an optimization use case solution.
+
+    This class stores the outcome of solving an optimization problem,
+    containing both the solution representation and its objective value.
+
+    Attributes
+    ----------
+    representation: Any
+        The representation of the solution, which could be in various forms
+        depending on the optimization problem.
+    obj_value: float
+        The objective function value achieved by this solution.
+    """
+
+    representation: Any
+    obj_value: float | None
+
+
+class UseCaseRepresentation(PrettyBase):
+    """
+    Representation of an optimization problem use case.
+
+    Attributes
+    ----------
+    results: list[UseCaseResult]
+        A collection of results obtained from solving this
+        optimization use case.
+    description: str
+        A human-readable description of the optimization use case.
+    """
+
+    results: list[UseCaseResult]
+    description: str