luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

luna_quantum/client/schemas/solve_job.py

@@ -0,0 +1,50 @@
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel
+
+from luna_quantum.client.schemas.enums.model_format import ModelFormat
+from luna_quantum.client.schemas.enums.status import StatusEnum
+
+
+class SolveJobSchema(BaseModel):
+    """
+    Solve job schema.
+
+    Attributes
+    ----------
+    id: str
+        The ID of the solve job.
+    status: StatusEnum
+        The current status of the solve job.
+    status_timeline: dict[StatusEnum, datetime]
+        The history of status changes for the solve job.
+    used_format: ModelFormat | None
+        The format that is used for solving. None if not applicable.
+    error_message: str | None
+        The error message if the solve job failed.
+    provider: str
+        The name of the provider where the solve job is scheduled.
+    solver_job_info: str | None
+        Additional information about the solve job. None if not available.
+    is_cancelable: bool
+        Indicates if the solve job can be cancelled.
+    is_cancellation_requested: bool
+        Indicates if cancellation of the solve job has been requested.
+    """
+
+    id: str
+    status: StatusEnum
+    status_timeline: dict[StatusEnum, datetime]
+    used_format: ModelFormat | None = None
+
+    error_message: str | None
+    provider: str
+
+    # TODO(Lev): Consider renaming? # noqa: FIX002
+    solver_job_info: str | None = None
+
+    is_cancelable: bool
+    is_cancellation_requested: bool
+
+    metadata: dict[str, Any] | None = None

luna_quantum/client/schemas/solver_info.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+
+
+class SolverInfo(BaseModel):
+    """Solver info schema."""
+
+    full_name: str
+    short_name: str
+    available: bool
+    params: dict  # type: ignore[type-arg]
+    description: str | None

luna_quantum/client/schemas/user.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, EmailStr
+
+
+class User(BaseModel):
+    """Pydantic model for user going OUT."""
+
+    email: EmailStr
+    first_name: str
+    last_name: str
+    groups: list[str] = []
+    orgs: list[str] = []

luna_quantum/client/schemas/wrappers/__init__.py

@@ -0,0 +1,5 @@
+from luna_quantum.client.schemas.wrappers.datetime_wrapper import (
+    PydanticDatetimeWrapper,
+)
+
+__all__ = ["PydanticDatetimeWrapper"]

luna_quantum/client/schemas/wrappers/datetime_wrapper.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Annotated
+
+from dateutil.parser import parse
+from pydantic import BeforeValidator
+
+
+def validate_datetime(date_string: str | datetime) -> datetime:
+    """Validate an ISO date string and return it in the local timezone.
+
+    Parameters
+    ----------
+    date_string : str
+        The ISO date string
+
+    Returns
+    -------
+    datetime
+        The datetime in the user's local timezone
+
+    Raises
+    ------
+    ValueError
+        If `date_string` does not have a valid format.
+    """
+    dt = date_string if isinstance(date_string, datetime) else parse(date_string)
+    return dt.astimezone()
+
+
+PydanticDatetimeWrapper = Annotated[datetime, BeforeValidator(validate_datetime)]

luna_quantum/client/utils/qpu_token_utils.py

