API reference

| The runs in sigs, in order, each one started when the one before it succeeds.

A chain of chains is flattened, so chain([a, chain([b, c])]) is a → b → c. Building a chain publishes nothing.

| The runs in parts, then callback once every part has succeeded.

The callback is sent with the list of part results as its argument, in the order the parts were given. Every part carries the same key and the same list of ids, so the part that finishes last can collect the set by itself.

A part that fails for good does not hold the chord open: the last part to finish records the callback as failed, so nobody waits on a callback that will never be sent.

| Every run in sigs, all at once, waited on together.

A chain given to a group is not broken up: its head is published and its tail travels with it, so the group waits on the chain's last link. The handle's value is the list of results in the order the sigs were given.

| Milliseconds since the epoch of an instant.

| An instant from milliseconds since the epoch.

| The defaults, documented field by field on [Policy].

| The object every other type hangs off.

It owns the three seams (broker, result store, chord counter), the clock the library reads instead of the system clock, and the registry that turns a message name back into a body. Nothing here is global: two apps in one process do not see each other's tasks.

| The result store the app was given, or None when it keeps nothing.

| A beat on app with nothing scheduled.

| Whether a body is registered under name.

| An app on broker, with backend keeping results, counter counting chord parts, and clock as the only source of time.

The store and the counter are optional: an app without a store runs tasks nobody waits on, and an app without a counter refuses to build a chord. A broker that also implements Backend and Counter — the in-memory one and the Redis one both do — is passed three times.

| The app's time, in milliseconds since the epoch.

| The policy registered under name, or None when nobody registered it.

| Register run under name and return the task a caller sends.

Registering twice under the same name replaces the first, which is what makes it possible to run the same task under two policies in one test.

| Every registered name, sorted so a page listing them is stable.

| A worker over queues that runs up to concurrency tasks at once.

prefetch is how many messages one worker may hold unsettled: a worker that holds more than it can run looks busy while the queue behind it starves.

| The wait before attempt attempt, counting the first attempt as one.

seed is what the spread is derived from: the task id in practice. Attempt zero never waits, since nothing has failed yet.

| The object that sends tasks on a schedule.

A beat holds a list of entries and, every tick, sends the ones whose time has come. It keeps the phase: a schedule of every hour fires at the same minute every hour even if one tick ran late, because the next time is computed from the time that was due, not from the time the tick happened.

| Schedule task with args under name.

The name identifies the entry, not the task: the same task may be scheduled twice under two names and two schedules.

| The entry names and when each fires next, soonest first.

| Stop after the tick in progress.

| A run, or a set of runs, a caller can wait on and look at.

The result type is the one the task returns: get decodes the stored JSON back into it. state and revoke work on anything, since a caller that wants to cancel a run does not care what it would have returned.

| The ids the handle waits on.

| A handle over ids whose value decodes into R; all makes get answer the list of results in the order of ids.

| A handle over ids of runs that already answer in JSON.

| A broker, result store, chord counter and inspector over maps.

clock is the same function the app is given: the broker needs time to know when a delayed message is due, and the library never reads the system clock itself.

| An empty broker whose time comes from clock.

| The wait before attempt attempt of a task whose id is seed.

| The first time this schedule fires strictly after at, or None when it never fires again.

| The first time this schedule fires at or after now.

| A piece of work that has not been published yet.

The messages are ready to go; waits is what a caller waits on afterwards, which for a chain is its last link and for a chord is the callback. Building a sig publishes nothing, so a canvas can be built once and sent twice.

| Every message this sig stands for, in the order they run: the links of a chain, the parts of a group.

| A registered body. Sending it writes a message and hands back a handle.

The argument type is what the body takes; the result type is what it returns, and the handle decodes the stored value back into it. Both go over the wire as JSON, so a task may be sent by one process and run by another.

| The name the message carries.

| The policy the registration was given.

| The run of args as a node of a canvas, without publishing it.

