code: def apriori(
      df,
      min_support=0.5,
      use_colnames=False,
      max_len=None,
      verbose=0,
      low_memory=False,
  ):
      """Get frequent itemsets from a one-hot DataFrame
  
      Parameters
      -----------
      df : pandas DataFrame
        pandas DataFrame the encoded format. Also supports
        DataFrames with sparse data; for more info, please
        see (https://pandas.pydata.org/pandas-docs/stable/
             user_guide/sparse.html#sparse-data-structures)
  
        Please note that the old pandas SparseDataFrame format
        is no longer supported in mlxtend >= 0.17.2.
  
        The allowed values are either 0/1 or True/False.
        For example,
  
      ```
               Apple  Bananas   Beer  Chicken   Milk   Rice
          0     True    False   True     True  False   True
          1     True    False   True    False  False   True
          2     True    False   True    False  False  False
          3     True     True  False    False  False  False
          4    False    False   True     True   True   True
          5    False    False   True    False   True   True
          6    False    False   True    False   True  False
          7     True     True  False    False  False  False
      ```
  
      min_support : float (default: 0.5)
        A float between 0 and 1 for minumum support of the itemsets returned.
        The support is computed as the fraction
        `transactions_where_item(s)_occur / total_transactions`.
  
      use_colnames : bool (default: False)
        If `True`, uses the DataFrames' column names in the returned DataFrame
        instead of column indices.
  
      max_len : int (default: None)
        Maximum length of the itemsets generated. If `None` (default) all
        possible itemsets lengths (under the apriori condition) are evaluated.
  
      verbose : int (default: 0)
        Shows the number of iterations if >= 1 and `low_memory` is `True`. If
        >=1 and `low_memory` is `False`, shows the number of combinations.
  
      low_memory : bool (default: False)
        If `True`, uses an iterator to search for combinations above
        `min_support`.
        Note that while `low_memory=True` should only be used for large dataset
        if memory resources are limited, because this implementation is approx.
        3-6x slower than the default.
  
  
      Returns
      -----------
      pandas DataFrame with columns ['support', 'itemsets'] of all itemsets
        that are >= `min_support` and < than `max_len`
        (if `max_len` is not None).
        Each itemset in the 'itemsets' column is of type `frozenset`,
        which is a Python built-in type that behaves similarly to
        sets except that it is immutable
        (For more info, see
        https://docs.python.org/3.6/library/stdtypes.html#frozenset).
  
      Examples
      -----------
      For usage examples, please see
      https://rasbt.github.io/mlxtend/user_guide/frequent_patterns/apriori/
  
      """
  
      def _support(_x, _n_rows, _is_sparse):
          """DRY private method to calculate support as the
          row-wise sum of values / number of rows
  
          Parameters
          -----------
  
          _x : matrix of bools or binary
  
          _n_rows : numeric, number of rows in _x
  
          _is_sparse : bool True if _x is sparse
  
          Returns
          -----------
          np.array, shape = (n_rows, )
  
          Examples
          -----------
          For usage examples, please see
          https://rasbt.github.io/mlxtend/user_guide/frequent_patterns/apriori/
  
          """
          out = np.sum(_x, axis=0) / _n_rows
          return np.array(out).reshape(-1)
  
      if min_support <= 0.0:
          raise ValueError(
              "`min_support` must be a positive "
              "number within the interval `(0, 1]`. "
              "Got %s." % min_support
          )
  
      fpc.valid_input_check(df)
  
      if hasattr(df, "sparse"):
          # DataFrame with SparseArray (pandas >= 0.24)
          if df.size == 0:
              X = df.values
          else:
              X = df.sparse.to_coo().tocsc()
          is_sparse = True
      else:
          # dense DataFrame
          X = df.values
          is_sparse = False
      support = _support(X, X.shape[0], is_sparse)
      ary_col_idx = np.arange(X.shape[1])
      support_dict = {1: support[support >= min_support]}
      itemset_dict = {
          1: ary_col_idx[support >= min_support].reshape(-1, 1)
      }
      max_itemset = 1
      rows_count = float(X.shape[0])
  
      all_ones = np.ones((int(rows_count), 1))
  
      while max_itemset and max_itemset < (max_len or float("inf")):
          next_max_itemset = max_itemset + 1
  
          # With exceptionally large datasets, the matrix operations can use a
          # substantial amount of memory. For low memory applications or large
          # datasets, set `low_memory=True` to use a slower but more memory-
          # efficient implementation.
          if low_memory:
              combin = generate_new_combinations_low_memory(
                  itemset_dict[max_itemset], X, min_support, is_sparse
              )
              # slightly faster than creating an array from a list of tuples
              combin = np.fromiter(combin, dtype=int)
              combin = combin.reshape(-1, next_max_itemset + 1)
  
              if combin.size == 0:
                  break
              if verbose:
                  print(
                      "\rProcessing %d combinations | Sampling itemset size %d"
                      % (combin.size, next_max_itemset),
                      end="",
                  )
  
              itemset_dict[next_max_itemset] = combin[:, 1:]
              support_dict[next_max_itemset] = (
                  combin[:, 0].astype(float) / rows_count
              )
              max_itemset = next_max_itemset
          else:
              combin = generate_new_combinations(
                  itemset_dict[max_itemset]
              )
              combin = np.fromiter(combin, dtype=int)
              combin = combin.reshape(-1, next_max_itemset)
  
              if combin.size == 0:
                  break
              if verbose:
                  print(
                      "\rProcessing %d combinations | Sampling itemset size %d"
                      % (combin.size, next_max_itemset),
                      end="",
                  )
  
              if is_sparse:
                  _bools = X[:, combin[:, 0]] == all_ones
                  for n in range(1, combin.shape[1]):
                      _bools = _bools & (X[:, combin[:, n]] == all_ones)
              else:
                  _bools = np.all(X[:, combin], axis=2)
  
              support = _support(
                  np.array(_bools), rows_count, is_sparse
              )
              _mask = (support >= min_support).reshape(-1)
              if any(_mask):
                  itemset_dict[next_max_itemset] = np.array(
                      combin[_mask]
                  )
                  support_dict[next_max_itemset] = np.array(
                      support[_mask]
                  )
                  max_itemset = next_max_itemset
              else:
                  # Exit condition
                  break
  
      all_res = []
      for k in sorted(itemset_dict):
          support = pd.Series(support_dict[k])
          itemsets = pd.Series(
              [frozenset(i) for i in itemset_dict[k]], dtype="object"
          )
  
          res = pd.concat((support, itemsets), axis=1)
          all_res.append(res)
  
      res_df = pd.concat(all_res)
      res_df.columns = ["support", "itemsets"]
      if use_colnames:
          mapping = {idx: item for idx, item in enumerate(df.columns)}
          res_df["itemsets"] = res_df["itemsets"].apply(
              lambda x: frozenset([mapping[i] for i in x])
          )
      res_df = res_df.reset_index(drop=True)
  
      if verbose:
          print()  # adds newline if verbose counter was used
  
      return res_df
  
imports: import numpy
  import pandas
  from ..frequent_patterns import fpcommon
label_desc: Use image node_id 3 for calling a global function with example usage: apriori(df, min_support, use_colnames, max_len, verbose, low_memory) and returns: res_df, np