iqm-station-control-client 3.16.1__py3-none-any.whl → 4.0.0__py3-none-any.whl

iqm/station_control/client/iqm_server/iqm_server_client.py

@@ -41,20 +41,21 @@ from iqm.station_control.client.iqm_server.grpc_utils import (
 )
 from iqm.station_control.client.iqm_server.meta_class import IqmServerClientMeta
 from iqm.station_control.client.list_models import DutFieldDataList, DutList
-from iqm.station_control.client.serializers import deserialize_sweep_results, serialize_sweep_task_request
+from iqm.station_control.client.serializers import deserialize_sweep_results, serialize_sweep_job_request
 from iqm.station_control.client.serializers.channel_property_serializer import unpack_channel_properties
 from iqm.station_control.client.serializers.setting_node_serializer import deserialize_setting_node
-from iqm.station_control.client.serializers.task_serializers import deserialize_sweep_task_request
+from iqm.station_control.client.serializers.task_serializers import deserialize_sweep_job_request
 from iqm.station_control.client.station_control import StationControlClient
 from iqm.station_control.interface.models import (
     DutData,
     DutFieldData,
+    JobStatus,
     Statuses,
     SweepData,
     SweepDefinition,
     SweepResults,
-    SweepStatus,
 )
+from iqm.station_control.interface.models.jobs import JobData, JobResult
 from iqm.station_control.interface.models.sweep import SweepBase
 
 logger = logging.getLogger(__name__)
@@ -112,7 +113,7 @@ class IqmServerClient(StationControlClient, metaclass=IqmServerClientMeta):
                 proto.SubmitJobRequestV1(
                     qc_id=self._current_qc.id,
                     type=proto.JobType.PULSE,
-                    payload=serialize_sweep_task_request(sweep_definition, queue_name="sweeps"),
+                    payload=serialize_sweep_job_request(sweep_definition, queue_name="sweeps"),
                     use_timeslot=self._connection_params.use_timeslot,
                 )
             )
@@ -122,8 +123,7 @@ class IqmServerClient(StationControlClient, metaclass=IqmServerClientMeta):
             job_id = from_proto_uuid(job.id)
             self._latest_submitted_sweep = dataclasses.replace(sweep_definition, sweep_id=job_id)
             return {
-                "sweep_id": str(job_id),
-                "task_id": str(job_id),
+                "job_id": str(job_id),
             }
 
     def get_sweep(self, sweep_id: uuid.UUID) -> SweepData:
@@ -140,7 +140,7 @@ class IqmServerClient(StationControlClient, metaclass=IqmServerClientMeta):
                 modified_timestamp=to_datetime(job.updated_at),
                 begin_timestamp=to_datetime(job.execution_started_at) if job.HasField("execution_started_at") else None,
                 end_timestamp=to_datetime(job.execution_ended_at) if job.HasField("execution_ended_at") else None,
-                sweep_status=to_sweep_status(job.status),
+                job_status=to_job_status(job.status),
                 # Sweep definition is a subclass of SweepBase so we can just copy all SweepBase fields
                 # from the input sweep to the sweep data
                 **{f.name: getattr(sweep, f.name) for f in dataclasses.fields(SweepBase)},
@@ -152,26 +152,28 @@ class IqmServerClient(StationControlClient, metaclass=IqmServerClientMeta):
             data_chunks = jobs.GetJobResultsV1(proto.JobLookupV1(id=to_proto_uuid(sweep_id)))
             return deserialize_sweep_results(load_all(data_chunks))
 
-    def revoke_sweep(self, sweep_id: uuid.UUID) -> None:
+    def abort_job(self, sweep_id: uuid.UUID) -> None:
         with wrap_error("Job cancellation failed"):
             jobs = proto.JobsStub(self._channel)
             jobs.CancelJobV1(proto.JobLookupV1(id=to_proto_uuid(sweep_id)))
 
-    def get_task(self, task_id: uuid.UUID) -> dict:
+    def get_job(self, job_id: uuid.UUID) -> JobData:
         with wrap_error("Job loading failed"):
             jobs = proto.JobsStub(self._channel)
