code: def tsfel_feature_dict_wrapper(features_dict: Dict) -> List[Callable]:
      """Wrapper enabling compatibility with tsfel feature extraction configurations.
  
      tsfel represents a collection of features as a dictionary, see more [here](https://tsfel.readthedocs.io/en/latest/descriptions/get_started.html#set-up-the-feature-extraction-config-file).
  
      By using this wrapper, we can plug in the features (that are present in the
      tsfel feature extraction configuration) in a tsflex ``FeatureCollection``.
      This enables to easily extract (a collection of) tsfel features while leveraging
      the flexibility of tsflex.
  
      .. Note::
          This wrapper wraps the output of tsfel its `get_features_by_domain` or
          `get_features_by_tag`. <br>
          See more [here](https://github.com/fraunhoferportugal/tsfel/blob/master/tsfel/feature_extraction/features_settings.py).
  
      Example
      -------
      ```python
      from tsflex.features import FeatureCollection, MultipleFeatureDescriptors
      from tsflex.features.integrations import tsfel_feature_dict_wrapper
      from tsfel.feature_extraction import get_features_by_domain
  
      stat_tsfel_feats = MultipleFeatureDescriptors(
          functions=tsfel_feature_dict_wrapper(get_features_by_domain("statistical")),
          series_names=["sig_0", "sig_1"],  # list of signal names
          windows="15min", strides="2min",
      )
  
      fc = FeatureCollection(stat_tsfel_feats)
      fc.calculate(data)  # calculate the features on your data
      ```
  
      Parameters
      ----------
      features_dict: Dictionary
          The tsfel collection of features (which is a dict).
  
      Returns
      -------
      List[Callable]
          List of the (wrapped) tsfel functions that are now directly compatible with
          with tsflex.
  
      """
  
      def get_output_names(config: dict):
          """Create the output_names based on the configuration."""
          nb_outputs = config["n_features"]
          func_name = config["function"].split(".")[-1]
          if isinstance(nb_outputs, str) and isinstance(
              config["parameters"][nb_outputs], int
          ):
              nb_outputs = config["parameters"][nb_outputs]
          if (
              func_name == "lpcc"
          ):  # Because https://github.com/fraunhoferportugal/tsfel/issues/103
              nb_outputs += 1
          if isinstance(nb_outputs, int):
              if nb_outputs == 1:
                  return func_name
              else:
                  return [
                      func_name + f"_{idx}"
                      for idx in range(1, nb_outputs + 1)
                  ]
          output_param = eval(config["parameters"][nb_outputs])
          return [
              func_name + f"_{nb_outputs}={v}" for v in output_param
          ]
  
      functions = []
      tsfel_mod = importlib.import_module("tsfel.feature_extraction")
      for (
          domain_feats
      ) in features_dict.values():  # Iterate over feature domains
          for (
              config
          ) in domain_feats.values():  # Iterate over function configs
              func = getattr(
                  tsfel_mod, config["function"].split(".")[-1]
              )
              params = (
                  config["parameters"] if config["parameters"] else {}
              )
              output_names = get_output_names(config)
              functions.append(
                  FuncWrapper(func, output_names, **params)
              )
      return functions
  
file_path: tsflex/tsflex/features/integrations.py
imports: import importlib
  from typing import Callable, Dict, List, Optional, Union
  import numpy
  import pandas
  from .function_wrapper import FuncWrapper, _get_name
label_desc: Use image node_id 3 for calling a global function with example usage: tsfel_feature_dict_wrapper(features_dict) and returns: functions, unknown, func_name, unknown