UncountablePythonSDK 0.0.68__py3-none-any.whl → 0.0.70__py3-none-any.whl

uncountable/integration/executors/generic_upload_executor.py

@@ -165,7 +165,7 @@ def _move_files_post_upload(
     filesystem_session.move_files([*success_file_transfers, *failed_file_transfers])
 
 
-class GenericUploadJob(Job):
+class GenericUploadJob(Job[None]):
     def __init__(
         self,
         data_source: GenericUploadDataSource,
@@ -177,6 +177,10 @@ class GenericUploadJob(Job):
         self.upload_strategy = upload_strategy
         self.data_source = data_source
 
+    @property
+    def payload_type(self) -> type[None]:
+        return type(None)
+
     def _construct_filesystem_session(self, args: JobArguments) -> FileSystemSession:
         match self.data_source:
             case GenericUploadDataSourceSFTP():

uncountable/integration/job.py

@@ -1,58 +1,85 @@
+import functools
+import typing
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 
+from pkgs.argument_parser import CachedParser
 from uncountable.core.async_batch import AsyncBatchProcessor
 from uncountable.core.client import Client
 from uncountable.integration.telemetry import JobLogger
-from uncountable.types import webhook_job_t
+from uncountable.types import base_t, webhook_job_t
 from uncountable.types.job_definition_t import JobDefinition, JobResult, ProfileMetadata
 
 
 @dataclass(kw_only=True)
-class JobArgumentsBase:
+class JobArguments:
     job_definition: JobDefinition
     profile_metadata: ProfileMetadata
     client: Client
     batch_processor: AsyncBatchProcessor
     logger: JobLogger
+    payload: base_t.JsonValue
 
 
-@dataclass(kw_only=True)
-class CronJobArguments(JobArgumentsBase):
-    pass
-
-
-@dataclass(kw_only=True)
-class WebhookJobArguments(JobArgumentsBase):
-    payload: webhook_job_t.WebhookEventBody
+# only for compatibility:
+CronJobArguments = JobArguments
 
 
-JobArguments = CronJobArguments | WebhookJobArguments
+PT = typing.TypeVar("PT")
 
 
-class Job(ABC):
+class Job(ABC, typing.Generic[PT]):
     _unc_job_registered: bool = False
 
+    @property
+    @abstractmethod
+    def payload_type(self) -> type[PT]: ...
+
     @abstractmethod
     def run_outer(self, args: JobArguments) -> JobResult: ...
 
+    @functools.cached_property
+    def _cached_payload_parser(self) -> CachedParser[PT]:
+        return CachedParser(self.payload_type)
+
+    def get_payload(self, payload: base_t.JsonValue) -> PT:
+        return self._cached_payload_parser.parse_storage(payload)
+
 
 class CronJob(Job):
+    @property
+    def payload_type(self) -> type[None]:
+        return type(None)
+
     def run_outer(self, args: JobArguments) -> JobResult:
         assert isinstance(args, CronJobArguments)
         return self.run(args)
 
     @abstractmethod
-    def run(self, args: CronJobArguments) -> JobResult: ...
+    def run(self, args: JobArguments) -> JobResult: ...
+
+
+WPT = typing.TypeVar("WPT")
+
 
+class WebhookJob(Job[webhook_job_t.WebhookEventPayload], typing.Generic[WPT]):
+    @property
+    def payload_type(self) -> type[webhook_job_t.WebhookEventPayload]:
+        return webhook_job_t.WebhookEventPayload
+
+    @property
+    @abstractmethod
+    def webhook_payload_type(self) -> type[WPT]: ...
 
-class WebhookJob(Job):
     def run_outer(self, args: JobArguments) -> JobResult:
-        assert isinstance(args, WebhookJobArguments)
-        return self.run(args)
+        webhook_body = self.get_payload(args.payload)
+        inner_payload = CachedParser(self.webhook_payload_type).parse_api(
+            webhook_body.data
+        )
+        return self.run(args, inner_payload)
 
     @abstractmethod
-    def run(self, args: WebhookJobArguments) -> JobResult: ...
+    def run(self, args: JobArguments, payload: WPT) -> JobResult: ...
 
 
 def register_job(cls: type[Job]) -> type[Job]:

uncountable/integration/queue_runner/command_server/__init__.py

@@ -0,0 +1,24 @@
+from .command_client import check_health, send_job_queue_message
+from .command_server import serve
+from .types import (
+    CommandEnqueueJob,
+    CommandEnqueueJobResponse,
+    CommandQueue,
+    CommandServerBadResponse,
+    CommandServerException,
+    CommandServerTimeout,
+    CommandTask,
+)
+
+__all__: list[str] = [
+    "serve",
+    "check_health",
+    "send_job_queue_message",
+    "CommandEnqueueJob",
+    "CommandEnqueueJobResponse",
+    "CommandTask",
+    "CommandQueue",
+    "CommandServerTimeout",
+    "CommandServerException",
+    "CommandServerBadResponse",
+]

uncountable/integration/queue_runner/command_server/command_client.py

@@ -0,0 +1,68 @@
+from contextlib import contextmanager
+from typing import Generator
+
+import grpc
+import simplejson as json
+
+from pkgs.serialization_util import serialize_for_api
+from uncountable.integration.queue_runner.command_server.protocol.command_server_pb2 import (
+    CheckHealthRequest,
+    CheckHealthResult,
+    EnqueueJobRequest,
+    EnqueueJobResult,
+)
+from uncountable.integration.queue_runner.command_server.types import (
+    CommandServerBadResponse,
+    CommandServerTimeout,
+)
+from uncountable.types import queued_job_t
+
+from .protocol.command_server_pb2_grpc import CommandServerStub
+
+_LOCAL_RPC_HOST = "localhost"
+_DEFAULT_MESSAGE_TIMEOUT_SECS = 2
+
+
+@contextmanager
+def command_server_connection(
+    host: str, port: int
+) -> Generator[CommandServerStub, None, None]:
+    try:
+        with grpc.insecure_channel(f"{host}:{port}") as channel:
+            stub = CommandServerStub(channel)
+            yield stub
+    except grpc._channel._InactiveRpcError as e:
+        raise CommandServerTimeout() from e
+
+
+def send_job_queue_message(
+    *,
+    job_ref_name: str,
+    payload: queued_job_t.QueuedJobPayload,
+    host: str = "localhost",
+    port: int,
+) -> str:
+    with command_server_connection(host=host, port=port) as stub:
+        request = EnqueueJobRequest(
+            job_ref_name=job_ref_name,
+            serialized_payload=json.dumps(serialize_for_api(payload)),
+        )
+
+        response = stub.EnqueueJob(request, timeout=_DEFAULT_MESSAGE_TIMEOUT_SECS)
+
+        assert isinstance(response, EnqueueJobResult)
+        if not response.successfully_queued:
+            raise CommandServerBadResponse("queue operation was not successful")
+
+        return response.queued_job_uuid
+
+
+def check_health(*, host: str = _LOCAL_RPC_HOST, port: int) -> bool:
+    with command_server_connection(host=host, port=port) as stub:
+        request = CheckHealthRequest()
+
+        response = stub.CheckHealth(request, timeout=_DEFAULT_MESSAGE_TIMEOUT_SECS)
+
+        assert isinstance(response, CheckHealthResult)
+
+        return response.success

uncountable/integration/queue_runner/command_server/command_server.py

@@ -0,0 +1,64 @@
+import asyncio
+
+import simplejson as json
+from grpc import aio
+
+from pkgs.argument_parser import CachedParser
+from uncountable.core.environment import get_local_admin_server_port
+from uncountable.integration.queue_runner.command_server.protocol.command_server_pb2 import (
+    CheckHealthRequest,
+    CheckHealthResult,
+    EnqueueJobRequest,
+    EnqueueJobResult,
+)
+from uncountable.integration.queue_runner.command_server.types import (
+    CommandEnqueueJob,
+    CommandEnqueueJobResponse,
+    CommandQueue,
+)
+from uncountable.types import queued_job_t
+
+from .protocol.command_server_pb2_grpc import (
+    CommandServerServicer,
+    add_CommandServerServicer_to_server,
+)
+
+queued_job_payload_parser = CachedParser(queued_job_t.QueuedJobPayload)
+
+
+async def serve(command_queue: CommandQueue) -> None:
+    server = aio.server()
+
+    class CommandServerHandler(CommandServerServicer):
+        async def EnqueueJob(
+            self, request: EnqueueJobRequest, context: aio.ServicerContext
+        ) -> EnqueueJobResult:
+            payload_json = json.loads(request.serialized_payload)
+            payload = queued_job_payload_parser.parse_api(payload_json)
+            response_queue: asyncio.Queue[CommandEnqueueJobResponse] = asyncio.Queue()
+            await command_queue.put(
+                CommandEnqueueJob(
+                    job_ref_name=request.job_ref_name,
+                    payload=payload,
+                    response_queue=response_queue,
+                )
+            )
+            response = await response_queue.get()
+            result = EnqueueJobResult(
+                successfully_queued=True, queued_job_uuid=response.queued_job_uuid
+            )
+            return result
+
+        async def CheckHealth(
+            self, request: CheckHealthRequest, context: aio.ServicerContext
+        ) -> CheckHealthResult:
+            return CheckHealthResult(success=True)
+
+    add_CommandServerServicer_to_server(CommandServerHandler(), server)
+
+    listen_addr = f"[::]:{get_local_admin_server_port()}"
+
+    server.add_insecure_port(listen_addr)
+
+    await server.start()
+    await server.wait_for_termination()

uncountable/integration/queue_runner/command_server/protocol/command_server.proto

@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+service CommandServer {
+	rpc EnqueueJob(EnqueueJobRequest) returns (EnqueueJobResult) {}
+	rpc CheckHealth(CheckHealthRequest) returns (CheckHealthResult) {}
+}
+
+message EnqueueJobRequest {
+	string job_ref_name = 1;
+	string serialized_payload = 2;
+}
+
+message EnqueueJobResult {
+	bool successfully_queued = 1;
+	string queued_job_uuid = 2;
+}
+
+message CheckHealthRequest {}
+
+message CheckHealthResult {
+	bool success = 1;
+}

uncountable/integration/queue_runner/command_server/protocol/command_server_pb2.py

@@ -0,0 +1,40 @@
+# ruff: noqa
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: uncountable/integration/queue_runner/command_server/protocol/command_server.proto
+# Protobuf Python Version: 4.25.1
+"""Generated protocol buffer code."""
+
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\nQuncountable/integration/queue_runner/command_server/protocol/command_server.proto"E\n\x11\x45nqueueJobRequest\x12\x14\n\x0cjob_ref_name\x18\x01 \x01(\t\x12\x1a\n\x12serialized_payload\x18\x02 \x01(\t"H\n\x10\x45nqueueJobResult\x12\x1b\n\x13successfully_queued\x18\x01 \x01(\x08\x12\x17\n\x0fqueued_job_uuid\x18\x02 \x01(\t"\x14\n\x12\x43heckHealthRequest"$\n\x11\x43heckHealthResult\x12\x0f\n\x07success\x18\x01 \x01(\x08\x32\x80\x01\n\rCommandServer\x12\x35\n\nEnqueueJob\x12\x12.EnqueueJobRequest\x1a\x11.EnqueueJobResult"\x00\x12\x38\n\x0b\x43heckHealth\x12\x13.CheckHealthRequest\x1a\x12.CheckHealthResult"\x00\x62\x06proto3'
+)
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(
+    DESCRIPTOR,
+    "uncountable.integration.queue_runner.command_server.protocol.command_server_pb2",
+    _globals,
+)
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    _globals["_ENQUEUEJOBREQUEST"]._serialized_start = 85
+    _globals["_ENQUEUEJOBREQUEST"]._serialized_end = 154
+    _globals["_ENQUEUEJOBRESULT"]._serialized_start = 156
+    _globals["_ENQUEUEJOBRESULT"]._serialized_end = 228
+    _globals["_CHECKHEALTHREQUEST"]._serialized_start = 230
+    _globals["_CHECKHEALTHREQUEST"]._serialized_end = 250
+    _globals["_CHECKHEALTHRESULT"]._serialized_start = 252
+    _globals["_CHECKHEALTHRESULT"]._serialized_end = 288
+    _globals["_COMMANDSERVER"]._serialized_start = 291
+    _globals["_COMMANDSERVER"]._serialized_end = 419
+# @@protoc_insertion_point(module_scope)

uncountable/integration/queue_runner/command_server/protocol/command_server_pb2.pyi

@@ -0,0 +1,38 @@
+# ruff: noqa
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Optional as _Optional
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class EnqueueJobRequest(_message.Message):
+    __slots__ = ("job_ref_name", "serialized_payload")
+    JOB_REF_NAME_FIELD_NUMBER: _ClassVar[int]
+    SERIALIZED_PAYLOAD_FIELD_NUMBER: _ClassVar[int]
+    job_ref_name: str
+    serialized_payload: str
+    def __init__(
+        self,
+        job_ref_name: _Optional[str] = ...,
+        serialized_payload: _Optional[str] = ...,
+    ) -> None: ...
+
+class EnqueueJobResult(_message.Message):
+    __slots__ = ("successfully_queued", "queued_job_uuid")
+    SUCCESSFULLY_QUEUED_FIELD_NUMBER: _ClassVar[int]
+    QUEUED_JOB_UUID_FIELD_NUMBER: _ClassVar[int]
+    successfully_queued: bool
+    queued_job_uuid: str
+    def __init__(
+        self, successfully_queued: bool = ..., queued_job_uuid: _Optional[str] = ...
+    ) -> None: ...
+
+class CheckHealthRequest(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class CheckHealthResult(_message.Message):
+    __slots__ = ("success",)
+    SUCCESS_FIELD_NUMBER: _ClassVar[int]
+    success: bool
+    def __init__(self, success: bool = ...) -> None: ...

uncountable/integration/queue_runner/command_server/protocol/command_server_pb2_grpc.py

@@ -0,0 +1,129 @@
+# mypy: disable-error-code="no-untyped-def"
+# ruff: noqa
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+
+import grpc
+
+from uncountable.integration.queue_runner.command_server.protocol import (
+    command_server_pb2 as uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2,
+)
+
+
+class CommandServerStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.EnqueueJob = channel.unary_unary(
+            "/CommandServer/EnqueueJob",
+            request_serializer=uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.EnqueueJobRequest.SerializeToString,
+            response_deserializer=uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.EnqueueJobResult.FromString,
+        )
+        self.CheckHealth = channel.unary_unary(
+            "/CommandServer/CheckHealth",
+            request_serializer=uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.CheckHealthRequest.SerializeToString,
+            response_deserializer=uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.CheckHealthResult.FromString,
+        )
+
+
+class CommandServerServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def EnqueueJob(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details("Method not implemented!")
+        raise NotImplementedError("Method not implemented!")
+
+    def CheckHealth(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details("Method not implemented!")
+        raise NotImplementedError("Method not implemented!")
+
+
+def add_CommandServerServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+        "EnqueueJob": grpc.unary_unary_rpc_method_handler(
+            servicer.EnqueueJob,
+            request_deserializer=uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.EnqueueJobRequest.FromString,
+            response_serializer=uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.EnqueueJobResult.SerializeToString,
+        ),
+        "CheckHealth": grpc.unary_unary_rpc_method_handler(
+            servicer.CheckHealth,
+            request_deserializer=uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.CheckHealthRequest.FromString,
+            response_serializer=uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.CheckHealthResult.SerializeToString,
+        ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+        "CommandServer", rpc_method_handlers
+    )
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+# This class is part of an EXPERIMENTAL API.
+class CommandServer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def EnqueueJob(
+        request,
+        target,
+        options=(),
+        channel_credentials=None,
+        call_credentials=None,
+        insecure=False,
+        compression=None,
+        wait_for_ready=None,
+        timeout=None,
+        metadata=None,
+    ):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            "/CommandServer/EnqueueJob",
+            uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.EnqueueJobRequest.SerializeToString,
+            uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.EnqueueJobResult.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+        )
+
+    @staticmethod
+    def CheckHealth(
+        request,
+        target,
+        options=(),
+        channel_credentials=None,
+        call_credentials=None,
+        insecure=False,
+        compression=None,
+        wait_for_ready=None,
+        timeout=None,
+        metadata=None,
+    ):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            "/CommandServer/CheckHealth",
+            uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.CheckHealthRequest.SerializeToString,
+            uncountable_dot_integration_dot_queue__runner_dot_command__server_dot_protocol_dot_command__server__pb2.CheckHealthResult.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+        )

uncountable/integration/queue_runner/command_server/types.py

@@ -0,0 +1,52 @@
+import asyncio
+import typing
+from dataclasses import dataclass
+from enum import StrEnum
+
+from uncountable.types import queued_job_t
+
+
+class CommandType(StrEnum):
+    ENQUEUE_JOB = "enqueue_job"
+
+
+RT = typing.TypeVar("RT")
+
+
+@dataclass(kw_only=True)
+class CommandBase(typing.Generic[RT]):
+    type: CommandType
+    response_queue: asyncio.Queue[RT]
+
+
+@dataclass(kw_only=True)
+class CommandEnqueueJobResponse:
+    queued_job_uuid: str
+
+
+@dataclass(kw_only=True)
+class CommandEnqueueJob(CommandBase[CommandEnqueueJobResponse]):
+    type: CommandType = CommandType.ENQUEUE_JOB
+    job_ref_name: str
+    payload: queued_job_t.QueuedJobPayload
+    response_queue: asyncio.Queue[CommandEnqueueJobResponse]
+
+
+_Command = CommandEnqueueJob
+
+
+CommandQueue = asyncio.Queue[_Command]
+
+CommandTask = asyncio.Task[_Command]
+
+
+class CommandServerException(Exception):
+    pass
+
+
+class CommandServerTimeout(CommandServerException):
+    pass
+
+
+class CommandServerBadResponse(CommandServerException):
+    pass

uncountable/integration/queue_runner/datastore/__init__.py

@@ -0,0 +1,3 @@
+from .datastore_sqlite import DatastoreSqlite
+
+__all__: list[str] = ["DatastoreSqlite"]

uncountable/integration/queue_runner/datastore/datastore_sqlite.py

@@ -0,0 +1,93 @@
+import uuid
+from datetime import datetime, timezone
+
+from sqlalchemy import delete, insert, select, update
+from sqlalchemy.engine import Engine
+
+from pkgs.argument_parser import CachedParser
+from pkgs.serialization_util import serialize_for_storage
+from uncountable.integration.db.session import DBSessionMaker
+from uncountable.integration.queue_runner.datastore.interface import Datastore
+from uncountable.integration.queue_runner.datastore.model import Base, QueuedJob
+from uncountable.types import queued_job_t
+
+queued_job_payload_parser = CachedParser(queued_job_t.QueuedJobPayload)
+
+
+class DatastoreSqlite(Datastore):
+    def __init__(self, session_maker: DBSessionMaker) -> None:
+        self.session_maker = session_maker
+        super().__init__()
+
+    @classmethod
+    def setup(cls, engine: Engine) -> None:
+        Base.metadata.create_all(engine)
+
+    def add_job_to_queue(
+        self, job_payload: queued_job_t.QueuedJobPayload, job_ref_name: str
+    ) -> queued_job_t.QueuedJob:
+        with self.session_maker() as session:
+            serialized_payload = serialize_for_storage(job_payload)
+            queued_job_uuid = str(uuid.uuid4())
+            num_attempts = 0
+            submitted_at = datetime.now(timezone.utc)
+            insert_stmt = insert(QueuedJob).values({
+                QueuedJob.id.key: queued_job_uuid,
+                QueuedJob.job_ref_name.key: job_ref_name,
+                QueuedJob.payload.key: serialized_payload,
+                QueuedJob.num_attempts: num_attempts,
+                QueuedJob.submitted_at: submitted_at,
+            })
+            session.execute(insert_stmt)
+            return queued_job_t.QueuedJob(
+                queued_job_uuid=queued_job_uuid,
+                job_ref_name=job_ref_name,
+                payload=job_payload,
+                submitted_at=submitted_at,
+                num_attempts=num_attempts,
+            )
+
+    def increment_num_attempts(self, queued_job_uuid: str) -> int:
+        with self.session_maker() as session:
+            update_stmt = (
+                update(QueuedJob)
+                .values({QueuedJob.num_attempts.key: QueuedJob.num_attempts + 1})
+                .filter(QueuedJob.id == queued_job_uuid)
+            )
+            session.execute(update_stmt)
+            session.flush()
+            # IMPROVE: python3.12's sqlite does not support the RETURNING clause
+            select_stmt = select(QueuedJob.num_attempts).filter(
+                QueuedJob.id == queued_job_uuid
+            )
+            return int(session.execute(select_stmt).one().num_attempts)
+
+    def remove_job_from_queue(self, queued_job_uuid: str) -> None:
+        with self.session_maker() as session:
+            delete_stmt = delete(QueuedJob).filter(QueuedJob.id == queued_job_uuid)
+            session.execute(delete_stmt)
+
+    def load_job_queue(self) -> list[queued_job_t.QueuedJob]:
+        with self.session_maker() as session:
+            select_stmt = select(
+                QueuedJob.id,
+                QueuedJob.payload,
+                QueuedJob.num_attempts,
+                QueuedJob.job_ref_name,
+                QueuedJob.submitted_at,
+            ).order_by(QueuedJob.submitted_at)
+
+            queued_jobs: list[queued_job_t.QueuedJob] = []
+            for row in session.execute(select_stmt):
+                parsed_payload = queued_job_payload_parser.parse_storage(row.payload)
+                queued_jobs.append(
+                    queued_job_t.QueuedJob(
+                        queued_job_uuid=row.id,
+                        job_ref_name=row.job_ref_name,
+                        num_attempts=row.num_attempts,
+                        submitted_at=row.submitted_at,
+                        payload=parsed_payload,
+                    )
+                )
+
+            return queued_jobs