This is an automated email from the ASF dual-hosted git repository.
vincbeck pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/airflow.git
The following commit(s) were added to refs/heads/main by this push:
new ccc897afc1 Fix simple typo in the documentation. (#42058)
ccc897afc1 is described below
commit ccc897afc16abcd504781e46edf1810eabc501ae
Author: Hyunsoo Kang <[email protected]>
AuthorDate: Wed Sep 11 02:15:46 2024 +0900
Fix simple typo in the documentation. (#42058)
---
docs/apache-airflow/howto/custom-operator.rst | 44 +++++++++++++--------------
1 file changed, 22 insertions(+), 22 deletions(-)
diff --git a/docs/apache-airflow/howto/custom-operator.rst
b/docs/apache-airflow/howto/custom-operator.rst
index ce32654a6b..f2b8db712d 100644
--- a/docs/apache-airflow/howto/custom-operator.rst
+++ b/docs/apache-airflow/howto/custom-operator.rst
@@ -281,44 +281,44 @@ templated field:
.. code-block:: python
class HelloOperator(BaseOperator):
- template_fields = "field_a"
+ template_fields = "foo"
- def __init__(field_a_id) -> None: # <- should be def
__init__(field_a)-> None
- self.field_a = field_a_id # <- should be self.field_a =
field_a
+ def __init__(self, foo_id) -> None: # should be def
__init__(self, foo) -> None
+ self.foo = foo_id # should be self.foo = foo
2. Templated fields' instance members must be assigned with their
corresponding parameter from the constructor,
either by a direct assignment or by calling the parent's constructor (in which
these fields are
defined as ``template_fields``) with explicit an assignment of the parameter.
-The following example is invalid, as the instance member ``self.field_a`` is
not assigned at all, despite being a
+The following example is invalid, as the instance member ``self.foo`` is not
assigned at all, despite being a
templated field:
.. code-block:: python
class HelloOperator(BaseOperator):
- template_fields = ("field_a", "field_b")
+ template_fields = ("foo", "bar")
- def __init__(field_a, field_b) -> None:
- self.field_b = field_b
+ def __init__(self, foo, bar) -> None:
+ self.bar = bar
-The following example is also invalid, as the instance member ``self.field_a``
of ``MyHelloOperator`` is initialized
+The following example is also invalid, as the instance member ``self.foo`` of
``MyHelloOperator`` is initialized
implicitly as part of the ``kwargs`` passed to its parent constructor:
.. code-block:: python
class HelloOperator(BaseOperator):
- template_fields = "field_a"
+ template_fields = "foo"
- def __init__(field_a) -> None:
- self.field_a = field_a
+ def __init__(self, foo) -> None:
+ self.foo = foo
class MyHelloOperator(HelloOperator):
- template_fields = ("field_a", "field_b")
+ template_fields = ("foo", "bar")
- def __init__(field_b, **kwargs) -> None: # <- should be def
__init__(field_a, field_b, **kwargs)
- super().__init__(**kwargs) # <- should be
super().__init__(field_a=field_a, **kwargs)
- self.field_b = field_b
+ def __init__(self, bar, **kwargs) -> None: # should be def
__init__(self, foo, bar, **kwargs)
+ super().__init__(**kwargs) # should be
super().__init__(foo=foo, **kwargs)
+ self.bar = bar
3. Applying actions on the parameter during the assignment in the constructor
is not allowed.
Any action on the value should be applied in the ``execute()`` method.
@@ -327,10 +327,10 @@ Therefore, the following example is invalid:
.. code-block:: python
class HelloOperator(BaseOperator):
- template_fields = "field_a"
+ template_fields = "foo"
- def __init__(field_a) -> None:
- self.field_a = field_a.lower() # <- assignment should be only
self.field_a = field_a
+ def __init__(self, foo) -> None:
+ self.foo = foo.lower() # assignment should be only self.foo =
foo
When an operator inherits from a base operator and does not have a constructor
defined on its own, the limitations above
do not apply. However, the templated fields must be set properly in the parent
according to those limitations.
@@ -340,14 +340,14 @@ Thus, the following example is valid:
.. code-block:: python
class HelloOperator(BaseOperator):
- template_fields = "field_a"
+ template_fields = "foo"
- def __init__(field_a) -> None:
- self.field_a = field_a
+ def __init__(self, foo) -> None:
+ self.foo = foo
class MyHelloOperator(HelloOperator):
- template_fields = "field_a"
+ template_fields = "foo"
The limitations above are enforced by a pre-commit named
'validate-operators-init'.
