`deeporigin.drug_discovery.protein_prep`¶

ProteinPrep drives deeporigin.protein-prep v10. Recommend inventories components, returns a component table (pandas.DataFrame), and updates the same object with an editable Selection. Prepare applies resolved keep/skip decisions and cleans the structure. run() blocks on served prepare (including loop modelling); find_pockets="novel" requires start() (workflow path). Pocket-bearing runs support quote / approve_amount and confirm(). Structure reports are not part of this tool — use StructureReport.

Recommend settings and prepare a protein with one mutable configuration.

ProteinPrep is the sole public preparation session. It uses deeporigin.protein-prep v10 for :meth:recommend and all :meth:run / :meth:start prepare paths. Extracting a ligand also requests one crystal-ligand Pocket per extract (find_pockets=from-crystal-ligand). Novel pockets use the platform workflow path; use :meth:start (not blocking :meth:run) for those.

Set :attr:find_pockets to "novel" or "from-crystal-ligand" to include pockets in prepare. :meth:get_results returns the prepared :class:~deeporigin.drug_discovery.structures.protein.Protein; use :meth:get_pockets and :meth:get_crystal_poses for other prepare artifacts. Structure reports are out of band — use :class:~deeporigin.drug_discovery.structure_report.StructureReport.

Usage::

prep = ProteinPrep(protein)
prep.recommend()
prep.keep(kind="water")
prep.skip(decision="review")
prep.model_missing_loops = False
prepared = prep.run()

Attributes¶

BoxGeometry `module-attribute` ¶

BoxGeometry = Literal['ligand-extents', 'fixed-radius']

ProteinPrepAction `module-attribute` ¶

ProteinPrepAction = Literal['recommend', 'prepare']

ProteinPrepFindPockets `module-attribute` ¶

ProteinPrepFindPockets = Literal[
    "no", "from-crystal-ligand", "novel"
]

Classes¶

ProteinPrep ¶

Bases: Execution, SyncExecutableMixin, AsyncExecutableMixin, NotebookWatchMixin

Recommend settings and prepare a protein.

All operations use deeporigin.protein-prep (v10). Blocking :meth:run supports served prepare including loop modelling. Novel pocket finding uses the platform workflow path — use :meth:start (with quote / approve_amount when pockets are billable). Structure reports are not produced by this tool; use :class:~deeporigin.drug_discovery.structure_report.StructureReport.

Attributes:

Name	Type	Description
`protein`	`Protein`	Constructor-only input protein structure.
`pdb_id`	`str \| None`	Mutable 4-character PDB ID for loop-modelling templates.
`selection`	`dict[str, Any] \| None`	Editable keep/review/skip/extract map. Reads return a copy.
`recommendation`	`DataFrame \| None`	Component table as a :class:`~pandas.DataFrame`, or `None` before recommend. Refreshes live `decision` values on each read.
`recommendation_payload`	`dict[str, Any] \| None`	Deep copy of analyzer JSON, or `None`.
`model_missing_loops`	`bool`	Whether prepare models missing loops.
`pocket`	`bool`	Optional Pocket Finder settings.

Attributes¶

USER_LOG_COLUMNS `class-attribute` ¶

USER_LOG_COLUMNS: list[str] = [
    "log_level",
    "tool_key",
    "timestamp",
    "message",
]

app `instance-attribute` ¶

app: str | None = None

approve_amount `instance-attribute` ¶

approve_amount: int | None = None

box_geometry `property` `writable` ¶

box_geometry: BoxGeometry | None

Crystal-ligand box geometry when :attr:find_pockets is crystal mode.

box_padding `property` `writable` ¶

box_padding: float | None

Padding for ligand-extents crystal-ligand boxes.

client `instance-attribute` ¶

client: DeepOriginClient = client

completed_at `instance-attribute` ¶

completed_at: str | None = None

component_id `property` `writable` ¶

component_id: str | None

Component id for find_pockets='from-crystal-ligand'.

cost `property` ¶

cost: float | None

Actual cost in dollars, set after execution completes.

This property cannot be set manually.

created_at `instance-attribute` ¶

created_at: str | None = None

created_by `instance-attribute` ¶

created_by: str | None = None

crystal_ligand `property` `writable` ¶

crystal_ligand: Ligand | None

External ligand file for find_pockets='from-crystal-ligand'.

