TeddyHartanto opened a new issue #8733:
URL: https://github.com/apache/airflow/issues/8733


   **Apache Airflow version**: master
   
   
   **Kubernetes version (if you are using kubernetes)** (use `kubectl 
version`): n/a
   
   **Environment**: n/a
   
   - **Cloud provider or hardware configuration**: n/a
   - **OS** (e.g. from /etc/os-release): n/a
   - **Kernel** (e.g. `uname -a`): n/a
   - **Install tools**: n/a
   - **Others**: n/a
   
   **What happened**:
   
   Found a typo in `airflow/airflow/ti_deps/deps/not_previously_skipped_dep.py`:
   ```python
   class NotPreviouslySkippedDep(BaseTIDep):
       """
       Determines if any of the task's direct upstream relatives have decided 
this task should
       be skipped.
       """
   
       NAME = "Not Previously Skipped"
       IGNORABLE = True
       IS_TASK_DEP = True
   ```
   
   **What you expected to happen**:
   
   `IGNORABLE`, though lexically correct, should have been `IGNOREABLE`, as 
specified in `BaseTIDep`:
   ```python
   class BaseTIDep:
       """
       Abstract base class for dependencies that must be satisfied in order for 
task
       instances to run. For example, a task that can only run if a certain 
number of its
       upstream tasks succeed. This is an abstract class and must be subclassed 
to be used.
       """
   
       # If this dependency can be ignored by a context in which it is added 
to. Needed
       # because some dependencies should never be ignoreable in their contexts.
       IGNOREABLE = False
   ```
   
   It is being used here:
   ```python
   @provide_session
       def get_dep_statuses(self, ti, session, dep_context=None):
           """
           Wrapper around the private _get_dep_statuses method that contains 
some global
           checks for all dependencies.
   
           :param ti: the task instance to get the dependency status for
           :type ti: airflow.models.TaskInstance
           :param session: database session
           :type session: sqlalchemy.orm.session.Session
           :param dep_context: the context for which this dependency should be 
evaluated for
           :type dep_context: DepContext
           """
           if dep_context is None:
               dep_context = DepContext()
   
           if self.IGNOREABLE and dep_context.ignore_all_deps:
               yield self._passing_status(
                   reason="Context specified all dependencies should be 
ignored.")
               return
   
           if self.IS_TASK_DEP and dep_context.ignore_task_deps:
               yield self._passing_status(
                   reason="Context specified all task dependencies should be 
ignored.")
               return
   
           yield from self._get_dep_statuses(ti, session, dep_context)
   ```
   
   **How to reproduce it**:
   
   n/a
   
   **Anything else we need to know**:
   
   nil


----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
[email protected]


Reply via email to