docs: def cdhit(seqs, out_file=None, temp_dir=None, threshold=0.975, make_db=True, quiet=False, threads=0, max_memory=800, retries=5, debug=False):
      '''
      Run CD-HIT.
  
      Args:
  
          seqs (list): An iterable of sequences, in any format that `abutils.utils.sequence.Sequence()`
              can handle
  
          threshold (float): Clustering identity threshold. Default is `0.975`.
  
          out_file (str): Path to the clustering output file. Default is to use
              `tempfile.NamedTemporaryFile` to generate an output file name.
  
          temp_dir (str): Path to the temporary directory. If not provided, `'/tmp'` is used.
  
          make_db (bool): Whether to build a SQlite database of sequence information. Required
              if you want to calculate consensus/centroid sequences for the resulting
              clusters or if you need to access the clustered sequences (not just sequence IDs)
              Default is `True`.
          
          quiet (bool): If `True`, surpresses printing of output/progress info. Default is `False`.
  
          threads (int): Number of threads (CPU cores) to be used for clustering. Default is `0`,
              which results in all available cores being used.
  
          max_memory (int): Max memory (in MB) for CD-HIT. Will be passed directly to CD-HIT through
              the `-M` runtime option. Default is `800`.
  
          debug (bool): If `True`, print standard output and standard error from CD-HIT. Default is `False`.
  
      Returns:
  
          If `make_db` is `True`, returns the CD-HIT output file path, the CD-HIT cluster file path,
              a `sqlite3` database connection object, and the database path. If `make_db` is `False`, only the
              CD-HIT output file path and CD-HIT cluster file path are returned.
      '''
      start_time = time.time()
      seqs = [Sequence(s) for s in seqs]
      if not quiet:
          print('CD-HIT: clustering {} seqeunces'.format(len(seqs)))
      if out_file is None:
          out_file = tempfile.NamedTemporaryFile(dir=temp_dir, delete=False)
          out_file.close()
          ofile = out_file.name
      else:
          ofile = os.path.expanduser(out_file)
      cfile = ofile + '.clstr'
      with open(ofile, 'w') as f: f.write('')
      with open(cfile, 'w') as f: f.write('')
      ifile = _make_cdhit_input(seqs, temp_dir)
      cdhit_cmd = 'cdhit -i {} -o {} -c {} -n 5 -d 0 -T {} -M {}'.format(ifile,
                                                                         ofile,
                                                                         threshold,
                                                                         threads,
                                                                         max_memory)
      while not all([os.path.getsize(cfile), os.path.getsize(cfile)]):
          cluster = sp.Popen(cdhit_cmd,
                          shell=True,
                          stdout=sp.PIPE,
                          stderr=sp.PIPE)
          stdout, stderr = cluster.communicate()
          if not retries:
              break
          retries -= 1
      end_time = time.time()
      if debug:
          print(stdout)
          print(stderr)
      else:
          os.unlink(ifile)
      if not quiet:
          print('CD-HIT: clustering took {:.2f} seconds'.format(end_time - start_time))
      if make_db:
          if not quiet:
              print('CD-HIT: building a SQLite3 database')
          seq_db, db_path = _build_seq_db(seqs, direc=temp_dir)
          return ofile, cfile, seq_db, db_path
      return ofile, cfile