docs: def _get_chrbands(self, limit, taxon):
          """
          For the given taxon, it will fetch the chr band file.
          We will not deal with the coordinate information with this parser.
          Here, we only are concerned with building the partonomy.
          :param limit:
          :return:
  
          """
          model = Model(self.graph)
          line_counter = 0
          myfile = '/'.join((self.rawdir, self.files[taxon]['file']))
          LOG.info("Processing Chr bands from FILE: %s", myfile)
          geno = Genotype(self.graph)
  
          # build the organism's genome from the taxon
          genome_label = self.files[taxon]['genome_label']
          taxon_id = 'NCBITaxon:' + taxon
  
          # add the taxon as a class.  adding the class label elsewhere
          model.addClassToGraph(taxon_id, None)
          model.addSynonym(taxon_id, genome_label)
  
          genome_id = geno.makeGenomeID(taxon_id)
          geno.addGenome(taxon_id, genome_label)
          model.addOWLPropertyClassRestriction(
              genome_id, self.globaltt['in taxon'], taxon_id)
  
          placed_scaffold_pattern = r'chr(\d+|X|Y|Z|W|MT|M)'
          # currently unused patterns
          # unlocalized_scaffold_pattern = placed_scaffold_pattern + r'_(\w+)_random'
          # unplaced_scaffold_pattern = r'chrUn_(\w+)'
  
          col = ['chrom', 'start', 'stop', 'band', 'rtype']
          with gzip.open(myfile, 'rb') as reader:
              for line in reader:
                  line_counter += 1
                  # skip comments
                  line = line.decode().strip()
                  if line[0] == '#':
                      continue
                  # chr13	4500000	10000000	p12	stalk
                  row = line.split('\t')
                  chrom = row[col.index('chrom')]
                  band = row[col.index('band')]
                  rtype = row[col.index('rtype')]
                  # NOTE
                  # some less-finished genomes have placed and unplaced scaffolds
                  # * Placed scaffolds:
                  #    Scaffold has an oriented location within a chromosome.
                  # * Unlocalized scaffolds:
                  #     scaffold 's chromosome  is known,
                  #     scaffold's position, orientation or both is not known.
                  # *Unplaced scaffolds:
                  #   it is not known which chromosome the scaffold belongs to.
                  # find out if the thing is a full on chromosome, or a scaffold:
                  # ex: unlocalized scaffold: chr10_KL568008v1_random
                  # ex: unplaced scaffold: chrUn_AABR07022428v1
  
                  mch = re.match(placed_scaffold_pattern+r'$', chrom)
                  if mch is not None and len(mch.groups()) == 1:
                      # the chromosome is the first match of the pattern
                      # chrom = m.group(1)  # TODO unused
                      pass
                  else:
                      # let's skip over anything that isn't a placed_scaffold
                      LOG.info("Skipping non-placed chromosome %s", chrom)
                      continue
                  # the chrom class, taxon as the reference
                  cclassid = makeChromID(chrom, taxon, 'CHR')
  
                  # add the chromosome as a class
                  geno.addChromosomeClass(chrom, taxon_id, genome_label)
                  model.addOWLPropertyClassRestriction(
                      cclassid, self.globaltt['member of'], genome_id)
  
                  # add the band(region) as a class
                  maplocclass_id = cclassid+band
                  maplocclass_label = makeChromLabel(chrom+band, genome_label)
                  if band is not None and band.strip() != '':
                      region_type_id = self.map_type_of_region(rtype)
                      model.addClassToGraph(
                          maplocclass_id, maplocclass_label,
                          region_type_id)
                  else:
                      region_type_id = self.globaltt['chromosome']
                  # add the staining intensity of the band
                  if re.match(r'g(neg|pos|var)', rtype):
                      if region_type_id in [
                              self.globaltt['chromosome_band'],
                              self.globaltt['chromosome_subband']]:
                          stain_type = self.resolve(rtype)
                          if stain_type is not None:
                              model.addOWLPropertyClassRestriction(
                                  maplocclass_id,
                                  self.globaltt['has_sequence_attribute'],
                                  self.resolve(rtype))
                      else:
                          # usually happens if it's a chromosome because
                          # they don't actually have banding info
                          LOG.info("feature type %s != chr band", region_type_id)
                  else:
                      LOG.warning('staining type not found: %s', rtype)
  
                  # get the parent bands, and make them unique
                  parents = list(self.make_parent_bands(band, set()))
                  # alphabetical sort will put them in smallest to biggest
                  parents.sort(reverse=True)
  
                  # print("PARENTS of", maplocclass_id, "=", parents)
                  # add the parents to the graph, in hierarchical order
                  # TODO this is somewhat inefficient due to
                  # re-adding upper-level nodes when iterating over the file
                  for prnt in parents:
                      parent = prnt.strip()
                      if parent is None or parent == "":
                          continue
                      pclassid = cclassid + parent  # class chr parts
                      pclass_label = makeChromLabel(chrom + parent, genome_label)
                      rti = getChrPartTypeByNotation(parent, self.graph)
                      model.addClassToGraph(pclassid, pclass_label, rti)
  
                      # for canonical chromosomes,
                      # then the subbands are subsequences of the full band
                      # add the subsequence stuff as restrictions
  
                      if prnt != parents[-1]:
                          grandparent = 1 + parents.index(prnt)
                          pid = cclassid + parents[grandparent]   # the instance
                          model.addOWLPropertyClassRestriction(
                              pclassid, self.globaltt['is subsequence of'], pid)
                          model.addOWLPropertyClassRestriction(
                              pid, self.globaltt['has subsequence'], pclassid)
                      else:
                          # add the last one (p or q usually)
                          # as attached to the chromosome
                          model.addOWLPropertyClassRestriction(
                              pclassid, self.globaltt['is subsequence of'], cclassid)
                          model.addOWLPropertyClassRestriction(
                              cclassid, self.globaltt['has subsequence'], pclassid)
  
                  # connect the band here to the first one in the parent list
                  if len(parents) > 0:
                      model.addOWLPropertyClassRestriction(
                          maplocclass_id, self.globaltt['is subsequence of'],
                          cclassid + parents[0])
                      model.addOWLPropertyClassRestriction(
                          cclassid + parents[0], self.globaltt['has subsequence'],
                          maplocclass_id)
  
                  if limit is not None and line_counter > limit:
                      break
  
          # TODO figure out the staining intensities for the encompassing bands
  
          return