docs: def _process_mrk_marker_view(self, limit):
          """
          This is the definition of markers
          (as in genes, but other genomic loci types as well).
          It looks up the identifiers in the hashmap
          This includes their labels, specific class, and identifiers
          TODO should we use the mrk_mouse_view instead?
  
          Triples:
          <marker_id> a owl:Class OR owl:NamedIndividual
              GENO:marker_type
              rdf:label <symbol>
              RO:in_taxon <NCBITaxon_id>
  
          :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, 'mrk_marker_view'))
          LOG.info("getting markers and assigning types")
          with open(raw, 'r') as f:
              f.readline()  # read the header row; skip
              for line in f:
                  line = line.rstrip("\n")
                  line_counter += 1
  
                  (marker_key, organism_key, marker_status_key,
                   symbol, name, latin_name, marker_type) = line.split('\t')
  
                  if self.test_mode is True:
                      if int(marker_key) not in self.test_keys.get('marker'):
                          continue
  
                  # use only non-withdrawn markers
                  if marker_status_key != '2':
                      marker_id = self.idhash['marker'].get(marker_key)
  
                      # only pull info for mouse genes for now
                      # other species should come from other dbs
                      if organism_key != '1':
                          continue
  
                      if marker_id is None:
                          LOG.error(
                              "can't find %s %s in the id hash", marker_key, symbol)
  
                      mapped_marker_type = self.resolve(marker_type.strip())
  
                      # if it's unlocated, or is not a gene,
                      # then don't add it as a class because
                      # it's not added as a gene.
                      # everything except for genes are modeled as individuals
  
                      if mapped_marker_type in [
                              self.globaltt['gene'],
                              self.globaltt['pseudogene']]:
                          model.addClassToGraph(
                              marker_id, symbol, mapped_marker_type, name)
                          model.addSynonym(
                              marker_id, name, self.globaltt['has_exact_synonym'])
                          self.markers['classes'].append(marker_id)
                      else:
                          model.addIndividualToGraph(
                              marker_id, symbol, mapped_marker_type, name)
                          model.addSynonym(
                              marker_id, name, self.globaltt['has_exact_synonym'])
                          self.markers['indiv'].append(marker_id)
  
                      self.label_hash[marker_id] = symbol
                      # add the taxon
                      taxon_id = self.resolve(latin_name)  # not always proper binomial
                      geno.addTaxon(taxon_id, marker_id)
  
                      # make MGI the leader for mouse genes.
                      if taxon_id == self.globaltt['Mus musculus']:
                          model.makeLeader(marker_id)
  
                      if not self.test_mode and limit is not None and line_counter > limit:
                          break
  
          return