luna-quantum 1.0.8rc2__cp314-cp314-macosx_11_0_arm64.whl

luna_quantum/solve/usecases/solve_job_cancel_usecase.py

@@ -0,0 +1,51 @@
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.solve.domain.solve_job import SolveJob
+from luna_quantum.solve.interfaces.usecases.solve_job_cancel_usecase_i import (
+    ISolveJobCancelUseCase,
+)
+from luna_quantum.util.log_utils import progress
+from luna_quantum.util.pydantic_utils import PydanticUtils
+
+
+class SolveJobCancelUseCase(ISolveJobCancelUseCase):
+    """
+    Handles the cancellation of a solve job through the provided client.
+
+    This class is responsible for interfacing with the given ILunaSolve client to
+    cancel an existing solve job by utilizing its `solution.cancel` method. It
+    validates and updates the solve job model after the cancellation.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        The client interface responsible for communicating with the backend
+        solve services.
+    """
+
+    client: ILunaSolve
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Canceling solve job...")
+    def __call__(self, solve_job: SolveJob) -> None:
+        """
+        Call method to process a given SolveJob.
+
+        This method interacts with an API client to process cancellation of a solution
+        related to the input SolveJob, updates the SolveJob model, and modifies it
+        using updated data.
+
+        Parameters
+        ----------
+        solve_job : SolveJob
+            The job instance that needs to be processed, updated, and validated.
+
+        Returns
+        -------
+        None
+        """
+        solve_job_schema = self.client.solve_job.cancel(solve_job_id=solve_job.id)
+
+        updated_solve_job = SolveJob.model_validate(solve_job_schema.model_dump())
+        PydanticUtils.update_model(solve_job, updated_solve_job)

luna_quantum/solve/usecases/solve_job_create_usecase.py

@@ -0,0 +1,112 @@
+from typing import TYPE_CHECKING, Any
+
+from luna_quantum.aqm_overwrites.model import Model
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.factories.usecase_factory import UseCaseFactory
+from luna_quantum.solve.domain.abstract.luna_algorithm import LunaAlgorithm
+from luna_quantum.solve.domain.abstract.qpu_token_backend import QpuTokenBackend
+from luna_quantum.solve.domain.solve_job import SolveJob
+from luna_quantum.solve.errors.model_metadata_missing_error import (
+    ModelMetadataMissingError,
+)
+from luna_quantum.solve.interfaces.algorithm_i import BACKEND_TYPE
+from luna_quantum.solve.interfaces.usecases.solve_job_create_usecase_i import (
+    ISolveJobCreateUseCase,
+)
+from luna_quantum.util.log_utils import progress
+
+if TYPE_CHECKING:
+    from luna_quantum.client.schemas.solve_job import SolveJobSchema
+    from luna_quantum.solve.domain.model_metadata import ModelMetadata
+    from luna_quantum.solve.interfaces.usecases import IModelLoadByIdUseCase
+
+
+class SolveJobCreateUseCase(ISolveJobCreateUseCase):
+    """
+    Create a solve job.
+
+    This class is responsible for creating a job through a specified client interface.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        The client implementation used to handle the job creation process.
+    """
+
+    client: ILunaSolve
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Scheduling solve job...")
+    def __call__(
+        self,
+        model: Model | str,
+        luna_solver: LunaAlgorithm[BACKEND_TYPE],
+        backend: BACKEND_TYPE,
+        name: str | None,
+    ) -> SolveJob:
+        """
+        Solve a model using the specified solver.
+
+        The function solves a given model using the provided LunaSolver instance. If a
+        string is given as the model, it fetches the model's metadata using a use-case.
+        If the model metadata is missing, an exception is raised. The function finally
+        creates a solve job using the solver and model information and returns it.
+
+        Parameters
+        ----------
+        model : Union[Model, str]
+            The model to be solved. It can either be an instance of `Model` or a
+            string representing the model ID.
+        luna_solver : LunaAlgorithm
+            The solver to be used for solving the model.
+        name: Optional[str]
+            The name of the solve job. Can be None.
+
+        Returns
+        -------
+        SolveJob
+            The job containing the results of the solving process.
+
+        Raises
+        ------
+        ModelMetadataMissingError
+            Raised when the metadata for the given model is missing.
+        """
+        metadata: ModelMetadata | None
+        if isinstance(model, str):
+            load_uc: IModelLoadByIdUseCase = UseCaseFactory.model_load_by_id(
+                client=self.client
+            )
+            metadata = load_uc(model_id=model).metadata
+        else:
+            model.save_luna(client=self.client)
+            metadata = model.metadata
+
+        if not metadata:
+            raise ModelMetadataMissingError
+
+        if isinstance(model, str):
+            model = Model.load_luna(model_id=model, client=self.client)
+
+        solver_parameters: dict[str, Any] = luna_solver.model_dump()
+        solver_parameters.update(backend.model_dump())
+
+        qpu_tokens = None
+        if isinstance(backend, QpuTokenBackend):
+            qpu_tokens = backend.get_qpu_tokens()
+
+        solve_job: SolveJobSchema = self.client.solve_job.create(
+            model_id=metadata.id,
+            solver_name=luna_solver.algorithm_name,
+            solver_parameters=solver_parameters,
+            provider=backend.provider,
+            qpu_tokens=qpu_tokens,
+            name=name,
+        )
+        sj = SolveJob.model_validate(solve_job.model_dump())
+
+        sj.set_evaluation_model(model)
+
+        return sj

