code: def get_recommended_primitives(
      entityset: EntitySet,
      include_time_series_primitives: bool = False,
      excluded_primitives: List[str] = DEFAULT_EXCLUDED_PRIMITIVES,
  ) -> List[str]:
      """Get a list of recommended primitives given an entity set.
  
      Description:
          This function works by first getting a list of valid primitives withholding any primitives specified in `excluded_primitives` that could be applied to a single-table EntitySet.
          Secondly, engineered features are created for non-numeric fields and are checked for non-uniqueness. If the feature is non-unique, it is added to the recommendation list.
          Then, numeric fields are checked for skewness. Depending on how skew a column is `square_root` or `natural_logarithm` will be recommended.
          Lastly if `include_time_series_primitives` is specified as `True`, `Lag` will always be recommended,
          as well as all Rolling and Expanding primitives if numeric columns are present.
  
      Args:
          entityset (EntitySet): EntitySet that only contains one dataframe.
          include_time_series_primitives (bool): Whether or not time-series primitives should be considered. Defaults to False.
          excluded_primitives (List[str]): List of transform primitives to exclude from recommendations. Defaults to DEFAULT_EXCLUDED_PRIMITIVES.
  
      Note:
          The main objective of this function is to recommend primitives that could potentially provide important features to the modeling process.
          Non-numeric primitives do a great job in mainly serving as a way to extract information from origin features that may essentially be meaningless by themselves (e.g., NaturalLanguage, Datetime, LatLong).
          That is why they are the main focus of this function. Numeric transform primitives are very case-by-case dependent and therefore it is hard to mathematically quantify which should be recommended.
          Therefore, only transform primitives that address skewed numeric columns are included, as this is a standard and quantifiable transformation step. The only exception to this rule being
          for time series problems. Because there are so few primitives that are only applicable for time series, all of them are included in the recommended primitives list.
  
      Note:
          This function currently only works for single table and will only recommend transform primitives.
      """
      es_dataframe_list = entityset.dataframes
      if len(es_dataframe_list) == 0:
          raise IndexError(
              "No DataFrame in EntitySet found. Please add a DataFrame."
          )
      if len(es_dataframe_list) > 1:
          raise IndexError(
              "Multi-table EntitySets are currently not supported. Please only use a single table EntitySet.",
          )
  
      target_dataframe_name = es_dataframe_list[0].ww.name
  
      recommended_primitives = set()
  
      if not include_time_series_primitives:
          excluded_primitives += TIME_SERIES_PRIMITIVES
  
      all_trans_primitives = get_transform_primitives()
      selected_trans_primitives = [
          p
          for name, p in all_trans_primitives.items()
          if name not in excluded_primitives
      ]
  
      valid_primitive_names = [
          prim.name
          for prim in get_valid_primitives(
              entityset,
              target_dataframe_name,
              1,
              selected_trans_primitives,
          )[1]
      ]
  
      recommended_primitives.update(
          _recommend_non_numeric_primitives(
              entityset,
              target_dataframe_name,
              valid_primitive_names,
          ),
      )
  
      recommended_primitives.update(
          _recommend_skew_numeric_primitives(
              entityset,
              target_dataframe_name,
              valid_primitive_names,
          ),
      )
  
      recommended_primitives.update(
          set(TIME_SERIES_PRIMITIVES).intersection(
              valid_primitive_names,
          ),
      )
      return list(recommended_primitives)
  
file_path: featuretools/featuretools/utils/recommend_primitives.py
imports: import logging
  from typing import List
  from featuretools.computational_backends import calculate_feature_matrix
  from featuretools.entityset import EntitySet
  from featuretools.primitives.utils import get_transform_primitives
  from featuretools.synthesis import dfs, get_valid_primitives
label_desc: Use image node_id 1 for calling a global function with example usage: get_recommended_primitives(entityset, include_time_series_primitives, excluded_primitives) and returns: list