code: def fill_in_config_options_for_voting_learners(
      learner_type: str, task: str, options_dict: BoolDict
  ) -> Tuple:
      """
      Fill in values specific to voting learners in the given template.
  
      Parameters
      ----------
      learner_type : str
          One of "classifier" or "regressor".
      task : str
          The voting learner task for which we are filling the values.
      options_dict : BoolDict
          A dictionary containing various boolean options which will
          be used to fill the values based on whether they are set
          to ``True`` or ``False`.
  
      Returns
      -------
      res : a 13-tuple
          A tuple containing the following items as determined by the options
          specified in ``options_dict``:
          - the path to the filled-in configuration file
          - the names of the underlying estimators used for the voting learner
          - a job prefix constructed using the experiment name, the task, the
            featureset name, and the learner name.
          - the path to any custom learner file used, if any
          - the names of the objective functions used, if any
          - the names of any output metrics used, if any
          - the list of fixed parameters used for the underlying estimators, if any
          - the list of parameter grids used for the underlying estimators, if any
          - the list of samplers used for the underlying estimators, if any
          - the number of cross-validation folds used (6 or 10)
          - the custom seed value used for cross-validation, if any
          - the number of learning curve cross-validation folds (10 or 20)
          - the list of learning curve training sizes
      """
      # setup learner-type specific values based on configuration options
      custom_learner = ""
      objectives = None
      output_metrics = []
      model_kwargs_list: Optional[List[Dict[str, Any]]] = None
      param_grid_list: Optional[List[Dict[str, Any]]] = None
      sampler_list = None
      num_cv_folds = learning_curve_cv_folds = 10
      cv_seed = 123456789
      fixed_parameters: List[Dict[str, Any]]
      learning_curve_train_sizes = [0.1, 0.325, 0.55, 0.775, 1.0]
      if learner_type == "classifier":
          learner_name = "VotingClassifier"
          estimator_names = [
              "LogisticRegression",
              "SVC",
              "MultinomialNB",
          ]
          fixed_parameters = [{"estimator_names": estimator_names}]
  
          if options_dict["with_model_kwargs_list"]:
              model_kwargs_list = [
                  {},
                  {"gamma": "auto"},
                  {"alpha": 0.01},
              ]
              fixed_parameters[0].update(
                  {"estimator_fixed_parameters": model_kwargs_list}
              )
  
          if options_dict["with_param_grid_list"]:
              param_grid_list = [{"penalty": ["l1", "l2"]}, {}, {}]
              fixed_parameters[0].update(
                  {"estimator_param_grids": param_grid_list}
              )
  
          if options_dict["with_sampler_list"]:
              sampler_list = ["SkewedChi2Sampler", "Nystroem", ""]
              fixed_parameters[0].update(
                  {"estimator_samplers": sampler_list}
              )
  
          if options_dict["with_soft_voting"]:
              fixed_parameters[0].update({"voting_type": "soft"})
  
          if options_dict["with_grid_search"]:
              objectives = (
                  ["accuracy", "f1_score_macro"]
                  if options_dict["with_multiple_objectives"]
                  else ["accuracy"]
              )
  
          if options_dict["with_output_metrics"]:
              output_metrics = ["f05", "f1_score_macro"]
  
      else:
          learner_name = "VotingRegressor"
          estimator_names = [
              "LinearRegression",
              "SVR",
              "RandomForestRegressor",
          ]
          fixed_parameters = [{"estimator_names": estimator_names}]
  
          if options_dict["with_model_kwargs_list"]:
              model_kwargs_list = [
                  {},
                  {"kernel": "poly"},
                  {"n_estimators": 200},
              ]
              fixed_parameters[0].update(
                  {"estimator_fixed_parameters": model_kwargs_list}
              )
  
          if options_dict["with_param_grid_list"]:
              param_grid_list = [{}, {"degree": [3, 4, 5]}, {}]
              fixed_parameters[0].update(
                  {"estimator_param_grids": param_grid_list}
              )
  
          if options_dict["with_sampler_list"]:
              sampler_list = ["", "AdditiveChi2Sampler", ""]
              fixed_parameters[0].update(
                  {"estimator_samplers": sampler_list}
              )
  
          if options_dict["with_grid_search"]:
              objectives = (
                  ["pearson", "neg_mean_squared_error"]
                  if options_dict["with_multiple_objectives"]
                  else ["pearson"]
              )
  
          if options_dict["with_output_metrics"]:
              output_metrics = ["spearman", "kendall_tau"]
  
      # create the dictionary that we will use to fill our config template
      experiment_name = "test_voting_learner"
      sub_prefix = task
      featureset_name = "f0"
      train_path = train_dir / f"{featureset_name}.jsonlines"
      job_name = f"{experiment_name}_{sub_prefix}_{featureset_name}_{learner_name}"
      values_to_fill_dict = {
          "experiment_name": f"{experiment_name}_{sub_prefix}",
          "train_file": str(train_path),
          "task": task,
          "learners": str([learner_name]),
          "grid_search": fix_json(
              str(options_dict["with_grid_search"])
          ),
          "featureset_names": str([featureset_name]),
          "fixed_parameters": str(fixed_parameters),
      }
  
      # insert additional values in this dictionary
      if task in ["evaluate", "predict"]:
          test_path = str(test_dir / f"{featureset_name}.jsonlines")
          values_to_fill_dict["test_file"] = str(test_path)
  
      if options_dict["with_grid_search"]:
          values_to_fill_dict["objectives"] = str(objectives)
  
      if options_dict["with_gs_folds"]:
          values_to_fill_dict["grid_search_folds"] = "4"
  
      if options_dict["with_shuffle"]:
          values_to_fill_dict["shuffle"] = "true"
  
      if options_dict["with_centering"]:
          values_to_fill_dict["feature_scaling"] = "with_mean"
  
      if options_dict["with_min_feature_count"]:
          values_to_fill_dict["min_feature_count"] = "2"
  
      if options_dict["with_custom_learner_path"]:
          custom_learner = str(other_dir / "custom_logistic_wrapper.py")
          values_to_fill_dict["custom_learner_path"] = custom_learner
  
      if options_dict["with_pos_label"]:
          values_to_fill_dict["pos_label"] = "dog"
  
      if options_dict["with_individual_predictions"]:
          values_to_fill_dict["save_votes"] = "true"
  
      if options_dict["with_output_metrics"]:
          values_to_fill_dict["metrics"] = str(output_metrics)
  
      if options_dict["with_prediction_prefix"]:
          values_to_fill_dict["predictions"] = str(output_dir)
  
      if options_dict["with_cv_folds"]:
          num_cv_folds = 6
          values_to_fill_dict["num_cv_folds"] = str(num_cv_folds)
  
      if options_dict["with_custom_cv_seed"]:
          cv_seed = 987
          values_to_fill_dict["cv_seed"] = str(cv_seed)
  
      if options_dict["without_save_cv_folds"]:
          values_to_fill_dict["save_cv_folds"] = "false"
  
      if options_dict["with_save_cv_models"]:
          values_to_fill_dict["save_cv_models"] = "true"
  
      if options_dict["with_learning_curve_cv_folds"]:
          learning_curve_cv_folds = 20
          values_to_fill_dict["learning_curve_cv_folds_list"] = str(
              [learning_curve_cv_folds]
          )
  
      if options_dict["with_learning_curve_train_sizes"]:
          learning_curve_train_sizes = [0.1, 0.5, 1.0]
          values_to_fill_dict["learning_curve_train_sizes"] = str(
              learning_curve_cv_folds
          )
  
      if task != "learning_curve":
          values_to_fill_dict["models"] = (
              str(other_dir)
              if options_dict["with_existing_model"]
              else str(output_dir)
          )
  
      # locate the voting learner config template and instantiate it
      config_template_path = (
          config_dir / f"{experiment_name}.template.cfg"
      )
      config_path = fill_in_config_options(
          config_template_path, values_to_fill_dict, sub_prefix
      )
  
      return (
          config_path,
          estimator_names,
          job_name,
          custom_learner,
          objectives,
          output_metrics,
          model_kwargs_list,
          param_grid_list,
          sampler_list,
          num_cv_folds,
          cv_seed,
          learning_curve_cv_folds,
          learning_curve_train_sizes,
      )
  
imports: import os
  import re
  from collections import OrderedDict
  from math import floor, log10
  from pathlib import Path
  from typing import Any, Dict, List, Optional, Tuple
  import numpy
  from numpy.random import RandomState
  from sklearn.datasets import fetch_california_housing, load_digits, make_classification, make_regression
  from sklearn.feature_extraction import FeatureHasher
  from sklearn.model_selection import KFold, ShuffleSplit, StratifiedKFold
  from sklearn.utils import shuffle
  from skll.config import _setup_config_parser, fix_json
  from skll.data import FeatureSet, NDJWriter
  from skll.types import PathOrStr
label_desc: Use image node_id 6 for calling a global function with example usage: fill_in_config_options_for_voting_learners(learner_type, task, options_dict) and returns: config_path,  estimator_names,  job_name,  custom_learner,  objectives,  output_metrics,  model_kwargs_list,  param_grid_list,  sampler_list,  num_cv_folds,  cv_seed,  learning_curve_cv_folds,  learning_curve_train_sizes