dto `property` ¶

dto: dict[str, Any] | None

Last tools execution DTO from the platform, if any.

estimate `property` ¶

estimate: float | None

Cost estimate in dollars, populated when the platform returns a quotation.

Set after run(quote=True), start(quote=True), or any call with approve_amount=-1. None until a quotation result is received. This property cannot be set manually.

find_pockets `property` `writable` ¶

find_pockets: ProteinPrepFindPockets

Whether prepare runs Pocket Finder (no, from-crystal-ligand, novel).

Infers from-crystal-ligand when the Selection extracts a ligand and pocket mode has not been set explicitly.

id `property` ¶

id: str | None

Platform execution ID when set (read-only).

ligand_id `property` `writable` ¶

ligand_id: str | None

In-structure ligand code for find_pockets='from-crystal-ligand'.

model_missing_loops `property` `writable` ¶

model_missing_loops: bool

Whether prepare will run loop modelling (unused for recommend).

name `instance-attribute` ¶

name = name

pdb_id `property` `writable` ¶

pdb_id: str | None

4-character PDB ID used for loop-modelling templates, if set.

pocket_count `property` `writable` ¶

pocket_count: int

Max pockets when :attr:find_pockets is "novel".

pocket_min_size `property` `writable` ¶

pocket_min_size: float

Minimum pocket size when :attr:find_pockets is "novel".

pocket_radius `property` `writable` ¶

pocket_radius: float | None

Half-edge for fixed-radius crystal-ligand boxes.

progress `instance-attribute` ¶

progress: dict | None = None

protein `property` ¶

protein: Protein

Constructor-only protein used for recommendation and preparation.

recommendation `property` ¶

recommendation: DataFrame | None

Component table, or None when analyzer evidence is missing.

recommendation_payload `property` ¶

recommendation_payload: dict[str, Any] | None

Deep copy of the analyzer recommendation payload.

runtime `property` ¶

runtime: float | None

Seconds from DTO startedAt to completedAt or current UTC time.

Uses :attr:dto (same shape as client.executions.get). When completedAt is present, it is the end time; otherwise the end time is datetime.now(timezone.utc). Returns None if there is no DTO or startedAt is missing or empty.

selection `property` `writable` ¶

selection: dict[str, Any] | None

Editable Selection copy, or None before recommendation.

session `instance-attribute` ¶

session: str | None = None

started_at `instance-attribute` ¶

started_at: str | None = None

status `instance-attribute` ¶

status: PlatformStatus | None = None

tool_key `class-attribute` `instance-attribute` ¶

tool_key: str = _PROTEIN_PREP_TOOL_KEY

tool_version `instance-attribute` ¶

tool_version = tool_version

Methods:¶

cancel ¶

cancel() -> None

Cancel a running or queued execution.

Raises:

Type	Description
`ValueError`	If the job has no execution ID.
`ValueError`	If the job is not in a cancellable state.

confirm ¶

confirm() -> None

Confirm a quoted tools execution on the platform.

Requires :attr:id and status equal to "Quoted". Uses :meth:~deeporigin.platform.executions.Executions.confirm with :data:~deeporigin.utils.constants.TOOL_EXECUTION_POST_TIMEOUT_SECONDS (10 minutes) and retry=False, then applies the returned DTO via :meth:update_from_dto so status, :attr:cost, and :attr:dto reflect the platform response. For direct (blocking) tools the response is typically terminal (Completed); for async tools it may be Created or Running — call :meth:sync until the job finishes.

Raises:

Type	Description
`ValueError`	If there is no platform execution id or status is not `"Quoted"`.

duplicate ¶

duplicate(
    *, client: DeepOriginClient | None = None
) -> Self

Create a fresh copy with the same configuration but no execution state.

Useful after from_id() to re-run the same calculation. The returned instance has no id, status, estimate, or cost — it is ready for run() / start().

Parameters:

Name	Type	Description	Default
`client`	`DeepOriginClient \| None`	Optional API client for the new instance. Falls back to the current instance's client.	`None`

Returns:

Type	Description
`Self`	A new instance sharing the same domain-specific configuration.

extract ¶

extract(
    component_ids: (
        str | Iterable[str] | DataFrame | None
    ) = None,
    *,
    kind: str | None = None,
    subtype: str | None = None,
    decision: str | None = None
) -> Self

