docs: def place(self, reverse_pipe, seqs_list, resolve_placements, files, args,
                slash_endings, tax_descr, clusterer):
          '''
          placement - This is the placement pipeline in GraftM, in aligned reads
                      are placed into phylogenetic trees, and the results interpreted.
                      If reverse reads are used, this is where the comparisons are made
                      between placements, for the summary tables to be build in the
                      next stage.
  
          Parameters
          ----------
          reverse_pipe : bool
              True: reverse reads are placed separately
              False: no reverse reads to place.
          seqs_list : list
              list of paths to alignment fastas to be placed into the tree
          resolve_placements : bool
              True:resolve placements to their most trusted taxonomy
              False: classify reads to their most trusted taxonomy, until the
                     confidence cutoff is reached.
          files : list
              graftM output file name object
          args : obj
              argparse object
          Returns
          -------
          trusted_placements : dict
              dictionary of reads and their trusted placements
          '''
          trusted_placements = {}
          files_to_delete = []
          # Merge the alignments so they can all be placed at once.
          alias_hash = self.alignment_merger(seqs_list, files.comb_aln_fa())
          files_to_delete += seqs_list
          files_to_delete.append(files.comb_aln_fa())
          if os.path.getsize(files.comb_aln_fa()) == 0:
              logging.debug("Combined alignment file has 0 size, not running pplacer")
              to_return = {}
              for idx, file in enumerate(seqs_list):
                  base_file=os.path.basename(file).replace('_forward_hits.aln.fa', '')
                  to_return[base_file] = {}
              return to_return
  
          # Run pplacer on merged file
          jplace = self.pplacer(files.jplace_output_path(), args.output_directory, files.comb_aln_fa(), args.threads)
          files_to_delete.append(jplace)
          logging.info("Placements finished")
  
          #Read the json of refpkg
          logging.info("Reading classifications")
          classifications=Classify(tax_descr).assignPlacement(
                                                             jplace,
                                                             args.placements_cutoff,
                                                             resolve_placements
                                                             )
          logging.info("Reads classified")
          # If the reverse pipe has been specified, run the comparisons between the two pipelines. If not then just return.
  
          for idx, file in enumerate(seqs_list):
  
              if reverse_pipe:
                  base_file=os.path.basename(file).replace('_forward_hits.aln.fa', '')
                  forward_gup=classifications.pop(sorted(classifications.keys())[0])
                  reverse_gup=classifications.pop(sorted(classifications.keys())[0])
                  seqs_list.pop(idx+1)
                  placements_hash = Compare().compare_placements(
                                                                 forward_gup,
                                                                 reverse_gup,
                                                                 args.placements_cutoff,
                                                                 slash_endings,
                                                                 base_file
                                                                 )
                  trusted_placements[base_file]=placements_hash['trusted_placements']
  
              else: # Set the trusted placements as
                  base_file=os.path.basename(file).replace('_hits.aln.fa', '')
                  trusted_placements[base_file]={}
                  if str(idx) in classifications:
                      for read, entry in classifications[str(idx)].items():
                          trusted_placements[base_file][read] = entry['placement']
          # Split the original jplace file
          # and write split jplaces to separate file directories
          with open(jplace) as f: jplace_json = json.load(f)
          cluster_dict = self.convert_cluster_dict_keys_to_aliases(clusterer.seq_library,
                                                                   alias_hash)
          hash_with_placements = self.jplace_split(jplace_json,
                                                   cluster_dict)
  
          for file_alias, placement_entries_list in hash_with_placements.items():
              alias_hash[file_alias]['place'] = placement_entries_list
  
          for k in alias_hash.keys():
              if 'place' not in alias_hash[k]:
                  alias_hash[k]['place'] = []
          self.write_jplace(jplace_json,
                            alias_hash)
  
          self.hk.delete(files_to_delete)# Remove combined split, not really useful
  
          return trusted_placements