docs: def process_nbk_html(self, limit):
          """
          Here we process the gene reviews books to fetch
          the clinical descriptions to include in the ontology.
          We only use books that have been acquired manually,
          as NCBI Bookshelf does not permit automated downloads.
          This parser will only process the books that are found in
          the ```raw/genereviews/books``` directory,
          permitting partial completion.
  
          :param limit:
          :return:
          """
          model = Model(self.graph)
          cnt = 0
          books_not_found = set()
          clin_des_regx = re.compile(r".*Summary.sec0")
          lit_cite_regex = re.compile(r".*Literature_Cited")
          pubmed_regex =  re.compile(r"pubmed")  # ??? for a static string?
          for nbk in self.book_ids:
              cnt += 1
              nbk_id = 'GeneReviews:'+nbk
              book_item = self.all_books.get(nbk)
              url = '/'.join((self.rawdir, book_item['file']))
  
              # figure out if the book is there; if so, process, otherwise skip
              book_dir = '/'.join((self.rawdir, 'books'))
              book_files = os.listdir(book_dir)
              if ''.join((nbk, '.html')) not in book_files:
                  # LOG.warning("No book found locally for %s; skipping", nbk)
                  books_not_found.add(nbk)
                  continue
              LOG.info("Processing %s", nbk)
  
              page = open(url)
              soup = BeautifulSoup(page.read())
  
              # sec0 == clinical description
              clin_summary = soup.find('div', id=clin_des_regx)
              if clin_summary is not None:
                  ptext = clin_summary.find('p').text
                  ptext = re.sub(r'\s+', ' ', ptext)
  
                  unlst = clin_summary.find('ul')
                  if unlst is not None:
                      item_text = list()
                      for lst_itm in unlst.find_all('li'):
                          item_text.append(re.sub(r'\s+', ' ', lst_itm.text))
                      ptext += ' '.join(item_text)
  
                  # add in the copyright and citation info to description
                  ptext = ' '.join((
                      ptext, '[GeneReviews:NBK1116, GeneReviews:NBK138602, ' +
                      nbk_id + ']'))
  
                  model.addDefinition(nbk_id, ptext.strip())
  
              # get the pubs
              pmid_set = set()
              pub_div = soup.find('div', id=lit_cite_regex)
              if pub_div is not None:
                  ref_list = pub_div.find_all('div', attrs={'class': "bk_ref"})
                  for ref in ref_list:
                      for anchor in ref.find_all(
                              'a', attrs={'href': pubmed_regex}):
                          if re.match(r'PubMed:', anchor.text):
                              pmnum = re.sub(r'PubMed:\s*', '', anchor.text)
                          else:
                              pmnum = re.search(
                                  r'\/pubmed\/(\d+)$', anchor['href']).group(1)
                          if pmnum is not None:
                              pmid = 'PMID:'+str(pmnum)
                              self.graph.addTriple(
                                  pmid, self.globaltt['is_about'], nbk_id)
                              pmid_set.add(pmnum)
                              reference = Reference(
                                  self.graph, pmid, self.globaltt['journal article'])
                              reference.addRefToGraph()
  
              # TODO add author history, copyright, license to dataset
  
              # TODO get PMID-NBKID equivalence (near foot of page),
              # and make it "is about" link
              # self.gu.addTriple(
              #   self.graph, pmid,
              #   self.globaltt['is_about'], nbk_id)
              # for example: NBK1191 PMID:20301370
  
              # add the book to the dataset
              self.dataset.setFileAccessUrl(book_item['url'])
  
              if limit is not None and cnt > limit:
                  break
  
              # finish looping through books
  
          bknfd = len(books_not_found)
          if len(books_not_found) > 0:
              if bknfd > 100:
                  LOG.warning("There were %d books not found.", bknfd)
              else:
                  LOG.warning(
                      "The following %d books were not found locally: %s", bknfd,
                      str(books_not_found))
          LOG.info(
              "Finished processing %d books for clinical descriptions", cnt - bknfd)
  
          return