Mark matching ligand Selection components to extract.

Same calling styles as :meth:keep. Non-ligand ids raise :class:ValueError.

Parameters:

Name	Type	Description	Default
`component_ids`	`str \| Iterable[str] \| DataFrame \| None`	Component ids to extract.	`None`
`kind`	`str \| None`	Extract every ligand Component of this kind (typically `ligand`).	`None`
`subtype`	`str \| None`	Extract every Component of this subtype.	`None`
`decision`	`str \| None`	Extract every Component with this live Decision.	`None`

Returns:

Name	Type	Description
`This`	`Self`	class:`ProteinPrep` (for chaining).

from_dto `classmethod` ¶

from_dto(
    dto: dict[str, Any],
    *,
    client: DeepOriginClient | None = None
) -> Self

Construct a ProteinPrep from a tools execution DTO.

Rehydrates protein-prep recommendation and preparation executions.

Parameters:

Name	Type	Description	Default
`dto`	`dict[str, Any]`	Execution payload (same shape as `client.executions.get`).	required
`client`	`DeepOriginClient \| None`	Optional API client. Uses the default if not provided.	`None`

Returns:

Type	Description
`Self`	A `ProteinPrep` with `id`, lifecycle fields, and domain inputs
`Self`	set.

Raises:

Type	Description
`ValueError`	If stored inputs are missing `protein` or use an unknown `action`.

from_id `classmethod` ¶

from_id(
    id: str, *, client: DeepOriginClient | None = None
) -> Self

Construct from a protein-prep execution id.

Parameters:

Name	Type	Description	Default
`id`	`str`	Platform execution ID.	required
`client`	`DeepOriginClient \| None`	Optional API client.	`None`

Returns:

Name	Type	Description
`Rehydrated`	`Self`	class:`ProteinPrep`.

from_last_run `classmethod` ¶

from_last_run(
    *, client: DeepOriginClient | None = None
) -> Self

Return the newest protein-prep execution.

Parameters:

Name	Type	Description	Default
`client`	`DeepOriginClient \| None`	Optional API client.	`None`

Returns:

Name	Type	Description
`Rehydrated`	`Self`	class:`ProteinPrep` for the newest matching execution.

Raises:

Type	Description
`ValueError`	If no protein-prep executions exist.

get_crystal_poses ¶

get_crystal_poses(
    dto: dict[str, Any] | None = None,
) -> PoseSet | None

Return crystal poses extracted during prepare when extract was selected.

Tries result-explorer rows (result_type=pose), then jobOutputs.poses. Rows use the Protein Prep Pose shape (origin: cocrystal, prepared protein_id, ligand_id, file_path, component_id). Coordinates are not downloaded; call :meth:~deeporigin.drug_discovery.structures.pose.Pose.download on individual poses when needed.

Parameters:

Name	Type	Description	Default
`dto`	`dict[str, Any] \| None`	Optional execution payload used as a job-output fallback.	`None`

Returns:

Name	Type	Description
`A`	`PoseSet \| None`	class:`~deeporigin.drug_discovery.structures.pose.PoseSet` of
	`PoseSet \| None`	crystal poses, an empty set when prepare completed with none, or
	`PoseSet \| None`	`None` when outputs are not published yet.

Raises:

Type	Description
`ValueError`	If :attr:`id` is unset.
`DeepOriginException`	If this was a recommend-only run.

get_pockets ¶

get_pockets(
    dto: dict[str, Any] | None = None,
) -> list[Pocket] | None

Return Pocket Finder results when this run requested pockets.

Parameters:

Name	Type	Description	Default
`dto`	`dict[str, Any] \| None`	Optional execution payload used as a job-output fallback.	`None`

Returns:

Type	Description
`list[Pocket] \| None`	Pocket list (possibly empty for a valid zero-pocket result), or
`list[Pocket] \| None`	`None` when requested but not yet published.

Raises:

Type	Description
`ValueError`	If :attr:`id` is unset, or this run did not request pockets.

get_results ¶

get_results(dto: dict[str, Any] | None = None) -> Protein

Load the prepared protein as an in-memory :class:Protein.

Works for either routed tool key. Tries result-explorer rows (result_type=preparedprotein), then jobOutputs.protein.

Parameters:

Name	Type	Description	Default
`dto`	`dict[str, Any] \| None`	Optional execution payload. Passing it avoids an extra GET when the result-explorer path fails but `jobOutputs` is already in hand.	`None`

Returns:

Type	Description
`Protein`	An in-memory :class:`Protein` for the prepared structure.

Raises:

Type	Description
`ValueError`	If :attr:`id` is unset.
`DeepOriginException`	If this was a recommend run, or no prepared protein could be loaded.

get_user_logs ¶

get_user_logs(
    *,
    limit: int | None = None,
    offset: int | None = None,
    select: list[str] | None = None,
    with_total_count: bool = False
) -> DataFrame | None

Search data-platform user_logs rows for this execution.

Uses :meth:deeporigin.platform.user_logs.UserLogs.search with this execution's id (tools executionId), stored as execution_id on user_logs rows — the same string passed to :meth:get_results as compute_job_id.

When no execution id is assigned yet, returns None without calling the API.

Parameters:

Name	Type	Description	Default
`limit`	`int \| None`	Max rows to return (forwarded to `UserLogs.search`).	`None`
`offset`	`int \| None`	Skip offset (forwarded).	`None`
`select`	`list[str] \| None`	Columns to select (forwarded).	`None`
`with_total_count`	`bool`	Request total count from the server (forwarded).	`False`

Returns:

Type	Description
`DataFrame \| None`	A DataFrame with columns `log_level`, `tool_key`, `timestamp`,
`DataFrame \| None`	and `message`. `tool_key` omits the `deeporigin.` prefix;
`DataFrame \| None`	`timestamp` is a compact humanized relative time. Returns `None`
`DataFrame \| None`	if this instance has no execution id yet or the client has no
`DataFrame \| None`	`user_logs` API.

keep ¶

keep(
    component_ids: (
        str | Iterable[str] | DataFrame | None
    ) = None,
    *,
    kind: str | None = None,
    subtype: str | None = None,
    decision: str | None = None
) -> Self

Mark matching Selection components to keep.

Pass ids (a string, iterable, or DataFrame id column) or keyword matchers, not both. kind="water" is equivalent to passing every water component id.

Parameters:

Name	Type	Description	Default
`component_ids`	`str \| Iterable[str] \| DataFrame \| None`	Component ids to keep.	`None`
`kind`	`str \| None`	Keep every Component of this kind.	`None`
`subtype`	`str \| None`	Keep every Component of this subtype.	`None`
`decision`	`str \| None`	Keep every Component with this live Decision.	`None`

Returns:

Name	Type	Description
`This`	`Self`	class:`ProteinPrep` (for chaining).

list `classmethod` ¶

list(
    *,
    client: DeepOriginClient | None = None,
    status: list[str] | None = None
) -> list[Self]

List protein-prep executions for this session type.

Parameters:

Name	Type	Description	Default
`client`	`DeepOriginClient \| None`	Optional API client.	`None`
`status`	`list[str] \| None`	Optional status filter on hydrated instances.	`None`

Returns:

Type	Description
`list[Self]`	Instances for `deeporigin.protein-prep`, newest `createdAt` first.

recommend ¶

recommend() -> DataFrame

Recommend settings into this object without binding an execution ID.

Always uses direct deeporigin.protein-prep. The platform operation is synchronous and persisted by the backend, but its execution ID is deliberately not copied onto this object. Repeated calls atomically replace :attr:recommendation and :attr:selection only after a complete recommendation is available.

Returns:

Type	Description
`DataFrame`	Component inventory table for this structure.

Raises:

Type	Description
`AttributeError`	If this object is already bound to prepare.
`DeepOriginException`	If recommendation output is unavailable.

run ¶

run(
    *,
    quote: bool = False,
    approve_amount: int | None = None
) -> Protein | None

Execute served prepare synchronously (blocking).

Valid for loops on or off when :attr:find_pockets is not "novel".

Parameters:

Name	Type	Description	Default
`quote`	`bool`	Shorthand for :data:`~deeporigin.utils.constants.QUOTE_APPROVE_AMOUNT`.	`False`
`approve_amount`	`int \| None`	Optional spend cap (usually omitted on this path).	`None`

Returns:

Type	Description
`Protein \| None`	An in-memory prepared :class:`Protein`, or `None` when Quoted.

Raises:

Type	Description
`ValueError`	If already submitted or this is not the direct path.
`DeepOriginException`	If no prepared PDB path could be loaded.

show ¶

show() -> None

Display the current execution in Jupyter using the execution card HTML view.

If no platform execution ID exists yet, shows the same card with a short notice instead of raising (see :meth:~deeporigin.platform.execution_display.ExecutionDisplay.from_pending).

skip ¶

skip(
    component_ids: (
        str | Iterable[str] | DataFrame | None
    ) = None,
    *,
    kind: str | None = None,
    subtype: str | None = None,
    decision: str | None = None
) -> Self

Mark matching Selection components to skip.

Same calling styles as :meth:keep.

Parameters:

Name	Type	Description	Default
`component_ids`	`str \| Iterable[str] \| DataFrame \| None`	Component ids to skip.	`None`
`kind`	`str \| None`	Skip every Component of this kind.	`None`
`subtype`	`str \| None`	Skip every Component of this subtype.	`None`
`decision`	`str \| None`	Skip every Component with this live Decision.	`None`

Returns:

Name	Type	Description
`This`	`Self`	class:`ProteinPrep` (for chaining).

start ¶

start(
    *,
    quote: bool = False,
    approve_amount: int | None = None,
    **kwargs
) -> None

Submit a persisted async execution to the platform.

Only valid when status is None (no execution exists yet). All other statuses raise immediately to prevent re-submission.

Pass quote=True or approve_amount=-1 to request a cost estimate without running. If the platform returns a Quoted DTO the instance is left in that state — call :meth:~deeporigin.drug_discovery.execution.Execution.confirm explicitly to proceed.

Parameters:

Name	Type	Description	Default
`quote`	`bool`	Shorthand for `approve_amount=-1`. Takes precedence when both `quote` and `approve_amount` are provided.	`False`
`approve_amount`	`int \| None`	Spend cap passed to the platform as `approveAmount`. `-1` (or any negative value) forces a quote-only create. `None` omits the field (platform may auto-confirm).	`None`
`**kwargs`		Forwarded verbatim to `_start_impl`.	`{}`

Raises:

Type	Description
`ValueError`	If the current status is not `None`.

stop_watching ¶

stop_watching() -> None

Cancel an in-flight watch loop if one is running.

Safe to call when no watch is active. Does not cancel the caller's current task when invoked from inside the watch loop.

sync ¶

sync() -> None

Fetch the latest tools execution from the platform and refresh fields.

Calls client.executions.get for :attr:id and applies the response with :meth:update_from_dto. Use when the job may have changed outside this process (for example after submission from the web UI), to poll lifecycle state, or to refresh an instance built from an older DTO. Available on sync-only and async execution types alike.

If executions.get returns a falsy value, this instance is left unchanged.

Raises:

Type	Description
`ValueError`	If this instance has no execution id yet.
`NotImplementedError`	If `type(self).tool_key` is empty (bare :class:`Execution`).
`ValueError`	If the returned DTO `tool.key` does not match this class (see :meth:`update_from_dto`).

update_from_dto ¶

update_from_dto(dto: dict[str, Any]) -> None

Apply tools execution fields from a protein-prep execution DTO.

Parameters:

Name	Type	Description	Default
`dto`	`dict[str, Any]`	Execution payload (same shape as `client.executions.get`).	required

Raises:

Type	Description
`ValueError`	If the DTO tool key is not `deeporigin.protein-prep`.

wait ¶

wait(
    *,
    poll_interval: float = 5.0,
    timeout: float | None = None
) -> dict[str, Any] | None

Block until this execution reaches a terminal state.

Parameters:

Name	Type	Description	Default
`poll_interval`	`float`	Seconds to sleep between polling cycles.	`5.0`
`timeout`	`float \| None`	Maximum total seconds to wait. If `None`, waits indefinitely.	`None`

Returns:

Type	Description
`dict[str, Any] \| None`	The latest execution DTO, or `None` if the platform returned no DTO.

Raises:

Type	Description
`ValueError`	If this instance has no execution id yet.
`TimeoutError`	If `timeout` elapses before the execution terminates.

watch `async` ¶

watch(
    *, interval: float = 5.0, blocking: bool = False
) -> Task | None

Start live notebook updates; optionally block until the job finishes.

By default, awaiting this coroutine finishes in one event-loop turn, so the cell returns while the display keeps updating in the background. Use this when you need to run other cells while the job runs::