luna_quantum/solve/usecases/solve_job_delete_usecase.py

@@ -0,0 +1,38 @@
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.solve.interfaces.usecases.solve_job_delete_usecase_i import (
+    ISolveJobDeleteUseCase,
+)
+from luna_quantum.util.log_utils import progress
+
+
+class SolveJobDeleteUseCase(ISolveJobDeleteUseCase):
+    """
+    Delete a solve job through the provided client interface.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        Client implementing the `ILunaSolve` interface responsible for interacting
+        with the solve service.
+    """
+
+    client: ILunaSolve
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Deleting solve job...")
+    def __call__(self, solve_job_id: str) -> None:
+        """
+        Delete a solve_job with the specified job ID.
+
+        This callable method is used to delete a solve_job given its unique job
+        identifier.
+
+        Parameters
+        ----------
+        solve_job_id : str
+            The unique identifier of the solve job to be deleted.
+
+        """
+        self.client.solve_job.delete(solve_job_id=solve_job_id)

luna_quantum/solve/usecases/solve_job_fetch_updates_usecase.py

@@ -0,0 +1,49 @@
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.solve.domain.solve_job import SolveJob
+from luna_quantum.solve.interfaces.usecases.solve_job_fetch_updates_usecase_i import (
+    ISolveJobFetchUpdatesUseCase,
+)
+from luna_quantum.util.log_utils import progress
+from luna_quantum.util.pydantic_utils import PydanticUtils
+
+
+class SolveJobFetchUpdatesUseCase(ISolveJobFetchUpdatesUseCase):
+    """
+    Fetches and applies updates to a solve job using a client.
+
+    This class is responsible for retrieving the latest updates for a solve job
+    from the client and applying them to the given solve job instance.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        Client used to fetch updates for solve jobs.
+    """
+
+    client: ILunaSolve
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Fetching solve job...")
+    def __call__(self, solve_job: SolveJob) -> None:
+        """
+        Execute fetch the updates of a specific `SolveJob` instance.
+
+        This callable validates and updates a `SolveJob` instance using data fetched
+        from the client. The fetched data is used to synchronize the job model with
+        the server's definition.
+
+        Parameters
+        ----------
+        solve_job : SolveJob
+            The job to be processed, validated, and updated.
+
+        Returns
+        -------
+        None
+        """
+        solve_job_schema = self.client.solve_job.get(solve_job_id=solve_job.id)
+        solve_job_updated = SolveJob.model_validate(solve_job_schema.model_dump())
+
+        PydanticUtils.update_model(solve_job, solve_job_updated)

