luna-quantum 1.0.8rc2__cp311-cp311-win_amd64.whl → 1.0.8rc4__cp311-cp311-win_amd64.whl

luna_quantum/_utility.py

@@ -0,0 +1,148 @@
+"""Utility module for internals."""
+
+import sys
+
+if sys.version_info < (3, 13):
+    from warnings import warn
+
+    class DeprecationWarning(Warning): ...  # noqa: A001
+
+    class deprecated:  # noqa: N801
+        """Indicate that a class, function or overload is deprecated.
+
+        When this decorator is applied to an object, the type checker
+        will generate a diagnostic on usage of the deprecated object.
+
+        Usage:
+
+            @deprecated("Use B instead")
+            class A:
+                pass
+
+            @deprecated("Use g instead")
+            def f():
+                pass
+
+            @overload
+            @deprecated("int support is deprecated")
+            def g(x: int) -> int: ...
+            @overload
+            def g(x: str) -> int: ...
+
+        The warning specified by *category* will be emitted at runtime
+        on use of deprecated objects. For functions, that happens on calls;
+        for classes, on instantiation and on creation of subclasses.
+        If the *category* is ``None``, no warning is emitted at runtime.
+        The *stacklevel* determines where the
+        warning is emitted. If it is ``1`` (the default), the warning
+        is emitted at the direct caller of the deprecated object; if it
+        is higher, it is emitted further up the stack.
+        Static type checker behavior is not affected by the *category*
+        and *stacklevel* arguments.
+
+        The deprecation message passed to the decorator is saved in the
+        ``__deprecated__`` attribute on the decorated object.
+        If applied to an overload, the decorator
+        must be after the ``@overload`` decorator for the attribute to
+        exist on the overload as returned by ``get_overloads()``.
+
+        See PEP 702 for details.
+
+        """
+
+        def __init__(
+            self,
+            message: str,
+            /,
+            *,
+            category: type[Warning] | None = DeprecationWarning,  # noqa: PYI011,RUF100
+            stacklevel: int = 1,
+        ) -> None:
+            if not isinstance(message, str):
+                raise TypeError(  # noqa: TRY003
+                    f"Expected an object of type str for 'message', not {type(message).__name__!r}"  # noqa: E501
+                )
+            self.message = message
+            self.category = category
+            self.stacklevel = stacklevel
+
+        def __call__(self, arg, /):  # noqa: C901,ANN001,ANN204
+            # Make sure the inner functions created below don't
+            # retain a reference to self.
+            msg = self.message
+            category = self.category
+            stacklevel = self.stacklevel
+            if category is None:
+                arg.__deprecated__ = msg
+                return arg
+            elif isinstance(arg, type):  # noqa: RET505
+                import functools  # noqa: PLC0415
+                from types import MethodType  # noqa: PLC0415
+
+                original_new = arg.__new__
+
+                @functools.wraps(original_new)
+                def __new__(cls, /, *args, **kwargs):  # noqa: N807,ANN001,ANN202,ANN003,ANN002
+                    if cls is arg:
+                        warn(msg, category=category, stacklevel=stacklevel + 1)
+                    if original_new is not object.__new__:
+                        return original_new(cls, *args, **kwargs)
+                    # Mirrors a similar check in object.__new__.
+                    elif cls.__init__ is object.__init__ and (args or kwargs):  # noqa: RET505
+                        raise TypeError(f"{cls.__name__}() takes no arguments")  # noqa: TRY003
+                    else:
+                        return original_new(cls)
+
+                arg.__new__ = staticmethod(__new__)
+
+                original_init_subclass = arg.__init_subclass__
+                # We need slightly different behavior if __init_subclass__
+                # is a bound method (likely if it was implemented in Python)
+                if isinstance(original_init_subclass, MethodType):
+                    original_init_subclass = original_init_subclass.__func__
+
+                    @functools.wraps(original_init_subclass)
+                    def __init_subclass__(*args, **kwargs):  # noqa: ANN002,ANN202,ANN003,N807
+                        warn(msg, category=category, stacklevel=stacklevel + 1)
+                        return original_init_subclass(*args, **kwargs)
+
+                    arg.__init_subclass__ = classmethod(__init_subclass__)
+                # Or otherwise, which likely means it's a builtin such as
+                # object's implementation of __init_subclass__.
+                else:
+
+                    @functools.wraps(original_init_subclass)
+                    def __init_subclass__(*args, **kwargs):  # noqa: ANN202,ANN002,ANN003,N807
+                        warn(msg, category=category, stacklevel=stacklevel + 1)
+                        return original_init_subclass(*args, **kwargs)
+
+                    arg.__init_subclass__ = __init_subclass__
+
+                arg.__deprecated__ = __new__.__deprecated__ = msg
+                __init_subclass__.__deprecated__ = msg
+                return arg
+            elif callable(arg):
+                import functools  # noqa: PLC0415
+                import inspect  # noqa: PLC0415
+
+                @functools.wraps(arg)
+                def wrapper(*args, **kwargs):  # noqa: ANN002,ANN003,ANN202
+                    warn(msg, category=category, stacklevel=stacklevel + 1)
+                    return arg(*args, **kwargs)
+
+                if inspect.iscoroutinefunction(arg):
+                    wrapper = inspect.markcoroutinefunction(wrapper)
+
+                arg.__deprecated__ = wrapper.__deprecated__ = msg
+                return wrapper
+            else:
+                raise TypeError(  # noqa: TRY003
+                    "@deprecated decorator with non-None category must be applied to "
+                    f"a class or callable, not {arg!r}"
+                )
+
+else:
+    from warnings import deprecated
+
+
+__all__ = ["deprecated"]

