diff --git a/swh/scheduler/backend.py b/swh/scheduler/backend.py
index 966b8f8..44641ef 100644
--- a/swh/scheduler/backend.py
+++ b/swh/scheduler/backend.py
@@ -1,1039 +1,1044 @@
 # Copyright (C) 2015-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import datetime
 import json
 import logging
 from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
 from uuid import UUID
 
 import attr
 from psycopg2.errors import CardinalityViolation
 import psycopg2.extras
 import psycopg2.pool
 
 from swh.core.db import BaseDb
 from swh.core.db.common import db_transaction
 from swh.scheduler.utils import utcnow
 
 from .exc import SchedulerException, StaleData, UnknownPolicy
 from .interface import ListedOriginPageToken, PaginatedListedOriginList
 from .model import ListedOrigin, Lister, OriginVisitStats, SchedulerMetrics
 
 logger = logging.getLogger(__name__)
 
 
 psycopg2.extensions.register_adapter(dict, psycopg2.extras.Json)
 psycopg2.extras.register_uuid()
 
 
 def format_query(query, keys):
     """Format a query with the given keys"""
 
     query_keys = ", ".join(keys)
     placeholders = ", ".join(["%s"] * len(keys))
 
     return query.format(keys=query_keys, placeholders=placeholders)
 
 
 class SchedulerBackend:
     """Backend for the Software Heritage scheduling database.
 
     """
 
     def __init__(self, db, min_pool_conns=1, max_pool_conns=10):
         """
         Args:
             db_conn: either a libpq connection string, or a psycopg2 connection
 
         """
         if isinstance(db, psycopg2.extensions.connection):
             self._pool = None
             self._db = BaseDb(db)
         else:
             self._pool = psycopg2.pool.ThreadedConnectionPool(
                 min_pool_conns,
                 max_pool_conns,
                 db,
                 cursor_factory=psycopg2.extras.RealDictCursor,
             )
             self._db = None
 
     def get_db(self):
         if self._db:
             return self._db
         return BaseDb.from_pool(self._pool)
 
     def put_db(self, db):
         if db is not self._db:
             db.put_conn()
 
     task_type_keys = [
         "type",
         "description",
         "backend_name",
         "default_interval",
         "min_interval",
         "max_interval",
         "backoff_factor",
         "max_queue_length",
         "num_retries",
         "retry_delay",
     ]
 
     @db_transaction()
     def create_task_type(self, task_type, db=None, cur=None):
         """Create a new task type ready for scheduling.
 
         Args:
             task_type (dict): a dictionary with the following keys:
 
                 - type (str): an identifier for the task type
                 - description (str): a human-readable description of what the
                   task does
                 - backend_name (str): the name of the task in the
                   job-scheduling backend
                 - default_interval (datetime.timedelta): the default interval
                   between two task runs
                 - min_interval (datetime.timedelta): the minimum interval
                   between two task runs
                 - max_interval (datetime.timedelta): the maximum interval
                   between two task runs
                 - backoff_factor (float): the factor by which the interval
                   changes at each run
                 - max_queue_length (int): the maximum length of the task queue
                   for this task type
 
         """
         keys = [key for key in self.task_type_keys if key in task_type]
         query = format_query(
             """insert into task_type ({keys}) values ({placeholders})
             on conflict do nothing""",
             keys,
         )
         cur.execute(query, [task_type[key] for key in keys])
 
     @db_transaction()
     def get_task_type(self, task_type_name, db=None, cur=None):
         """Retrieve the task type with id task_type_name"""
         query = format_query(
             "select {keys} from task_type where type=%s", self.task_type_keys,
         )
         cur.execute(query, (task_type_name,))
         return cur.fetchone()
 
     @db_transaction()
     def get_task_types(self, db=None, cur=None):
         """Retrieve all registered task types"""
         query = format_query("select {keys} from task_type", self.task_type_keys,)
         cur.execute(query)
         return cur.fetchall()
 
     @db_transaction()
     def get_lister(
         self, name: str, instance_name: Optional[str] = None, db=None, cur=None
     ) -> Optional[Lister]:
         """Retrieve information about the given instance of the lister from the
         database.
         """
         if instance_name is None:
             instance_name = ""
 
         select_cols = ", ".join(Lister.select_columns())
 
         query = f"""
             select {select_cols} from listers
               where (name, instance_name) = (%s, %s)
         """
 
         cur.execute(query, (name, instance_name))
 
         ret = cur.fetchone()
         if not ret:
             return None
 
         return Lister(**ret)
 
     @db_transaction()
     def get_or_create_lister(
         self, name: str, instance_name: Optional[str] = None, db=None, cur=None
     ) -> Lister:
         """Retrieve information about the given instance of the lister from the
         database, or create the entry if it did not exist.
         """
 
         if instance_name is None:
             instance_name = ""
 
         select_cols = ", ".join(Lister.select_columns())
         insert_cols, insert_meta = (
             ", ".join(tup) for tup in Lister.insert_columns_and_metavars()
         )
 
         query = f"""
             with added as (
               insert into listers ({insert_cols}) values ({insert_meta})
                 on conflict do nothing
                 returning {select_cols}
             )
             select {select_cols} from added
           union all
             select {select_cols} from listers
               where (name, instance_name) = (%(name)s, %(instance_name)s);
         """
 
         cur.execute(query, attr.asdict(Lister(name=name, instance_name=instance_name)))
 
         return Lister(**cur.fetchone())
 
     @db_transaction()
     def update_lister(self, lister: Lister, db=None, cur=None) -> Lister:
         """Update the state for the given lister instance in the database.
 
         Returns:
             a new Lister object, with all fields updated from the database
 
         Raises:
             StaleData if the `updated` timestamp for the lister instance in
         database doesn't match the one passed by the user.
         """
 
         select_cols = ", ".join(Lister.select_columns())
         set_vars = ", ".join(
             f"{col} = {meta}"
             for col, meta in zip(*Lister.insert_columns_and_metavars())
         )
 
         query = f"""update listers
                       set {set_vars}
                       where id=%(id)s and updated=%(updated)s
                       returning {select_cols}"""
 
         cur.execute(query, attr.asdict(lister))
         updated = cur.fetchone()
 
         if not updated:
             raise StaleData("Stale data; Lister state not updated")
 
         return Lister(**updated)
 
     @db_transaction()
     def record_listed_origins(
         self, listed_origins: Iterable[ListedOrigin], db=None, cur=None
     ) -> List[ListedOrigin]:
         """Record a set of origins that a lister has listed.
 
         This performs an "upsert": origins with the same (lister_id, url,
         visit_type) values are updated with new values for
         extra_loader_arguments, last_update and last_seen.
         """
 
         pk_cols = ListedOrigin.primary_key_columns()
         select_cols = ListedOrigin.select_columns()
         insert_cols, insert_meta = ListedOrigin.insert_columns_and_metavars()
 
         upsert_cols = [col for col in insert_cols if col not in pk_cols]
         upsert_set = ", ".join(f"{col} = EXCLUDED.{col}" for col in upsert_cols)
 
         query = f"""INSERT into listed_origins ({", ".join(insert_cols)})
                        VALUES %s
                     ON CONFLICT ({", ".join(pk_cols)}) DO UPDATE
                        SET {upsert_set}
                     RETURNING {", ".join(select_cols)}
         """
 
         ret = psycopg2.extras.execute_values(
             cur=cur,
             sql=query,
             argslist=(attr.asdict(origin) for origin in listed_origins),
             template=f"({', '.join(insert_meta)})",
             page_size=1000,
             fetch=True,
         )
 
         return [ListedOrigin(**d) for d in ret]
 
     @db_transaction()
     def get_listed_origins(
         self,
         lister_id: Optional[UUID] = None,
         url: Optional[str] = None,
         limit: int = 1000,
         page_token: Optional[ListedOriginPageToken] = None,
         db=None,
         cur=None,
     ) -> PaginatedListedOriginList:
         """Get information on the listed origins matching either the `url` or
         `lister_id`, or both arguments.
         """
 
         query_filters: List[str] = []
         query_params: List[Union[int, str, UUID, Tuple[UUID, str]]] = []
 
         if lister_id:
             query_filters.append("lister_id = %s")
             query_params.append(lister_id)
 
         if url is not None:
             query_filters.append("url = %s")
             query_params.append(url)
 
         if page_token is not None:
             query_filters.append("(lister_id, url) > %s")
             # the typeshed annotation for tuple() is too strict.
             query_params.append(tuple(page_token))  # type: ignore
 
         query_params.append(limit)
 
         select_cols = ", ".join(ListedOrigin.select_columns())
         if query_filters:
             where_clause = "where %s" % (" and ".join(query_filters))
         else:
             where_clause = ""
 
         query = f"""SELECT {select_cols}
                     from listed_origins
                     {where_clause}
                     ORDER BY lister_id, url
                     LIMIT %s"""
 
         cur.execute(query, tuple(query_params))
         origins = [ListedOrigin(**d) for d in cur]
 
         if len(origins) == limit:
             page_token = (str(origins[-1].lister_id), origins[-1].url)
         else:
             page_token = None
 
         return PaginatedListedOriginList(origins, page_token)
 
     @db_transaction()
     def grab_next_visits(
         self,
         visit_type: str,
         count: int,
         policy: str,
         timestamp: Optional[datetime.datetime] = None,
         db=None,
         cur=None,
     ) -> List[ListedOrigin]:
         """Get at most the `count` next origins that need to be visited with
         the `visit_type` loader according to the given scheduling `policy`.
 
         This will mark the origins as scheduled in the origin_visit_stats
         table, to avoid scheduling multiple visits to the same origin.
 
         Arguments:
           visit_type: type of visits to schedule
           count: number of visits to schedule
           policy: the scheduling policy used to select which visits to schedule
           timestamp: the mocked timestamp at which we're recording that the visits are
             being scheduled (defaults to the current time)
         """
         if timestamp is None:
             timestamp = utcnow()
 
         origin_select_cols = ", ".join(ListedOrigin.select_columns())
 
         query_args: List[Any] = []
 
         where_clauses = []
 
         # "NOT enabled" = the lister said the origin no longer exists
         where_clauses.append("enabled")
 
         # Only schedule visits of the given type
         where_clauses.append("visit_type = %s")
         query_args.append(visit_type)
 
         # Don't re-schedule visits if they're already scheduled but we haven't
         # recorded a result yet, unless they've been scheduled more than a week
         # ago (it probably means we've lost them in flight somewhere).
         where_clauses.append(
             """origin_visit_stats.last_scheduled IS NULL
             OR origin_visit_stats.last_scheduled < GREATEST(
               %s - '7 day'::interval,
               origin_visit_stats.last_eventful,
               origin_visit_stats.last_uneventful,
               origin_visit_stats.last_failed,
               origin_visit_stats.last_notfound
             )
         """
         )
         query_args.append(timestamp)
 
         if policy == "oldest_scheduled_first":
             order_by = "origin_visit_stats.last_scheduled NULLS FIRST"
         elif policy == "never_visited_oldest_update_first":
             # never visited origins have a NULL last_snapshot
             where_clauses.append("origin_visit_stats.last_snapshot IS NULL")
 
             # order by increasing last_update (oldest first)
             where_clauses.append("listed_origins.last_update IS NOT NULL")
             order_by = "listed_origins.last_update"
         elif policy == "already_visited_order_by_lag":
             # TODO: store "visit lag" in a materialized view?
 
             # visited origins have a NOT NULL last_snapshot
             where_clauses.append("origin_visit_stats.last_snapshot IS NOT NULL")
 
             # ignore origins we have visited after the known last update
             where_clauses.append("listed_origins.last_update IS NOT NULL")
             where_clauses.append(
                 """
               listed_origins.last_update
               > GREATEST(
                 origin_visit_stats.last_eventful,
                 origin_visit_stats.last_uneventful
               )
             """
             )
 
             # order by decreasing visit lag
             order_by = """\
               listed_origins.last_update
               - GREATEST(
                 origin_visit_stats.last_eventful,
                 origin_visit_stats.last_uneventful
               )
               DESC
             """
         else:
             raise UnknownPolicy(f"Unknown scheduling policy {policy}")
 
         select_query = f"""
           SELECT
             {origin_select_cols}
           FROM
             listed_origins
           LEFT JOIN
             origin_visit_stats USING (url, visit_type)
           WHERE
             ({") AND (".join(where_clauses)})
           ORDER BY
             {order_by}
           LIMIT %s
         """
         query_args.append(count)
 
         query = f"""
             WITH selected_origins AS (
                {select_query}
             ),
             update_stats AS (
               INSERT INTO
                 origin_visit_stats (
                   url, visit_type, last_scheduled
                 )
               SELECT
                 url, visit_type, %s
               FROM
                 selected_origins
               ON CONFLICT (url, visit_type) DO UPDATE
                 SET last_scheduled = GREATEST(
                   origin_visit_stats.last_scheduled,
                   EXCLUDED.last_scheduled
                 )
             )
             SELECT
               *
             FROM
               selected_origins
         """
         query_args.append(timestamp)
 
         cur.execute(query, tuple(query_args))
         return [ListedOrigin(**d) for d in cur]
 
     task_create_keys = [
         "type",
         "arguments",
         "next_run",
         "policy",
         "status",
         "retries_left",
         "priority",
     ]
     task_keys = task_create_keys + ["id", "current_interval"]
 
     @db_transaction()
     def create_tasks(self, tasks, policy="recurring", db=None, cur=None):
         """Create new tasks.
 
         Args:
             tasks (list): each task is a dictionary with the following keys:
 
                 - type (str): the task type
                 - arguments (dict): the arguments for the task runner, keys:
 
                       - args (list of str): arguments
                       - kwargs (dict str -> str): keyword arguments
 
                 - next_run (datetime.datetime): the next scheduled run for the
                   task
 
         Returns:
             a list of created tasks.
 
         """
         cur.execute("select swh_scheduler_mktemp_task()")
         db.copy_to(
             tasks,
             "tmp_task",
             self.task_create_keys,
             default_values={"policy": policy, "status": "next_run_not_scheduled"},
             cur=cur,
         )
         query = format_query(
             "select {keys} from swh_scheduler_create_tasks_from_temp()", self.task_keys,
         )
         cur.execute(query)
         return cur.fetchall()
 
     @db_transaction()
     def set_status_tasks(
-        self, task_ids, status="disabled", next_run=None, db=None, cur=None
+        self,
+        task_ids: List[int],
+        status: str = "disabled",
+        next_run: Optional[datetime.datetime] = None,
+        db=None,
+        cur=None,
     ):
         """Set the tasks' status whose ids are listed.
 
         If given, also set the next_run date.
         """
         if not task_ids:
             return
         query = ["UPDATE task SET status = %s"]
