code: def generate_import_code(pipeline, operators, impute=False):
      
      def merge_imports(old_dict, new_dict):
          # Key is a module name
          for key in new_dict.keys():
              if key in old_dict.keys():
                  # Union imports from the same module
                  old_dict[key] = set(old_dict[key]) | set(new_dict[key])
              else:
                  old_dict[key] = set(new_dict[key])
  
      operators_used = [x.name for x in pipeline if isinstance(x, deap.gp.Primitive)]
      pipeline_text = 'import numpy as np\nimport pandas as pd\n'
      pipeline_imports = _starting_imports(operators, operators_used)
  
      # Build dict of import requirments from list of operators
      import_relations = {op.__name__: op.import_hash for op in operators}
  
      # Add the imputer if necessary
      if impute:
          pipeline_imports['sklearn.preprocessing'] = ['Imputer']
  
      # Build import dict from operators used
      for op in operators_used:
          try:
              operator_import = import_relations[op]
              merge_imports(pipeline_imports, operator_import)
          except KeyError:
              pass  # Operator does not require imports
  
      # Build import string
      for key in sorted(pipeline_imports.keys()):
          module_list = ', '.join(sorted(pipeline_imports[key]))
          pipeline_text += 'from {} import {}\n'.format(key, module_list)
  
      return pipeline_text
docs: Generate all library import calls for use in TPOT.export().
  
      Parameters
      ----------
      pipeline: List
          List of operators in the current optimized pipeline
      operators:
          List of operator class from operator library
      impute : bool
          Whether to impute new values in the feature set.
  
      Returns
      -------
      pipeline_text: String
          The Python code that imports all required library used in the current
          optimized pipeline