airflow.timetables.base

Module Contents

class airflow.timetables.base.DataInterval[source]

Bases: typing.NamedTuple

A data interval for a DagRun to operate over.

Both start and end MUST be "aware", i.e. contain timezone information.

start :DateTime[source]
end :DateTime[source]
classmethod exact(cls, at: DateTime)[source]

Represent an "interval" containing only an exact time.

class airflow.timetables.base.TimeRestriction[source]

Bases: typing.NamedTuple

Restriction on when a DAG can be scheduled for a run.

Specifically, the run must not be earlier than earliest, nor later than latest. If catchup is False, the run must also not be earlier than the current time, i.e. "missed" schedules are not backfilled.

These values are generally set on the DAG or task's start_date, end_date, and catchup arguments.

Both earliest and latest, if not None, are inclusive; a DAG run can happen exactly at either point of time. They are guaranteed to be aware (i.e. contain timezone information) for TimeRestriction instances created by Airflow.

earliest :Optional[DateTime][source]
latest :Optional[DateTime][source]
catchup :bool[source]
class airflow.timetables.base.DagRunInfo[source]

Bases: typing.NamedTuple

Information to schedule a DagRun.

Instances of this will be returned by timetables when they are asked to schedule a DagRun creation.

run_after :DateTime[source]

The earliest time this DagRun is created and its tasks scheduled.

This MUST be "aware", i.e. contain timezone information.

data_interval :DataInterval[source]

The data interval this DagRun to operate over.

logical_date[source]

Infer the logical date to represent a DagRun.

This replaces execution_date in Airflow 2.1 and prior. The idea is essentially the same, just a different name.

classmethod exact(cls, at: DateTime)[source]

Represent a run on an exact time.

classmethod interval(cls, start: DateTime, end: DateTime)[source]

Represent a run on a continuous schedule.

In such a schedule, each data interval starts right after the previous one ends, and each run is scheduled right after the interval ends. This applies to all schedules prior to AIP-39 except @once and None.

class airflow.timetables.base.Timetable[source]

Bases: airflow.typing_compat.Protocol

Protocol that all Timetable classes are expected to implement.

periodic :bool = True[source]

Whether this timetable runs periodically.

This defaults to and should generally be True, but some special setups like schedule_interval=None and "@once" set it to False.

can_run :bool = True[source]

Whether this timetable can actually schedule runs.

This defaults to and should generally be True, but NullTimetable sets this to False.

summary[source]

A short summary for the timetable.

This is used to display the timetable in the web UI. A cron expression timetable, for example, can use this to display the expression. The default implementation returns the timetable's type name.

classmethod deserialize(cls, data: Dict[str, Any])[source]

Deserialize a timetable from data.

This is called when a serialized DAG is deserialized. data will be whatever was returned by serialize during DAG serialization. The default implementation constructs the timetable without any arguments.

serialize(self)[source]

Serialize the timetable for JSON encoding.

This is called during DAG serialization to store timetable information in the database. This should return a JSON-serializable dict that will be fed into deserialize when the DAG is deserialized. The default implementation returns an empty dict.

validate(self)[source]

Validate the timetable is correctly specified.

Override this method to provide run-time validation raised when a DAG is put into a dagbag. The default implementation does nothing.

Raises

AirflowTimetableInvalid on validation failure.

infer_manual_data_interval(self, *, run_after: DateTime)[source]

When a DAG run is manually triggered, infer a data interval for it.

This is used for e.g. manually-triggered runs, where run_after would be when the user triggers the run. The default implementation raises NotImplementedError.

next_dagrun_info(self, *, last_automated_data_interval: Optional[DataInterval], restriction: TimeRestriction)[source]

Provide information to schedule the next DagRun.

The default implementation raises NotImplementedError.

Parameters

  • last_automated_data_interval -- The data interval of the associated DAG's last scheduled or backfilled run (manual runs not considered).

  • restriction -- Restriction to apply when scheduling the DAG run. See documentation of TimeRestriction for details.

Returns

Information on when the next DagRun can be scheduled. None means a DagRun will not happen. This does not mean no more runs will be scheduled even again for this DAG; the timetable can return a DagRunInfo object when asked at another time.

Was this entry helpful?