-        args = [status]
+        args: List[Any] = [status]
         if next_run:
             query.append(", next_run = %s")
             args.append(next_run)
         query.append(" WHERE id IN %s")
         args.append(tuple(task_ids))
 
         cur.execute("".join(query), args)
 
     @db_transaction()
     def disable_tasks(self, task_ids, db=None, cur=None):
         """Disable the tasks whose ids are listed."""
         return self.set_status_tasks(task_ids, db=db, cur=cur)
 
     @db_transaction()
     def search_tasks(
         self,
         task_id=None,
         task_type=None,
         status=None,
         priority=None,
         policy=None,
         before=None,
         after=None,
         limit=None,
         db=None,
         cur=None,
     ):
         """Search tasks from selected criterions"""
         where = []
         args = []
 
         if task_id:
             if isinstance(task_id, (str, int)):
                 where.append("id = %s")
             else:
                 where.append("id in %s")
                 task_id = tuple(task_id)
             args.append(task_id)
         if task_type:
             if isinstance(task_type, str):
                 where.append("type = %s")
             else:
                 where.append("type in %s")
                 task_type = tuple(task_type)
             args.append(task_type)
         if status:
             if isinstance(status, str):
                 where.append("status = %s")
             else:
                 where.append("status in %s")
                 status = tuple(status)
             args.append(status)
         if priority:
             if isinstance(priority, str):
                 where.append("priority = %s")
             else:
                 priority = tuple(priority)
                 where.append("priority in %s")
             args.append(priority)
         if policy:
             where.append("policy = %s")
             args.append(policy)
         if before:
             where.append("next_run <= %s")
             args.append(before)
         if after:
             where.append("next_run >= %s")
             args.append(after)
 
         query = "select * from task"
         if where:
             query += " where " + " and ".join(where)
         if limit:
             query += " limit %s :: bigint"
             args.append(limit)
         cur.execute(query, args)
         return cur.fetchall()
 
     @db_transaction()
     def get_tasks(self, task_ids, db=None, cur=None):
         """Retrieve the info of tasks whose ids are listed."""
         query = format_query("select {keys} from task where id in %s", self.task_keys)
         cur.execute(query, (tuple(task_ids),))
         return cur.fetchall()
 
     @db_transaction()
     def peek_ready_tasks(
         self,
         task_type,
         timestamp=None,
         num_tasks=None,
         num_tasks_priority=None,
         db=None,
         cur=None,
     ):
         """Fetch the list of ready tasks
 
         Args:
             task_type (str): filtering task per their type
             timestamp (datetime.datetime): peek tasks that need to be executed
                 before that timestamp
             num_tasks (int): only peek at num_tasks tasks (with no priority)
             num_tasks_priority (int): only peek at num_tasks_priority
                                       tasks (with priority)
 
         Returns:
             a list of tasks
 
         """
         if timestamp is None:
             timestamp = utcnow()
 
         cur.execute(
             """select * from swh_scheduler_peek_ready_tasks(
                 %s, %s, %s :: bigint, %s :: bigint)""",
             (task_type, timestamp, num_tasks, num_tasks_priority),
         )
         logger.debug("PEEK %s => %s" % (task_type, cur.rowcount))
         return cur.fetchall()
 
     @db_transaction()
     def grab_ready_tasks(
         self,
         task_type,
         timestamp=None,
         num_tasks=None,
         num_tasks_priority=None,
         db=None,
         cur=None,
     ):
         """Fetch the list of ready tasks, and mark them as scheduled
 
         Args:
             task_type (str): filtering task per their type
             timestamp (datetime.datetime): grab tasks that need to be executed
                 before that timestamp
             num_tasks (int): only grab num_tasks tasks (with no priority)
             num_tasks_priority (int): only grab oneshot num_tasks tasks (with
                                       priorities)
 
         Returns:
             a list of tasks
 
         """
         if timestamp is None:
             timestamp = utcnow()
         cur.execute(
             """select * from swh_scheduler_grab_ready_tasks(
                  %s, %s, %s :: bigint, %s :: bigint)""",
             (task_type, timestamp, num_tasks, num_tasks_priority),
         )
         logger.debug("GRAB %s => %s" % (task_type, cur.rowcount))
         return cur.fetchall()
 
     @db_transaction()
     def peek_ready_priority_tasks(
         self,
         task_type: str,
         timestamp: Optional[datetime.datetime] = None,
         num_tasks: Optional[int] = None,
         db=None,
         cur=None,
     ) -> List[Dict]:
         if timestamp is None:
             timestamp = utcnow()
 
         cur.execute(
             """select * from swh_scheduler_peek_any_ready_priority_tasks(
                 %s, %s, %s :: bigint)""",
             (task_type, timestamp, num_tasks),
         )
         logger.debug("PEEK %s => %s", task_type, cur.rowcount)
         return cur.fetchall()
 
     @db_transaction()
     def grab_ready_priority_tasks(
         self,
         task_type: str,
         timestamp: Optional[datetime.datetime] = None,
         num_tasks: Optional[int] = None,
         db=None,
         cur=None,
     ) -> List[Dict]:
         if timestamp is None:
             timestamp = utcnow()
         cur.execute(
             """select * from swh_scheduler_grab_any_ready_priority_tasks(
                  %s, %s, %s :: bigint)""",
             (task_type, timestamp, num_tasks),
         )
         logger.debug("GRAB %s => %s", task_type, cur.rowcount)
         return cur.fetchall()
 
     task_run_create_keys = ["task", "backend_id", "scheduled", "metadata"]
 
     @db_transaction()
     def schedule_task_run(
         self, task_id, backend_id, metadata=None, timestamp=None, db=None, cur=None
     ):
         """Mark a given task as scheduled, adding a task_run entry in the database.
 
         Args:
             task_id (int): the identifier for the task being scheduled
             backend_id (str): the identifier of the job in the backend
             metadata (dict): metadata to add to the task_run entry
             timestamp (datetime.datetime): the instant the event occurred
 
         Returns:
             a fresh task_run entry
 
         """
 
         if metadata is None:
             metadata = {}
 
         if timestamp is None:
             timestamp = utcnow()
 
         cur.execute(
             "select * from swh_scheduler_schedule_task_run(%s, %s, %s, %s)",
             (task_id, backend_id, metadata, timestamp),
         )
 
         return cur.fetchone()
 
     @db_transaction()
     def mass_schedule_task_runs(self, task_runs, db=None, cur=None):
         """Schedule a bunch of task runs.
 
         Args:
             task_runs (list): a list of dicts with keys:
 
                 - task (int): the identifier for the task being scheduled
                 - backend_id (str): the identifier of the job in the backend
                 - metadata (dict): metadata to add to the task_run entry
                 - scheduled (datetime.datetime): the instant the event occurred
 
         Returns:
             None
         """
         cur.execute("select swh_scheduler_mktemp_task_run()")
         db.copy_to(task_runs, "tmp_task_run", self.task_run_create_keys, cur=cur)
         cur.execute("select swh_scheduler_schedule_task_run_from_temp()")
 
     @db_transaction()
     def start_task_run(
         self, backend_id, metadata=None, timestamp=None, db=None, cur=None
     ):
         """Mark a given task as started, updating the corresponding task_run
            entry in the database.
 
         Args:
             backend_id (str): the identifier of the job in the backend
             metadata (dict): metadata to add to the task_run entry
             timestamp (datetime.datetime): the instant the event occurred
 
         Returns:
             the updated task_run entry
 
         """
 
         if metadata is None:
             metadata = {}
 
         if timestamp is None:
             timestamp = utcnow()
 
         cur.execute(
             "select * from swh_scheduler_start_task_run(%s, %s, %s)",
             (backend_id, metadata, timestamp),
         )
 
         return cur.fetchone()
 
     @db_transaction()
     def end_task_run(
         self,
         backend_id,
         status,
         metadata=None,
         timestamp=None,
         result=None,
         db=None,
         cur=None,
     ):
         """Mark a given task as ended, updating the corresponding task_run entry in the
         database.
 
         Args:
             backend_id (str): the identifier of the job in the backend
             status (str): how the task ended; one of: 'eventful', 'uneventful',
                 'failed'
             metadata (dict): metadata to add to the task_run entry
             timestamp (datetime.datetime): the instant the event occurred
 
         Returns:
             the updated task_run entry
 
         """
 
         if metadata is None:
             metadata = {}
 
         if timestamp is None:
             timestamp = utcnow()
 
         cur.execute(
             "select * from swh_scheduler_end_task_run(%s, %s, %s, %s)",
             (backend_id, status, metadata, timestamp),
         )
         return cur.fetchone()
 
     @db_transaction()
     def filter_task_to_archive(
         self,
         after_ts: str,
         before_ts: str,
         limit: int = 10,
         page_token: Optional[str] = None,
         db=None,
         cur=None,
     ) -> Dict[str, Any]:
         """Compute the tasks to archive within the datetime interval
         [after_ts, before_ts[. The method returns a paginated result.
 
         Returns:
             dict with the following keys:
               - **next_page_token**: opaque token to be used as
                 `page_token` to retrieve the next page of result. If absent,
                 there is no more pages to gather.
               - **tasks**: list of task dictionaries with the following keys:
 
                     **id** (str): origin task id
                     **started** (Optional[datetime]): started date
                     **scheduled** (datetime): scheduled date
                     **arguments** (json dict): task's arguments
                     ...
 
         """
         assert not page_token or isinstance(page_token, str)
         last_id = -1 if page_token is None else int(page_token)
         tasks = []
         cur.execute(
             "select * from swh_scheduler_task_to_archive(%s, %s, %s, %s)",
             (after_ts, before_ts, last_id, limit + 1),
         )
         for row in cur:
             task = dict(row)
             # nested type index does not accept bare values
             # transform it as a dict to comply with this
             task["arguments"]["args"] = {
                 i: v for i, v in enumerate(task["arguments"]["args"])
             }
             kwargs = task["arguments"]["kwargs"]
             task["arguments"]["kwargs"] = json.dumps(kwargs)
             tasks.append(task)
 
         if len(tasks) >= limit + 1:  # remains data, add pagination information
             result = {
                 "tasks": tasks[:limit],
                 "next_page_token": str(tasks[-1]["task_id"]),
             }
         else:
             result = {"tasks": tasks}
 
         return result
 
     @db_transaction()
     def delete_archived_tasks(self, task_ids, db=None, cur=None):
         """Delete archived tasks as much as possible. Only the task_ids whose
            complete associated task_run have been cleaned up will be.
 
         """
         _task_ids = _task_run_ids = []
         for task_id in task_ids:
             _task_ids.append(task_id["task_id"])
             _task_run_ids.append(task_id["task_run_id"])
 
         cur.execute(
             "select * from swh_scheduler_delete_archived_tasks(%s, %s)",
             (_task_ids, _task_run_ids),
         )
 
     task_run_keys = [
         "id",
         "task",
         "backend_id",
         "scheduled",
         "started",
         "ended",
         "metadata",
         "status",
     ]
 
     @db_transaction()
     def get_task_runs(self, task_ids, limit=None, db=None, cur=None):
         """Search task run for a task id"""
         where = []
         args = []
 
         if task_ids:
             if isinstance(task_ids, (str, int)):
                 where.append("task = %s")
             else:
                 where.append("task in %s")
                 task_ids = tuple(task_ids)
             args.append(task_ids)
         else:
             return ()
 
         query = "select * from task_run where " + " and ".join(where)
         if limit:
             query += " limit %s :: bigint"
             args.append(limit)
         cur.execute(query, args)
         return cur.fetchall()
 
     @db_transaction()
     def get_priority_ratios(self, db=None, cur=None):
         cur.execute("select id, ratio from priority_ratio")
         return {row["id"]: row["ratio"] for row in cur.fetchall()}
 
     @db_transaction()
     def origin_visit_stats_upsert(
         self, origin_visit_stats: Iterable[OriginVisitStats], db=None, cur=None
     ) -> None:
         pk_cols = OriginVisitStats.primary_key_columns()
         insert_cols, insert_meta = OriginVisitStats.insert_columns_and_metavars()
 
         query = f"""
             INSERT into origin_visit_stats AS ovi ({", ".join(insert_cols)})
             VALUES %s
             ON CONFLICT ({", ".join(pk_cols)}) DO UPDATE
             SET last_eventful = coalesce(excluded.last_eventful, ovi.last_eventful),
                 last_uneventful = coalesce(excluded.last_uneventful, ovi.last_uneventful),
                 last_failed = coalesce(excluded.last_failed, ovi.last_failed),
                 last_notfound = coalesce(excluded.last_notfound, ovi.last_notfound),
                 last_snapshot = coalesce(excluded.last_snapshot, ovi.last_snapshot)
         """  # noqa
 
         try:
             psycopg2.extras.execute_values(
                 cur=cur,
                 sql=query,
                 argslist=(
                     attr.asdict(visit_stats) for visit_stats in origin_visit_stats
                 ),
                 template=f"({', '.join(insert_meta)})",
                 page_size=1000,
                 fetch=False,
             )
         except CardinalityViolation as e:
             raise SchedulerException(repr(e))
 
     @db_transaction()
     def origin_visit_stats_get(
         self, ids: Iterable[Tuple[str, str]], db=None, cur=None
     ) -> List[OriginVisitStats]:
         if not ids:
             return []
         primary_keys = tuple((origin, visit_type) for (origin, visit_type) in ids)
         query = format_query(
             """
             SELECT {keys}
             FROM (VALUES %s) as stats(url, visit_type)
             INNER JOIN origin_visit_stats USING (url, visit_type)
         """,
             OriginVisitStats.select_columns(),
         )
         rows = psycopg2.extras.execute_values(
             cur=cur, sql=query, argslist=primary_keys, fetch=True
         )
         return [OriginVisitStats(**row) for row in rows]
 
     @db_transaction()
     def update_metrics(
         self,
         lister_id: Optional[UUID] = None,
         timestamp: Optional[datetime.datetime] = None,
         db=None,
         cur=None,
     ) -> List[SchedulerMetrics]:
         """Update the performance metrics of this scheduler instance.
 
         Returns the updated metrics.
 
         Args:
           lister_id: if passed, update the metrics only for this lister instance
           timestamp: if passed, the date at which we're updating the metrics,
             defaults to the database NOW()
         """
         query = format_query(
             "SELECT {keys} FROM update_metrics(%s, %s)",
             SchedulerMetrics.select_columns(),
         )
         cur.execute(query, (lister_id, timestamp))
         return [SchedulerMetrics(**row) for row in cur.fetchall()]
 
     @db_transaction()
     def get_metrics(
         self,
         lister_id: Optional[UUID] = None,
         visit_type: Optional[str] = None,
         db=None,
         cur=None,
     ) -> List[SchedulerMetrics]:
         """Retrieve the performance metrics of this scheduler instance.
 
         Args:
           lister_id: filter the metrics for this lister instance only
           visit_type: filter the metrics for this visit type only
         """
 
         where_filters = []
         where_args = []
         if lister_id:
             where_filters.append("lister_id = %s")
             where_args.append(str(lister_id))
         if visit_type:
             where_filters.append("visit_type = %s")
             where_args.append(visit_type)
 
         where_clause = ""
         if where_filters:
             where_clause = f"where {' and '.join(where_filters)}"
 
         query = format_query(
             "SELECT {keys} FROM scheduler_metrics %s" % where_clause,
             SchedulerMetrics.select_columns(),
         )
 
         cur.execute(query, tuple(where_args))
         return [SchedulerMetrics(**row) for row in cur.fetchall()]