@@ -0,0 +1,147 @@
+import os
+
+from luna_quantum.client.schemas.qpu_token.qpu_token import (
+    QpuToken,
+    QpuTokenSource,
+    TokenProvider,
+)
+
+
+class QpuTokenUtils:
+    """Utilities for QPU tokens."""
+
+    @staticmethod
+    def patch_qpu_tokens_from_env(
+        qpu_token: TokenProvider = TokenProvider(),
+    ) -> TokenProvider | None:
+        """
+        Add QPU tokens from environment variables.
+
+        If a token is not found in the environment, it will be set to None.
+        If no token-provider is provided, a new one will be created.
+
+        Parameters
+        ----------
+        qpu_token: TokenProvider
+            Token-provider to update. If no token-provider is provided,
+            a new one will be created.
+
+        Returns
+        -------
+        Optional[TokenProvider]
+            Returns the updated token-provider. If the token-provider is empty,
+            returns None.
+        """
+        qpu_token.dwave = QpuTokenUtils.get_token_from_provider_or_env(
+            token=qpu_token.dwave, env_key="LUNA_DWAVE_TOKEN"
+        )
+        qpu_token.ibm = QpuTokenUtils.get_token_from_provider_or_env(
+            token=qpu_token.ibm, env_key="LUNA_IBM_TOKEN"
+        )
+        qpu_token.qctrl = QpuTokenUtils.get_token_from_provider_or_env(
+            token=qpu_token.qctrl, env_key="LUNA_QCTRL_TOKEN"
+        )
+        qpu_token.fujitsu = QpuTokenUtils.get_token_from_provider_or_env(
+            token=qpu_token.fujitsu, env_key="LUNA_FUJITSU_TOKEN"
+        )
+        qpu_token.aws_access_key = QpuTokenUtils.get_token_from_provider_or_env(
+            token=qpu_token.aws_access_key, env_key="LUNA_AWS_ACCESS_KEY"
+        )
+        qpu_token.aws_secret_access_key = QpuTokenUtils.get_token_from_provider_or_env(
+            token=qpu_token.aws_secret_access_key, env_key="LUNA_AWS_SECRET_ACCESS_KEY"
+        )
+        qpu_token.aws_session_token = QpuTokenUtils.get_token_from_provider_or_env(
+            token=qpu_token.aws_session_token, env_key="LUNA_AWS_SESSION_TOKEN"
+        )
+
+        if QpuTokenUtils.is_token_provider_empty(qpu_token):
+            return None
+
+        return qpu_token
+
+    @staticmethod
+    def is_qpu_token_empty(qpu_token: QpuToken) -> bool:
+        """
+        Check if the QpuToken object is empty.
+
+        An empty QpuToken is defined as having both its `name` and `token`
+        attributes set to `None`.
+
+        Parameters
+        ----------
+        qpu_token : QpuToken
+            The QpuToken object to check for emptiness.
+
+        Returns
+        -------
+        bool
+            True if the QpuToken is empty, otherwise False.
+
+        """
+        return qpu_token.name is None and qpu_token.token is None
+
+    @staticmethod
+    def is_token_provider_empty(qpu_token: TokenProvider) -> bool:
+        """
+        Check if the token provider is empty.
+
+        The function checks whether all attributes of the provided token provider are
+        None, indicating that it is empty.
+
+        Parameters
+        ----------
+        qpu_token : TokenProvider
+            The token provider object containing various token attributes.
+
+        Returns
+        -------
+        bool
+            True if all token attributes are None, otherwise False.
+        """
+        if qpu_token is None:
+            return True
+        for field in [
+            qpu_token.dwave,
+            qpu_token.ibm,
+            qpu_token.qctrl,
+            qpu_token.fujitsu,
+            qpu_token.aws_access_key,
+            qpu_token.aws_secret_access_key,
+            qpu_token.aws_session_token,
+        ]:
+            if field is not None and not QpuTokenUtils.is_qpu_token_empty(field):
+                return False
+        return True
+
+    @staticmethod
+    def get_token_from_provider_or_env(
+        token: QpuToken | None, env_key: str
+    ) -> QpuToken | None:
+        """
+        Get token from provider or environment variable.
+
+        If a token is provided and not empty, return it. Otherwise, attempt to retrieve
+        a token from the specified environment variable. If no token is found, return
+        None.
+
+        Parameters
+        ----------
+        token : Optional[QpuToken]
+            Token provided by the caller.
+        env_key : str
+            The key for the environment variable to look for a token.
+
+        Returns
+        -------
+        Optional[QpuToken]
+            The token retrieved either from the provided input or the environment.
+        """
+        if token is None or QpuTokenUtils.is_qpu_token_empty(token):
+            env_value = os.environ.get(env_key, None)
+            if env_value is not None:
+                return QpuToken(
+                    source=QpuTokenSource.INLINE,
+                    token=env_value,
+                )
+            return None
+        return token

luna_quantum/config.py

@@ -0,0 +1,11 @@
+from pydantic_settings import BaseSettings
+
+
+class Config(BaseSettings):
+    """Class for all config values."""
+
+    LUNA_LOG_DEFAULT_LEVEL: str = "INFO"
+    LUNA_LOG_DISABLE_SPINNER: bool = False
+
+
+config = Config()

