docs: def resolve_feats(feat_list, seqin, seqref, start, locus, missing, verbose=False, verbosity=0):
      """
      resolve_feats - Resolves features from alignments
  
      :param feat_list: List of the found features
      :type feat_list: ``List``
      :param seqin: The input sequence
      :type seqin: ``str``
      :param locus: The input locus
      :type locus: ``str``
      :param start: Where the sequence start in the alignment
      :type start: ``int``
      :param missing: List of the unmapped features
      :type missing: ``List``
      :param verbose: Flag for running in verbose mode.
      :type verbose: ``bool``
      :param verbosity: Numerical value to indicate how verbose the output will be in verbose mode.
      :type verbosity: ``int``
      :rtype: :ref:`ann`
      """
      structures = get_structures()
      logger = logging.getLogger("Logger." + __name__)
      seq = SeqRecord(seq=Seq("".join(seqin), SingleLetterAlphabet()))
      seq_covered = len(seq.seq)
      coordinates = dict(map(lambda x: [x, 1],
                         [i for i in range(0, len(seq.seq)+1)]))
  
      mapping = dict(map(lambda x: [x, 1],
                         [i for i in range(0, len(seq.seq)+1)]))
  
      diff = 0
      if len(feat_list) > 1:
          if verbose:
              logger.error("resolve_feats error")
          return Annotation(complete_annotation=False)
      else:
          features = {}
          full_annotation = {}
          features = feat_list[0]
  
          # Need to sort
          feature_list = sorted(features.keys(),
                                key=lambda f: structures[locus][f])
  
          diff_f = True
          for feat in feature_list:
              if feat in missing:
                  f = features[feat]
                  seqrec = f.extract(seq)
                  seq_covered -= len(seqrec.seq)
                  if re.search("-", str(seqrec.seq)):
                      l1 = len(seqrec.seq)
                      newseq = re.sub(r'-', '', str(seqrec.seq))
                      seqrec.seq = Seq(newseq, IUPAC.unambiguous_dna)
                      tmdiff = l1 - len(newseq)
                      diff += tmdiff
  
                  if seqrec.seq:
                      #logger.error("FEAT HAS SEQ " + feat)
                      if diff_f and diff > 0:
                          sp = f.location.start + start
                          diff_f = False
                      else:
                          sp = f.location.start + start - diff
  
                      ep = f.location.end + start - diff
                      featn = SeqFeature(FeatureLocation(ExactPosition(sp),
                                                         ExactPosition(ep),
                                                         strand=1), type=f.type)
  
                      features.update({feat: featn})
                      full_annotation.update({feat: seqrec})
  
                      for i in range(featn.location.start, featn.location.end):
                          if i in coordinates:
                              del coordinates[i]
                          mapping[i] = feat
              else:
                  f = features[feat]
                  seqrec = f.extract(seq)
                  seq_covered -= len(seqrec.seq)
                  if re.search("-", str(seqrec.seq)):
                      l1 = len(seqrec.seq)
                      newseq = re.sub(r'-', '', str(seqrec.seq))
                      seqrec.seq = Seq(newseq, IUPAC.unambiguous_dna)
                      tmdiff = l1 - len(newseq)
                      diff += tmdiff
  
          blocks = getblocks(coordinates)
          rmapping = {k+start: mapping[k] for k in mapping.keys()}
  
          # Print out what features are missing
          if verbose and verbosity > 0 and len(full_annotation.keys()) > 1:
              logger.info("Features resolved:")
              for f in full_annotation:
                  logger.info(f)
          else:
              if verbose:
                  logger.info("Failed to resolve")
  
          if not full_annotation or len(full_annotation) == 0:
              if verbose:
                  logger.info("Failed to align missing features")
              return Annotation(complete_annotation=False)
          else:
              return Annotation(annotation=full_annotation,
                                method="clustalo",
                                features=features,
                                mapping=rmapping,
                                blocks=blocks,
                                seq=seq)