class_docstr: Create a new ComprehensiveFCParameters instance. You have to pass this instance to the
  extract_feature instance.
  
  It is basically a dictionary (and also based on one), which is a mapping from
  string (the same names that are in the feature_calculators.py file) to a list of dictionary of parameters,
  which should be used when the function with this name is called.
  
  Only those strings (function names), that are keys in this dictionary, will be later used to extract
  features - so whenever you delete a key from this dict, you disable the calculation of this feature.
  
  You can use the settings object with
  
  >>> from tsfresh.feature_extraction import extract_features, ComprehensiveFCParameters
  >>> extract_features(df, default_fc_parameters=ComprehensiveFCParameters())
  
  to extract all features (which is the default nevertheless) or you change the ComprehensiveFCParameters
  object to other types (see below).
code: def __init__(self):
      name_to_param = {}
  
      for name, func in feature_calculators.__dict__.items():
          if (
              callable(func)
              and hasattr(func, "fctype")
              and len(getfullargspec(func).args) == 1
          ):
              name_to_param[name] = None
  
      name_to_param.update(
          {
              "time_reversal_asymmetry_statistic": [
                  {"lag": lag} for lag in range(1, 4)
              ],
              "c3": [{"lag": lag} for lag in range(1, 4)],
              "cid_ce": [{"normalize": True}, {"normalize": False}],
              "symmetry_looking": [{"r": r * 0.05} for r in range(20)],
              "large_standard_deviation": [
                  {"r": r * 0.05} for r in range(1, 20)
              ],
              "quantile": [
                  {"q": q}
                  for q in [0.1, 0.2, 0.3, 0.4, 0.6, 0.7, 0.8, 0.9]
              ],
              "autocorrelation": [{"lag": lag} for lag in range(10)],
              "agg_autocorrelation": [
                  {"f_agg": s, "maxlag": 40}
                  for s in ["mean", "median", "var"]
              ],
              "partial_autocorrelation": [
                  {"lag": lag} for lag in range(10)
              ],
              "number_cwt_peaks": [{"n": n} for n in [1, 5]],
              "number_peaks": [{"n": n} for n in [1, 3, 5, 10, 50]],
              "binned_entropy": [
                  {"max_bins": max_bins} for max_bins in [10]
              ],
              "index_mass_quantile": [
                  {"q": q}
                  for q in [0.1, 0.2, 0.3, 0.4, 0.6, 0.7, 0.8, 0.9]
              ],
              "cwt_coefficients": [
                  {"widths": width, "coeff": coeff, "w": w}
                  for width in [(2, 5, 10, 20)]
                  for coeff in range(15)
                  for w in (2, 5, 10, 20)
              ],
              "spkt_welch_density": [
                  {"coeff": coeff} for coeff in [2, 5, 8]
              ],
              "ar_coefficient": [
                  {"coeff": coeff, "k": k}
                  for coeff in range(10 + 1)
                  for k in [10]
              ],
              "change_quantiles": [
                  {"ql": ql, "qh": qh, "isabs": b, "f_agg": f}
                  for ql in [0.0, 0.2, 0.4, 0.6, 0.8]
                  for qh in [0.2, 0.4, 0.6, 0.8, 1.0]
                  for b in [False, True]
                  for f in ["mean", "var"]
                  if ql < qh
              ],
              "fft_coefficient": [
                  {"coeff": k, "attr": a}
                  for a, k in product(
                      ["real", "imag", "abs", "angle"], range(100)
                  )
              ],
              "fft_aggregated": [
                  {"aggtype": s}
                  for s in ["centroid", "variance", "skew", "kurtosis"]
              ],
              "value_count": [{"value": value} for value in [0, 1, -1]],
              "range_count": [
                  {"min": -1, "max": 1},
                  {"min": -1e12, "max": 0},
                  {"min": 0, "max": 1e12},
              ],
              "approximate_entropy": [
                  {"m": 2, "r": r} for r in [0.1, 0.3, 0.5, 0.7, 0.9]
              ],
              "friedrich_coefficients": (
                  lambda m: [
                      {"coeff": coeff, "m": m, "r": 30}
                      for coeff in range(m + 1)
                  ]
              )(3),
              "max_langevin_fixed_point": [{"m": 3, "r": 30}],
              "linear_trend": [
                  {"attr": "pvalue"},
                  {"attr": "rvalue"},
                  {"attr": "intercept"},
                  {"attr": "slope"},
                  {"attr": "stderr"},
              ],
              "agg_linear_trend": [
                  {"attr": attr, "chunk_len": i, "f_agg": f}
                  for attr in ["rvalue", "intercept", "slope", "stderr"]
                  for i in [5, 10, 50]
                  for f in ["max", "min", "mean", "var"]
              ],
              "augmented_dickey_fuller": [
                  {"attr": "teststat"},
                  {"attr": "pvalue"},
                  {"attr": "usedlag"},
              ],
              "number_crossing_m": [{"m": 0}, {"m": -1}, {"m": 1}],
              "energy_ratio_by_chunks": [
                  {"num_segments": 10, "segment_focus": i}
                  for i in range(10)
              ],
              "ratio_beyond_r_sigma": [
                  {"r": x}
                  for x in [0.5, 1, 1.5, 2, 2.5, 3, 5, 6, 7, 10]
              ],
              "linear_trend_timewise": [
                  {"attr": "pvalue"},
                  {"attr": "rvalue"},
                  {"attr": "intercept"},
                  {"attr": "slope"},
                  {"attr": "stderr"},
              ],
              "count_above": [{"t": 0}],
              "count_below": [{"t": 0}],
              "lempel_ziv_complexity": [
                  {"bins": x} for x in [2, 3, 5, 10, 100]
              ],
              "fourier_entropy": [
                  {"bins": x} for x in [2, 3, 5, 10, 100]
              ],
              "permutation_entropy": [
                  {"tau": 1, "dimension": x} for x in [3, 4, 5, 6, 7]
              ],
              "query_similarity_count": [
                  {"query": None, "threshold": 0.0}
              ],
              "matrix_profile": [
                  {"threshold": 0.98, "feature": f}
                  for f in ["min", "max", "mean", "median", "25", "75"]
              ],
              "mean_n_absolute_max": [
                  {
                      "number_of_maxima": 3,
                      "number_of_maxima": 5,
                      "number_of_maxima": 7,
                  }
              ],
          }
      )
  
      # remove missing dependencies
      for name, func in feature_calculators.__dict__.items():
          if (
              callable(func)
              and hasattr(func, "dependency_available")
              and getattr(func, "dependency_available") is False
          ):
              name_to_param.pop(name)
              _logger.warning(
                  f"Dependency not available for {name}, this feature will be disabled!"
              )
  
      super().__init__(name_to_param)
  
imports: import logging
  from builtins import range
  from collections import UserDict
  from inspect import getfullargspec
  from itertools import product
  import cloudpickle
  import pandas
  from tsfresh.feature_extraction import feature_calculators
  from tsfresh.utilities.string_manipulation import get_config_from_string
label_desc: Use image node_id 1 to create a new ComprehensiveFCParameters object from inherited base classes: PickableSettings with example: obj = ComprehensiveFCParameters()