luna_quantum/solve/usecases/solve_job_get_result_usecase.py

@@ -0,0 +1,95 @@
+from luna_quantum._core import Solution
+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.status import StatusEnum
+from luna_quantum.solve.domain.solve_job import SolveJob
+from luna_quantum.solve.interfaces.usecases.solve_job_get_result_usecase_i import (
+    ISolveJobGetResultUseCase,
+)
+from luna_quantum.util.active_waiting import ActiveWaiting
+from luna_quantum.util.log_utils import Logging, progress
+
+
+class SolveJobGetResultUseCase(ISolveJobGetResultUseCase):
+    """
+    Handle the process of retrieving and interacting with a solve job's result.
+
+    This class interacts with a backend client to manage fetching and handling
+    results for a solve job, using different strategies for waiting and polling
+    depending on the specified call style.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        Client used to interact with the solve job and retrieve its results.
+    """
+
+    client: ILunaSolve
+    logger = Logging.get_logger(__name__)
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Retrieving solve job...")
+    def __call__(
+        self,
+        solve_job: SolveJob,
+        sleep_time_max: float,
+        sleep_time_increment: float,
+        sleep_time_initial: float,
+        call_style: CallStyle,
+    ) -> Solution | None:
+        """
+        Execute the given solve job with specified waiting strategy.
+
+        Parameters
+        ----------
+        solve_job : SolveJob
+            The job that needs to be solved.
+        sleep_time_max : float
+            The maximum amount of time to wait between checks.
+        sleep_time_increment : float
+            The incremental step to increase sleep time during active waiting.
+        sleep_time_initial : float
+            The initial sleep time for the waiting strategy.
+        call_style : CallStyle
+            The style of waiting (e.g., active waiting) to use when processing the job.
+
+        Returns
+        -------
+        Optional[Solution]
+            The solution for the given solve job if successfully processed, otherwise
+            None.
+        """
+        if call_style is CallStyle.ACTIVE_WAITING:
+            final_states = StatusEnum.CANCELED, StatusEnum.DONE, StatusEnum.FAILED
+
+            ActiveWaiting.run(
+                loop_check=lambda: solve_job.get_status(
+                    client=self.client, status_source="remote"
+                )
+                not in final_states,
+                loop_call=None,
+                sleep_time_max=sleep_time_max,
+                sleep_time_increment=sleep_time_increment,
+                sleep_time_initial=sleep_time_initial,
+            )
+        try:
+            if solve_job.status == StatusEnum.CANCELED:
+                self.logger.warning(
+                    "Solve job is cancelled. Result cannot be retrieved."
+                )
+                return None
+            if solve_job.status == StatusEnum.FAILED:
+                self.logger.error(
+                    f"Solve job failed with the error '{solve_job.error_message}'."
+                )
+                return None
+            aq_solution: Solution = self.client.solve_job.get_solution(
+                solve_job_id=solve_job.id
+            )
+        except Exception:
+            # TODO(Llewellyn) more fine grained exception handling # noqa: FIX002, TD004
+            return None
+
+        return aq_solution

luna_quantum/transformations.py

@@ -0,0 +1,18 @@
+"""Transformations collection.
+
+The `transformations` module provides a collection of transformations for converting
+between various representations of optimization problems and their solutions.
+
+Transformations generally convert between different representations of an optimization
+model. For example, changing the Sense of a model.
+
+Each transformation encapsulates the logic needed for transforming a model to a desired
+output model with changed properties and the logic to convert a solution of the output
+model back to a solution representation matching the input model.
+
+In addition to the predefined transformations contained in this module.
+One can implement their own transformations by implementing the `TransformationPass`
+and `AnalysisPass` abstract classes. See the examples for further details.
+"""
+
+from ._core.transformations import *  # type: ignore[reportMissingImports] # noqa: F403