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