diff --git a/swh/scheduler/cli/task.py b/swh/scheduler/cli/task.py
index e2d2d97..304d98d 100644
--- a/swh/scheduler/cli/task.py
+++ b/swh/scheduler/cli/task.py
@@ -1,751 +1,757 @@
-# Copyright (C) 2016-2020  The Software Heritage developers
+# Copyright (C) 2016-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
+from __future__ import annotations
+
 # WARNING: do not import unnecessary things here to keep cli startup time under
 # control
 import locale
 import logging
-from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional
 
 import click
 
 from . import cli
 
 if TYPE_CHECKING:
+    import datetime
+
     # importing swh.storage.interface triggers the load of 300+ modules, so...
     from swh.model.model import Origin
     from swh.storage.interface import StorageInterface
 
 
 locale.setlocale(locale.LC_ALL, "")
 CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
 DATETIME = click.DateTime()
 
 
 def format_dict(d):
     """Recursively format date objects in the dict passed as argument"""
     import datetime
 
     ret = {}
     for k, v in d.items():
         if isinstance(v, (datetime.date, datetime.datetime)):
             v = v.isoformat()
         elif isinstance(v, dict):
             v = format_dict(v)
         ret[k] = v
     return ret
 
 
 def pretty_print_list(list, indent=0):
     """Pretty-print a list"""
     return "".join("%s%r\n" % (" " * indent, item) for item in list)
 
 
 def pretty_print_dict(dict, indent=0):
     """Pretty-print a list"""
     return "".join(
         "%s%s: %r\n" % (" " * indent, click.style(key, bold=True), value)
         for key, value in sorted(dict.items())
     )
 
 
 def pretty_print_run(run, indent=4):
     fmt = (
         "{indent}{backend_id} [{status}]\n"
         "{indent}  scheduled: {scheduled} [{started}:{ended}]"
     )
     return fmt.format(indent=" " * indent, **format_dict(run))
 
 
 def pretty_print_task(task, full=False):
     """Pretty-print a task
 
     If 'full' is True, also print the status and priority fields.
 
     >>> import datetime
     >>> task = {
     ...     'id': 1234,
     ...     'arguments': {
     ...         'args': ['foo', 'bar', True],
     ...         'kwargs': {'key': 'value', 'key2': 42},
     ...     },
     ...     'current_interval': datetime.timedelta(hours=1),
     ...     'next_run': datetime.datetime(2019, 2, 21, 13, 52, 35, 407818),
     ...     'policy': 'oneshot',
     ...     'priority': None,
     ...     'status': 'next_run_not_scheduled',
     ...     'type': 'test_task',
     ... }
     >>> print(click.unstyle(pretty_print_task(task)))
     Task 1234
       Next run: ... (2019-02-21T13:52:35.407818)
       Interval: 1:00:00
       Type: test_task
       Policy: oneshot
       Args:
         'foo'
         'bar'
         True
       Keyword args:
         key: 'value'
         key2: 42
     <BLANKLINE>
     >>> print(click.unstyle(pretty_print_task(task, full=True)))
     Task 1234
       Next run: ... (2019-02-21T13:52:35.407818)
       Interval: 1:00:00
       Type: test_task
       Policy: oneshot
       Status: next_run_not_scheduled
       Priority:\x20
       Args:
         'foo'
         'bar'
         True
       Keyword args:
         key: 'value'
         key2: 42
     <BLANKLINE>
     """
     import humanize
 
     next_run = task["next_run"]
     lines = [
         "%s %s\n" % (click.style("Task", bold=True), task["id"]),
         click.style("  Next run: ", bold=True),
         "%s (%s)" % (humanize.naturaldate(next_run), next_run.isoformat()),
         "\n",
         click.style("  Interval: ", bold=True),
         str(task["current_interval"]),
         "\n",
         click.style("  Type: ", bold=True),
         task["type"] or "",
         "\n",
         click.style("  Policy: ", bold=True),
         task["policy"] or "",
         "\n",
     ]
     if full:
         lines += [
             click.style("  Status: ", bold=True),
             task["status"] or "",
             "\n",
             click.style("  Priority: ", bold=True),
             task["priority"] or "",
             "\n",
         ]
     lines += [
         click.style("  Args:\n", bold=True),
         pretty_print_list(task["arguments"]["args"], indent=4),
         click.style("  Keyword args:\n", bold=True),
         pretty_print_dict(task["arguments"]["kwargs"], indent=4),
     ]
 
     return "".join(lines)
 
 
 @cli.group("task")
 @click.pass_context
 def task(ctx):
     """Manipulate tasks."""
     pass
 
 
 @task.command("schedule")
 @click.option(
     "--columns",
     "-c",
     multiple=True,
     default=["type", "args", "kwargs", "next_run"],
     type=click.Choice(["type", "args", "kwargs", "policy", "next_run"]),
     help="columns present in the CSV file",
 )
 @click.option("--delimiter", "-d", default=",")
 @click.argument("file", type=click.File(encoding="utf-8"))
 @click.pass_context
 def schedule_tasks(ctx, columns, delimiter, file):
     """Schedule tasks from a CSV input file.
 
     The following columns are expected, and can be set through the -c option:
 
      - type: the type of the task to be scheduled (mandatory)
 
      - args: the arguments passed to the task (JSON list, defaults to an empty
        list)
 
      - kwargs: the keyword arguments passed to the task (JSON object, defaults
        to an empty dict)
 
      - next_run: the date at which the task should run (datetime, defaults to
        now)
 
     The CSV can be read either from a named file, or from stdin (use - as
     filename).
 
     Use sample:
 
     cat scheduling-task.txt | \
         python3 -m swh.scheduler.cli \
             --database 'service=swh-scheduler-dev' \
             task schedule \
                 --columns type --columns kwargs --columns policy \
                 --delimiter ';' -
 
     """
     import csv
     import json
 
     from swh.scheduler.utils import utcnow
 
     tasks = []
     now = utcnow()
     scheduler = ctx.obj["scheduler"]
     if not scheduler:
         raise ValueError("Scheduler class (local/remote) must be instantiated")
 
     reader = csv.reader(file, delimiter=delimiter)
     for line in reader:
         task = dict(zip(columns, line))
         args = json.loads(task.pop("args", "[]"))
         kwargs = json.loads(task.pop("kwargs", "{}"))
         task["arguments"] = {
             "args": args,
             "kwargs": kwargs,
         }
         task["next_run"] = task.get("next_run", now)
         tasks.append(task)
 
     created = scheduler.create_tasks(tasks)
 
     output = [
         "Created %d tasks\n" % len(created),
     ]
     for task in created:
         output.append(pretty_print_task(task))
 
     click.echo_via_pager("\n".join(output))
 
 
 @task.command("add")
 @click.argument("type", nargs=1, required=True)
 @click.argument("options", nargs=-1)
 @click.option(
     "--policy", "-p", default="recurring", type=click.Choice(["recurring", "oneshot"])
 )
 @click.option(
     "--priority", "-P", default=None, type=click.Choice(["low", "normal", "high"])
 )
 @click.option("--next-run", "-n", default=None)
 @click.pass_context
 def schedule_task(ctx, type, options, policy, priority, next_run):
     """Schedule one task from arguments.
 
     The first argument is the name of the task type, further ones are
     positional and keyword argument(s) of the task, in YAML format.
     Keyword args are of the form key=value.
 
     Usage sample:
 
     swh-scheduler --database 'service=swh-scheduler' \
         task add list-pypi
 
     swh-scheduler --database 'service=swh-scheduler' \
         task add list-debian-distribution --policy=oneshot distribution=stretch
 
     Note: if the priority is not given, the task won't have the priority set,
     which is considered as the lowest priority level.
     """
     from swh.scheduler.utils import utcnow
 
     from .utils import parse_options
 
     scheduler = ctx.obj["scheduler"]
     if not scheduler:
         raise ValueError("Scheduler class (local/remote) must be instantiated")
 
     now = utcnow()
 
     (args, kw) = parse_options(options)
     task = {
         "type": type,
         "policy": policy,
         "priority": priority,
         "arguments": {"args": args, "kwargs": kw,},
         "next_run": next_run or now,
     }
     created = scheduler.create_tasks([task])
 
     output = [
         "Created %d tasks\n" % len(created),
     ]
     for task in created:
         output.append(pretty_print_task(task))
 
     click.echo("\n".join(output))
 
 
 def iter_origins(  # use string annotations to prevent some pkg loading
     storage: "StorageInterface", page_token: "Optional[str]" = None,
 ) -> "Iterator[Origin]":
     """Iterate over origins in the storage. Optionally starting from page_token.
 
     This logs regularly an info message during pagination with the page_token. This, in
     order to feed it back to the cli if the process interrupted.
 
     Yields
         origin model objects from the storage
 
     """
     while True:
         page_result = storage.origin_list(page_token=page_token)
         page_token = page_result.next_page_token
         yield from page_result.results
         if not page_token:
             break
         click.echo(f"page_token: {page_token}\n")
 
 
 @task.command("schedule_origins")
 @click.argument("type", nargs=1, required=True)
 @click.argument("options", nargs=-1)
 @click.option(
     "--batch-size",
     "-b",
     "origin_batch_size",
     default=10,
     show_default=True,
     type=int,
     help="Number of origins per task",
 )
 @click.option(
     "--page-token",
     default=0,
     show_default=True,
     type=str,
     help="Only schedule tasks for origins whose ID is greater",
 )
 @click.option(
     "--limit",
     default=None,
     type=int,
     help="Limit the tasks scheduling up to this number of tasks",
 )
 @click.option("--storage-url", "-g", help="URL of the (graph) storage API")
 @click.option(
     "--dry-run/--no-dry-run",
     is_flag=True,
     default=False,
     help="List only what would be scheduled.",
 )
 @click.pass_context
 def schedule_origin_metadata_index(
     ctx, type, options, storage_url, origin_batch_size, page_token, limit, dry_run
 ):
     """Schedules tasks for origins that are already known.
 
     The first argument is the name of the task type, further ones are
     keyword argument(s) of the task in the form key=value, where value is
     in YAML format.
 
     Usage sample:
 
     swh-scheduler --database 'service=swh-scheduler' \
         task schedule_origins index-origin-metadata
     """
     from itertools import islice
 
     from swh.storage import get_storage
 
     from .utils import parse_options, schedule_origin_batches
 
     scheduler = ctx.obj["scheduler"]
     storage = get_storage("remote", url=storage_url)
     if dry_run:
         scheduler = None
 
     (args, kw) = parse_options(options)
     if args:
         raise click.ClickException("Only keywords arguments are allowed.")
 
     origins = iter_origins(storage, page_token=page_token)
     if limit:
         origins = islice(origins, limit)
 
     origin_urls = (origin.url for origin in origins)
     schedule_origin_batches(scheduler, type, origin_urls, origin_batch_size, kw)
 
 
 @task.command("list-pending")
 @click.argument("task-types", required=True, nargs=-1)
 @click.option(
     "--limit",
     "-l",
     required=False,
     type=click.INT,
     help="The maximum number of tasks to fetch",
 )
 @click.option(
     "--before",
     "-b",
     required=False,
     type=DATETIME,
     help="List all jobs supposed to run before the given date",
 )
 @click.pass_context
 def list_pending_tasks(ctx, task_types, limit, before):
     """List the tasks that are going to be run.
 
     You can override the number of tasks to fetch
 
     """
     from swh.scheduler import compute_nb_tasks_from
 
     scheduler = ctx.obj["scheduler"]
     if not scheduler:
         raise ValueError("Scheduler class (local/remote) must be instantiated")
     num_tasks, num_tasks_priority = compute_nb_tasks_from(limit)
 
     output = []
     for task_type in task_types:
         pending = scheduler.peek_ready_tasks(
             task_type,
             timestamp=before,
             num_tasks=num_tasks,
             num_tasks_priority=num_tasks_priority,
         )
         output.append("Found %d %s tasks\n" % (len(pending), task_type))
 
         for task in pending:
             output.append(pretty_print_task(task))
 
     click.echo("\n".join(output))
 
 
 @task.command("list")
 @click.option(
     "--task-id",
     "-i",
     default=None,
     multiple=True,
     metavar="ID",
     help="List only tasks whose id is ID.",
 )
 @click.option(
     "--task-type",
     "-t",
     default=None,
     multiple=True,
     metavar="TYPE",
     help="List only tasks of type TYPE",
 )
 @click.option(
     "--limit",
     "-l",
     required=False,
     type=click.INT,
     help="The maximum number of tasks to fetch.",
 )
 @click.option(
     "--status",
     "-s",
     multiple=True,
     metavar="STATUS",
     type=click.Choice(
         ("next_run_not_scheduled", "next_run_scheduled", "completed", "disabled")
     ),
     default=None,
     help="List tasks whose status is STATUS.",
 )
 @click.option(
     "--policy",
     "-p",
     default=None,
     type=click.Choice(["recurring", "oneshot"]),
     help="List tasks whose policy is POLICY.",
 )
 @click.option(
     "--priority",
     "-P",
     default=None,
     multiple=True,
     type=click.Choice(["all", "low", "normal", "high"]),
     help="List tasks whose priority is PRIORITY.",
 )
 @click.option(
     "--before",
     "-b",
     required=False,
     type=DATETIME,
     metavar="DATETIME",
     help="Limit to tasks supposed to run before the given date.",
 )
 @click.option(
     "--after",
     "-a",
     required=False,
     type=DATETIME,
     metavar="DATETIME",
     help="Limit to tasks supposed to run after the given date.",
 )
 @click.option(
     "--list-runs",
     "-r",
     is_flag=True,
     default=False,
     help="Also list past executions of each task.",
 )
 @click.pass_context
 def list_tasks(
     ctx, task_id, task_type, limit, status, policy, priority, before, after, list_runs
 ):
     """List tasks.
     """
     scheduler = ctx.obj["scheduler"]
     if not scheduler:
         raise ValueError("Scheduler class (local/remote) must be instantiated")
 
     if not task_type:
         task_type = [x["type"] for x in scheduler.get_task_types()]
 
     # if task_id is not given, default value for status is
     #  'next_run_not_scheduled'
     # if task_id is given, default status is 'all'
     if task_id is None and status is None:
         status = ["next_run_not_scheduled"]
     if status and "all" in status:
         status = None
 
     if priority and "all" in priority:
         priority = None
 
     output = []
     tasks = scheduler.search_tasks(
         task_id=task_id,
         task_type=task_type,
         status=status,
         priority=priority,
         policy=policy,
         before=before,
         after=after,
         limit=limit,
     )
     if list_runs:
         runs = {t["id"]: [] for t in tasks}
         for r in scheduler.get_task_runs([task["id"] for task in tasks]):
             runs[r["task"]].append(r)
     else:
         runs = {}
 
     output.append("Found %d tasks\n" % (len(tasks)))
     for task in tasks:
         output.append(pretty_print_task(task, full=True))
         if runs.get(task["id"]):
             output.append(click.style("  Executions:", bold=True))
             for run in runs[task["id"]]:
                 output.append(pretty_print_run(run, indent=4))
 
     click.echo("\n".join(output))
 
 
 @task.command("respawn")
 @click.argument("task-ids", required=True, nargs=-1)
 @click.option(
     "--next-run",
     "-n",
     required=False,
     type=DATETIME,
     metavar="DATETIME",
     default=None,
     help="Re spawn the selected tasks at this date",
 )
 @click.pass_context
