code: def convert_featurebase_list_to_feature_list(
      featurebase_list: List[FeatureBase],
  ) -> List[LiteFeature]:
      """
      Convert a List of FeatureBase objects to a list LiteFeature objects
  
      Args:
          featurebase_list (List[FeatureBase]):
  
      Returns:
         LiteFeatures (List[LiteFeature]) - converted LiteFeature objects
      """
  
      def rfunc(fb: FeatureBase) -> List[LiteFeature]:
          base_features = [
              feature
              for feature_list in [rfunc(x) for x in fb.base_features]
              for feature in feature_list
          ]
          col_schema = fb.column_schema
  
          logical_type = col_schema.logical_type
          if logical_type is not None:
              assert issubclass(type(logical_type), LogicalType)
              logical_type = type(logical_type)
  
          tags = col_schema.semantic_tags
  
          if isinstance(fb, IdentityFeature):
              primitive = None
          else:
              primitive = fb.primitive
              assert isinstance(primitive, PrimitiveBase)
  
          if fb.number_output_features > 1:
              features: List[LiteFeature] = []
  
              for idx, name in enumerate(fb.get_feature_names()):
                  f = LiteFeature(
                      name=name,
                      logical_type=logical_type,
                      tags=tags,
                      primitive=primitive,
                      base_features=base_features,
                      # TODO: use when working with multi-table
                      df_id=None,
                      idx=idx,
                  )
                  features.append(f)
  
              for feature in features:
                  related_features = [
                      f for f in features if f.id != feature.id
                  ]
                  feature.related_features = set(related_features)
  
              return features
  
          return [
              LiteFeature(
                  name=fb.get_name(),
                  logical_type=logical_type,
                  tags=tags,
                  primitive=primitive,
                  base_features=base_features,
                  # TODO: use when working with multi-table
                  df_id=None,
              ),
          ]
  
      return [
          feature
          for feature_list in [rfunc(fb) for fb in featurebase_list]
          for feature in feature_list
      ]
  
file_path: featuretools/featuretools/feature_discovery/convertors.py
imports: from __future__ import annotations
  from typing import Dict, List
  import pandas
  from woodwork.logical_types import LogicalType
  from featuretools.feature_base.feature_base import FeatureBase, IdentityFeature, TransformFeature
  from featuretools.feature_discovery.LiteFeature import LiteFeature
  from featuretools.primitives import TransformPrimitive
  from featuretools.primitives.base.primitive_base import PrimitiveBase
label_desc: Use image node_id 1 for calling a global function with example usage: convert_featurebase_list_to_feature_list(featurebase_list) and returns: unknown, list, features