code: def all_estimators(
      estimator_types=None,
      filter_tags=None,
      exclude_estimators=None,
      return_names=True,
      as_dataframe=False,
      return_tags=None,
      suppress_import_stdout=True,
  ):
      """Get a list of all estimators from sktime.
  
      This function crawls the module and gets all classes that inherit
      from sktime's and sklearn's base classes.
  
      Not included are: the base classes themselves, classes defined in test
      modules.
  
      Parameters
      ----------
      estimator_types: str, list of str, optional (default=None)
          Which kind of estimators should be returned.
          if None, no filter is applied and all estimators are returned.
          if str or list of str, strings define scitypes specified in search
                  only estimators that are of (at least) one of the scitypes are returned
              possible str values are entries of registry.BASE_CLASS_REGISTER (first col)
                  for instance 'classifier', 'regressor', 'transformer', 'forecaster'
      return_names: bool, optional (default=True)
          if True, estimator class name is included in the all_estimators()
              return in the order: name, estimator class, optional tags, either as
              a tuple or as pandas.DataFrame columns
          if False, estimator class name is removed from the all_estimators()
              return.
      filter_tags: dict of (str or list of str), optional (default=None)
          For a list of valid tag strings, use the registry.all_tags utility.
          subsets the returned estimators as follows:
              each key/value pair is statement in "and"/conjunction
                  key is tag name to sub-set on
                  value str or list of string are tag values
                  condition is "key must be equal to value, or in set(value)"
      exclude_estimators: str, list of str, optional (default=None)
          Names of estimators to exclude.
      as_dataframe: bool, optional (default=False)
          if True, all_estimators will return a pandas.DataFrame with named
              columns for all of the attributes being returned.
          if False, all_estimators will return a list (either a list of
              estimators or a list of tuples, see Returns)
      return_tags: str or list of str, optional (default=None)
          Names of tags to fetch and return each estimator's value of.
          For a list of valid tag strings, use the registry.all_tags utility.
          if str or list of str,
              the tag values named in return_tags will be fetched for each
              estimator and will be appended as either columns or tuple entries.
      suppress_import_stdout : bool, optional. Default=True
          whether to suppress stdout printout upon import.
  
      Returns
      -------
      all_estimators will return one of the following:
          1. list of estimators, if return_names=False, and return_tags is None
          2. list of tuples (optional estimator name, class, ~optional estimator
                  tags), if return_names=True or return_tags is not None.
          3. pandas.DataFrame if as_dataframe = True
          if list of estimators:
              entries are estimators matching the query,
              in alphabetical order of estimator name
          if list of tuples:
              list of (optional estimator name, estimator, optional estimator
              tags) matching the query, in alphabetical order of estimator name,
              where
              ``name`` is the estimator name as string, and is an
                  optional return
              ``estimator`` is the actual estimator
              ``tags`` are the estimator's values for each tag in return_tags
                  and is an optional return.
          if dataframe:
              all_estimators will return a pandas.DataFrame.
              column names represent the attributes contained in each column.
              "estimators" will be the name of the column of estimators, "names"
              will be the name of the column of estimator class names and the string(s)
              passed in return_tags will serve as column names for all columns of
              tags that were optionally requested.
  
      Examples
      --------
      >>> from sktime.registry import all_estimators
      >>> # return a complete list of estimators as pd.Dataframe
      >>> all_estimators(as_dataframe=True)
      >>> # return all forecasters by filtering for estimator type
      >>> all_estimators("forecaster")
      >>> # return all forecasters which handle missing data in the input by tag filtering
      >>> all_estimators("forecaster", filter_tags={"handles-missing-data": True})
  
      References
      ----------
      Modified version from scikit-learn's `all_estimators()`.
      """
      MODULES_TO_IGNORE = (
          "tests",
          "setup",
          "contrib",
          "benchmarking",
          "utils",
          "all",
          "plotting",
          "_split",
          "test_split",
      )
  
      result = []
      ROOT = str(
          Path(__file__).parent.parent
      )  # sktime package root directory
  
      if estimator_types:
          clsses = _check_estimator_types(estimator_types)
          if not isinstance(estimator_types, list):
              estimator_types = [estimator_types]
          CLASS_LOOKUP = {x: y for x, y in zip(estimator_types, clsses)}
      else:
          CLASS_LOOKUP = None
  
      result = all_objects(
          object_types=estimator_types,
          filter_tags=filter_tags,
          exclude_objects=exclude_estimators,
          return_names=return_names,
          as_dataframe=as_dataframe,
          return_tags=return_tags,
          suppress_import_stdout=suppress_import_stdout,
          package_name="sktime",
          path=ROOT,
          modules_to_ignore=MODULES_TO_IGNORE,
          class_lookup=CLASS_LOOKUP,
      )
  
      return result
  
file_path: sktime/sktime/registry/_lookup.py
imports: from copy import deepcopy
  from operator import itemgetter
  from pathlib import Path
  import pandas
  from skbase.lookup import all_objects
  from sktime.base import BaseEstimator
  from sktime.registry._base_classes import BASE_CLASS_LIST, BASE_CLASS_LOOKUP, TRANSFORMER_MIXIN_LIST
  from sktime.registry._tags import ESTIMATOR_TAG_REGISTER
label_desc: Use image node_id 1 for calling a global function with example usage: all_estimators(estimator_types, filter_tags, exclude_estimators, return_names, as_dataframe, return_tags, suppress_import_stdout) and returns: result