docs: def _process_nlx_157874_1_view(self, raw, limit=None):
          """
          This table contains the Elements of Morphology data that has been
          screen-scraped into DISCO.
          Note that foaf:depiction is inverse of foaf:depicts relationship.
  
          Since it is bad form to have two definitions,
          we concatenate the two into one string.
  
          Turtle:
              <eom id> a owl:Class
                  rdf:label Literal(eom label)
                  oboInOwl:has_related_synonym Literal(synonym list)
                  IAO:definition Literal(objective_def. subjective def)
                  foaf:depiction Literal(small_image_url),
                                 Literal(large_image_url)
                  foaf:page Literal(page_url)
                  rdfs:comment Literal(long commented text)
  
  
          :param raw:
          :param limit:
          :return:
          """
  
          model = Model(self.graph)
          with open(raw, 'r') as f1:
              f1.readline()  # read the header row; skip
              reader = csv.reader(f1, delimiter='\t', quotechar='\"')
              for line in reader:
                  (morphology_term_id, morphology_term_num,
                   morphology_term_label, morphology_term_url,
                   terminology_category_label, terminology_category_url,
                   subcategory, objective_definition, subjective_definition,
                   comments, synonyms, replaces, small_figure_url,
                   large_figure_url, e_uid, v_uid, v_uuid,
                   v_last_modified, v_status, v_lastmodified_epoch) = line
  
                  # note:
                  # e_uid v_uuid v_last_modified terminology_category_url
                  # subcategory v_uid morphology_term_num
                  # terminology_category_label hp_label notes
                  # are currently unused.
  
                  # Add morphology term to graph as a class
                  # with label, type, and description.
                  model.addClassToGraph(morphology_term_id, morphology_term_label)
  
                  # Assemble the description text
  
                  if subjective_definition != '' and not (
                          re.match(r'.+\.$', subjective_definition)):
                      # add a trailing period.
                      subjective_definition = subjective_definition.strip() + '.'
                  if objective_definition != '' and not (
                          re.match(r'.+\.$', objective_definition)):
                      # add a trailing period.
                      objective_definition = objective_definition.strip() + '.'
  
                  definition = '  '.join(
                      (objective_definition, subjective_definition)).strip()
  
                  model.addDefinition(morphology_term_id, definition)
  
                  # <term id> FOAF:depicted_by literal url
                  # <url> type foaf:depiction
  
                  # do we want both images?
                  # morphology_term_id has depiction small_figure_url
                  if small_figure_url != '':
                      model.addDepiction(morphology_term_id,
                                         small_figure_url)
  
                  # morphology_term_id has depiction large_figure_url
                  if large_figure_url != '':
                      model.addDepiction(morphology_term_id,
                                         large_figure_url)
  
                  # morphology_term_id has comment comments
                  if comments != '':
                      model.addComment(morphology_term_id, comments.strip())
  
                  for syn in synonyms.split(';'):
                      model.addSynonym(
                          morphology_term_id, syn.strip(),
                          self.globaltt['has_exact_synonym'])
  
                  # morphology_term_id has_related_synonym replaces (; delimited)
                  if replaces != '' and replaces != synonyms:
                      for syn in replaces.split(';'):
                          model.addSynonym(
                              morphology_term_id, syn.strip(),
                              self.globaltt['has_related_synonym'])
  
                  # <morphology_term_id> <foaf:page> morphology_term_url
                  if morphology_term_id is not None and morphology_term_url is not None:
                      reference = Reference(
                          self.graph, morphology_term_url, self.globaltt['web page'])
                      reference.addPage(morphology_term_id, morphology_term_url)
  
                  if limit is not None and reader.line_num > limit:
                      break
          return