docs: def _process_gxd_allele_pair_view(self, limit):
          """
          This assumes that the genotype and alleles
          have already been added to the id hashmap.
          We use the Genotype methods to add all the parts we need.
          Triples added:
          <genotype_id> has_part <vslc>
          <vslc> has_part <allele1>
          <vslc> has_part <allele2>
          <vslc> has_zygosity <zygosity>
  
          :param limit:
          :return:
  
          """
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
          model = Model(graph)
          geno = Genotype(graph)
          line_counter = 0
          raw = '/'.join((self.rawdir, 'gxd_allelepair_view'))
          LOG.info("processing allele pairs (VSLCs) for genotypes")
          geno_hash = {}
          with open(raw, 'r') as f:
              f.readline()  # read the header row; skip
              for line in f:
                  line = line.rstrip("\n")
                  line_counter += 1
  
                  (allelepair_key, genotype_key, allele_key_1, allele_key_2,
                   allele1, allele2, allelestate) = line.split('\t')
                  # NOTE: symbol = gene/marker,
                  # allele1 + allele2 = VSLC,
                  # allele1/allele2 = variant locus,
                  # allelestate = zygosity
                  # FIXME Need to handle alleles not in the *<*> format,
                  # incl gene traps, induced mut, & transgenics
  
                  if self.test_mode is True:
                      if int(genotype_key) not in self.test_keys.get('genotype'):
                          continue
  
                  genotype_id = self.idhash['genotype'].get(genotype_key)
                  if genotype_id not in geno_hash:
                      geno_hash[genotype_id] = set()
                  if genotype_id is None:
                      LOG.error(
                          "genotype_id not found for key %s; skipping", genotype_key)
                      continue
  
                  allele1_id = self.idhash['allele'].get(allele_key_1)
                  allele2_id = self.idhash['allele'].get(allele_key_2)
  
                  # Need to map the allelestate to a zygosity term
                  zygosity_id = self.resolve(allelestate.strip())
                  ivslc_id = self._makeInternalIdentifier('vslc', allelepair_key)
  
                  geno_hash[genotype_id].add(ivslc_id)
                  # TODO: VSLC label likely needs processing similar to
                  # the processing in the all_allele_view
                  # FIXME: handle null alleles
                  vslc_label = allele1+'/'
                  if allele2_id is None:
                      if zygosity_id in [
                              self.globaltt['hemizygous insertion-linked'],
                              self.globaltt['hemizygous-x'],
                              self.globaltt['hemizygous-y'],
                              self.globaltt['hemizygous']]:
                          vslc_label += '0'
                      elif zygosity_id == self.globaltt['heterozygous']:
                          vslc_label += '+'
                      elif zygosity_id == self.globaltt['indeterminate']:
                          vslc_label += '?'
                      elif zygosity_id == self.globaltt['homozygous']:
                          # we shouldn't get here, but for testing this is handy
                          vslc_label += allele1
                      else:  # heteroplasmic,  homoplasmic,  FIXME add these if possible
                          LOG.info(
                              "A different kind of zygosity found is: %s",
                              self.globaltcid[zygosity_id])
                          vslc_label += '?'
                  else:
                      vslc_label += allele2
  
                  model.addIndividualToGraph(
                      ivslc_id, vslc_label,
                      self.globaltt['variant single locus complement'])
                  self.label_hash[ivslc_id] = vslc_label
                  rel1 = rel2 = self.globaltt['has_variant_part']
                  if allele1_id in self.wildtype_alleles:
                      rel1 = self.globaltt['has_reference_part']
                  if allele2_id in self.wildtype_alleles:
                      rel2 = self.globaltt['has_reference_part']
                  geno.addPartsToVSLC(
                      ivslc_id, allele1_id, allele2_id, zygosity_id, rel1, rel2)
  
                  # if genotype_id not in geno_hash:
                  #     geno_hash[genotype_id] = [vslc_label]
                  # else:
                  #     geno_hash[genotype_id] += [vslc_label]
  
                  if not self.test_mode and limit is not None and line_counter > limit:
                      break
  
          # build the gvc and the genotype label
          for gt in geno_hash.keys():
              if gt is None:   # not sure why, but sometimes this is the case
                  continue
              vslcs = sorted(list(geno_hash[gt]))
              gvc_label = None
              if len(vslcs) > 1:
                  gvc_id = re.sub(r'_', '', ('-'.join(vslcs)))
                  gvc_id = re.sub(r':', '', gvc_id)
                  gvc_id = '_:'+gvc_id
                  vslc_labels = []
                  for v in vslcs:
                      vslc_labels.append(self.label_hash[v])
                  gvc_label = '; '.join(vslc_labels)
  
                  model.addIndividualToGraph(
                      gvc_id, gvc_label, self.globaltt['genomic_variation_complement'])
                  self.label_hash[gvc_id] = gvc_label
                  for v in vslcs:
                      geno.addParts(v, gvc_id, self.globaltt['has_variant_part'])
                      geno.addVSLCtoParent(v, gvc_id)
                  geno.addParts(gvc_id, gt, self.globaltt['has_variant_part'])
              elif len(vslcs) == 1:
                  gvc_id = vslcs[0]
                  gvc_label = self.label_hash[gvc_id]
                  # type the VSLC as also a GVC
                  model.addIndividualToGraph(
                      gvc_id, gvc_label, self.globaltt['genomic_variation_complement'])
                  geno.addVSLCtoParent(gvc_id, gt)
              else:
                  LOG.info("No VSLCs for %s", gt)
  
              # make the genotype label = gvc + background
              bkgd_id = self.geno_bkgd.get(gt)
              if bkgd_id is not None:
                  bkgd_label = self.label_hash.get(bkgd_id)
                  if bkgd_label is None:
                      bkgd_label = bkgd_id  # just in case
              else:
                  bkgd_label = 'n.s.'
              if gvc_label is not None:
                  genotype_label = gvc_label + ' ['+bkgd_label+']'
              else:
                  genotype_label = '['+bkgd_label+']'
  
              model.addIndividualToGraph(gt, genotype_label)
              self.label_hash[gt] = genotype_label
  
          return