-def respawn_tasks(ctx, task_ids, next_run):
+def respawn_tasks(ctx, task_ids: List[str], next_run: datetime.datetime):
     """Respawn tasks.
 
     Respawn tasks given by their ids (see the 'task list' command to
     find task ids) at the given date (immediately by default).
 
     Eg.
 
        swh-scheduler task respawn 1 3 12
     """
     from swh.scheduler.utils import utcnow
 
     scheduler = ctx.obj["scheduler"]
     if not scheduler:
         raise ValueError("Scheduler class (local/remote) must be instantiated")
     if next_run is None:
         next_run = utcnow()
     output = []
 
+    task_ids_int = [int(id_) for id_ in task_ids]
+
     scheduler.set_status_tasks(
-        task_ids, status="next_run_not_scheduled", next_run=next_run
+        task_ids_int, status="next_run_not_scheduled", next_run=next_run
     )
-    output.append("Respawn tasks %s\n" % (task_ids,))
+    output.append("Respawn tasks %s\n" % (task_ids_int,))
 
     click.echo("\n".join(output))
 
 
 @task.command("archive")
 @click.option(
     "--before",
     "-b",
     default=None,
     help="""Task whose ended date is anterior will be archived.
                       Default to current month's first day.""",
 )
 @click.option(
     "--after",
     "-a",
     default=None,
     help="""Task whose ended date is after the specified date will
                       be archived. Default to prior month's first day.""",
 )
 @click.option(
     "--batch-index",
     default=1000,
     type=click.INT,
     help="Batch size of tasks to read from db to archive",
 )
 @click.option(
     "--bulk-index",
     default=200,
     type=click.INT,
     help="Batch size of tasks to bulk index",
 )
 @click.option(
     "--batch-clean",
     default=1000,
     type=click.INT,
     help="Batch size of task to clean after archival",
 )
 @click.option(
     "--dry-run/--no-dry-run",
     is_flag=True,
     default=False,
     help="Default to list only what would be archived.",
 )
 @click.option("--verbose", is_flag=True, default=False, help="Verbose mode")
 @click.option(
     "--cleanup/--no-cleanup",
     is_flag=True,
     default=True,
     help="Clean up archived tasks (default)",
 )
 @click.option(
     "--start-from",
     type=click.STRING,
     default=None,
     help="(Optional) default page to start from.",
 )
 @click.pass_context
 def archive_tasks(
     ctx,
     before,
     after,
     batch_index,
     bulk_index,
     batch_clean,
     dry_run,
     verbose,
     cleanup,
     start_from,
 ):
     """Archive task/task_run whose (task_type is 'oneshot' and task_status
        is 'completed') or (task_type is 'recurring' and task_status is
        'disabled').
 
        With --dry-run flag set (default), only list those.
 
     """
     from itertools import groupby
 
     from swh.core.utils import grouper
     from swh.scheduler.backend_es import ElasticSearchBackend
     from swh.scheduler.utils import utcnow
 
     config = ctx.obj["config"]
     scheduler = ctx.obj["scheduler"]
 
     if not scheduler:
         raise ValueError("Scheduler class (local/remote) must be instantiated")
 
     logging.basicConfig(level=logging.DEBUG if verbose else logging.INFO)
     logger = logging.getLogger(__name__)
     logging.getLogger("urllib3").setLevel(logging.WARN)
     logging.getLogger("elasticsearch").setLevel(logging.ERROR)
     if dry_run:
         logger.info("**DRY-RUN** (only reading db)")
     if not cleanup:
         logger.info("**NO CLEANUP**")
 
     es_storage = ElasticSearchBackend(**config)
     now = utcnow()
 
     # Default to archive tasks from a rolling month starting the week
     # prior to the current one
     if not before:
         before = now.shift(weeks=-1).format("YYYY-MM-DD")
 
     if not after:
         after = now.shift(weeks=-1).shift(months=-1).format("YYYY-MM-DD")
 
     logger.debug(
         "index: %s; cleanup: %s; period: [%s ; %s]"
         % (not dry_run, not dry_run and cleanup, after, before)
     )
 
     def get_index_name(
         data: Dict[str, Any], es_storage: ElasticSearchBackend = es_storage
     ) -> str:
         """Given a data record, determine the index's name through its ending
            date. This varies greatly depending on the task_run's
            status.
 
         """
         date = data.get("started")
         if not date:
             date = data["scheduled"]
         return es_storage.compute_index_name(date.year, date.month)
 
     def index_data(before, page_token, batch_index):
         while True:
             result = scheduler.filter_task_to_archive(
                 after, before, page_token=page_token, limit=batch_index
             )
             tasks_sorted = sorted(result["tasks"], key=get_index_name)
             groups = groupby(tasks_sorted, key=get_index_name)
             for index_name, tasks_group in groups:
                 logger.debug("Index tasks to %s" % index_name)
                 if dry_run:
                     for task in tasks_group:
                         yield task
                     continue
 
                 yield from es_storage.streaming_bulk(
                     index_name,
                     tasks_group,
                     source=["task_id", "task_run_id"],
                     chunk_size=bulk_index,
                 )
 
             page_token = result.get("next_page_token")
             if page_token is None:
                 break
 
     gen = index_data(before, page_token=start_from, batch_index=batch_index)
     if cleanup:
         for task_ids in grouper(gen, n=batch_clean):
             task_ids = list(task_ids)
             logger.info("Clean up %s tasks: [%s, ...]" % (len(task_ids), task_ids[0]))
             if dry_run:  # no clean up
                 continue
             ctx.obj["scheduler"].delete_archived_tasks(task_ids)
     else:
         for task_ids in grouper(gen, n=batch_index):
             task_ids = list(task_ids)
             logger.info("Indexed %s tasks: [%s, ...]" % (len(task_ids), task_ids[0]))
 
     logger.debug("Done!")
