docs: def _process_feature_affected_genes(self, limit=None):
          """
          This table lists (intrinsic) genomic sequence alterations
          and their affected gene(s).
          It provides the sequence alteration ID, SO type, abbreviation,
          and relationship to the affected gene, with the gene's ID, symbol,
          and SO type (gene/pseudogene).
  
          Triples created:
          <gene id> a class:
          <gene id> rdfs:label gene_symbol
          <gene id> subclass of gene/pseudogene
  
          <variant locus id> is a GENO:allele
          <variant locus id> rdfs:label <variant_locus_label>
          <variant locus id> is an allele of <gene id>
          <variant locus id> has alternate part <sequence alteration id>
  
          <sequence alteration id> is an allele of <gene id>
          <sequence alteration id> rdf:type <sequence alteration type>
  
          :param limit:
          :return:
  
          """
  
          # can use this to process and build the variant locus.
          # but will need to process through some kind of helper hash,
          # just like we do with the genotype file.
          # that's because each gene is on a separate line
          # for example, ZDB-ALT-021021-2 is a deficiency that affects 4 genes
          # that case is when the relationship is != 'is allele of'
  
          LOG.info("Processing feature affected genes")
          line_counter = 0
          raw = '/'.join(
              (self.rawdir, self.files['feature_affected_gene']['file']))
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
          model = Model(graph)
          geno = Genotype(graph)
          with open(raw, 'r', encoding="iso-8859-1") as csvfile:
              filereader = csv.reader(csvfile, delimiter='\t', quotechar='\"')
              for row in filereader:
                  line_counter += 1
                  (genomic_feature_id, feature_so_id,
                   genomic_feature_abbreviation, gene_symbol, gene_id,
                   gene_so_id, genomic_feature_marker_relationship) = row[0:7]
  
                  # Sequence alteration types present in file:
                  # SO:0000159 - deletion,
                  # SO:0000199 - translocation,
                  # SO:0000667 - insertion,
                  # SO:0001059 - sequence_alteration,
                  # SO:0001060 - sequence_variant,
                  # SO:0001218 - transgenic insertion,
                  # SO:1000005 - complex_substitution,
                  # SO:1000008 - point_mutation,
                  # SO:1000029 - chromosomal_deletion,
                  # SO:1000032 - indel
  
                  genomic_feature_id = 'ZFIN:' + genomic_feature_id.strip()
                  gene_id = 'ZFIN:' + gene_id.strip()
  
                  self.id_label_map[
                      genomic_feature_id] = genomic_feature_abbreviation
                  self.id_label_map[gene_id] = gene_symbol
  
                  if self.test_mode and (
                          re.sub(r'ZFIN:', '', gene_id) not in self.test_ids['gene'] and
                          re.sub(r'ZFIN:', '', genomic_feature_id)
                          not in self.test_ids['allele']):
                      continue
  
                  geno.addGene(gene_id, gene_symbol, gene_so_id)
  
                  # add the gene to the list of things altered by this thing
                  if genomic_feature_id not in self.variant_loci_genes:
                      self.variant_loci_genes[genomic_feature_id] = [gene_id]
                  else:
                      if gene_id not in self.variant_loci_genes[genomic_feature_id]:
                          self.variant_loci_genes[genomic_feature_id] += [gene_id]
  
                  sequence_alteration_type = feature_so_id
                  # Add the sequence alteration id, label, and type
                  geno.addSequenceAlteration(
                      genomic_feature_id,
                      genomic_feature_abbreviation,
                      sequence_alteration_type)
  
                  if sequence_alteration_type == 'is allele of':
                      vl_label = geno.make_variant_locus_label(
                          gene_symbol, genomic_feature_abbreviation)
  
                      vl_id = self._make_variant_locus_id(gene_id, genomic_feature_id)
  
                      self.id_label_map[vl_id] = vl_label
  
                      # create the variant locus,
                      # add it's parts and relationship to the gene
                      geno.addSequenceAlterationToVariantLocus(
                          genomic_feature_id, vl_id)
                      model.addIndividualToGraph(
                          vl_id, vl_label, self.globaltt['variant_locus'])
                      geno.addAlleleOfGene(vl_id, gene_id)
  
                      # note that deficiencies or translocations
                      # that affect only one gene are considered alleles here
                      # by zfin, which is appropriate.
                      # I don't yet see duplications
                  else:
                      # don't make the variant loci for the other things
                      # which include deficiencies, translocations, transgenes
                      # TODO review this
                      pass
  
                  if not self.test_mode and limit is not None and line_counter > limit:
                      break
  
          LOG.info("Done with feature affected genes")
          return