luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

luna_quantum/solve/usecases/model_get_solution_usecase.py

@@ -0,0 +1,59 @@
+from luna_quantum._core import Solution
+from luna_quantum.aqm_overwrites import Model
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.client.schemas.enums.status import StatusEnum
+from luna_quantum.solve.interfaces.usecases.model_get_solutions_usecase_i import (
+    IModelGetSolutionUseCase,
+)
+from luna_quantum.util.log_utils import progress
+
+
+class ModelGetSolutionUseCase(IModelGetSolutionUseCase):
+    """
+    Use case for retrieving solutions of a model.
+
+    Handles the process of interacting with the client to get all solutions
+    for a specific AQ model based on its metadata and associated ID.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        The client responsible for fetching solutions from the external source.
+    """
+
+    client: ILunaSolve
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Loading solution...")
+    def __call__(self, model: Model) -> list[Solution]:
+        """
+        Load solutions of the given Model input.
+
+        This function retrieves and returns a list of ISolution instances for the
+        given Model. If the Model does not have metadata, an empty list is returned.
+
+        Parameters
+        ----------
+        model : Model
+            The input Model object whose associated solutions are to be retrieved.
+
+        Returns
+        -------
+        list[Solution]
+            A list of Solution objects associated with the given Model.
+        """
+        if model.metadata is None:
+            return []
+
+        model_id = model.metadata.id
+
+        solve_jobs = self.client.solve_job.get_all(model_id=model_id)
+
+        # TODO THIS IS SUPER INEFFICIENT  # noqa: FIX002, TD002, TD004
+        return [
+            self.client.solve_job.get_solution(solve_job_id=s.id)
+            for s in solve_jobs
+            if s.status is StatusEnum.DONE
+        ]

luna_quantum/solve/usecases/model_get_solve_jobs_usecase.py

@@ -0,0 +1,62 @@
+from typing import TYPE_CHECKING
+
+from luna_quantum.aqm_overwrites import Model
+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.model_get_solve_jobs_usecase_i import (
+    IModelGetSolveJobUseCase,
+)
+from luna_quantum.util.log_utils import progress
+
+if TYPE_CHECKING:
+    from luna_quantum.client.schemas.solve_job import SolveJobSchema
+
+
+class ModelGetSolveJobsUseCase(IModelGetSolveJobUseCase):
+    """
+    Handle the retrieval of solve jobs for a given Model.
+
+    This class is responsible for interacting with the client to fetch solve jobs
+    related to a given Model. It ensures that the required metadata is present
+    before performing operations with the client.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        The client used to communicate with the solve job backend or service.
+    """
+
+    client: ILunaSolve
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Loading solve job...")
+    def __call__(self, model: Model) -> list[SolveJob]:
+        """
+        Load solve jobs from the given Model instance.
+
+        Fetches and validates all solve jobs associated with the given Model's
+        metadata and returns them as a list of SolveJob objects. If metadata is
+        missing in the Model, an empty list is returned.
+
+        Parameters
+        ----------
+        model : Model
+            The Model instance whose associated solve jobs are to be fetched.
+
+        Returns
+        -------
+        List[SolveJob]
+            A list of SolveJob objects derived from the fetched solve jobs..
+        """
+        if model.metadata is None:
+            return []
+
+        model_id = model.metadata.id
+
+        solutions: list[SolveJobSchema] = self.client.solve_job.get_all(
+            model_id=model_id
+        )
+
+        return [SolveJob.model_validate(s.model_dump()) for s in solutions]

luna_quantum/solve/usecases/model_load_by_id_usecase.py

@@ -0,0 +1,47 @@
+from luna_quantum.aqm_overwrites import Model
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.solve.interfaces.usecases.model_load_by_id_usecase_i import (
+    IModelLoadByIdUseCase,
+)
+from luna_quantum.util.log_utils import progress
+
+
+class ModelLoadByIdUseCase(IModelLoadByIdUseCase):
+    """
+    Load an Model by its identifier.
+
+    This class interacts with a client implementing ILunaSolve to fetch and load
+    model models, providing their metadata and content.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        The client used for fetching the model models.
+    """
+
+    client: ILunaSolve
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Retrieving model...")
+    def __call__(self, model_id: str) -> Model:
+        """
+        Retrieve a Model object based on the given model id.
+
+        This method fetches a model schema using the provided model identifier, converts
+        it to a Model object, and validates its metadata before returning it.
+
+        Parameters
+        ----------
+        model_id : str
+            The unique identifier of the model to retrieve.
+
+        Returns
+        -------
+        Model
+            The retrieved model, with associated metadata validated and populated.
+        """
+        aq_model: Model = self.client.model.get_model(model_id=model_id)
+
+        return aq_model

luna_quantum/solve/usecases/model_load_by_metadata_usecase.py

@@ -0,0 +1,52 @@
+from luna_quantum.aqm_overwrites import Model
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.solve.domain.model_metadata import ModelMetadata
+from luna_quantum.solve.interfaces.usecases.model_load_by_metadata_usecase_i import (
+    IModelLoadByMetadataUseCase,
+)
+from luna_quantum.util.log_utils import progress
+
+
+class ModelLoadByMetadataUseCase(IModelLoadByMetadataUseCase):
+    """
+    Loads an model model using metadata.
+
+    The purpose of this class is to load an model model from a given metadata
+    object using the specified client. It retrieves the model and attaches the metadata
+    to it.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        The client responsible for interacting with the model backend.
+    """
+
+    client: ILunaSolve
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Retrieving model...")
+    def __call__(self, model_metadata: ModelMetadata) -> Model:
+        """
+        Callable to retrieve and update an Model instance.
+
+        This method interacts with the client to fetch an Model based on the
+        provided ModelMetadata, updates the model's metadata, and then returns
+        the updated Model instance.
+
+        Parameters
+        ----------
+        model_metadata : ModelMetadata
+            The metadata object containing the ID and relevant data for fetching
+            the corresponding Model.
+
+        Returns
+        -------
+        Model
+            The fetched and updated Model instance.
+
+        """
+        aq_model: Model = self.client.model.get_model(model_id=model_metadata.id)
+
+        return aq_model