diff --git a/swh/scheduler/interface.py b/swh/scheduler/interface.py
index f4a7236..a0a7939 100644
--- a/swh/scheduler/interface.py
+++ b/swh/scheduler/interface.py
@@ -1,452 +1,457 @@
 # Copyright (C) 2015-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 
 import datetime
 from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
 from uuid import UUID
 
 from typing_extensions import Protocol, runtime_checkable
 
 from swh.core.api import remote_api_endpoint
 from swh.core.api.classes import PagedResult
 from swh.scheduler.model import ListedOrigin, Lister, OriginVisitStats, SchedulerMetrics
 
 ListedOriginPageToken = Tuple[str, str]
 
 
 class PaginatedListedOriginList(PagedResult[ListedOrigin, ListedOriginPageToken]):
     """A list of listed origins, with a continuation token"""
 
     def __init__(
         self,
         results: List[ListedOrigin],
         next_page_token: Union[None, ListedOriginPageToken, List[str]],
     ):
         parsed_next_page_token: Optional[Tuple[str, str]] = None
         if next_page_token is not None:
             if len(next_page_token) != 2:
                 raise TypeError("Expected Tuple[str, str] or list of size 2.")
             parsed_next_page_token = tuple(next_page_token)  # type: ignore
         super().__init__(results, parsed_next_page_token)
 
 
 @runtime_checkable
 class SchedulerInterface(Protocol):
     @remote_api_endpoint("task_type/create")
     def create_task_type(self, task_type):
         """Create a new task type ready for scheduling.
 
         Args:
             task_type (dict): a dictionary with the following keys:
 
                 - type (str): an identifier for the task type
                 - description (str): a human-readable description of what the
                   task does
                 - backend_name (str): the name of the task in the
                   job-scheduling backend
                 - default_interval (datetime.timedelta): the default interval
                   between two task runs
                 - min_interval (datetime.timedelta): the minimum interval
                   between two task runs
                 - max_interval (datetime.timedelta): the maximum interval
                   between two task runs
                 - backoff_factor (float): the factor by which the interval
                   changes at each run
                 - max_queue_length (int): the maximum length of the task queue
                   for this task type
 
         """
         ...
 
     @remote_api_endpoint("task_type/get")
     def get_task_type(self, task_type_name):
         """Retrieve the task type with id task_type_name"""
         ...
 
     @remote_api_endpoint("task_type/get_all")
     def get_task_types(self):
         """Retrieve all registered task types"""
         ...
 
     @remote_api_endpoint("task/create")
     def create_tasks(self, tasks, policy="recurring"):
         """Create new tasks.
 
         Args:
             tasks (list): each task is a dictionary with the following keys:
 
                 - type (str): the task type
                 - arguments (dict): the arguments for the task runner, keys:
 
                       - args (list of str): arguments
                       - kwargs (dict str -> str): keyword arguments
 
                 - next_run (datetime.datetime): the next scheduled run for the
                   task
 
         Returns:
             a list of created tasks.
 
         """
         ...
 
     @remote_api_endpoint("task/set_status")
