• Home
• Python API Reference
• airflow.models
• airflow.models.mappedoperator

airflow.models.mappedoperator

Module Contents

Classes

OperatorPartial	An "intermediate state" returned by BaseOperator.partial().
MappedOperator	Object representing a mapped operator in a DAG.

Functions

validate_mapping_kwargs(op, func, value)
prevent_duplicates(kwargs1, kwargs2, *, fail_reason)
ensure_xcomarg_return_value(arg)

Attributes

ValidationSource

airflow.models.mappedoperator.ValidationSource

airflow.models.mappedoperator.validate_mapping_kwargs(op, func, value)

airflow.models.mappedoperator.prevent_duplicates(kwargs1, kwargs2, *, fail_reason)

airflow.models.mappedoperator.ensure_xcomarg_return_value(arg)

class airflow.models.mappedoperator.OperatorPartial

An “intermediate state” returned by BaseOperator.partial().

This only exists at DAG-parsing time; the only intended usage is for the user to call .expand() on it at some point (usually in a method chain) to create a MappedOperator to add into the DAG.

operator_class :type[airflow.models.baseoperator.BaseOperator]

kwargs :dict[str, Any]

__attrs_post_init__()

__repr__()

Return repr(self).

__del__()

expand(**mapped_kwargs)

expand_kwargs(kwargs, *, strict=True)

class airflow.models.mappedoperator.MappedOperator(context=None)

Bases: airflow.models.abstractoperator.AbstractOperator

Object representing a mapped operator in a DAG.

property task_type: str

Implementing Operator.

property operator_name: str

property inherits_from_empty_operator: bool

Implementing Operator.

property roots: Sequence[airflow.models.abstractoperator.AbstractOperator]

Implementing DAGNode.

property leaves: Sequence[airflow.models.abstractoperator.AbstractOperator]

Implementing DAGNode.

property owner: str

property email: None | str | Iterable[str]

property trigger_rule: airflow.utils.trigger_rule.TriggerRule

property depends_on_past: bool

property ignore_first_depends_on_past: bool

property wait_for_downstream: bool

property retries: int | None

property queue: str

property pool: str

property pool_slots: str | None

property execution_timeout: datetime.timedelta | None

property max_retry_delay: datetime.timedelta | None

property retry_delay: datetime.timedelta

property retry_exponential_backoff: bool

property priority_weight: int

property weight_rule: int

property sla: datetime.timedelta | None

property max_active_tis_per_dag: int | None

property resources: Resources | None

property on_execute_callback: TaskStateChangeCallback | None

property on_failure_callback: TaskStateChangeCallback | None

property on_retry_callback: TaskStateChangeCallback | None

property on_success_callback: TaskStateChangeCallback | None

property run_as_user: str | None

property executor_config: dict

property inlets: list[Any]

property outlets: list[Any]

property doc: str | None

property doc_md: str | None

property doc_json: str | None

property doc_yaml: str | None

property doc_rst: str | None

property output: airflow.models.xcom_arg.XComArg

Returns reference to XCom pushed by current operator

operator_class :type[BaseOperator] | dict[str, Any]

expand_input :airflow.models.expandinput.ExpandInput

partial_kwargs :dict[str, Any]

task_id :str

params :dict | None

deps :frozenset[airflow.ti_deps.deps.base_ti_dep.BaseTIDep]

operator_extra_links :Collection[airflow.models.baseoperator.BaseOperatorLink]

template_ext :Sequence[str]

template_fields :Collection[str]

template_fields_renderers :dict[str, str]

ui_color :str

ui_fgcolor :str

dag :DAG | None

task_group :TaskGroup | None

start_date :pendulum.DateTime | None

end_date :pendulum.DateTime | None

upstream_task_ids :set[str]

downstream_task_ids :set[str]

is_mapped :ClassVar[bool] = True

subdag :None

HIDE_ATTRS_FROM_UI :ClassVar[frozenset[str]]

__hash__()

Return hash(self).

__repr__()

Return repr(self).

__attrs_post_init__()

classmethod get_serialized_fields()

static deps_for(operator_class)

get_dag()

Implementing Operator.

serialize_for_task_group()

Implementing DAGNode.

unmap(resolve)

Get the “normal” Operator after applying the current mapping.

The resolve argument is only used if operator_class is a real class, i.e. if this operator is not serialized. If operator_class is not a class (i.e. this DAG has been deserialized), this returns a SerializedBaseOperator that “looks like” the actual unmapping result.

If resolve is a two-tuple (context, session), the information is used to resolve the mapped arguments into init arguments. If it is a mapping, no resolving happens, the mapping directly provides those init arguments resolved from mapped kwargs.

expand_mapped_task(run_id, *, session)

Create the mapped task instances for mapped task.

Returns

The newly created mapped TaskInstances (if any) in ascending order by map index, and the maximum map_index.

Return type

tuple[Sequence[airflow.models.taskinstance.TaskInstance], int]

prepare_for_execution()

iter_mapped_dependencies()

Upstream dependencies that provide XComs used by this task for task mapping.

parse_time_mapped_ti_count()

Number of mapped TaskInstances that can be created at DagRun create time.

This only considers literal mapped arguments, and would return None when any non-literal values are used for mapping.

Returns

None if non-literal mapped arg encountered, or the total number of mapped TIs this task should have.

Return type

int | None

get_mapped_ti_count(run_id, *, session)

Number of mapped TaskInstances that can be created at run time.

This considers both literal and non-literal mapped arguments, and the result is therefore available when all depended tasks have finished. The return value should be identical to parse_time_mapped_ti_count if all mapped arguments are literal.

Returns

None if upstream tasks are not complete yet, or the total number of mapped TIs this task should have.

Return type

int | None

render_template_fields(context, jinja_env=None)

Template all attributes listed in template_fields.

If the operator is mapped, this should return the unmapped, fully rendered, and map-expanded operator. The mapped operator should not be modified. However, context will be modified in-place to reference the unmapped operator for template rendering.

If the operator is not mapped, this should modify the operator in-place.

Previous Next

Was this entry helpful?