class_docstr: Base class for all pipeline objects.
  
  Notes
  -----
  This class should not be instantiated, only subclassed.
code: def _validate_include_exclude_params(self):
      if self.include is not None and self.exclude is not None:
          for key in self.include.keys():
              if key in self.exclude.keys():
                  raise ValueError(
                      "Cannot specify include and exclude for same step '{}'.".format(
                          key
                      )
                  )
  
      supported_steps = {
          step[0]: step[1]
          for step in self.steps
          if isinstance(step[1], AutoSklearnChoice)
      }
      for arg in ["include", "exclude"]:
          argument = getattr(self, arg)
          if not argument:
              continue
          for key in list(argument.keys()):
              if key not in supported_steps:
                  raise ValueError(
                      "The provided key '{}' in the '{}' argument is not valid. The"
                      " only supported keys for this task are {}".format(
                          key, arg, list(supported_steps.keys())
                      )
                  )
  
              candidate_components = argument[key]
              if not (
                  isinstance(candidate_components, list)
                  and candidate_components
              ):
                  raise ValueError(
                      "The provided value of the key '{}' in the '{}' argument is "
                      "not valid. The value must be a non-empty list.".format(
                          key, arg
                      )
                  )
  
              available_components = list(
                  supported_steps[key]
                  .get_available_components(
                      dataset_properties=self.dataset_properties
                  )
                  .keys()
              )
              for component in candidate_components:
                  if component not in available_components:
                      raise ValueError(
                          "The provided component '{}' for the key '{}' in the '{}'"
                          " argument is not valid. The supported components for the"
                          " step '{}' for this task are {}".format(
                              component,
                              key,
                              arg,
                              key,
                              available_components,
                          )
                      )
  
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 20 for calling the BasePipeline obj's underlying member method code with example usage: obj._validate_include_exclude_params() without return types