luna_quantum/_utility.pyi

@@ -0,0 +1,20 @@
+import sys
+
+if sys.version_info < (3, 13):  # noqa: PYI066
+    class DeprecationWarning(Warning): ...  # noqa: A001
+
+    class deprecated:  # noqa: N801
+        def __init__(
+            self,
+            message: str,
+            /,
+            *,
+            category: type[Warning] | None = ...,
+            stacklevel: int = 1,
+        ) -> None: ...
+        def __call__(self, arg, /): ...  # noqa: ANN001,ANN204
+
+else:
+    from warnings import deprecated
+
+__all__ = ["deprecated"]

luna_quantum/exceptions/luna_quantum_call_type_error.py

@@ -0,0 +1,9 @@
+from luna_quantum.client.schemas.enums.call_style import CallStyle
+from luna_quantum.exceptions.base_luna_quantum_error import BaseLunaQuantumError
+
+
+class LunaQuantumCallStyleError(BaseLunaQuantumError):
+    """Luna Quantum call style error."""
+
+    def __init__(self, call_style: CallStyle) -> None:
+        super().__init__(f"The call style '{call_style}' is not supported.")

luna_quantum/factories/usecase_factory.py

@@ -3,6 +3,7 @@ from typing import ClassVar
 from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
 from luna_quantum.solve.interfaces.usecases import (
     IModelLoadMetadataByHashUseCase,
+    ISolveJobGetByIdUseCase,
 )
 from luna_quantum.solve.interfaces.usecases.model_delete_usecase_i import (
     IModelDeleteUseCase,
@@ -64,6 +65,7 @@ class UseCaseFactory:
     _solve_job_delete_class: ClassVar[type[ISolveJobDeleteUseCase]]
     _solve_job_get_result_class: ClassVar[type[ISolveJobGetResultUseCase]]
     _solve_job_fetch_updates_class: ClassVar[type[ISolveJobFetchUpdatesUseCase]]
+    _solve_job_get_by_id_class: ClassVar[type[ISolveJobGetByIdUseCase]]
 
     @classmethod
     def set_model_fetch_class(
@@ -232,6 +234,19 @@ class UseCaseFactory:
         """
         cls._solve_job_fetch_updates_class = solve_job_fetch_updates_class
 
+    @classmethod
+    def set_solve_job_get_id_class(
+        cls, solve_job_get_by_id_class: type[ISolveJobGetByIdUseCase]
+    ) -> None:
+        """Set the implementation class for fetching solve job updates.
+
+        Parameters
+        ----------
+        solve_job_get_by_id_class : Type[ISolveJobGetByIdUseCase]
+            The class implementing ISolveJobGetByIdUseCase
+        """
+        cls._solve_job_get_by_id_class = solve_job_get_by_id_class
+
     @classmethod
     def model_load_by_id(cls, client: ILunaSolve) -> IModelLoadByIdUseCase:
         """
@@ -437,6 +452,23 @@ class UseCaseFactory:
         """
         return cls._solve_job_fetch_updates_class(client=client)
 
+    @classmethod
+    def solve_job_get_by_id(cls, client: ILunaSolve) -> ISolveJobGetByIdUseCase:
+        """
+        Get the use-case to retrieve a solve-job by its id.
+
+        Parameters
+        ----------
+        client : ILunaSolve
+            The client used to retrieve a solve-job.
+
+        Returns
+        -------
+        ISolveJobGetByIdUseCase
+            An instance of the class responsible for retrieving a solve job by its id.
+        """
+        return cls._solve_job_get_by_id_class(client=client)
+
     @classmethod
     def model_load_metadata_by_hash(
         cls, client: ILunaSolve

luna_quantum/solve/domain/solve_job.py

@@ -1,18 +1,23 @@
-from logging import Logger
-from typing import Any, ClassVar, Literal
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
 from pydantic import BaseModel, PrivateAttr
 
-from luna_quantum._core import Solution
-from luna_quantum.aqm_overwrites.model import Model
-from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
 from luna_quantum.client.schemas.enums.call_style import CallStyle
-from luna_quantum.client.schemas.enums.model_format import ModelFormat
-from luna_quantum.client.schemas.enums.status import StatusEnum
-from luna_quantum.client.schemas.wrappers import PydanticDatetimeWrapper
+from luna_quantum.client.schemas.enums.model_format import ModelFormat  # noqa: TC001
+from luna_quantum.client.schemas.enums.status import StatusEnum  # noqa: TC001
+from luna_quantum.client.schemas.wrappers import PydanticDatetimeWrapper  # noqa: TC001
 from luna_quantum.factories.luna_solve_client_factory import LunaSolveClientFactory
 from luna_quantum.util.log_utils import Logging
 
+if TYPE_CHECKING:
+    from logging import Logger
+
+    from luna_quantum._core import Solution
+    from luna_quantum.aqm_overwrites.model import Model
+    from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+
 
 class SolveJob(BaseModel):
     """A model to represent a job for solving model problems."""
@@ -194,3 +199,32 @@ class SolveJob(BaseModel):
         )
 
         UseCaseFactory.solve_job_delete(client=c).__call__(solve_job_id=self.id)
+
+    @staticmethod
+    def get_by_id(solve_job_id: str, client: ILunaSolve | None = None) -> SolveJob:
+        """
+        Retrieve a solve-job by its ID.
+
+        Para>meters
+        ----------
+        solve_job_id: str
+            Get the solve-job id for which a SolveJob should be retrieved.
+        client : Optional[ILunaSolve], optional
+            The client to be used for job deletion. If not provided, a default client
+            is retrieved using `ClientFactory`.
+
+        Returns
+        -------
+        SolveJob
+            The solve-job object.
+
+
+        """
+        c: ILunaSolve = LunaSolveClientFactory.get_client(client)
+        from luna_quantum.factories.usecase_factory import (  # noqa: PLC0415
+            UseCaseFactory,
+        )
+
+        return UseCaseFactory.solve_job_get_by_id(client=c).__call__(
+            solve_job_id=solve_job_id
+        )

luna_quantum/solve/interfaces/usecases/__init__.py

@@ -34,6 +34,9 @@ from .solve_job_delete_usecase_i import (
 from .solve_job_fetch_updates_usecase_i import (
     ISolveJobFetchUpdatesUseCase,
 )
+from .solve_job_get_by_id_usecase_i import (
+    ISolveJobGetByIdUseCase,
+)
 from .solve_job_get_result_usecase_i import (
     ISolveJobGetResultUseCase,
 )
@@ -51,5 +54,6 @@ __all__ = [
     "ISolveJobCreateUseCase",
     "ISolveJobDeleteUseCase",
     "ISolveJobFetchUpdatesUseCase",
+    "ISolveJobGetByIdUseCase",
     "ISolveJobGetResultUseCase",
 ]

luna_quantum/solve/interfaces/usecases/solve_job_get_by_id_usecase_i.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+    from luna_quantum.solve.domain.solve_job import SolveJob
+
+
+class ISolveJobGetByIdUseCase(ABC):
+    """Represent an abstract base to retrieve a solve-job by its id."""
+
+    @abstractmethod
+    def __init__(self, client: ILunaSolve) -> None:
+        pass
+
+    @abstractmethod
+    def __call__(self, solve_job_id: str) -> SolveJob:
+        """
+        Represent an abstract base for callable objects to retrieve solve jobs.
+
+        Parameters
+        ----------
+        solve_job_id : str
+            The id of the solve-job to retrieve.
+        """

luna_quantum/solve/parameters/algorithms/quantum_gate/__init__.py

@@ -1,4 +1,4 @@
-from .flex_qaoa import FlexQAOA
+from .flexqaoa import FlexQAOA
 from .qaoa import QAOA
 from .qaoa_fo import QAOA_FO
 from .vqe import VQE

luna_quantum/solve/parameters/algorithms/quantum_gate/flex_qaoa/__init__.py

@@ -1,26 +1,10 @@
-from .config import AdvancedConfig, XYMixer
-from .flex_qaoa import FlexQAOA
-from .optimizers import (
-    CombinedOptimizerParams,
-    InterpolateOptimizerParams,
-    LinearOptimizerParams,
-)
-from .pipeline import (
-    IndicatorFunctionParams,
-    OneHotParams,
-    PipelineParams,
-    QuadraticPenaltyParams,
-)
+import warnings
 
-__all__ = [
-    "AdvancedConfig",
-    "CombinedOptimizerParams",
-    "FlexQAOA",
-    "IndicatorFunctionParams",
-    "InterpolateOptimizerParams",
-    "LinearOptimizerParams",
-    "OneHotParams",
-    "PipelineParams",
-    "QuadraticPenaltyParams",
-    "XYMixer",
-]
+from luna_quantum.solve.parameters.algorithms.quantum_gate.flexqaoa import *  # noqa: F403
+
+warnings.warn(
+    "The module `flex_qaoa` is deprecated and will be removed in the future. "
+    "Use 'flexqaoa' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

luna_quantum/solve/parameters/algorithms/quantum_gate/flexqaoa/__init__.py

@@ -0,0 +1,29 @@
+from .config import CustomConfig
+from .flexqaoa import FlexQAOA
+from .optimizers import (
+    CombinedOptimizerParams,
+    InterpolateOptimizerParams,
+)
+from .pipeline import (
+    IndicatorFunctionConfig,
+    InequalityToEqualityConfig,
+    PenaltySetting,
+    PipelineParams,
+    QuadraticPenaltyConfig,
+    SetpackingAsOnehotConfig,
+    XYMixerConfig,
+)
+
+__all__ = [
+    "CombinedOptimizerParams",
+    "CustomConfig",
+    "FlexQAOA",
+    "IndicatorFunctionConfig",
+    "InequalityToEqualityConfig",
+    "InterpolateOptimizerParams",
+    "PenaltySetting",
+    "PipelineParams",
+    "QuadraticPenaltyConfig",
+    "SetpackingAsOnehotConfig",
+    "XYMixerConfig",
+]

luna_quantum/solve/parameters/algorithms/quantum_gate/flexqaoa/config.py

@@ -0,0 +1,58 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field, PositiveInt
+
+
+class CustomConfig(BaseModel):
+    """Additional FlexQAOA circuit configuration.
+
+    Attributes
+    ----------
+    max_qubits : PositiveInt | None
+        Maximum number of qubits allowed for the circuit. If `None`, no limit is
+        applied. Default: `None`.
+    minimize_qubits : bool
+        Minimize the number of used qubits in the circuit if set to `True`. Otherwise,
+        minimize circuit depth. Default: `False`.
+    wstate : Literal["log", "bilinear", "linear"]
+        WState generation cricuit. Choice between:
+
+        - `"log"`: Logarithmic-depth binary tree circuit.
+        - `"linear"`: Linear circuit construction.
+        - `"bilinear"`: Bi-linear circuit construction, starts in the middle and
+                        linearly constructs the circuit outwards.
+
+        Default: `"log"`
+    qft_synth : Literal["line", "full"]
+        QFT synthesis method. Choice between:
+
+        - `"full"`: Shorter circuit depth implementation that requires all-to-all
+                    connectivity.
+        - `"line"`: Longer circuit depth implementation that requires linear
+                    connectivity.
+
+        Default: `"full"`
+    """
+
+    max_qubits: PositiveInt | None = Field(
+        default=None,
+        description="Maximum number of qubits allowed for the circuit. If `None`, no "
+        "limit is applied.",
+    )
+    minimize_qubits: bool = Field(
+        default=False,
+        description="Minimize the number of used qubits in the circuit "
+        "if set to `True`. Otherwise, minimize circuit depth.",
+    )
+    wstate: Literal["log", "bilinear", "linear"] = Field(
+        default="log",
+        description="WState generation cricuit. Choice between: Logarithmic-depth (log)"
+        " binary tree circuit and linear or bilinear construction. bilinear places the "
+        "start in the middle and linearly constructs the circuit outwards.",
+    )
+    qft_synth: Literal["line", "full"] = Field(
+        default="full",
+        description="QFT synthesis method. Shorter depth (full) implementation requires"
+        " all-to-all connectivity. Longer (line) implementation requires only linear "
+        "connectivity.",
+    )