| The object that runs tasks.

A worker consumes from queues, runs up to concurrency bodies at once, and settles each message according to the task's policy: a failure within the retry budget goes back on the queue with an eta computed from the backoff, a success advances the chain or the chord the message carries.

stop is graceful: it stops taking new messages, waits up to grace milliseconds for the ones in flight, then cancels whatever is left.

| Whether stop has been called.

| The most messages this worker holds unsettled at once.

| The queues this worker takes from.

| The keys a chord's join lives under in Celery's redis backend: the results as they arrive (.j, a sorted set scored by the part's index), the adjustment to the size (.t), and the size itself (.s).

| The key Celery's result backend stores a run under.

| The outcome of a run that raised error on attempt retries.

| The outcome of a run that returned value.

| Read a Celery envelope back into a message.

queue is what the broker knows and the envelope names, so a message read off a list is told which list it came from.

| Whether the message may run at now: its eta, when set, has come.

| Whether the message is past the time it may still run at now.

| A message for name with argument args, queued on default with no delay and no retries behind it.

| A message read from its JSON text. The FromJson impl is the same reading; this is the entry a broker uses, so a bad payload is refused in this library's terms rather than in the JSON module's.

| The JSON text of a message, which is what a broker stores.

| The message as Celery's envelope, ready to be pushed on a queue.

| An outcome read back from Celery's result backend.

| An outcome as Celery's result backend writes it, so a Celery client waiting on AsyncResult reads what a worker here finished.

| The label a result store writes for a state. These are the labels the published protocol uses, so a result written by another producer reads back as the same state.

| Whether no further state will follow. A caller waiting for a result stops here.

| The state a store's label names. An unknown label is refused rather than read as Pending: a store that grew a state this library does not know is a store this library must not guess about.

| A job every milliseconds, before a unit is chosen.

every(10).seconds() is ten seconds and every(10).minutes() is ten minutes; every(250) on its own is two hundred and fifty milliseconds.

| One rhythm inside a process.

Built by [every] and refined in a chain: every(10).minutes() is ten minutes, .at(":30") puts it on the half minute, and .run(action) gives it something to do. The interval is kept in milliseconds, which is the unit the rest of this library uses; every(n) on its own is n milliseconds.

| Where in the period the run lands: ":30" is thirty seconds past the boundary, "15:30" fifteen minutes and thirty seconds past it, and "9:15:00" nine hours, fifteen minutes past it.

A time that does not fit the period is refused rather than rounded, since a rhythm that fires at a time it was not asked for is worse than one that does not start.

| The interval read as days.

| How many of those runs raised.

| The interval read as hours.

| How long one period is, in milliseconds.

| The interval read as minutes.

| The name of the job, job until one is given.

| A name for the job, for a page that lists what is scheduled.

| The first time this job fires strictly after after.

The rhythm is anchored to the epoch and shifted by the job's offset, so a job every ten minutes at ":30" fires at 00:00:30, 00:10:30 and so on, whatever time it was added at. Strictly after is what makes a loop that has just fired ask for the run after it, rather than for the one it has just done.

| When the job runs next, in milliseconds since the epoch.

| What the job does, and the job itself so the chain can continue.

| How many times the job has run.

| The interval read as seconds.

| A set of jobs and the clock they run against.

The scheduler holds no queue and no store: a job that must survive a restart, run on another machine, or be retried belongs on a task instead. What it does keep is the rhythm — the next run of each job is computed from the run that was due, not from the moment the loop happened to wake, so a loop that was busy for a while does not drag every job with it.

| Take job into the schedule, with its first run computed from now.

The job is held as it was given: changing it afterwards changes nothing, so build the chain before adding it.

| A scheduler whose only source of time is clock.

| Every job, soonest first, with how many times each has run.

| Stop after the run in progress. The loop wakes at least every 50 milliseconds, so this takes effect promptly even with nothing scheduled.