docs: def process_allele_phenotype(self, limit=None):
          """
          This file compactly lists variant to phenotype associations,
          such that in a single row, there may be >1 variant listed
          per phenotype and paper.  This indicates that each variant is
          individually assocated with the given phenotype,
          as listed in 1+ papers.
          (Not that the combination of variants is producing the phenotype.)
          :param limit:
          :return:
  
          """
  
          raw = '/'.join((self.rawdir, self.files['allele_pheno']['file']))
  
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
  
          LOG.info("Processing Allele phenotype associations")
          line_counter = 0
          geno = Genotype(graph)
          with open(raw, 'r') as csvfile:
              filereader = csv.reader(csvfile, delimiter='\t', quotechar='\"')
              for row in filereader:
                  if re.match(r'!', ''.join(row)):  # header
                      continue
                  line_counter += 1
                  (db, gene_num, gene_symbol, is_not, phenotype_id, ref,
                   eco_symbol, with_or_from, aspect, gene_name, gene_synonym,
                   gene_class, taxon, date, assigned_by, blank, blank2) = row
  
                  if self.test_mode and gene_num not in self.test_ids['gene']:
                      continue
  
                  # TODO add NOT phenotypes
                  if is_not == 'NOT':
                      continue
  
                  eco_symbol = eco_symbol.strip()
                  eco_id = None
                  if eco_symbol.strip() != '':
                      eco_id = self.resolve(eco_symbol)
  
                  # according to the GOA spec, persons are not allowed to be
                  # in the reference column, therefore they the variant and
                  # persons are swapped between the reference and with column.
                  # we unswitch them here.
                  temp_var = temp_ref = None
                  if re.search(r'WBVar|WBRNAi', ref):
                      temp_var = ref
                      # move the paper from the with column into the ref
                  if re.search(r'WBPerson', with_or_from):
                      temp_ref = with_or_from
                  if temp_var is not None or temp_ref is not None:
                      with_or_from = temp_var
                      ref = temp_ref
  
                  allele_list = re.split(r'\|', with_or_from)
                  if len(allele_list) == 0:
                      LOG.error(
                          "Missing alleles from phenotype assoc at line %d",
                          line_counter)
                      continue
                  else:
                      for allele in allele_list:
                          allele_num = re.sub(r'WB:', '', allele.strip())
                          allele_id = 'WormBase:' + allele_num
                          gene_id = 'WormBase:' + gene_num
  
                          if re.search(r'WBRNAi', allele_id):
                              # make the reagent-targeted gene,
                              # & annotate that instead of the RNAi item directly
                              rnai_num = re.sub(r'WormBase:', '', allele_id)
                              rnai_id = allele_id
                              rtg_id = self.make_reagent_targeted_gene_id(
                                  gene_num, rnai_num)
                              geno.addReagentTargetedGene(
                                  rnai_id, 'WormBase:' + gene_num, rtg_id)
                              geno.addGeneTargetingReagent(
                                  rnai_id, None, self.globaltt['RNAi_reagent'], gene_id)
                              allele_id = rtg_id
                          elif re.search(r'WBVar', allele_id):
                              # this may become deprecated by using wormmine
                              # make the allele to gene relationship
                              # the WBVars are really sequence alterations
  
                              # the public name will come from elsewhere
                              geno.addSequenceAlteration(allele_id, None)
                              vl_id = '_:'+'-'.join((gene_num, allele_num))
                              geno.addSequenceAlterationToVariantLocus(
                                  allele_id, vl_id)
                              geno.addAlleleOfGene(vl_id, gene_id)
                          else:
                              LOG.warning(
                                  "Some kind of allele I don't recognize: %s", allele_num)
                              continue
                          assoc = G2PAssoc(graph, self.name, allele_id, phenotype_id)
  
                          if eco_id is not None:
                              assoc.add_evidence(eco_id)
  
                          if ref is not None and ref != '':
                              ref = re.sub(r'(WB:|WB_REF:)', 'WormBase:', ref)
                              reference = Reference(graph, ref)
                              if re.search(r'Person', ref):
                                  reference.setType(self.globaltt['person'])
                                  assoc.add_evidence(
                                      self.globaltt[
                                          'inference from background scientific knowledge'])
                              reference.addRefToGraph()
                              assoc.add_source(ref)
  
                          assoc.add_association_to_graph()
  
                          # finish looping through all alleles
  
                  if not self.test_mode \
                          and limit is not None and line_counter > limit:
                      break
  
          return