code: def _apply_post_filters(
      df: cudf.DataFrame, filters: List[List[tuple]] | None
  ) -> cudf.DataFrame:
      """Apply DNF filters to an in-memory DataFrame
  
      Disjunctive normal form (DNF) means that the inner-most
      tuple describes a single column predicate. These inner
      predicates are combined with an AND conjunction into a
      larger predicate. The outer-most list then combines all
      of the combined filters with an OR disjunction.
      """
  
      if not filters:
          # No filters to apply
          return df
  
      def _handle_in(
          column: cudf.Series, value, *, negate
      ) -> cudf.Series:
          if not isinstance(value, (list, set, tuple)):
              raise TypeError(
                  "Value of 'in'/'not in' filter must be a list, set, or tuple."
              )
          return ~column.isin(value) if negate else column.isin(value)
  
      def _handle_is(
          column: cudf.Series, value, *, negate
      ) -> cudf.Series:
          if value not in {np.nan, None}:
              raise TypeError(
                  "Value of 'is'/'is not' filter must be np.nan or None."
              )
          return ~column.isna() if negate else column.isna()
  
      handlers: Dict[str, Callable] = {
          "==": operator.eq,
          "!=": operator.ne,
          "<": operator.lt,
          "<=": operator.le,
          ">": operator.gt,
          ">=": operator.ge,
          "in": partial(_handle_in, negate=False),
          "not in": partial(_handle_in, negate=True),
          "is": partial(_handle_is, negate=False),
          "is not": partial(_handle_is, negate=True),
      }
  
      # Can re-set the index before returning if we filter
      # out rows from a DataFrame with a default RangeIndex
      # (to reduce memory usage)
      reset_index = (
          isinstance(df.index, cudf.RangeIndex)
          and df.index.name is None
          and df.index.start == 0
          and df.index.step == 1
      )
  
      try:
          selection: cudf.Series = reduce(
              operator.or_,
              (
                  reduce(
                      operator.and_,
                      (
                          handlers[op](df[column], value)
                          for (column, op, value) in expr
                      ),
                  )
                  for expr in filters
              ),
          )
          if reset_index:
              return df[selection].reset_index(drop=True)
          return df[selection]
      except (KeyError, TypeError):
          warnings.warn(
              f"Row-wise filtering failed in read_parquet for {filters}"
          )
          return df
  
imports: from __future__ import annotations
  import itertools
  import math
  import operator
  import shutil
  import tempfile
  import warnings
  from collections import defaultdict
  from contextlib import ExitStack
  from functools import partial, reduce
  from typing import Callable, Dict, List, Optional, Tuple
  from uuid import uuid4
  import numpy
  import pandas
  from pyarrow import dataset
  import cudf
  from cudf._lib import parquet
  from cudf.api.types import is_list_like
  from cudf.core.column import build_categorical_column, column_empty, full
  from cudf.utils import ioutils
  from cudf.utils.nvtx_annotation import _cudf_nvtx_annotate
label_desc: Use image node_id 7 for calling a global function with example usage: _apply_post_filters(df, filters) and returns: df, unknown, unknown, df, df, df