docs: def get_gfe(self, annotation, locus):
          """
          creates GFE from a sequence annotation
  
          :param locus:  The gene locus
          :type locus: ``str``
          :param annotation: An sequence annotation object
          :type annotation: ``List``
          :rtype: ``List``
  
          Returns:
              The GFE notation and the associated features in an array
  
          """
          features = []
          accessions = {}
          for feat in annotation.annotation:
              if isinstance(annotation.annotation[feat], DBSeq) \
                      or isinstance(annotation.annotation[feat], Seq):
                  seq = str(annotation.annotation[feat])
              else:
                  seq = str(annotation.annotation[feat].seq)
  
              # TODO: Drop this if statement
              if isutr(feat):
                  feat_str = ":".join([locus, str(1), feat, seq])
  
                  # If the feature has been loaded or stored
                  # then use that instead of making a feature request
                  if self.verbose and self.verbosity > 2:
                      self.logger.info("Getting accession " + feat_str)
  
                  if feat_str in self.all_feats[locus]:
  
                      if self.verbose and self.verbosity > 2:
                          self.logger.info("Feature found " + feat_str)
  
                      accession = self.all_feats[locus][feat_str]
                      feature = Feature(term=feat,
                                        rank=1,
                                        locus=locus,
                                        sequence=seq,
                                        accession=accession)
                      accessions.update({feat: accession})
                      features.append(feature)
                  else:
                      if self.verbose and self.verbosity > 2:
                          self.logger.info(self.logname + "Making FeatureRequest " + feat_str)
  
                      # Create FeatureRequest object
                      request = FeatureRequest(locus=locus,
                                               term=feat,
                                               rank=1,
                                               sequence=seq)
  
                      # Attempt to make feature request
                      try:
                          feature = self.api.create_feature(body=request)
                          accessions.update({feat: feature.accession})
                          features.append(feature)
                      except ApiException as e:
                          self.logger.error(self.logname + "Exception when calling DefaultApi->create_feature" + e)
                          blank_feat = Feature(term=feat, rank=1, locus=locus,
                                               sequence=seq)
                          accessions.update({feat: 0})
                          features.append(blank_feat)
  
                      # Store new features for quick retrieval if flag passed
                      if self.store_features:
  
                          # Adding new feature to all_feats
                          self.all_feats[locus].update({feat_str: feature.accession})
  
                          # Calculating memory size of all_feats
                          if self.verbose and self.verbosity > 1:
                              self.logger.info(self.logname + "Storing new feature " + feat_str)
                              mem = "{:4.4f}".format(sys.getsizeof(self.all_feats) / 1000000)
                              self.logger.info(self.logname + "Updated * all_feats " + mem + " MB *")
  
              else:
                  term, rank = feat.split("_")
                  feat_str = ":".join([locus, str(rank), term, seq])
  
                  # If the feature has been loaded or stored
                  # then use that instead of making a feature request
                  if feat_str in self.all_feats[locus]:
  
                      if self.verbose and self.verbosity > 2:
                          self.logger.info(self.logname + "Feature found " + feat_str)
  
                      accession = self.all_feats[locus][feat_str]
                      feature = Feature(term=term,
                                        rank=rank,
                                        locus=locus,
                                        sequence=seq,
                                        accession=accession)
                      accessions.update({feat: accession})
                      features.append(feature)
                  else:
  
                      if self.verbose and self.verbosity > 2:
                          self.logger.info(self.logname + "Making FeatureRequest " + feat_str)
  
                      # Create FeatureRequest object
                      request = FeatureRequest(locus=locus,
                                               term=term,
                                               rank=rank,
                                               sequence=seq)
  
                      # Attempt to make feature request
                      try:
                          feature = self.api.create_feature(body=request)
                          accessions.update({feat: feature.accession})
                          features.append(feature)
                      except ApiException as e:
                          self.logger.error(self.logname + "Exception when calling DefaultApi->create_feature %e" + e)
                          blank_feat = Feature(term=term, rank=rank, locus=locus,
                                               sequence=seq)
                          accessions.update({feat: 0})
                          features.append(blank_feat)
  
                      # Store new features for quick retrieval if flag passed
                      if self.store_features:
  
                          # Adding new feature to all_feats
                          self.all_feats[locus].update({feat_str: feature.accession})
  
                          # Calculating memory size of all_feats
                          if self.verbose and self.verbosity > 1:
                              self.logger.info(self.logname + "Storing new feature " + feat_str)
                              mem = "{:4.4f}".format(sys.getsizeof(self.all_feats) / 1000000)
                              self.logger.info(self.logname + "Updated * all_feats " + mem + " MB *")
  
          # Creating GFE
          gfe = self._make_gfe(accessions, locus)
  
          if self.verbose:
              self.logger.info("GFE = " + gfe)
  
          return features, gfe