orca-sdk 0.0.94__py3-none-any.whl → 0.0.95__py3-none-any.whl

orca_sdk/embedding_model.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from datetime import datetime
-from typing import TYPE_CHECKING, Sequence, cast, overload
+from typing import TYPE_CHECKING, Literal, Sequence, cast, overload
 
 from ._generated_api_client.api import (
     create_finetuned_embedding_model,
@@ -24,8 +24,8 @@ from ._generated_api_client.models import (
     PretrainedEmbeddingModelName,
 )
 from ._utils.common import CreateMode, DropMode
-from ._utils.task import TaskStatus, wait_for_task
 from .datasource import Datasource
+from .job import Job, Status
 
 if TYPE_CHECKING:
     from .memoryset import LabeledMemoryset
@@ -79,15 +79,61 @@ class _EmbeddingModel:
         return embeddings if isinstance(value, list) else embeddings[0]
 
 
-class _PretrainedEmbeddingModelMeta(type):
-    def __getattr__(cls, name: str) -> PretrainedEmbeddingModel:
-        if cls != FinetunedEmbeddingModel and name in PretrainedEmbeddingModelName.__members__:
-            return PretrainedEmbeddingModel._get(name)
-        else:
-            raise AttributeError(f"'{cls.__name__}' object has no attribute '{name}'")
+class _ModelDescriptor:
+    """
+    Descriptor for lazily loading embedding models with IDE autocomplete support.
 
+    This class implements the descriptor protocol to provide lazy loading of embedding models
+    while maintaining IDE autocomplete functionality. It delays the actual loading of models
+    until they are accessed, which improves startup performance.
 
-class PretrainedEmbeddingModel(_EmbeddingModel, metaclass=_PretrainedEmbeddingModelMeta):
+    The descriptor pattern works by defining how attribute access is handled. When a class
+    attribute using this descriptor is accessed, the __get__ method is called, which then
+    retrieves or initializes the actual model on first access.
+    """
+
+    def __init__(self, name: str):
+        """
+        Initialize a model descriptor.
+
+        Args:
+            name: The name of the embedding model in PretrainedEmbeddingModelName
+        """
+        self.name = name
+        self.model = None  # Model is loaded lazily on first access
+
+    def __get__(self, instance, owner_class):
+        """
+        Descriptor protocol method called when the attribute is accessed.
+
+        This method implements lazy loading - the actual model is only initialized
+        the first time it's accessed. Subsequent accesses will use the cached model.
+
+        Args:
+            instance: The instance the attribute was accessed from, or None if accessed from the class
+            owner_class: The class that owns the descriptor
+
+        Returns:
+            The initialized embedding model
+
+        Raises:
+            AttributeError: If no model with the given name exists
+        """
+        # When accessed from an instance, redirect to class access
+        if instance is not None:
+            return self.__get__(None, owner_class)
+
+        # Load the model on first access
+        if self.model is None:
+            try:
+                self.model = PretrainedEmbeddingModel._get(self.name)
+            except (KeyError, AttributeError):
+                raise AttributeError(f"No embedding model named {self.name}")
+
+        return self.model
+
+
+class PretrainedEmbeddingModel(_EmbeddingModel):
     """
     A pretrained embedding model
 
@@ -102,6 +148,11 @@ class PretrainedEmbeddingModel(_EmbeddingModel, metaclass=_PretrainedEmbeddingMo
     - **`GTE_BASE`**: Alibaba's GTE model from Hugging Face ([Alibaba-NLP/gte-base-en-v1.5](https://huggingface.co/Alibaba-NLP/gte-base-en-v1.5))
     - **`DISTILBERT`**: DistilBERT embedding model from Hugging Face ([distilbert-base-uncased](https://huggingface.co/distilbert-base-uncased))
     - **`GTE_SMALL`**: GTE-Small embedding model from Hugging Face ([Supabase/gte-small](https://huggingface.co/Supabase/gte-small))
+    - **`E5_LARGE`**: E5-Large instruction-tuned embedding model from Hugging Face ([intfloat/multilingual-e5-large-instruct](https://huggingface.co/intfloat/multilingual-e5-large-instruct))
+    - **`GIST_LARGE`**: GIST-Large embedding model from Hugging Face ([avsolatorio/GIST-large-Embedding-v0](https://huggingface.co/avsolatorio/GIST-large-Embedding-v0))
+    - **`MXBAI_LARGE`**: Mixbreas's Large embedding model from Hugging Face ([mixedbread-ai/mxbai-embed-large-v1](https://huggingface.co/mixedbread-ai/mxbai-embed-large-v1))
+    - **`QWEN2_1_5B`**: Alibaba's Qwen2-1.5B instruction-tuned embedding model from Hugging Face ([Alibaba-NLP/gte-Qwen2-1.5B-instruct](https://huggingface.co/Alibaba-NLP/gte-Qwen2-1.5B-instruct))
+
 
     Examples:
         >>> PretrainedEmbeddingModel.CDE_SMALL
@@ -114,6 +165,17 @@ class PretrainedEmbeddingModel(_EmbeddingModel, metaclass=_PretrainedEmbeddingMo
         uses_context: Whether the pretrained embedding model uses context
     """
 
+    # Define descriptors for model access with IDE autocomplete
+    CDE_SMALL = _ModelDescriptor("CDE_SMALL")
+    CLIP_BASE = _ModelDescriptor("CLIP_BASE")
+    GTE_BASE = _ModelDescriptor("GTE_BASE")
+    DISTILBERT = _ModelDescriptor("DISTILBERT")
+    GTE_SMALL = _ModelDescriptor("GTE_SMALL")
+    E5_LARGE = _ModelDescriptor("E5_LARGE")
+    GIST_LARGE = _ModelDescriptor("GIST_LARGE")
+    MXBAI_LARGE = _ModelDescriptor("MXBAI_LARGE")
+    QWEN2_1_5B = _ModelDescriptor("QWEN2_1_5B")
+
     _model_name: PretrainedEmbeddingModelName
 
     def __init__(self, metadata: PretrainedEmbeddingModelMetadata):
@@ -151,6 +213,29 @@ class PretrainedEmbeddingModel(_EmbeddingModel, metaclass=_PretrainedEmbeddingMo
             cls._instances[str(name)] = cls(get_pretrained_embedding_model(cast(PretrainedEmbeddingModelName, name)))
         return cls._instances[str(name)]
 
+    @classmethod
+    def open(cls, name: str) -> PretrainedEmbeddingModel:
+        """
+        Open an embedding model by name.
+
+        This is an alternative method to access models for environments
+        where IDE autocomplete for model names is not available.
+
+        Params:
+            name: Name of the model to open (e.g., "GTE_BASE", "CLIP_BASE")
+
+        Returns:
+            The embedding model instance
+
+        Examples:
+            >>> model = PretrainedEmbeddingModel.open("GTE_BASE")
+        """
+        try:
+            # Use getattr to access the descriptor which will initialize the model
+            return getattr(cls, name)
+        except AttributeError:
+            raise ValueError(f"Unknown model name: {name}")
+
     @classmethod
     def exists(cls, name: str) -> bool:
         """
@@ -164,6 +249,23 @@ class PretrainedEmbeddingModel(_EmbeddingModel, metaclass=_PretrainedEmbeddingMo
         """
         return name in PretrainedEmbeddingModelName
 
+    @overload
+    def finetune(
+        self,
+        name: str,
+        train_datasource: Datasource | LabeledMemoryset,
+        *,
+        eval_datasource: Datasource | None = None,
+        label_column: str = "label",
+        value_column: str = "value",
+        training_method: EmbeddingFinetuningMethod | str = EmbeddingFinetuningMethod.CLASSIFICATION,
+        training_args: dict | None = None,
+        if_exists: CreateMode = "error",
+        background: Literal[True],
+    ) -> Job[FinetunedEmbeddingModel]:
+        pass
+
+    @overload
     def finetune(
         self,
         name: str,
@@ -175,7 +277,23 @@ class PretrainedEmbeddingModel(_EmbeddingModel, metaclass=_PretrainedEmbeddingMo
         training_method: EmbeddingFinetuningMethod | str = EmbeddingFinetuningMethod.CLASSIFICATION,
         training_args: dict | None = None,
         if_exists: CreateMode = "error",
+        background: Literal[False] = False,
     ) -> FinetunedEmbeddingModel:
+        pass
+
+    def finetune(
+        self,
+        name: str,
+        train_datasource: Datasource | LabeledMemoryset,
+        *,
+        eval_datasource: Datasource | None = None,
+        label_column: str = "label",
+        value_column: str = "value",
+        training_method: EmbeddingFinetuningMethod | str = EmbeddingFinetuningMethod.CLASSIFICATION,
+        training_args: dict | None = None,
+        if_exists: CreateMode = "error",
+        background: bool = False,
+    ) -> FinetunedEmbeddingModel | Job[FinetunedEmbeddingModel]:
         """
         Finetune an embedding model
 
@@ -190,6 +308,7 @@ class PretrainedEmbeddingModel(_EmbeddingModel, metaclass=_PretrainedEmbeddingMo
                 If not provided, reasonable training arguments will be used for the specified training method
             if_exists: What to do if a finetuned embedding model with the same name already exists, defaults to
                 `"error"`. Other option is `"open"` to open the existing finetuned embedding model.
+            background: Whether to run the operation in the background and return a job handle
 
         Returns:
             The finetuned embedding model
@@ -233,8 +352,11 @@ class PretrainedEmbeddingModel(_EmbeddingModel, metaclass=_PretrainedEmbeddingMo
                 training_args=(FinetuneEmbeddingModelRequestTrainingArgs.from_dict(training_args or {})),
             ),
         )
-        wait_for_task(res.finetuning_task_id, description="Finetuning embedding model")
-        return FinetunedEmbeddingModel.open(res.id)
+        job = Job(
+            res.finetuning_task_id,
+            lambda: FinetunedEmbeddingModel.open(res.id),
+        )
+        return job if background else job.result()
 
 
 class FinetunedEmbeddingModel(_EmbeddingModel):
@@ -254,7 +376,7 @@ class FinetunedEmbeddingModel(_EmbeddingModel):
     id: str
     created_at: datetime
     updated_at: datetime
-    _status: TaskStatus
+    _status: Status
 
     def __init__(self, metadata: FinetunedEmbeddingModelMetadata):
         # for internal use only, do not document
@@ -262,7 +384,7 @@ class FinetunedEmbeddingModel(_EmbeddingModel):
         self.created_at = metadata.created_at
         self.updated_at = metadata.updated_at
         self.base_model_name = metadata.base_model
-        self._status = metadata.finetuning_status
+        self._status = Status(metadata.finetuning_status.value)
         super().__init__(
             name=metadata.name,
             embedding_dim=metadata.embedding_dim,
@@ -344,6 +466,6 @@ class FinetunedEmbeddingModel(_EmbeddingModel):
         """
         try:
             delete_finetuned_embedding_model(name_or_id)
-        except LookupError:
+        except (LookupError, RuntimeError):
             if if_not_exists == "error":
                 raise

orca_sdk/embedding_model_test.py

@@ -1,3 +1,4 @@
+import logging
 from uuid import uuid4
 
 import pytest
@@ -7,8 +8,8 @@ from .embedding_model import (
     FinetunedEmbeddingModel,
     PretrainedEmbeddingModel,
     PretrainedEmbeddingModelName,
-    TaskStatus,
 )
+from .job import Status
 from .memoryset import LabeledMemoryset
 
 
@@ -34,8 +35,11 @@ def test_open_pretrained_model_not_found():
 
 def test_all_pretrained_models():
     models = PretrainedEmbeddingModel.all()
-    assert len(models) == len(PretrainedEmbeddingModelName)
-    assert all(m.name in PretrainedEmbeddingModelName.__members__ for m in models)
+    assert len(models) > 1
+    if len(models) != len(PretrainedEmbeddingModelName):
+        logging.warning("Please regenerate the SDK client! Some pretrained model names are not exposed yet.")
+    model_names = [m.name for m in models]
+    assert all(enum_member in model_names for enum_member in PretrainedEmbeddingModelName.__members__)
 
 
 def test_embed_text():
@@ -62,7 +66,7 @@ def test_finetune_model_with_datasource(finetuned_model: FinetunedEmbeddingModel
     assert finetuned_model.base_model == PretrainedEmbeddingModel.DISTILBERT
     assert finetuned_model.embedding_dim == 768
     assert finetuned_model.max_seq_length == 512
-    assert finetuned_model._status == TaskStatus.COMPLETED
+    assert finetuned_model._status == Status.COMPLETED
 
 
 def test_finetune_model_with_memoryset(readonly_memoryset: LabeledMemoryset):
@@ -74,7 +78,7 @@ def test_finetune_model_with_memoryset(readonly_memoryset: LabeledMemoryset):
     assert finetuned_model.base_model == PretrainedEmbeddingModel.DISTILBERT
     assert finetuned_model.embedding_dim == 768
     assert finetuned_model.max_seq_length == 512
-    assert finetuned_model._status == TaskStatus.COMPLETED
+    assert finetuned_model._status == Status.COMPLETED
 
 
 def test_finetune_model_already_exists_error(datasource: Datasource, finetuned_model):
@@ -96,7 +100,7 @@ def test_finetune_model_already_exists_return(datasource: Datasource, finetuned_
     assert new_model.base_model == PretrainedEmbeddingModel.DISTILBERT
     assert new_model.embedding_dim == 768
     assert new_model.max_seq_length == 512
-    assert new_model._status == TaskStatus.COMPLETED
+    assert new_model._status == Status.COMPLETED
 
 
 def test_finetune_model_unauthenticated(unauthenticated, datasource: Datasource):

orca_sdk/job.py

@@ -0,0 +1,329 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import Callable, Generic, TypedDict, TypeVar, cast
+
+from tqdm.auto import tqdm
+
+from ._generated_api_client.api import abort_task, get_task, get_task_status, list_tasks
+from ._generated_api_client.models import TaskStatus
+
+
+class JobConfig(TypedDict):
+    refresh_interval: int
+    show_progress: bool
+    max_wait: int
+
+
+class Status(Enum):
+    """Status of a cloud job in the task queue"""
+
+    # the INITIALIZED state should never be returned by the API
+
+    DISPATCHED = "DISPATCHED"
+    """The job has been queued and is waiting to be processed"""
+
+    PROCESSING = "PROCESSING"
+    """The job is being processed"""
+
+    COMPLETED = "COMPLETED"
+    """The job has been completed successfully"""
+
+    FAILED = "FAILED"
+    """The job has failed"""
+
+    ABORTING = "ABORTING"
+    """The job is being aborted"""
+
+    ABORTED = "ABORTED"
+    """The job has been aborted"""
+
+
+TResult = TypeVar("TResult")
+
+
+class Job(Generic[TResult]):
+    """
+    Handle to a job that is run in the OrcaCloud
+
+    Attributes:
+        id: Unique identifier for the job
+        type: Type of the job
+        status: Current status of the job
+        steps_total: Total number of steps in the job, present if the job started processing
+        steps_completed: Number of steps completed in the job, present if the job started processing
+        completion: Percentage of the job that has been completed, present if the job started processing
+        exception: Exception that occurred during the job, present if the status is `FAILED`
+        value: Value of the result of the job, present if the status is `COMPLETED`
+        created_at: When the job was queued for processing
+        updated_at: When the job was last updated
+        refreshed_at: When the job status was last refreshed
+
+    Note:
+        Accessing status and related attributes will refresh the job status in the background.
+    """
+
+    id: str
+    type: str
+    status: Status
+    steps_total: int | None
+    steps_completed: int | None
+    exception: str | None
+    value: TResult | None
+    updated_at: datetime
+    created_at: datetime
+    refreshed_at: datetime
+
+    @property
+    def completion(self) -> float:
+        """
+        Percentage of the job that has been completed, present if the job started processing
+        """
+        return (self.steps_completed or 0) / self.steps_total if self.steps_total is not None else 0
+
+    # Global configuration for all jobs
+    config: JobConfig = {
+        "refresh_interval": 3,
+        "show_progress": True,
+        "max_wait": 60 * 60,
+    }
+
+    def __repr__(self) -> str:
+        return "Job({" + f" type: {self.type}, status: {self.status}, completion: {self.completion:.0%} " + "})"
+
+    @classmethod
+    def set_config(
+        cls, *, refresh_interval: int | None = None, show_progress: bool | None = None, max_wait: int | None = None
+    ):
+        """
+        Set global configuration for running jobs
+
+        Args:
+            refresh_interval: Time to wait between polling the job status in seconds, default is 3
+            show_progress: Whether to show a progress bar when calling the wait method, default is True
+            max_wait: Maximum time to wait for the job to complete in seconds, default is 1 hour
+        """
+        if refresh_interval is not None:
+            cls.config["refresh_interval"] = refresh_interval
+        if show_progress is not None:
+            cls.config["show_progress"] = show_progress
+        if max_wait is not None:
+            cls.config["max_wait"] = max_wait
+
+    @classmethod
+    def query(
+        cls,
+        status: Status | list[Status] | None = None,
+        type: str | list[str] | None = None,
+        limit: int | None = None,
+        offset: int = 0,
+        start: datetime | None = None,
+        end: datetime | None = None,
+    ) -> list[Job]:
+        """
+        Query the job queue for jobs matching the given filters
+
+        Args:
+            status: Optional status or list of statuses to filter by
+            type: Optional type or list of types to filter by
+            limit: Maximum number of jobs to return
+            offset: Offset into the list of jobs to return
+            start: Optional minimum creation time of the jobs to query for
+            end: Optional maximum creation time of the jobs to query for
+
+        Returns:
+            List of jobs matching the given filters
+        """
+        tasks = list_tasks(
+            status=(
+                [TaskStatus(s.value) for s in status]
+                if isinstance(status, list)
+                else TaskStatus(status.value) if isinstance(status, Status) else None
+            ),
+            type=type,
+            limit=limit,
+            offset=offset,
+            start_timestamp=start,
+            end_timestamp=end,
+        )
+
+        # can't use constructor because it makes an API call, so we construct the objects manually
+        return [
+            (
+                lambda t: (
+                    obj := cls.__new__(cls),
+                    setattr(obj, "id", t.id),
+                    setattr(obj, "type", t.type),
+                    setattr(obj, "status", Status(t.status.value)),
+                    setattr(obj, "steps_total", t.steps_total),
+                    setattr(obj, "steps_completed", t.steps_completed),
+                    setattr(obj, "exception", t.exception),
+                    setattr(obj, "value", cast(TResult, t.result.to_dict()) if t.result is not None else None),
+                    setattr(obj, "updated_at", t.updated_at),
+                    setattr(obj, "created_at", t.created_at),
+                    setattr(obj, "refreshed_at", datetime.now()),
+                    obj,
+                )[-1]
+            )(t)
+            for t in tasks
+        ]
+
+    def __init__(self, id: str, get_value: Callable[[], TResult | None] | None = None):
+        """
+        Create a handle to a job in the job queue
+
+        Args:
+            id: Unique identifier for the job
+            get_value: Optional function to customize how the value is resolved, if not provided the result will be a dict
+        """
+        self.id = id
+        task = get_task(self.id)
+
+        self._get_value = get_value or (
+            lambda: (r := get_task(id).result) and (cast(TResult, r.to_dict()) if r else None)
+        )
+        self.type = task.type
+        self.status = Status(task.status.value)
+        self.steps_total = task.steps_total
+        self.steps_completed = task.steps_completed
+        self.exception = task.exception
+        self.value = (
+            None
+            if task.status != TaskStatus.COMPLETED
+            else (
+                get_value()
+                if get_value is not None
+                else cast(TResult, task.result.to_dict()) if task.result is not None else None
+            )
+        )
+        self.updated_at = task.updated_at
+        self.created_at = task.created_at
+        self.refreshed_at = datetime.now()
+
+    def refresh(self, throttle: float = 0):
+        """
+        Refresh the status and progress of the job
+
+        Params:
+            throttle: Minimum time in seconds between refreshes
+        """
+        current_time = datetime.now()
+        # Skip refresh if last refresh was too recent
+        if (current_time - self.refreshed_at) < timedelta(seconds=throttle):
+            return
+        self.refreshed_at = current_time
+
+        status_info = get_task_status(self.id)
+        self.status = Status(status_info.status.value)
+        if status_info.steps_total is not None:
+            self.steps_total = status_info.steps_total
+        if status_info.steps_completed is not None:
+            self.steps_completed = status_info.steps_completed
+
+        self.exception = status_info.exception
+        self.updated_at = status_info.updated_at
+
+        if status_info.status == TaskStatus.COMPLETED:
+            self.value = self._get_value()
+
+    def __getattribute__(self, name: str):
+        # if the attribute is not immutable, refresh the job if it hasn't been refreshed recently
+        if name in ["status", "updated_at", "steps_total", "steps_completed", "exception", "value"]:
+            self.refresh(self.config["refresh_interval"])
+        return super().__getattribute__(name)
+
+    def wait(
+        self, show_progress: bool | None = None, refresh_interval: int | None = None, max_wait: int | None = None
+    ) -> None:
+        """
+        Block until the job is complete
+
+        Params:
+            show_progress: Show a progress bar while waiting for the job to complete
+            refresh_interval: Polling interval in seconds while waiting for the job to complete
+            max_wait: Maximum time to wait for the job to complete in seconds
+
+        Note:
+            The defaults for the config parameters can be set globally using the
+            [`set_config`][orca_sdk.Job.set_config] method.
+
+            This method will not return the result or raise an exception if the job fails. Call
+            [`result`][orca_sdk.Job.result] instead if you want to get the result.
+
+        Raises:
+            RuntimeError: If the job times out
+        """
+        start_time = time.time()
+        show_progress = show_progress if show_progress is not None else self.config["show_progress"]
+        refresh_interval = refresh_interval if refresh_interval is not None else self.config["refresh_interval"]
+        max_wait = max_wait if max_wait is not None else self.config["max_wait"]
+        pbar = None
+        while True:
+            # setup progress bar if steps total is known
+            if not pbar and self.steps_total is not None and show_progress:
+                desc = " ".join(self.type.split("_")).lower()
+                pbar = tqdm(total=self.steps_total, desc=desc)
+
+            # return if job is complete
+            if self.status in [Status.COMPLETED, Status.FAILED, Status.ABORTED]:
+                if pbar:
+                    pbar.update(self.steps_total - pbar.n)
+                    pbar.close()
+                return
+
+            # raise error if job timed out
+            if (time.time() - start_time) > max_wait:
+                raise RuntimeError(f"Job {self.id} timed out after {max_wait}s")
+
+            # update progress bar
+            if pbar and self.steps_completed is not None:
+                pbar.update(self.steps_completed - pbar.n)
+
+            # sleep before retrying
+            time.sleep(refresh_interval)
+
+    def result(
+        self, show_progress: bool | None = None, refresh_interval: int | None = None, max_wait: int | None = None
+    ) -> TResult:
+        """
+        Block until the job is complete and return the result value
+
+        Params:
+            show_progress: Show a progress bar while waiting for the job to complete
+            refresh_interval: Polling interval in seconds while waiting for the job to complete
+            max_wait: Maximum time to wait for the job to complete in seconds
+
+        Note:
+            The defaults for the config parameters can be set globally using the
+            [`set_config`][orca_sdk.Job.set_config] method.
+
+            This method will raise an exception if the job fails. Use [`wait`][orca_sdk.Job.wait]
+            if you just want to wait for the job to complete without raising errors on failure.
+
+        Returns:
+            The result value of the job
+
+        Raises:
+            RuntimeError: If the job fails or times out
+        """
+        if self.value is not None:
+            return self.value
+        self.wait(show_progress, refresh_interval, max_wait)
+        if self.status != Status.COMPLETED:
+            raise RuntimeError(f"Job failed with exception: {self.exception}")
+        assert self.value is not None
+        return self.value
+
+    def abort(self, show_progress: bool = False, refresh_interval: int = 1, max_wait: int = 20) -> None:
+        """
+        Abort the job
+
+        Params:
+            show_progress: Optionally show a progress bar while waiting for the job to abort
+            refresh_interval: Polling interval in seconds while waiting for the job to abort
+            max_wait: Maximum time to wait for the job to abort in seconds
+        """
+        abort_task(self.id)
+        self.wait(show_progress, refresh_interval, max_wait)

orca_sdk/job_test.py

@@ -0,0 +1,48 @@
+import time
+
+from .classification_model import ClassificationModel
+from .datasource import Datasource
+from .job import Job, Status
+
+
+def test_job_creation(classification_model: ClassificationModel, datasource: Datasource):
+    job = classification_model.evaluate(datasource, background=True)
+    assert job.id is not None
+    assert job.type == "EVALUATE_MODEL"
+    assert job.status in [Status.DISPATCHED, Status.PROCESSING]
+    assert job.created_at is not None
+    assert job.updated_at is not None
+    assert job.refreshed_at is not None
+    assert len(Job.query(limit=5, type="EVALUATE_MODEL")) >= 1
+
+
+def test_job_result(classification_model: ClassificationModel, datasource: Datasource):
+    job = classification_model.evaluate(datasource, background=True)
+    result = job.result(show_progress=False)
+    assert result is not None
+    assert job.status == Status.COMPLETED
+    assert job.steps_completed is not None
+    assert job.steps_completed == job.steps_total
+
+
+def test_job_wait(classification_model: ClassificationModel, datasource: Datasource):
+    job = classification_model.evaluate(datasource, background=True)
+    job.wait(show_progress=False)
+    assert job.status == Status.COMPLETED
+    assert job.steps_completed is not None
+    assert job.steps_completed == job.steps_total
+    assert job.value is not None
+
+
+def test_job_refresh(classification_model: ClassificationModel, datasource: Datasource):
+    job = classification_model.evaluate(datasource, background=True)
+    last_refreshed_at = job.refreshed_at
+    # accessing the status attribute should refresh the job after the refresh interval
+    Job.set_config(refresh_interval=1)
+    time.sleep(1)
+    job.status
+    assert job.refreshed_at > last_refreshed_at
+    last_refreshed_at = job.refreshed_at
+    # calling refresh() should immediately refresh the job
+    job.refresh()
+    assert job.refreshed_at > last_refreshed_at