docs: def _process_gene_marker_relationships(self, limit=None):
          """
          Gene-marker relationships include:
              clone contains gene,
              coding sequence of,
              contains polymorphism,
              gene contains small segment,
              gene encodes small segment,
              gene has artifact,
              gene hybridized by small segment,
              gene produces transcript,
              gene product recognized by antibody,
              knockdown reagent targets gene,
              promoter of,
              transcript targets gene
  
          Here, we only process the following:
              knockdown reagent targets gene,
              coding sequence of,
              promoter of,
              transcript targets gene
  
          We only take a fraction of these here...
          we are interested in the knockdown reagents, promoters, and
          the transgenic constructs with coding bits.
  
          :param limit:
          :return:
  
          """
  
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
          model = Model(graph)
          LOG.info("Processing gene marker relationships")
          line_counter = 0
          raw = '/'.join((self.rawdir, self.files['gene_marker_rel']['file']))
          geno = Genotype(graph)
  
          with open(raw, 'r', encoding="iso-8859-1") as csvfile:
              filereader = csv.reader(csvfile, delimiter='\t', quotechar='\"')
              for row in filereader:
                  line_counter += 1
  
                  (gene_id, gene_so_id, gene_symbol, marker_id, marker_so_id,
                   marker_symbol, relationship
                   # , empty
                  ) = row
  
                  if self.test_mode and not (
                          gene_id in self.test_ids['gene'] or
                          marker_id in self.test_ids['allele'] or
                          marker_id in self.test_ids['morpholino']):
                      continue
  
                  # there are many relationships, but we only take a few for now
                  if relationship in [
                          'knockdown reagent targets gene',
                          'coding sequence of',
                          'gene product recognized by antibody',
                          'promoter of',
                          'transcript targets gene']:
                      gene_id = 'ZFIN:' + gene_id.strip()
                      geno.addGene(gene_id, gene_symbol, gene_so_id)
  
                      marker_id = 'ZFIN:' + marker_id.strip()
                      if relationship == 'knockdown reagent targets gene':
                          geno.addGeneTargetingReagent(
                              marker_id, marker_symbol, marker_so_id, gene_id)
                          # waiting to add the reagent_targeted_gene
                          # until processing environments
  
                      elif relationship == 'coding sequence of':
                          # we add the partonomy
                          # directly to the allele in the process_fish method
                          geno.addConstruct(
                              marker_id, marker_symbol, marker_so_id)
                          transgene_part_id = self._make_transgene_part_id(
                              marker_id, gene_id, relationship)
                          transgene_part_label = 'Tg('+relationship+' '+gene_symbol+')'
                          model.addIndividualToGraph(
                              transgene_part_id, transgene_part_label,
                              self.globaltt['coding_transgene_feature'])
                          geno.addSequenceDerivesFrom(transgene_part_id, gene_id)
  
                          # save the transgenic parts in a hashmap for later
                          if marker_id not in self.transgenic_parts:
                              self.transgenic_parts[marker_id] = set()
                          self.transgenic_parts[marker_id].add(transgene_part_id)
                          self.id_label_map[transgene_part_id] = transgene_part_label
  
                      elif relationship == 'gene product recognized by antibody':
                          # TODO for ticket #32
                          pass
                      elif relationship == 'promoter of':
                          # transgenic constructs with promoters regions
                          # we add the partonomy
                          # directly to the allele in the process_fish method
                          geno.addConstruct(marker_id, marker_symbol, marker_so_id)
                          transgene_part_id = self._make_transgene_part_id(
                              marker_id, gene_id, relationship)
                          transgene_part_label = 'Tg(' + relationship + ' ' +\
                              gene_symbol + ')'
                          model.addIndividualToGraph(
                              transgene_part_id, transgene_part_label,
                              self.globaltt['regulatory_transgene_feature'])
                          geno.addSequenceDerivesFrom(transgene_part_id, gene_id)
  
                          # save the transgenic parts in a hashmap for later
                          if marker_id not in self.transgenic_parts:
                              self.transgenic_parts[marker_id] = set()
                          self.transgenic_parts[marker_id].add(transgene_part_id)
  
                      elif relationship == 'transcript targets gene':  # miRNAs
                          # TODO should this be an interaction
                          # instead of this special relationship?
                          model.addIndividualToGraph(
                              marker_id, marker_symbol, marker_so_id)
                          graph.addTriple(
                              marker_id, self.globaltt['targets_gene'], gene_id)
                      else:
                          pass
  
                  self.id_label_map[marker_id] = marker_symbol
                  # just in case we haven't seen it before
                  self.id_label_map[gene_id] = gene_symbol
  
                  if not self.test_mode and limit is not None and line_counter > limit:
                      break
  
          LOG.info("Done with gene marker relationships")
          return