-            job: proto.JobV1 = jobs.GetJobV1(proto.JobLookupV1(id=to_proto_uuid(task_id)))
-            return {
-                # It would be nice to have these typed somewhere...
-                "task_id": str(from_proto_uuid(job.id)),
-                "task_status": to_task_status(job.status),
-                "task_result": {"message": ""},
-                "task_error": job.error if job.HasField("error") else "",
-                "position": job.queue_position if job.HasField("queue_position") else None,
-                "is_position_capped": False,
-            }
+            job: proto.JobV1 = jobs.GetJobV1(proto.JobLookupV1(id=to_proto_uuid(job_id)))
+            return JobData(
+                job_id=from_proto_uuid(job.id),
+                job_status=job.status,
+                job_result=JobResult(
+                    job_id=from_proto_uuid(job.id),
+                    parallel_sweep_progress=[],
+                    interrupted=False,
+                ),
+                job_error=job.error if job.HasField("error") else "",
+                position=job.queue_position if job.HasField("queue_position") else None,
+            )
 
-    def _wait_task_completion(
+    def _wait_job_completion(
         self,
         task_id: str,
         update_progress_callback: Callable[[Statuses], None] | None,
@@ -284,28 +286,28 @@ def parse_calibration_set(cal_set_data: bytes) -> tuple[uuid.UUID, dict[str, Obs
 
 
 def payload_to_sweep(job_payload: bytes) -> SweepDefinition:
-    sweep, _ = deserialize_sweep_task_request(job_payload)
+    sweep, _ = deserialize_sweep_job_request(job_payload)
     return sweep
 
 
-def to_sweep_status(job_status: proto.JobStatus) -> SweepStatus:
+def to_job_status(job_status: proto.JobStatus) -> JobStatus:
     match job_status:
         case proto.JobStatus.IN_QUEUE:
-            return SweepStatus.PENDING
+            return JobStatus.PENDING_EXECUTION
         case proto.JobStatus.EXECUTING:
-            return SweepStatus.PROGRESS
+            return JobStatus.EXECUTION_START
         case proto.JobStatus.FAILED:
-            return SweepStatus.FAILURE
+            return JobStatus.FAILED
         case proto.JobStatus.COMPLETED:
-            return SweepStatus.SUCCESS
+            return JobStatus.READY
         case proto.JobStatus.INTERRUPTED:
-            return SweepStatus.INTERRUPTED
+            return JobStatus.ABORTED
         case proto.JobStatus.CANCELLED:
-            return SweepStatus.REVOKED
+            return JobStatus.ABORTED
     raise ValueError(f"Unknown job status: '{job_status}'")
 
 
-def to_task_status(job_status: proto.JobStatus) -> str:
+def to_string_job_status(job_status: proto.JobStatus) -> str:
     match job_status:
         case proto.JobStatus.IN_QUEUE:
             return "PENDING"

iqm/station_control/client/serializers/__init__.py

@@ -30,6 +30,6 @@ from iqm.station_control.client.serializers.sweep_serializers import (
     serialize_sweep_results,
 )
 from iqm.station_control.client.serializers.task_serializers import (
-    serialize_run_task_request,
-    serialize_sweep_task_request,
+    serialize_run_job_request,
+    serialize_sweep_job_request,
 )

iqm/station_control/client/serializers/sweep_serializers.py

@@ -27,7 +27,8 @@ from exa.common.data.setting_node import SettingNode
 from exa.common.sweep.database_serialization import decode_and_validate_sweeps, encode_nd_sweeps
 from iqm.station_control.client.serializers.datetime_serializers import deserialize_datetime, serialize_datetime
 from iqm.station_control.client.serializers.playlist_serializers import pack_playlist, unpack_playlist
-from iqm.station_control.interface.models import SweepData, SweepDefinition, SweepResults, SweepStatus
+from iqm.station_control.interface.models import SweepData, SweepDefinition, SweepResults
+from iqm.station_control.interface.models.jobs import JobStatus
 
 
 def serialize_sweep_definition(sweep_definition: SweepDefinition) -> SweepDefinitionProto:
@@ -74,7 +75,7 @@ def serialize_sweep_data(sweep_data: SweepData) -> dict:
         "modified_timestamp": serialize_datetime(sweep_data.modified_timestamp),
         "begin_timestamp": serialize_datetime(sweep_data.begin_timestamp),
         "end_timestamp": serialize_datetime(sweep_data.end_timestamp),
-        "sweep_status": sweep_data.sweep_status.value,
+        "job_status": sweep_data.job_status.value,
     }
 
 
@@ -90,7 +91,7 @@ def deserialize_sweep_data(data: dict) -> SweepData:
         modified_timestamp=deserialize_datetime(data["modified_timestamp"]),
         begin_timestamp=deserialize_datetime(data["begin_timestamp"]),
         end_timestamp=deserialize_datetime(data["end_timestamp"]),
-        sweep_status=SweepStatus(data["sweep_status"]),
+        job_status=JobStatus(data["job_status"]),
     )
 
 

iqm/station_control/client/serializers/task_serializers.py

@@ -29,7 +29,7 @@ from iqm.station_control.client.serializers.sweep_serializers import (
 from iqm.station_control.interface.models import RunDefinition, SweepDefinition
 
 
-def serialize_run_task_request(run_definition: RunDefinition, queue_name: str) -> bytes:
+def serialize_run_job_request(run_definition: RunDefinition, queue_name: str) -> bytes:
     """Wrap `run_definition` and `queue_name` into a protobuf message and serialize into a bitstring.
 
     Args:
@@ -42,10 +42,10 @@ def serialize_run_task_request(run_definition: RunDefinition, queue_name: str) -
 
     """
     payload = serialize_run_definition(run_definition)
-    return _serialize_task_request(payload, queue_name, run_definition.sweep_definition.sweep_id)
+    return _serialize_job_request(payload, queue_name, run_definition.sweep_definition.sweep_id)
 
 
-def serialize_sweep_task_request(sweep_definition: SweepDefinition, queue_name: str) -> bytes:
+def serialize_sweep_job_request(sweep_definition: SweepDefinition, queue_name: str) -> bytes:
     """Wrap `sweep_definition` and `queue_name` into a protobuf message and serialize into a bitstring.
 
     Args:
@@ -58,10 +58,16 @@ def serialize_sweep_task_request(sweep_definition: SweepDefinition, queue_name:
 
     """
     payload = serialize_sweep_definition(sweep_definition)
-    return _serialize_task_request(payload, queue_name, sweep_definition.sweep_id)
+    return _serialize_job_request(payload, queue_name, sweep_definition.sweep_id)
 
 
-def deserialize_sweep_task_request(data: bytes) -> tuple[SweepDefinition, str]:
+def _serialize_job_request(payload: Any, queue_name: str, sweep_id: uuid.UUID) -> bytes:
+    sweep_job_request_proto = SweepTaskRequestProto(queue_name=queue_name, sweep_id=str(sweep_id))
+    sweep_job_request_proto.payload.Pack(payload, type_url_prefix="iqm-data-definitions")
+    return sweep_job_request_proto.SerializeToString()
+
+
+def deserialize_sweep_job_request(data: bytes) -> tuple[SweepDefinition, str]:
     """Deserializes `sweep_definition` and `queue_name` from the serialized bitstring.
 
     Args:
@@ -81,9 +87,3 @@ def deserialize_sweep_task_request(data: bytes) -> tuple[SweepDefinition, str]:
     sweep_definition = deserialize_sweep_definition(sweep_definition_proto)
     queue_name = sweep_task_request_proto.queue_name
     return sweep_definition, queue_name
-
-
-def _serialize_task_request(payload: Any, queue_name: str, sweep_id: uuid.UUID) -> bytes:
-    sweep_task_request_proto = SweepTaskRequestProto(queue_name=queue_name, sweep_id=str(sweep_id))
-    sweep_task_request_proto.payload.Pack(payload, type_url_prefix="iqm-data-definitions")
-    return sweep_task_request_proto.SerializeToString()

iqm/station_control/client/station_control.py

@@ -55,8 +55,8 @@ from iqm.station_control.client.list_models import (
 from iqm.station_control.client.serializers import (
     deserialize_run_data,
     deserialize_sweep_results,
-    serialize_run_task_request,
-    serialize_sweep_task_request,
+    serialize_run_job_request,
+    serialize_sweep_job_request,
 )
 from iqm.station_control.client.serializers.channel_property_serializer import unpack_channel_properties
 from iqm.station_control.client.serializers.setting_node_serializer import deserialize_setting_node
@@ -87,6 +87,7 @@ from iqm.station_control.interface.models import (
     SweepDefinition,
     SweepResults,
 )
+from iqm.station_control.interface.models.jobs import JobData, JobStatus
 from iqm.station_control.interface.pydantic_base import PydanticBase
 
 logger = logging.getLogger(__name__)
@@ -277,14 +278,14 @@ class StationControlClient:
             sweep_definition: The content of the sweep to be created.
 
         Returns:
-            Dict containing the task ID  and sweep ID, and corresponding hrefs, of a successful sweep execution
-            in monolithic mode or successful submission to the task queue in remote mode.
+            Dict containing the job ID  and sweep ID, and corresponding hrefs, of a successful sweep execution
+            in monolithic mode or successful submission to the job queue in remote mode.
 
         Raises:
             ExaError if submitting a sweep failed.
 
         """
-        data = serialize_sweep_task_request(sweep_definition, queue_name="sweeps")
+        data = serialize_sweep_job_request(sweep_definition, queue_name="sweeps")
         headers = {"Content-Type": "application/octet-stream"}
         return self._send_request(requests.post, "sweeps", data=data, headers=headers).json()
 
@@ -293,14 +294,13 @@ class StationControlClient:
         response = self._send_request(requests.get, f"sweeps/{sweep_id}")
         return deserialize_sweep_data(response.json())
 
-    def revoke_sweep(self, sweep_id: uuid.UUID) -> None:
-        """Either remove a sweep task from the queue, or abort it gracefully if it's already executing.
+    def abort_job(self, job_id: uuid.UUID) -> None:
+        """Either remove a job from the queue, or abort it gracefully if it's already executing.
 
-        If the task was already executing when revoked, the status of the task will be set to ``"INTERRUPTED"``.
-        If the task had not started yet, the status will be set to ``"REVOKED"``.
-        If the task is not found or is already finished nothing happens.
+        The status of the job will be set to ``JobStatus.ABORTED``.
+        If the job is not found or is already finished nothing happens.
         """
-        self._send_request(requests.post, f"sweeps/{sweep_id}/revoke")
+        self._send_request(requests.post, f"jobs/{job_id}/abort")
 
     def delete_sweep(self, sweep_id: uuid.UUID) -> None:
         """Delete sweep in the database."""
@@ -315,15 +315,15 @@ class StationControlClient:
         self,
         run_definition: RunDefinition,
         update_progress_callback: Callable[[Statuses], None] | None = None,
-        wait_task_completion: bool = True,
+        wait_job_completion: bool = True,
     ) -> bool:
         """Execute an N-dimensional sweep of selected variables and save run, sweep and results."""
-        data = serialize_run_task_request(run_definition, queue_name="sweeps")
+        data = serialize_run_job_request(run_definition, queue_name="sweeps")
 
         headers = {"Content-Type": "application/octet-stream"}
         response = self._send_request(requests.post, "runs", data=data, headers=headers)
-        if wait_task_completion:
-            return self._wait_task_completion(response.json()["task_id"], update_progress_callback)
+        if wait_job_completion:
+            return self._wait_job_completion(response.json()["job_id"], update_progress_callback)
         return False
 
     def get_run(self, run_id: uuid.UUID) -> RunData:
@@ -675,70 +675,62 @@ class StationControlClient:
         response = self._send_request(requests.get, f"sequence-results/{sequence_id}")
         return SequenceResultData.model_validate(response.json())
 
-    def get_task(self, task_id: uuid.UUID) -> dict:
-        """Get task data."""
-        response = self._send_request(requests.get, f"tasks/{task_id}")
+    def get_job(self, job_id: uuid.UUID) -> JobData:
+        """Get job data."""
+        response = self._send_request(requests.get, f"jobs/{job_id}")
         return response.json()
 
-    def _wait_task_completion(self, task_id: str, update_progress_callback: Callable[[Statuses], None] | None) -> bool:
-        logger.info("Celery task ID: %s", task_id)
+    def _wait_job_completion(self, job_id: str, update_progress_callback: Callable[[Statuses], None] | None) -> bool:
+        logger.info("Waiting for job ID: %s", job_id)
         update_progress_callback = update_progress_callback or (lambda status: None)
         try:
-            task_status = self._poll_task_status_while_in_pending(task_id, update_progress_callback)
-            if task_status == "PROGRESS":
-                self._poll_task_status_while_in_progress(task_id, update_progress_callback)
+            job_status = self._poll_job_status_until_execution_start(job_id, update_progress_callback)
+            if JobStatus(job_status) not in JobStatus.terminal_statuses():
+                self._poll_job_status_until_terminal(job_id, update_progress_callback)
         except KeyboardInterrupt as exc:
-            logger.info("Caught %s, revoking task %s", exc, task_id)
-            self._send_request(requests.post, f"tasks/{task_id}/revoke")
+            logger.info("Caught %s, revoking job %s", exc, job_id)
+            self.abort_job(uuid.UUID(job_id))
             return True
         return False
 
-    def _poll_task_status_while_in_pending(
-        self, task_id: str, update_progress_callback: Callable[[Statuses], None]
-    ) -> str:
-        # Keep polling task status as long as it's PENDING, and update progress with `update_progress_callback`.
+    def _poll_job_status_until_execution_start(
+        self, job_id: str, update_progress_callback: Callable[[Statuses], None]
+    ) -> JobStatus:
+        # Keep polling job status as long as it's PENDING, and update progress with `update_progress_callback`.
         max_seen_position = 0
-        was_warned = False
         while True:
-            task = self._poll_task(task_id)
-            if task["task_status"] != "PENDING":
+            job = self._poll_job(job_id)
+            if job["job_status"] >= JobStatus.EXECUTION_START:
                 if max_seen_position:
                     update_progress_callback([("Progress in queue", max_seen_position, max_seen_position)])
-                return task["task_status"]
-            position = task["position"]
+                return job["job_status"]
+            position = job["position"]
+
             if position == 0:
                 sleep(1)
                 continue
             max_seen_position = max(max_seen_position, position)
-            if task["is_position_capped"] and not was_warned:
-                logger.info(
-                    "Over %s tasks before this in queue. Progress will be shown when in top %s.",
-                    max_seen_position,
-                    max_seen_position,
-                )
-                was_warned = True
-            else:
-                update_progress_callback([("Progress in queue", max_seen_position - position, max_seen_position)])
+            update_progress_callback([("Progress in queue", max_seen_position - position, max_seen_position)])
             sleep(1)
 
-    def _poll_task_status_while_in_progress(
+    def _poll_job_status_until_terminal(
         self,
-        task_id: str,
+        job_id: str,
         update_progress_callback: Callable[[Statuses], None],
     ) -> None:
-        # Keep polling task status as long as it's PROGRESS, and update progress with `update_progress_callback`.
+        # Keep polling job status until it finishes, and update progress with `update_progress_callback`.
         while True:
-            task = self._poll_task(task_id)
-            update_progress_callback(task["task_result"].get("parallel_sweep_progress", []))
-            if task["task_status"] != "PROGRESS":
+            job = self._poll_job(job_id)
+            update_progress_callback(job["job_result"].get("parallel_sweep_progress", []))
+            if JobStatus(job["job_status"]) in JobStatus.terminal_statuses():
                 return
             sleep(1)
 
-    def _poll_task(self, task_id: str) -> dict:
-        task = self._send_request(requests.get, f"tasks/{task_id}").json()
-        if task["task_status"] == "FAILURE":
-            raise InternalServerError(f"Task: {task.get('task_id')}\n{task.get('task_error')}")
-        return task
+    def _poll_job(self, job_id: str) -> JobData:
+        job = self._send_request(requests.get, f"jobs/{job_id}").json()
+        if job["job_status"] == JobStatus.FAILED:
+            raise InternalServerError(f"Job: {job.get('job_id')}\n{job.get('job_error')}")
+        return job
 
     def _send_request(
         self, http_method: Callable[..., requests.Response], url_path: str, **kwargs

iqm/station_control/interface/models/__init__.py

@@ -14,6 +14,9 @@
 """Station control interface models."""
 
 from iqm.station_control.interface.models.dut import DutData, DutFieldData
+from iqm.station_control.interface.models.jobs import (
+    JobStatus,
+)
 from iqm.station_control.interface.models.observation import (
     ObservationData,
     ObservationDefinition,
@@ -32,7 +35,7 @@ from iqm.station_control.interface.models.sequence import (
     SequenceResultData,
     SequenceResultDefinition,
 )
-from iqm.station_control.interface.models.sweep import SweepData, SweepDefinition, SweepStatus
+from iqm.station_control.interface.models.sweep import SweepData, SweepDefinition
 from iqm.station_control.interface.models.type_aliases import (
     DutType,
     GetObservationsMode,

iqm/station_control/interface/models/jobs.py

@@ -0,0 +1,125 @@
+# Copyright 2025 IQM
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Job executor artifact and state models."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+import functools
+from uuid import UUID
+
+from iqm.station_control.interface.pydantic_base import PydanticBase
+
+
+class TimelineEntry(PydanticBase):
+    """Status and timestamp pair as described in a job timeline."""
+
+    status: JobStatus
+    timestamp: datetime
+
+
+class JobResult(PydanticBase):
+    """Progress information about a running job."""
+
+    job_id: UUID
+    parallel_sweep_progress: list[tuple[str, int, int]]
+    interrupted: bool
+
+
+class JobData(PydanticBase):
+    """Job response data model"""
+
+    job_id: UUID
+    job_status: JobStatus
+    job_result: JobResult
+    job_error: str | None
+    position: int | None
+
+
+@functools.total_ordering
+class JobStatus(Enum):
+    """Enumeration of different states a job can be in. The ordering of these statuses is important,
+    and execution logic relies on it. Thus if a new status is added, ensure that it is slotted
+    in at the appropriate place. See the __lt__ implementation for further details.
+    """
+
+    # Received by the server
+    RECEIVED = "received"
+
+    # Validating the job
+    VALIDATING = "validating"
+    ACCEPTED = "accepted"
+
+    PREPARING_CALIBRATION = "preparing_calibration"
+
+    # Running PulLA
+    PENDING_COMPILATION = "pending_compilation"
+    COMPILING = "compiling"
+    COMPILED = "compiled"
+
+    # Executing sweep
+    STORING_SWEEP_METADATA = "storing_sweep_metadata"
+    METADATA_STORED = "metadata_stored"
+    PENDING_EXECUTION = "pending_execution"
+    EXECUTION_START = "execution_start"
+    EXECUTION_END = "execution_end"
+    PENDING_POST_PROCESSING = "pending_post_processing"
+    POST_PROCESSING = "post_processing"
+    READY = "ready"
+
+    # Job failed, can happen at any stage
+    FAILED = "failed"
+
+    # Job aborted
+    ABORTED = "aborted"
+
+    def __str__(self):
+        return self.name.lower()
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def __eq__(self, other):
+        if isinstance(other, str):
+            try:
+                other = JobStatus(other.lower())
+            except ValueError:
+                return False
+        elif not isinstance(other, JobStatus):
+            return NotImplemented
+        return self.name == other.name
+
+    def __lt__(self, other):
+        """Enable comparison according to definition order.
+
+        Examples:
+            >>> JobStatus.ACCEPTED < JobStatus.COMPILED
+            True
+
+        """
+        if isinstance(other, str):
+            try:
+                other = JobStatus(other.lower())
+            except ValueError:
+                return NotImplemented
+        elif not isinstance(other, JobStatus):
+            return NotImplemented
+        members = list(JobStatus.__members__.values())
+        return members.index(self) < members.index(other)
+
+    @classmethod
+    def terminal_statuses(cls) -> set[JobStatus]:
+        """Statuses from which the execution can't continue."""
+        return {cls.ABORTED, cls.FAILED, cls.READY}

iqm/station_control/interface/models/monitor.py

@@ -0,0 +1,45 @@
+# Copyright 2024 IQM
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""job executor artifact and state models."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from uuid import UUID
+
+from iqm.station_control.interface.models import JobStatus
+from iqm.station_control.interface.pydantic_base import PydanticBase
+
+
+class JobStateTimestamp(PydanticBase):
+    """Represents a single timestamped state for a job."""
+
+    job_id: UUID
+    status: JobStatus
+    timestamp: datetime
+
+
+class JobsInQueue(PydanticBase):
+    """List of jobs in a particular queue, corresponding to some job state."""
+
+    jobs: list[JobStateTimestamp] = []
+    job_count: int = 0
+
+
+class QueueState(PydanticBase):
+    """Describes the state of a single job queue."""
+
+    queue: JobStatus
+    jobs_in_queue: int
+    completed_jobs: int

iqm/station_control/interface/models/sweep.py

@@ -15,13 +15,13 @@
 
 from dataclasses import dataclass
 from datetime import datetime
-from enum import Enum
 import uuid
 
 from iqm.models.playlist import Playlist
 
 from exa.common.data.setting_node import SettingNode
 from exa.common.sweep.util import NdSweep
+from iqm.station_control.interface.models.jobs import JobStatus
 
 
 @dataclass(kw_only=True)
@@ -50,23 +50,6 @@ class SweepDefinition(SweepBase):
     """A :class:`~iqm.models.playlist.Playlist` that should be uploaded to the controllers."""
 
 
-class SweepStatus(Enum):
-    """Status for sweeps."""
-
-    PENDING = "PENDING"
-    """Sweep waiting for execution or status unknown"""
-    PROGRESS = "PROGRESS"
-    """Sweep is currently being executed"""
-    SUCCESS = "SUCCESS"
-    """Sweep has succeeded, ready for result retrieval"""
-    FAILURE = "FAILURE"
-    """Sweep has failed"""
-    REVOKED = "REVOKED"
-    """Sweep was revoked from execution"""
-    INTERRUPTED = "INTERRUPTED"
-    """Sweep was interrupted during its execution"""
-
-
 @dataclass(kw_only=True)
 class SweepData(SweepBase):
     """The content of the sweep stored in the database."""
@@ -79,5 +62,5 @@ class SweepData(SweepBase):
     """Time when the sweep began in the station control."""
     end_timestamp: datetime | None
     """Time when the sweep ended in the station control."""
-    sweep_status: SweepStatus
+    job_status: JobStatus
     """Status of sweep execution."""

{iqm_station_control_client-3.16.1.dist-info → iqm_station_control_client-4.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-station-control-client
-Version: 3.16.1
+Version: 4.0.0
 Summary: Python client for communicating with Station Control Service
 Author-email: IQM Finland Oy <info@meetiqm.com>
 License: Apache License

{iqm_station_control_client-3.16.1.dist-info → iqm_station_control_client-4.0.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 iqm/station_control/client/__init__.py,sha256=BmBIBdZa10r-IWCFzZ1-0DG6GQKPIXqGXltfXop4ZeQ,942
 iqm/station_control/client/list_models.py,sha256=SjD0DbCrM9z1SSuGoQS83lyJmDLuMOatpJUoW8itW9s,2335
-iqm/station_control/client/station_control.py,sha256=XdYBblHtMJ6H81PC5R9Orazo6gfVS577tfA7e4D-x7I,37900
+iqm/station_control/client/station_control.py,sha256=XMLN3bNklF40N-6N1M-lF4vfG8IouX2qE1ZI_ujH3ck,37474
 iqm/station_control/client/utils.py,sha256=cpS3hXEeeIXeqd_vBnnwo3JHS83FrNpG07SiTUwUx-I,1650
 iqm/station_control/client/iqm_server/__init__.py,sha256=nLsRHN1rnOKXwuzaq_liUpAYV3sis5jkyHccSdacV7U,624
 iqm/station_control/client/iqm_server/error.py,sha256=ZLV2-gxFLHZjZVkI3L5sWcBMiay7NT-ijIEvrXgVJT8,1166
 iqm/station_control/client/iqm_server/grpc_utils.py,sha256=ee42C31_JIXlP6ikZQbohgUQjqCvcSSxIW_9lm9MMV8,5727
-iqm/station_control/client/iqm_server/iqm_server_client.py,sha256=24qQQONpw_9tzoYYtDkYLZLRAxLjk3xI5JAqK6DUCWk,14589
+iqm/station_control/client/iqm_server/iqm_server_client.py,sha256=ZSon3fHpgfAF8M3tymSu9LfVG-LAxDY_ddQhbrR4uAU,14612
 iqm/station_control/client/iqm_server/meta_class.py,sha256=pePJ0Xy0aiJg-bZWK8D87gblq6imfXLsZHjpZkf5D9s,1399
 iqm/station_control/client/iqm_server/proto/__init__.py,sha256=mOJQ_H-NEyJMffRaDSSZeXrScHaHaHEXULv-O_OJA3A,1345
 iqm/station_control/client/iqm_server/proto/calibration_pb2.py,sha256=gum0DGmqxhbfaar8SqahmSif1pB6hgo0pVcnoi3VMUo,3017
@@ -25,28 +25,30 @@ iqm/station_control/client/iqm_server/proto/uuid_pb2.pyi,sha256=9LXcqNoQS1iapCso
 iqm/station_control/client/iqm_server/proto/uuid_pb2_grpc.py,sha256=SF40l84__r-OGGNYBru5ik9gih-XqeTq2iwM5gMN5Qc,726
 iqm/station_control/client/iqm_server/testing/__init__.py,sha256=wCNfJHIR_bqG3ZBlgm55v90Rih7VCpfctoIMfwRMgjk,567
 iqm/station_control/client/iqm_server/testing/iqm_server_mock.py,sha256=X_Chi8TKx95PiuhFfGnRu9LxeIpnKKynW_8tXwxFQD8,3340
-iqm/station_control/client/serializers/__init__.py,sha256=8os3EGOtNTRFaviZdGwDyMt9GUpM3ZP7icPKAxOg1qg,1438
+iqm/station_control/client/serializers/__init__.py,sha256=Hui5SrT4NVeV-27g116ZJgvRQo8ednLMsGpu4V39g1k,1436
 iqm/station_control/client/serializers/channel_property_serializer.py,sha256=ChlX8B-blM5hjv3pUExHOd-vE3O_myPwILu36KZYYNU,7121
 iqm/station_control/client/serializers/datetime_serializers.py,sha256=Ke6VRHa_359xYxXTegs8iweoDfuGeBDgkoOtGBbyC1Q,1122
 iqm/station_control/client/serializers/playlist_serializers.py,sha256=S8RuKdqeJxqUf7_kqTDXIKnuo6g-WpzGY7cesSQa3Rw,18086
 iqm/station_control/client/serializers/run_serializers.py,sha256=4zH0I5EvvaP7wgLMprXXWa36nAPO4Lv0fPkCrDC_v-g,6698
 iqm/station_control/client/serializers/setting_node_serializer.py,sha256=m4Sbm8Qr3GiSNiE-Jh8gFEgfscfN1xxELb0vCa9cK70,1197
 iqm/station_control/client/serializers/struct_serializer.py,sha256=QztBsbRlRG_UrtpQLE3bi0WKEVn48kVB91H1g26PvqQ,3270
-iqm/station_control/client/serializers/sweep_serializers.py,sha256=2COfE3ewusjeIp7q3sQWEpc9nzUrfjMNTeemihtpzKA,5725
-iqm/station_control/client/serializers/task_serializers.py,sha256=m0H2JTxak_eAyl88Ptj7EmJhcAIW5ozPJEVYfZYBIu8,3709
+iqm/station_control/client/serializers/sweep_serializers.py,sha256=pfdr36L6whk6M5koUsQsL61R1WUWiLOgQUHvwIVBUyY,5766
+iqm/station_control/client/serializers/task_serializers.py,sha256=KTd3zdfqr9kSIiEbwsoSNiSu_hxzFfDOlLuttoyBfps,3700
 iqm/station_control/interface/__init__.py,sha256=MIQla-cBKPbZqBkp-LNyPfjiV0gzf-IFEwrMMhsnKlg,785
 iqm/station_control/interface/list_with_meta.py,sha256=GAXIDEXKeua6-2FoQ_O1tkhx-d8pBMGHaIkdvgg-cag,1185
 iqm/station_control/interface/pydantic_base.py,sha256=MVzcsH7wG1DON-qTw6KLpUDay7_b_9CDQgymVzg9HwI,1303
-iqm/station_control/interface/models/__init__.py,sha256=PbENb1YhX2OLGTiJNvj70e5Acj7f8jMP3hp5ncH5U-0,1527
+iqm/station_control/interface/models/__init__.py,sha256=JeXFg-ltPOoSY6qVclUKCVyt-7okNgCptLb3h3t3JD4,1587
 iqm/station_control/interface/models/dut.py,sha256=dd1SpcsBe4P057jvcPqv39SjzekewwP07hThFe5ulNA,1216
+iqm/station_control/interface/models/jobs.py,sha256=nQNyMauQu99LTUK38meVWXSMdX3D-Fgn8VsYDMTwYN8,3611
+iqm/station_control/interface/models/monitor.py,sha256=9p-hg5DWrlbCIrJ0GyQ90DrHr1Yc9DCQyfpsQCm0cDE,1328
 iqm/station_control/interface/models/observation.py,sha256=Jce4lIsUtHRIFT3nr-cbKvh3dbR2Y_yM5x0yyvUdjF8,3261
 iqm/station_control/interface/models/observation_set.py,sha256=Ko2o3-9I38NfjNF2IQPcwfbwpkTQ3PIU7fUiSaDleX8,3031
 iqm/station_control/interface/models/run.py,sha256=m-iE3QMPQUOF7bsw8JCAM1Bd6bDVhAgxrtc_AC7rCkc,4097
 iqm/station_control/interface/models/sequence.py,sha256=uOqMwF1x-vW6UHs2WnPD3PsuSgV3a8OTAsgn_4UENLw,2723
-iqm/station_control/interface/models/sweep.py,sha256=6SQ4Ty4_Rm1KTeR7YfrLmwyD-AnNE495LMxYu8dM4Ko,2947
+iqm/station_control/interface/models/sweep.py,sha256=ZV_1zcEF5_NY0nPgC75tU7s14TE1o0croBSClIVSmCE,2493
 iqm/station_control/interface/models/type_aliases.py,sha256=3LB9viZVi8osavY5kKF8TH1crayG7-MLjgBqXDCqL2s,1018
-iqm_station_control_client-3.16.1.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
-iqm_station_control_client-3.16.1.dist-info/METADATA,sha256=EjhzW71-UsNn_IHGwwsVhLmPK2s1AHlU-X2wGUQQzSE,14010
-iqm_station_control_client-3.16.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_station_control_client-3.16.1.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_station_control_client-3.16.1.dist-info/RECORD,,
+iqm_station_control_client-4.0.0.dist-info/LICENSE.txt,sha256=R6Q7eUrLyoCQgWYorQ8WJmVmWKYU3dxA3jYUp0wwQAw,11332
+iqm_station_control_client-4.0.0.dist-info/METADATA,sha256=P4V5yKTIBLiuLj4UJvlEoBYQmec-eH4iAqNn6UBJysU,14009
+iqm_station_control_client-4.0.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_station_control_client-4.0.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_station_control_client-4.0.0.dist-info/RECORD,,