luna_quantum/solve/usecases/model_load_metadata_by_hash_usecase.py

@@ -0,0 +1,51 @@
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.solve.domain.model_metadata import ModelMetadata
+from luna_quantum.solve.interfaces.usecases import (
+    IModelLoadMetadataByHashUseCase,
+)
+from luna_quantum.util.log_utils import progress
+
+
+class ModelLoadMetadataByHashUseCase(IModelLoadMetadataByHashUseCase):
+    """
+    Load metadata for an AQ model using a hash.
+
+    This class interacts with the client to retrieve and validate the metadata
+    of an AQ model by providing its unique hash value.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        The client used to retrieve AQ model metadata.
+    """
+
+    client: ILunaSolve
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Retrieving model metadata...")
+    def __call__(self, model_hash: int) -> ModelMetadata:
+        """
+        Retrieve the metadata for a specific model using its unique hash.
+
+        This callable retrieves the model metadata by communicating with a client
+        based on the provided model hash. It validates the
+        retrieved metadata against the ModelMetadata schema and returns a
+        validated object.
+
+        Parameters
+        ----------
+        model_hash : int
+            The unique hash identifier for the model whose metadata is to be
+            retrieved.
+
+        Returns
+        -------
+        ModelMetadata
+            A validated object containing metadata information about the model.
+
+        """
+        aq_model_schema = self.client.model.get_metadata_by_hash(model_hash=model_hash)
+
+        return ModelMetadata.model_validate(aq_model_schema.model_dump())

luna_quantum/solve/usecases/model_save_usecase.py

@@ -0,0 +1,63 @@
+from typing import TYPE_CHECKING
+
+from luna_quantum.aqm_overwrites import Model
+from luna_quantum.client.interfaces.services.luna_solve_i import ILunaSolve
+from luna_quantum.solve.domain.model_metadata import ModelMetadata
+from luna_quantum.solve.interfaces.usecases.model_save_usecase_i import (
+    IModelSaveUseCase,
+)
+from luna_quantum.util.log_utils import progress
+
+if TYPE_CHECKING:
+    from luna_quantum.client.schemas.model_metadata import ModelMetadataSchema
+
+
+class ModelSaveUseCase(IModelSaveUseCase):
+    """
+    Represents a use case for saving an Model instance.
+
+    Provides functionality to interface with a client implementation for
+    retrieving or creating model metadata and saving model information. The
+    metadata retrieved is not written to the model instance.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        The client used to perform operations related to saving and retrieving
+        Model metadata, such as fetching metadata by hash or creating new
+        metadata.
+    """
+
+    client: ILunaSolve
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Saving model...")
+    def __call__(self, model: Model) -> ModelMetadata:
+        """
+        Retrieve model metadata, if the model does not exist create and retrieve it.
+
+        This function attempts to fetch the metadata of the given `Model` instance
+        from the model client. If the metadata is not found, the model is saved
+        with the client and the metadata is retrieved again.
+
+        Parameters
+        ----------
+        model : Model
+            The model instance for which metadata is being retrieved or created.
+
+        Returns
+        -------
+        ModelMetadata
+            The validated metadata associated with the given model instance.
+        """
+        metadata: ModelMetadataSchema
+        try:
+            metadata = self.client.model.get_metadata_by_hash(
+                model_hash=model.__hash__()
+            )
+        except Exception:  # TODO(Llewellyn): make more specific to # noqa: FIX002
+            #  Not found exception
+            metadata = self.client.model.create(model=model)
+        return ModelMetadata.model_validate(metadata.model_dump())

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_by_id_usecase.py

@@ -0,0 +1,44 @@
+from typing import TYPE_CHECKING
+
+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_get_by_id_usecase_i import (
+    ISolveJobGetByIdUseCase,
+)
+from luna_quantum.util.log_utils import Logging, progress
+
+if TYPE_CHECKING:
+    from luna_quantum.client.schemas.solve_job import SolveJobSchema
+
+
+class SolveJobGetByIdUseCase(ISolveJobGetByIdUseCase):
+    """
+    Represent an abstract base to retrieve a solve-job by its id.
+
+    This class interacts with a backend client to retrieve a solve job by its id.
+
+    Attributes
+    ----------
+    client : ILunaSolve
+        Client used to retrieve the solve job.
+    """
+
+    client: ILunaSolve
+    logger = Logging.get_logger(__name__)
+
+    def __init__(self, client: ILunaSolve) -> None:
+        self.client = client
+
+    @progress(total=None, desc="Retrieving solve job by id...")
+    def __call__(self, solve_job_id: str) -> SolveJob:
+        """
+        Retive a solve-job by its id.
+
+        Parameters
+        ----------
+        solve_job_id : str
+            The id of the solve-job to retrieve.
+        """
+        solve_job: SolveJobSchema = self.client.solve_job.get(solve_job_id=solve_job_id)
+
+        return SolveJob.model_validate(solve_job.model_dump())