docs: def _get_gene_info(self, limit):
          """
          Currently loops through the gene_info file and
          creates the genes as classes, typed with SO.  It will add their label,
          any alternate labels as synonyms, alternate ids as equivlaent classes.
          HPRDs get added as protein products.
          The chromosome and chr band get added as blank node regions,
          and the gene is faldo:located
          on the chr band.
          :param limit:
          :return:
  
          """
          src_key = 'gene_info'
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
  
          geno = Genotype(graph)
          model = Model(graph)
  
          # not unzipping the file
          LOG.info("Processing 'Gene Info' records")
          line_counter = 0
          gene_info = '/'.join((self.rawdir, self.files[src_key]['file']))
          LOG.info("FILE: %s", gene_info)
          # Add taxa and genome classes for those in our filter
  
          band_regex = re.compile(r'[0-9A-Z]+[pq](\d+)?(\.\d+)?$')
          for tax_num in self.tax_ids:
              tax_id = ':'.join(('NCBITaxon', tax_num))
              # tax label can get added elsewhere
              geno.addGenome(tax_id, tax_num)
              # label added elsewhere
              model.addClassToGraph(tax_id, None)
  
          col = self.files[src_key]['columns']
          with gzip.open(gene_info, 'rb') as tsv:
              row = tsv.readline().decode().strip().split('\t')
              row[0] = row[0][1:]  # strip comment
              if col != row:
                  LOG.info(
                      '%s\nExpected Headers:\t%s\nRecived Headers:\t%s\n',
                      src_key, col, row)
                  LOG.info(set(col) - set(row))
  
              for line in tsv:
                  line = line.strip()
                  line_counter += 1
                  if line[0] == '#':  # skip comments
                      continue
                  row = line.decode().strip().split('\t')
  
                  # ##set filter=None in init if you don't want to have a filter
                  # if self.id_filter is not None:
                  #     if ((self.id_filter == 'taxids' and \
                  #          (tax_num not in self.tax_ids))
                  #           or (self.id_filter == 'geneids' and \
                  #               (int(gene_num) not in self.gene_ids))):
                  #         continue
                  # #### end filter
  
                  gene_num = row[col.index('GeneID')]
                  if self.test_mode and int(gene_num) not in self.gene_ids:
                      continue
                  tax_num = row[col.index('tax_id')]
                  if not self.test_mode and tax_num not in self.tax_ids:
                      continue
                  tax_id = ':'.join(('NCBITaxon', tax_num))
                  gene_id = ':'.join(('NCBIGene', gene_num))
                  gtype = row[col.index('type_of_gene')].strip()
                  gene_type_id = self.resolve(gtype)
                  symbol = row[col.index('Symbol')]
                  if symbol == 'NEWENTRY':
                      label = None
                  else:
                      label = symbol
                  # sequence feature, not a gene
                  if gene_type_id == self.globaltt['sequence_feature']:
                      self.class_or_indiv[gene_id] = 'I'
                  else:
                      self.class_or_indiv[gene_id] = 'C'
  
                  if not self.test_mode and limit is not None and line_counter > limit:
                      continue
  
                  desc = row[col.index('description')]
                  if self.class_or_indiv[gene_id] == 'C':
                      model.addClassToGraph(gene_id, label, gene_type_id, desc)
                      # NCBI will be the default leader (for non mods),
                      # so we will not add the leader designation here.
                  else:
                      model.addIndividualToGraph(gene_id, label, gene_type_id, desc)
                      # in this case, they aren't genes.
                      # so we want someone else to be the leader
                  name = row[col.index('Full_name_from_nomenclature_authority')]
                  if name != '-':
                      model.addSynonym(gene_id, name)
                  synonyms = row[col.index('Synonyms')].strip()
                  if synonyms != '-':
                      for syn in synonyms.split('|'):
                          model.addSynonym(
                              gene_id, syn.strip(), model.globaltt['has_related_synonym'])
                  other_designations = row[col.index('Other_designations')].strip()
                  if other_designations != '-':
                      for syn in other_designations.split('|'):
                          model.addSynonym(
                              gene_id, syn.strip(), model.globaltt['has_related_synonym'])
                  dbxrefs = row[col.index('dbXrefs')].strip()
                  if dbxrefs != '-':
                      self._add_gene_equivalencies(dbxrefs, gene_id, tax_id)
  
                  # edge cases of id | symbol | chr | map_loc:
                  # 263     AMD1P2    X|Y  with   Xq28 and Yq12
                  # 438     ASMT      X|Y  with   Xp22.3 or Yp11.3    # in PAR
                  # no idea why there's two bands listed - possibly 2 assemblies
                  # 419     ART3      4    with   4q21.1|4p15.1-p14
                  # 28227   PPP2R3B   X|Y  Xp22.33; Yp11.3            # in PAR
                  # this is of "unknown" type == susceptibility
                  # 619538  OMS     10|19|3 10q26.3;19q13.42-q13.43;3p25.3
                  # unlocated scaffold
                  # 101928066       LOC101928066    1|Un    -\
                  # mouse --> 2C3
                  # 11435   Chrna1  2       2 C3|2 43.76 cM
                  # mouse --> 11B1.1
                  # 11548   Adra1b  11      11 B1.1|11 25.81 cM
                  # 11717   Ampd3   7       7 57.85 cM|7 E2-E3        # mouse
                  # 14421   B4galnt1        10      10 D3|10 74.5 cM  # mouse
                  # 323212  wu:fb92e12      19|20   -                 # fish
                  # 323368  ints10  6|18    -                         # fish
                  # 323666  wu:fc06e02      11|23   -                 # fish
  
                  # feel that the chr placement can't be trusted in this table
                  # when there is > 1 listed
                  # with the exception of human X|Y,
                  # we will only take those that align to one chr
  
                  # FIXME remove the chr mapping below
                  # when we pull in the genomic coords
                  chrom = row[col.index('chromosome')].strip()
                  if chrom != '-' and chrom != '':
                      if re.search(r'\|', chrom) and chrom not in ['X|Y', 'X; Y']:
                          # means that there's uncertainty in the mapping.
                          # so skip it
                          # TODO we'll need to figure out how to deal with
                          # >1 loc mapping
                          LOG.info(
                              '%s is non-uniquely mapped to %s. Skipping for now.',
                              gene_id, chrom)
                          continue
                          # X|Y	Xp22.33;Yp11.3
  
                      # if(not re.match(
                      #        r'(\d+|(MT)|[XY]|(Un)$',str(chr).strip())):
                      #    print('odd chr=',str(chr))
                      if chrom == 'X; Y':
                          chrom = 'X|Y'  # rewrite the PAR regions for processing
                      # do this in a loop to allow PAR regions like X|Y
                      for chromosome in re.split(r'\|', chrom):
                          # assume that the chromosome label is added elsewhere
                          geno.addChromosomeClass(chromosome, tax_id, None)
                          mychrom = makeChromID(chromosome, tax_num, 'CHR')
                          # temporarily use taxnum for the disambiguating label
                          mychrom_syn = makeChromLabel(chromosome, tax_num)
                          model.addSynonym(mychrom, mychrom_syn)
                          map_loc = row[col.index('map_location')].strip()
                          band_match = re.match(band_regex, map_loc)
                          if band_match is not None and len(band_match.groups()) > 0:
                              # if tax_num != '9606':
                              #     continue
                              # this matches the regular kind of chrs,
                              # so make that kind of band
                              # not sure why this matches?
                              #   chrX|Y or 10090chr12|Un"
                              # TODO we probably need a different regex
                              # per organism
                              # the maploc_id already has the numeric chromosome
                              # in it, strip it first
                              bid = re.sub(r'^' + chromosome, '', map_loc)
                              # the generic location (no coordinates)
                              maploc_id = makeChromID(chromosome + bid, tax_num, 'CHR')
                              # print(map_loc,'-->',bid,'-->',maploc_id)
                              # Assume it's type will be added elsewhere
                              band = Feature(graph, maploc_id, None, None)
                              band.addFeatureToGraph()
                              # add the band as the containing feature
                              graph.addTriple(
                                  gene_id,
                                  self.globaltt['is subsequence of'],
                                  maploc_id)
                          else:
                              # TODO handle these cases: examples are:
                              # 15q11-q22,Xp21.2-p11.23,15q22-qter,10q11.1-q24,
                              # 12p13.3-p13.2|12p13-p12,1p13.3|1p21.3-p13.1,
                              # 12cen-q21,22q13.3|22q13.3
                              LOG.debug(
                                  'not regular band pattern for %s: %s', gene_id, map_loc)
                              # add the gene as a subsequence of the chromosome
                              graph.addTriple(
                                  gene_id, self.globaltt['is subsequence of'], mychrom)
  
                  geno.addTaxon(tax_id, gene_id)
  
          return