code: def _conditional_join_compute(
      df: pd.DataFrame,
      right: pd.DataFrame,
      conditions: list,
      how: str,
      sort_by_appearance: bool,
      df_columns: Any,
      right_columns: Any,
      keep: str,
      use_numba: bool,
      indicator: Union[bool, str],
      force: bool,
      return_matching_indices=False,
  ) -> pd.DataFrame:
      """
      This is where the actual computation
      for the conditional join takes place.
      """
  
      (
          df,
          right,
          conditions,
          how,
          sort_by_appearance,
          df_columns,
          right_columns,
          keep,
          use_numba,
          indicator,
          force,
      ) = _conditional_join_preliminary_checks(
          df,
          right,
          conditions,
          how,
          sort_by_appearance,
          df_columns,
          right_columns,
          keep,
          use_numba,
          indicator,
          force,
          return_matching_indices,
      )
  
      eq_check = False
      le_lt_check = False
      for condition in conditions:
          left_on, right_on, op = condition
          _conditional_join_type_check(
              df[left_on], right[right_on], op, use_numba
          )
          if op == _JoinOperator.STRICTLY_EQUAL.value:
              eq_check = True
          elif op in less_than_join_types.union(
              greater_than_join_types
          ):
              le_lt_check = True
      df.index = range(len(df))
      right.index = range(len(right))
  
      if (len(conditions) > 1) or eq_check:
          if eq_check:
              result = _multiple_conditional_join_eq(
                  df,
                  right,
                  conditions,
                  keep,
                  use_numba,
                  force,
              )
          elif le_lt_check:
              result = _multiple_conditional_join_le_lt(
                  df, right, conditions, keep, use_numba
              )
          else:
              result = _multiple_conditional_join_ne(
                  df, right, conditions, keep
              )
      else:
          left_on, right_on, op = conditions[0]
          if use_numba:
              from janitor.functions._numba import _numba_single_join
  
              result = _numba_single_join(
                  left=df[left_on],
                  right=right[right_on],
                  op=op,
                  keep=keep,
              )
          else:
              result = _generic_func_cond_join(
                  left=df[left_on],
                  right=right[right_on],
                  op=op,
                  multiple_conditions=False,
                  keep=keep,
              )
  
      if result is None:
          result = np.array([], dtype=np.intp), np.array(
              [], dtype=np.intp
          )
  
      if return_matching_indices:
          return result
  
      return _create_frame(
          df,
          right,
          *result,
          how,
          df_columns,
          right_columns,
          indicator,
      )
  
imports: from __future__ import annotations
  import operator
  import warnings
  from typing import Any, Hashable, Literal, Optional, Union
  import numpy
  import pandas
  import pandas_flavor
  from pandas.api.types import is_datetime64_dtype, is_dtype_equal, is_extension_array_dtype, is_numeric_dtype, is_timedelta64_dtype
  from pandas.core.reshape.merge import _MergeOperation
  from janitor.functions.utils import _generic_func_cond_join, _JoinOperator, _keep_output, col, greater_than_join_types, less_than_join_types
  from janitor.utils import check, check_column, find_stack_level
label_desc: Use image node_id 5 for calling a global function with example usage: _conditional_join_compute(df, right, conditions, how, sort_by_appearance, df_columns, right_columns, keep, use_numba, indicator, force, return_matching_indices) and returns: _create_frame, result