docs: def obvious_conflict_checker(ctx, name_tuples, blacklist=None):
      """ This is a pre-flight check function that will completely ignore
          recipe order or choosing an actual value in any of the multiple
          choice tuples/dependencies, and just do a very basic obvious
          conflict check.
      """
      deps_were_added_by = dict()
      deps = set()
      if blacklist is None:
          blacklist = set()
  
      # Add dependencies for all recipes:
      to_be_added = [(name_tuple, None) for name_tuple in name_tuples]
      while len(to_be_added) > 0:
          current_to_be_added = list(to_be_added)
          to_be_added = []
          for (added_tuple, adding_recipe) in current_to_be_added:
              assert(type(added_tuple) == tuple)
              if len(added_tuple) > 1:
                  # No obvious commitment in what to add, don't check it itself
                  # but throw it into deps for later comparing against
                  # (Remember this function only catches obvious issues)
                  deps.add(added_tuple)
                  continue
  
              name = added_tuple[0]
              recipe_conflicts = set()
              recipe_dependencies = []
              try:
                  # Get recipe to add and who's ultimately adding it:
                  recipe = Recipe.get_recipe(name, ctx)
                  recipe_conflicts = {c.lower() for c in recipe.conflicts}
                  recipe_dependencies = get_dependency_tuple_list_for_recipe(
                      recipe, blacklist=blacklist
                  )
              except ValueError:
                  pass
              adder_first_recipe_name = adding_recipe or name
  
              # Collect the conflicts:
              triggered_conflicts = []
              for dep_tuple_list in deps:
                  # See if the new deps conflict with things added before:
                  if set(dep_tuple_list).intersection(
                         recipe_conflicts) == set(dep_tuple_list):
                      triggered_conflicts.append(dep_tuple_list)
                      continue
  
                  # See if what was added before conflicts with the new deps:
                  if len(dep_tuple_list) > 1:
                      # Not an obvious commitment to a specific recipe/dep
                      # to be added, so we won't check.
                      # (remember this function only catches obvious issues)
                      continue
                  try:
                      dep_recipe = Recipe.get_recipe(dep_tuple_list[0], ctx)
                  except ValueError:
                      continue
                  conflicts = [c.lower() for c in dep_recipe.conflicts]
                  if name in conflicts:
                      triggered_conflicts.append(dep_tuple_list)
  
              # Throw error on conflict:
              if triggered_conflicts:
                  # Get first conflict and see who added that one:
                  adder_second_recipe_name = "'||'".join(triggered_conflicts[0])
                  second_recipe_original_adder = deps_were_added_by.get(
                      (adder_second_recipe_name,), None
                  )
                  if second_recipe_original_adder:
                      adder_second_recipe_name = second_recipe_original_adder
  
                  # Prompt error:
                  raise BuildInterruptingException(
                      "Conflict detected: '{}'"
                      " inducing dependencies {}, and '{}'"
                      " inducing conflicting dependencies {}".format(
                          adder_first_recipe_name,
                          (recipe.name,),
                          adder_second_recipe_name,
                          triggered_conflicts[0]
                      ))
  
              # Actually add it to our list:
              deps.add(added_tuple)
              deps_were_added_by[added_tuple] = adding_recipe
  
              # Schedule dependencies to be added
              to_be_added += [
                  (dep, adder_first_recipe_name or name)
                  for dep in recipe_dependencies
                  if dep not in deps
              ]
      # If we came here, then there were no obvious conflicts.
      return None