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

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