docs: def _process_gxd_genotype_view(self, limit=None):
          """
          This table indicates the relationship between a genotype
          and it's background strain.  It leverages the Genotype class methods
          to do this.
  
          Makes these triples:
          <MGI:genotypeid> GENO:has_reference_part <MGI:strainid>
          <MGI:strainid> a GENO:genomic_background
  
          If the genotype id isn't in the hashmap, it adds it here
          (but this shouldn't happen):
          <MGI:genotypeid> a GENO:genotype
  
          If the strain isn't in the hashmap, it also adds it here with a
          monarchized identifier using the unique key of the strain,
          formatted like:  :_mgistrainkey12345
  
          :param limit:
          :return:
          """
  
          line_counter = 0
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
  
          geno = Genotype(graph)
          model = Model(graph)
  
          raw = '/'.join((self.rawdir, 'gxd_genotype_view'))
          LOG.info("getting genotypes and their backgrounds")
          with open(raw, 'r') as f1:
              f1.readline()  # read the header row; skip
              for line in f1:
                  line = line.rstrip("\n")
                  line_counter += 1
                  (genotype_key, strain_key, strain, mgiid) = line.split('\t')
  
                  if self.test_mode is True:
                      if int(genotype_key) not in self.test_keys.get('genotype'):
                          continue
  
                  if self.idhash['genotype'].get(genotype_key) is None:
                      # just in case we haven't seen it before,
                      # catch and add the id mapping here
                      self.idhash['genotype'][genotype_key] = mgiid
                      geno.addGenotype(mgiid, None)
                      # the label is elsewhere...
                      # need to add the MGI label as a synonym
  
                  # if it's in the hash,
                  # assume that the individual was created elsewhere
                  strain_id = self.idhash['strain'].get(strain_key)
                  background_type = self.globaltt['genomic_background']
                  if strain_id is None or int(strain_key) < 0:
                      if strain_id is None:
                          # some of the strains don't have public identifiers!
                          # so we make one up, and add it to the hash
                          strain_id = self._makeInternalIdentifier('strain', strain_key)
                          self.idhash['strain'].update({strain_key: strain_id})
                          model.addComment(strain_id, "strain_key:" + strain_key)
                      elif int(strain_key) < 0:
                          # these are ones that are unidentified/unknown.
                          # so add instances of each.
                          strain_id = self._makeInternalIdentifier(
                              'strain', re.sub(r':', '', str(strain_id)))
                          strain_id += re.sub(r':', '', str(mgiid))
                          strain_id = re.sub(r'^_', '_:', strain_id)
                          strain_id = re.sub(r'::', ':', strain_id)
                          model.addDescription(
                              strain_id,
                              "This genomic background is unknown.  " +
                              "This is a placeholder background for " +
                              mgiid + ".")
                          background_type = self.globaltt[
                              'unspecified_genomic_background']
  
                      # add it back to the idhash
                      LOG.info(
                          "adding background as internal id: %s %s: %s",
                          strain_key, strain, strain_id)
  
                  geno.addGenomicBackgroundToGenotype(
                      strain_id, mgiid, background_type)
  
                  self.label_hash[strain_id] = strain
  
                  # add BG to a hash so we can build the genotype label later
                  self.geno_bkgd[mgiid] = strain_id
  
                  if not self.test_mode and limit is not None and line_counter > limit:
                      break
  
          return