task = await abfe.watch()

Set blocking=True or export JOB_WATCH_BLOCK=1 (truthy values: 1, true, yes, on) to run the poll loop inline so the cell does not return until a terminal state — useful for nbconvert --execute and doc CI (see :data:~deeporigin.utils.constants.JOB_WATCH_BLOCK_ENV)::

await abfe.watch(blocking=True)
# or: export JOB_WATCH_BLOCK=1

Parameters:

Name	Type	Description	Default
`interval`	`float`	Seconds between polls.	`5.0`
`blocking`	`bool`	When True, await the watch loop instead of returning a background task. Also blocks when `JOB_WATCH_BLOCK` is truthy.	`False`

Returns:

Type	Description
`Task \| None`	The background task when not blocking; `None` when blocking.
`Task \| None`	Cancel a background watch with :meth:`stop_watching` or `task.cancel()`.

deeporigin.drug_discovery.protein_prep¶

Attributes¶

BoxGeometry module-attribute ¶

ProteinPrepAction module-attribute ¶

ProteinPrepFindPockets module-attribute ¶

Classes¶

ProteinPrep ¶

Attributes¶

USER_LOG_COLUMNS class-attribute ¶

app instance-attribute ¶

approve_amount instance-attribute ¶

box_geometry property writable ¶

box_padding property writable ¶

client instance-attribute ¶

completed_at instance-attribute ¶

component_id property writable ¶

cost property ¶

created_at instance-attribute ¶

created_by instance-attribute ¶

crystal_ligand property writable ¶

dto property ¶

estimate property ¶

find_pockets property writable ¶

id property ¶

ligand_id property writable ¶

model_missing_loops property writable ¶

name instance-attribute ¶

pdb_id property writable ¶

pocket_count property writable ¶

pocket_min_size property writable ¶

pocket_radius property writable ¶

progress instance-attribute ¶

protein property ¶

recommendation property ¶

recommendation_payload property ¶

runtime property ¶

selection property writable ¶

session instance-attribute ¶

started_at instance-attribute ¶

status instance-attribute ¶

tool_key class-attribute instance-attribute ¶

tool_version instance-attribute ¶

Methods:¶

cancel ¶

confirm ¶

duplicate ¶

extract ¶

from_dto classmethod ¶

from_id classmethod ¶

from_last_run classmethod ¶

get_crystal_poses ¶

get_pockets ¶

get_results ¶

get_user_logs ¶

keep ¶

list classmethod ¶

recommend ¶

run ¶

show ¶

skip ¶

start ¶

stop_watching ¶

sync ¶

update_from_dto ¶

wait ¶

watch async ¶

Functions:¶

`deeporigin.drug_discovery.protein_prep`¶

BoxGeometry `module-attribute` ¶

ProteinPrepAction `module-attribute` ¶

ProteinPrepFindPockets `module-attribute` ¶

USER_LOG_COLUMNS `class-attribute` ¶

app `instance-attribute` ¶

approve_amount `instance-attribute` ¶

box_geometry `property` `writable` ¶

box_padding `property` `writable` ¶

client `instance-attribute` ¶

completed_at `instance-attribute` ¶

component_id `property` `writable` ¶

cost `property` ¶

created_at `instance-attribute` ¶

created_by `instance-attribute` ¶

crystal_ligand `property` `writable` ¶

dto `property` ¶

estimate `property` ¶

find_pockets `property` `writable` ¶

id `property` ¶

ligand_id `property` `writable` ¶

model_missing_loops `property` `writable` ¶

name `instance-attribute` ¶

pdb_id `property` `writable` ¶

pocket_count `property` `writable` ¶

pocket_min_size `property` `writable` ¶

pocket_radius `property` `writable` ¶

progress `instance-attribute` ¶

protein `property` ¶

recommendation `property` ¶

recommendation_payload `property` ¶

runtime `property` ¶

selection `property` `writable` ¶

session `instance-attribute` ¶

started_at `instance-attribute` ¶

status `instance-attribute` ¶

tool_key `class-attribute` `instance-attribute` ¶

tool_version `instance-attribute` ¶

from_dto `classmethod` ¶

from_id `classmethod` ¶

from_last_run `classmethod` ¶

list `classmethod` ¶

watch `async` ¶