-    def set_status_tasks(self, task_ids, status="disabled", next_run=None):
+    def set_status_tasks(
+        self,
+        task_ids: List[int],
+        status: str = "disabled",
+        next_run: Optional[datetime.datetime] = None,
+    ):
         """Set the tasks' status whose ids are listed.
 
         If given, also set the next_run date.
         """
         ...
 
     @remote_api_endpoint("task/disable")
     def disable_tasks(self, task_ids):
         """Disable the tasks whose ids are listed."""
         ...
 
     @remote_api_endpoint("task/search")
     def search_tasks(
         self,
         task_id=None,
         task_type=None,
         status=None,
         priority=None,
         policy=None,
         before=None,
         after=None,
         limit=None,
     ):
         """Search tasks from selected criterions"""
         ...
 
     @remote_api_endpoint("task/get")
     def get_tasks(self, task_ids):
         """Retrieve the info of tasks whose ids are listed."""
         ...
 
     @remote_api_endpoint("task/peek_ready")
     def peek_ready_tasks(
         self, task_type, timestamp=None, num_tasks=None, num_tasks_priority=None,
     ):
         """Fetch the list of ready tasks
 
         Args:
             task_type (str): filtering task per their type
             timestamp (datetime.datetime): peek tasks that need to be executed
                 before that timestamp
             num_tasks (int): only peek at num_tasks tasks (with no priority)
             num_tasks_priority (int): only peek at num_tasks_priority
                                       tasks (with priority)
 
         Returns:
             a list of tasks
 
         """
         ...
 
     @remote_api_endpoint("task/grab_ready")
     def grab_ready_tasks(
         self, task_type, timestamp=None, num_tasks=None, num_tasks_priority=None,
     ):
         """Fetch the list of ready tasks, and mark them as scheduled
 
         Args:
             task_type (str): filtering task per their type
             timestamp (datetime.datetime): grab tasks that need to be executed
                 before that timestamp
             num_tasks (int): only grab num_tasks tasks (with no priority)
             num_tasks_priority (int): only grab oneshot num_tasks tasks (with
                                       priorities)
 
         Returns:
             a list of tasks
 
         """
         ...
 
     @remote_api_endpoint("task/peek_ready_with_priority")
     def peek_ready_priority_tasks(
         self,
         task_type: str,
         timestamp: Optional[datetime.datetime] = None,
         num_tasks: Optional[int] = None,
     ) -> List[Dict]:
         """Fetch list of tasks (with any priority) ready to be scheduled.
 
         Args:
             task_type: filtering task per their type
             timestamp: peek tasks that need to be executed before that timestamp
             num_tasks: only peek at num_tasks tasks (with no priority)
 
         Returns:
             a list of tasks
 
         """
         ...
 
     @remote_api_endpoint("task/grab_ready_with_priority")
     def grab_ready_priority_tasks(
         self,
         task_type: str,
         timestamp: Optional[datetime.datetime] = None,
         num_tasks: Optional[int] = None,
     ) -> List[Dict]:
         """Fetch and schedule the list of tasks (with any priority) ready to be scheduled.
 
         Args:
             task_type: filtering task per their type
             timestamp: grab tasks that need to be executed
                 before that timestamp
             num_tasks: only grab num_tasks tasks (with no priority)
 
         Returns:
             a list of tasks
 
         """
         ...
 
     @remote_api_endpoint("task_run/schedule_one")
     def schedule_task_run(self, task_id, backend_id, metadata=None, timestamp=None):
         """Mark a given task as scheduled, adding a task_run entry in the database.
 
         Args:
             task_id (int): the identifier for the task being scheduled
             backend_id (str): the identifier of the job in the backend
             metadata (dict): metadata to add to the task_run entry
             timestamp (datetime.datetime): the instant the event occurred
 
         Returns:
             a fresh task_run entry
 
         """
         ...
 
     @remote_api_endpoint("task_run/schedule")
     def mass_schedule_task_runs(self, task_runs):
         """Schedule a bunch of task runs.
 
         Args:
             task_runs (list): a list of dicts with keys:
 
                 - task (int): the identifier for the task being scheduled
                 - backend_id (str): the identifier of the job in the backend
                 - metadata (dict): metadata to add to the task_run entry
                 - scheduled (datetime.datetime): the instant the event occurred
 
         Returns:
             None
         """
         ...
 
     @remote_api_endpoint("task_run/start")
     def start_task_run(self, backend_id, metadata=None, timestamp=None):
         """Mark a given task as started, updating the corresponding task_run
            entry in the database.
 
         Args:
             backend_id (str): the identifier of the job in the backend
             metadata (dict): metadata to add to the task_run entry
             timestamp (datetime.datetime): the instant the event occurred
 
         Returns:
             the updated task_run entry
 
         """
         ...
 
     @remote_api_endpoint("task_run/end")
     def end_task_run(
         self, backend_id, status, metadata=None, timestamp=None, result=None,
     ):
         """Mark a given task as ended, updating the corresponding task_run entry in the
         database.
 
         Args:
             backend_id (str): the identifier of the job in the backend
             status (str): how the task ended; one of: 'eventful', 'uneventful',
                 'failed'
             metadata (dict): metadata to add to the task_run entry
             timestamp (datetime.datetime): the instant the event occurred
 
         Returns:
             the updated task_run entry
 
         """
         ...
 
     @remote_api_endpoint("task/filter_for_archive")
     def filter_task_to_archive(
         self,
         after_ts: str,
         before_ts: str,
         limit: int = 10,
         page_token: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Compute the tasks to archive within the datetime interval
         [after_ts, before_ts[. The method returns a paginated result.
 
         Returns:
             dict with the following keys:
               - **next_page_token**: opaque token to be used as
                 `page_token` to retrieve the next page of result. If absent,
                 there is no more pages to gather.
               - **tasks**: list of task dictionaries with the following keys:
 
                     **id** (str): origin task id
                     **started** (Optional[datetime]): started date
                     **scheduled** (datetime): scheduled date
                     **arguments** (json dict): task's arguments
                     ...
 
         """
         ...
 
     @remote_api_endpoint("task/delete_archived")
     def delete_archived_tasks(self, task_ids):
         """Delete archived tasks as much as possible. Only the task_ids whose
            complete associated task_run have been cleaned up will be.
 
         """
         ...
 
     @remote_api_endpoint("task_run/get")
     def get_task_runs(self, task_ids, limit=None):
         """Search task run for a task id"""
         ...
 
     @remote_api_endpoint("lister/get")
     def get_lister(
         self, name: str, instance_name: Optional[str] = None
     ) -> Optional[Lister]:
         """Retrieve information about the given instance of the lister from the
         database.
         """
         ...
 
     @remote_api_endpoint("lister/get_or_create")
     def get_or_create_lister(
         self, name: str, instance_name: Optional[str] = None
     ) -> Lister:
         """Retrieve information about the given instance of the lister from the
         database, or create the entry if it did not exist.
         """
         ...
 
     @remote_api_endpoint("lister/update")
     def update_lister(self, lister: Lister) -> Lister:
         """Update the state for the given lister instance in the database.
 
         Returns:
             a new Lister object, with all fields updated from the database
 
         Raises:
             StaleData if the `updated` timestamp for the lister instance in
         database doesn't match the one passed by the user.
         """
         ...
 
     @remote_api_endpoint("origins/record")
     def record_listed_origins(
         self, listed_origins: Iterable[ListedOrigin]
     ) -> List[ListedOrigin]:
         """Record a set of origins that a lister has listed.
 
         This performs an "upsert": origins with the same (lister_id, url,
         visit_type) values are updated with new values for
         extra_loader_arguments, last_update and last_seen.
         """
         ...
 
     @remote_api_endpoint("origins/get")
     def get_listed_origins(
         self,
         lister_id: Optional[UUID] = None,
         url: Optional[str] = None,
         limit: int = 1000,
         page_token: Optional[ListedOriginPageToken] = None,
     ) -> PaginatedListedOriginList:
         """Get information on the listed origins matching either the `url` or
         `lister_id`, or both arguments.
 
         Use the `limit` and `page_token` arguments for continuation. The next
         page token, if any, is returned in the PaginatedListedOriginList object.
         """
         ...
 
     @remote_api_endpoint("origins/grab_next")
     def grab_next_visits(
         self,
         visit_type: str,
         count: int,
         policy: str,
         timestamp: Optional[datetime.datetime] = None,
     ) -> List[ListedOrigin]:
         """Get at most the `count` next origins that need to be visited with
         the `visit_type` loader according to the given scheduling `policy`.
 
         This will mark the origins as scheduled in the origin_visit_stats
         table, to avoid scheduling multiple visits to the same origin.
 
         Arguments:
           visit_type: type of visits to schedule
           count: number of visits to schedule
           policy: the scheduling policy used to select which visits to schedule
           timestamp: the mocked timestamp at which we're recording that the visits are
             being scheduled (defaults to the current time)
         """
         ...
 
     @remote_api_endpoint("priority_ratios/get")
     def get_priority_ratios(self):
         ...
 
     @remote_api_endpoint("visit_stats/upsert")
     def origin_visit_stats_upsert(
         self, origin_visit_stats: Iterable[OriginVisitStats]
     ) -> None:
         """Create a new origin visit stats
         """
         ...
 
     @remote_api_endpoint("visit_stats/get")
     def origin_visit_stats_get(
         self, ids: Iterable[Tuple[str, str]]
     ) -> List[OriginVisitStats]:
         """Retrieve the stats for an origin with a given visit type
 
         If some visit_stats are not found, they are filtered out of the result. So the
         output list may be of length inferior to the length of the input list.
 
         """
         ...
 
     @remote_api_endpoint("scheduler_metrics/update")
     def update_metrics(
         self,
         lister_id: Optional[UUID] = None,
         timestamp: Optional[datetime.datetime] = None,
     ) -> List[SchedulerMetrics]:
         """Update the performance metrics of this scheduler instance.
 
         Returns the updated metrics.
 
         Args:
           lister_id: if passed, update the metrics only for this lister instance
           timestamp: if passed, the date at which we're updating the metrics,
             defaults to the database NOW()
         """
         ...
 
     @remote_api_endpoint("scheduler_metrics/get")
     def get_metrics(
         self, lister_id: Optional[UUID] = None, visit_type: Optional[str] = None
     ) -> List[SchedulerMetrics]:
         """Retrieve the performance metrics of this scheduler instance.
 
         Args:
           lister_id: filter the metrics for this lister instance only
           visit_type: filter the metrics for this visit type only
         """
         ...