docs: def _process_pubinfo(self, limit=None):
          """
          This will pull the zfin internal publication information,
          and map them to their equivalent pmid, and make labels.
  
          Triples created:
          <pub_id> is an individual
          <pub_id> rdfs:label <pub_label>
          <pubmed_id> is an individual
          <pubmed_id> rdfs:label <pub_label>
  
          <pub_id> sameIndividual <pubmed_id>
          :param limit:
          :return:
  
          """
  
          line_counter = 0
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
          model = Model(graph)
          raw = '/'.join((self.rawdir, self.files['pubs']['file']))
          with open(raw, 'r', encoding="latin-1") as csvfile:
              filereader = csv.reader(csvfile, delimiter='\t', quotechar='\"')
              for row in filereader:
                  line_counter += 1
                  try:
                      (pub_id, pubmed_id, authors, title,
                       journal, year, vol, pages) = row
                  except ValueError:
                      try:
                          (pub_id, pubmed_id, authors, title,
                           journal, year, vol, pages
                           # , empty
                          ) = row
                      except ValueError:
                          LOG.warning("Error parsing row %s: ", row)
  
                  if self.test_mode and (
                          'ZFIN:' + pub_id not in self.test_ids['pub'] and
                          'PMID:' + pubmed_id not in self.test_ids['pub']):
                      continue
  
                  pub_id = 'ZFIN:' + pub_id.strip()
                  # trim the author list for ease of reading
                  alist = re.split(r',', authors)
                  if len(alist) > 1:
                      astring = ' '.join((alist[0].strip(), 'et al'))
                  else:
                      astring = authors
  
                  pub_label = '; '.join((astring, title, journal, year, vol, pages))
                  ref = Reference(graph, pub_id)
                  ref.setShortCitation(pub_label)
                  ref.setYear(year)
                  ref.setTitle(title)
  
                  if pubmed_id is not None and pubmed_id != '':
                      # let's make an assumption that if there's a pubmed id,
                      # that it is a journal article
                      ref.setType(self.globaltt['journal article'])
  
                      pubmed_id = 'PMID:' + pubmed_id.strip()
                      rpm = Reference(graph, pubmed_id, self.globaltt['journal article'])
                      rpm.addRefToGraph()
  
                      model.addSameIndividual(pub_id, pubmed_id)
                      model.makeLeader(pubmed_id)
  
                  ref.addRefToGraph()
  
                  if not self.test_mode and limit is not None and line_counter > limit:
                      break
  
          return