class_docstr: Base class for all pipeline objects.
  
  Notes
  -----
  This class should not be instantiated, only subclassed.
code: def _get_base_search_space(
      self,
      cs,
      dataset_properties,
      include,
      exclude,
      pipeline,
      feat_type: Optional[FEAT_TYPE_TYPE] = None,
  ):
      if include is None:
          if self.include is None:
              include = {}
          else:
              include = self.include
  
      keys = [pair[0] for pair in pipeline]
      for key in include:
          if key not in keys:
              raise ValueError(
                  "Invalid key in include: %s; should be one "
                  "of %s" % (key, keys)
              )
  
      if exclude is None:
          if self.exclude is None:
              exclude = {}
          else:
              exclude = self.exclude
  
      keys = [pair[0] for pair in pipeline]
      for key in exclude:
          if key not in keys:
              raise ValueError(
                  "Invalid key in exclude: %s; should be one "
                  "of %s" % (key, keys)
              )
  
      if "sparse" not in dataset_properties:
          # This dataset is probably dense
          dataset_properties["sparse"] = False
      if "signed" not in dataset_properties:
          # This dataset probably contains unsigned data
          dataset_properties["signed"] = False
  
      matches = (
          autosklearn.pipeline.create_searchspace_util.get_match_array(
              pipeline=pipeline,
              dataset_properties=dataset_properties,
              include=include,
              exclude=exclude,
          )
      )
  
      # Now we have only legal combinations at this step of the pipeline
      # Simple sanity checks
      assert np.sum(matches) != 0, "No valid pipeline found."
  
      assert np.sum(matches) <= np.size(
          matches
      ), "'matches' is not binary; %s <= %d, %s" % (
          str(np.sum(matches)),
          np.size(matches),
          str(matches.shape),
      )
  
      # Iterate each dimension of the matches array (each step of the
      # pipeline) to see if we can add a hyperparameter for that step
      for node_idx, n_ in enumerate(pipeline):
          node_name, node = n_
  
          is_choice = isinstance(node, AutoSklearnChoice)
  
          # if the node isn't a choice we can add it immediately because it
          #  must be active (if it wasn't, np.sum(matches) would be zero
          if not is_choice:
              cs.add_configuration_space(
                  node_name,
                  node.get_hyperparameter_search_space(
                      dataset_properties=dataset_properties,
                      feat_type=feat_type,
                  ),
              )
          # If the node is a choice, we have to figure out which of its
          #  choices are actually legal choices
          else:
              choices_list = autosklearn.pipeline.create_searchspace_util.find_active_choices(
                  matches,
                  node,
                  node_idx,
                  dataset_properties,
                  include.get(node_name),
                  exclude.get(node_name),
              )
              sub_config_space = node.get_hyperparameter_search_space(
                  feat_type=feat_type,
                  dataset_properties=dataset_properties,
                  include=choices_list,
              )
              cs.add_configuration_space(node_name, sub_config_space)
  
      # And now add forbidden parameter configurations
      # According to matches
      if np.sum(matches) < np.size(matches):
          cs = autosklearn.pipeline.create_searchspace_util.add_forbidden(
              conf_space=cs,
              pipeline=pipeline,
              matches=matches,
              dataset_properties=dataset_properties,
              include=include,
              exclude=exclude,
          )
  
      return cs
  
imports: from abc import ABCMeta
  from typing import Dict, Optional, Union
  import numpy
  import scipy.sparse
  from ConfigSpace import Configuration
  from sklearn.pipeline import Pipeline
  import autosklearn.pipeline.create_searchspace_util
  from autosklearn.askl_typing import FEAT_TYPE_TYPE
  from .components.base import AutoSklearnChoice, AutoSklearnComponent
label_desc: Use image node_id 14 for calling the BasePipeline obj's underlying member method code with example usage: obj._get_base_search_space(cs, dataset_properties, include, exclude, pipeline, feat_type) and returns: cs