luna_quantum/decorators.py

@@ -0,0 +1,248 @@
+"""Decorators."""
+
+from collections.abc import Callable
+from typing import Any, Generic, TypeAlias, TypeVar
+
+from typing_extensions import override
+
+from . import Model, Solution
+from .transformations import (
+    ActionType,
+    AnalysisCache,
+    AnalysisPass,
+    BasePass,
+    MetaAnalysisPass,
+    TransformationOutcome,
+    TransformationPass,
+)
+
+T = TypeVar("T")
+
+AnalysisSignature: TypeAlias = Callable[[Model, AnalysisCache], T]
+
+MetaAnalysisSignature: TypeAlias = Callable[[list[BasePass], AnalysisCache], T]
+
+Outcome: TypeAlias = (
+    TransformationOutcome | tuple[Model, ActionType] | tuple[Model, ActionType, Any]
+)
+TransformationSignature: TypeAlias = Callable[
+    [Model, AnalysisCache],
+    Outcome,
+]
+BackwardsSignature: TypeAlias = Callable[[Solution, AnalysisCache], Solution]
+
+
+def __identity_backwards(solution: Solution, _: AnalysisCache) -> Solution:
+    return solution
+
+
+class DynamicAnalysisPass(AnalysisPass, Generic[T]):
+    def __init__(
+        self,
+        name: str,
+        requires: list[str],
+        func: AnalysisSignature[T],
+    ) -> None:
+        self._name = name
+        self._requires = requires
+        self._func = func
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def requires(self) -> list[str]:
+        return self._requires
+
+    def __repr__(self) -> str:
+        return f'FunctionAnalysis(name="{self.name}")'
+
+    @override
+    def run(self, model: Model, cache: AnalysisCache) -> T:
+        return self._func(model, cache)
+
+    def __call__(self, model: Model, cache: AnalysisCache) -> T:
+        return self._func(model, cache)
+
+
+class DynamicMetaAnalysisPass(MetaAnalysisPass, Generic[T]):
+    def __init__(
+        self,
+        name: str,
+        requires: list[str],
+        func: MetaAnalysisSignature[T],
+    ) -> None:
+        self._name = name
+        self._requires = requires
+        self._func = func
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def requires(self) -> list[str]:
+        return self._requires
+
+    def __repr__(self) -> str:
+        return f'FunctionMetaAnalysis(name="{self.name}")'
+
+    @override
+    def run(self, passes: list[BasePass], cache: AnalysisCache) -> T:
+        return self._func(passes, cache)
+
+    def __call__(self, passes: list[BasePass], cache: AnalysisCache) -> T:
+        return self._func(passes, cache)
+
+
+class DynamicTransformationPass(TransformationPass):
+    def __init__(
+        self,
+        name: str,
+        requires: list[str],
+        invalidates: list[str],
+        func: TransformationSignature,
+        backwards: BackwardsSignature,
+    ) -> None:
+        self._name = name
+        self._requires = requires
+        self._invalidates = invalidates
+        self._func = func
+        self._backwards = backwards
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def requires(self) -> list[str]:
+        return self._requires
+
+    @override
+    def run(self, model: Model, cache: AnalysisCache) -> Outcome:
+        return self._func(model, cache)
+
+    @override
+    def backwards(self, solution: Solution, cache: AnalysisCache) -> Solution:
+        return self._backwards(solution, cache)
+
+    def __call__(self, model: Model, cache: AnalysisCache) -> Outcome:
+        return self._func(model, cache)
+
+    def __repr__(self) -> str:
+        return f'FunctionTransformation(name="{self.name}")'
+
+
+def analyse(
+    name: str | None = None, requires: list[str] | None = None
+) -> Callable[[AnalysisSignature[T]], DynamicAnalysisPass[T]]:
+    """Create an AnalysisPass instance from a function.
+
+    Parameters
+    ----------
+    name: str | None
+        The name of the analysis pass. If no name provided, uses the function name.
+    requires: list[str] | None
+        List of required analysis passes (defaults to empty list)
+
+    Returns
+    -------
+    Callable[[Callable[[Model, AnalysisCache], Any]], AnalysisPass]
+        An instance of a dynamically created AnalysisPass subclass
+    """
+    if requires is None:
+        requires = []
+
+    _T = TypeVar("_T")
+
+    def _decorator(
+        func: AnalysisSignature[_T],
+    ) -> DynamicAnalysisPass[_T]:
+        loc_name = name or func.__name__.replace("_", "-")
+
+        return DynamicAnalysisPass(name=loc_name, requires=requires, func=func)
+
+    return _decorator
+
+
+def meta_analyse(
+    name: str | None = None, requires: list[str] | None = None
+) -> Callable[[MetaAnalysisSignature[T]], DynamicMetaAnalysisPass[T]]:
+    """Create an MetaAnalysisPass instance from a function.
+
+    Parameters
+    ----------
+    name: str | None
+        The name of the analysis pass. If no name provided, uses the function name.
+    requires: list[str] | None
+        List of required analysis passes (defaults to empty list)
+
+    Returns
+    -------
+    Callable[[Callable[[list[BasePass], AnalysisCache], Any]], MetaAnalysisPass]
+        An instance of a dynamically created AnalysisPass subclass
+    """
+    if requires is None:
+        requires = []
+
+    _T = TypeVar("_T")
+
+    def _decorator(
+        func: MetaAnalysisSignature[_T],
+    ) -> DynamicMetaAnalysisPass[_T]:
+        loc_name = name or func.__name__.replace("_", "-")
+
+        return DynamicMetaAnalysisPass(name=loc_name, requires=requires, func=func)
+
+    return _decorator
+
+
+def transform(
+    name: str | None = None,
+    requires: list[str] | None = None,
+    invalidates: list[str] | None = None,
+    backwards: BackwardsSignature | None = None,
+) -> Callable[[TransformationSignature], DynamicTransformationPass]:
+    """Create an TransformationPass instance from a function.
+
+    Parameters
+    ----------
+    name: str | None = None
+        The name of the analysis pass. If no name provided, uses the function name.
+    requires: list[str] | None = None
+        List of required analysis passes (defaults to empty list)
+    invalidates: list[str] | None = None
+        List of analysis results to invalidate (defaults to empty list)
+    backwards: BackwardsSignature | None = None,
+        Solution backwards mapping function. If none provided, pass solution upstream
+        without modification.
+
+    Returns
+    -------
+    Callable[[TransformationSignature], DynamicTransformationPass]
+        An instance of a dynamically created TransformationPass subclass
+    """
+    if requires is None:
+        requires = []
+    if invalidates is None:
+        invalidates = []
+
+    if backwards is None:
+        backwards = __identity_backwards
+
+    def _decorator(func: TransformationSignature) -> DynamicTransformationPass:
+        loc_name = name or func.__name__.replace("_", "-")
+
+        return DynamicTransformationPass(
+            name=loc_name,
+            requires=requires,
+            invalidates=invalidates,
+            func=func,
+            backwards=backwards,
+        )
+
+    return _decorator
+
+
+__all__ = ["analyse", "transform"]

luna_quantum/errors.py

@@ -0,0 +1,34 @@
+"""
+Define error types for validation, failures, and runtime evaluation issues.
+
+This module defines the set of custom exception classes used throughout the system
+to handle errors related to model translation, environment management, solution
+evaluation, and sampling.
+
+The exceptions are categorized as follows:
+
+1. **Model Errors**:
+   - Raised when a model does not meet certain structural or semantic requirements,
+     such as being quadratic, unconstrained, or having the correct variable types.
+
+2. **Translation Errors**:
+   - Raised when issues occur during translation between formats, including both
+     model and solution translation failures.
+
+3. **Variable and Constraint Errors**:
+   - Raised when there are issues related to variable creation, lookup, duplication,
+     or constraint naming.
+
+4. **Environment Errors**:
+   - Raised when conflicts or inconsistencies occur in managing active environments,
+     such as having multiple active environments or none at all.
+
+5. **Sampling and Evaluation Errors**:
+   - Raised during post-processing or evaluation of samples, particularly when the
+     sample does not conform to expected formats or contains incompatible data.
+
+These error classes enable precise and meaningful error handling, helping developers
+diagnose and respond to failures consistently and effectively.
+"""
+
+from ._core.errors import *  # type: ignore[reportMissingImports] # noqa: F403