Python bibtexparser.loads方法代码示例

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def parse_bibtex(self, full_path=None):
        """
            (class, str) -> None
        """

        if full_path is None:
            full_path = 'data\\orcid-bibtex-output.bib'

        with open(full_path) as bibtex_file:
            bibtex_str = bibtex_file.read()

        bib_database = bibtexparser.loads(bibtex_str)
        self.data['pubabstract'] = list()
        for _bibtex in bib_database.entries:
            try:
                self.data['pubabstract'].append(_bibtex['abstract'])
            except Exception, ex:
                print '[e] exception {}'.format(str(ex)) 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def read_entry_dir(self, direc, update_files=True):
    """add a directory that contain files from a single entry
    """
    dirname = os.path.basename(direc)
    hidden_bib = hidden_bibtex(direc)
    if not os.path.exists(hidden_bib):
        raise TypeError('hidden bib missing: not an entry dir')

    db = bibtexparser.loads(open(hidden_bib).read())
    assert len(db.entries) == 1, 'hidden bib must have one entry, got: '+str(len(db.entries))
    entry = db.entries[0]

    if update_files:
        for root, direcs, files in os.walk(direc):
            break # do not look further in subdirectories, cause any rename would flatten the tree
        files = [os.path.join(direc, file) for file in files if not file.startswith('.')]

    entry['file'] = format_file(files)
    return entry 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def add_pdf(self, pdf, attachments=None, rename=False, copy=False, search_doi=True, search_fulltext=True, scholar=False, **kw):
        
        bibtex = extract_pdf_metadata(pdf, search_doi, search_fulltext, scholar=scholar)

        bib = bibtexparser.loads(bibtex)
        entry = bib.entries[0]

        files = [pdf]
        if attachments:
            files += attachments

        entry['file'] = format_file([os.path.abspath(f) for f in files])
        entry['ID'] = self.generate_key(entry)
        logger.debug('generated PDF key: '+entry['ID'])

        kw.pop('update_key', True)
            # logger.warn('fetched key is always updated when adding PDF to existing bib')
        self.insert_entry(entry, update_key=True, **kw)

        if rename:
            self.rename_entry_files(entry, copy=copy) 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def fetch_entry(e):
    if 'doi' in e and isvaliddoi(e['doi']):
        bibtex = fetch_bibtex_by_doi(e['doi'])
    else:
        kw = {}
        if e.get('author',''):
            kw['author'] = latex_to_unicode(family_names(e['author']))
        if e.get('title',''):
            kw['title'] = latex_to_unicode(family_names(e['title']))
        if kw:
            bibtex = fetch_bibtex_by_fulltext_crossref('', **kw)
        else:
            ValueError('no author not title field')
    db = bibtexparser.loads(bibtex)
    return db.entries[0] 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def update_bib(bib_arxiv, automatic=True, i=0):
    bib_id = bib_arxiv["ID"]

    arxiv_id = bib_arxiv["journal"].partition(":")[2]
    arxiv_title = bib_arxiv["title"]

    found, published, bib_string = check_arxiv_published(
        arxiv_id,
        field="id"
    )
    bib = bibtexparser.loads(bib_string)
    if found:
        if automatic:
            bib = bib.entries[0]
        else:
            question = "{} >> {} ".format(arxiv_title,
                                          bib.entries[0]["title"])
            question += " was "
            if not published:
                question += " not published. Use bib from arxiv?y/n"
            else:
                question += " published."
                question += " Replace with new bib ?y/n"

            replace = input(question)
            if replace == "y":
                bib = bib.entries[0]

        bib["ID"] = bib_id
    else:
        print("'{}' not founded with a id {}".format(
            arxiv_title,
            arxiv_id
        ))
        bib = bib_arxiv

    return bib 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def update_bib(bib):
    bib_id = bib["ID"]
    if "doi" in bib:
            found, bib_string = get_bib_from_doi(bib["doi"])
            if found:
                bib = bibtexparser.loads(bib_string).entries[0]

    bib["ID"] = bib_id
    return bib 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def update_bib(bib, get_first=True):
    bib_id = bib["ID"]
    if "doi" not in bib and "title" in bib:
        found, bib_string = get_bib_from_title(bib["title"], get_first)
        if found:
            bib = bibtexparser.loads(bib_string).entries[0]
    bib["ID"] = bib_id
    return bib 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def parse_bibtex(bibtex):
    """
    Parse a single bibtex record represented as a string to a dict
    """
    parser = BibTexParser()
    parser.customization = customizations
    db = bibtexparser.loads(bibtex, parser=parser)

    if not db.entries:
        raise ValueError('No bibtex item was parsed.')
    if len(db.entries) > 1:
        logger.warning("%d bibtex items, defaulting to first one",
                       len(db.entries))

    return db.entries[0] 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def fetch_bibtex_by_fulltext_crossref(txt, **kw):
    work = Works(etiquette=my_etiquette)
    logger.debug(six.u('crossref fulltext seach:\n')+six.u(txt))

    # get the most likely match of the first results
    # results = []
    # for i, r in enumerate(work.query(txt).sort('score')):
    #     results.append(r)
    #     if i > 50:
    #         break
    query = work.query(txt, **kw).sort('score')
    query_result = query.do_http_request('get', query.url, custom_header=str(query.etiquette)).text
    results = json.loads(query_result)['message']['items']

    if len(results) > 1:
        maxscore = 0
        result = results[0]
        for res in results:
            score = _crossref_score(txt, res)
            if score > maxscore:
                maxscore = score
                result = res
        logger.info('score: '+str(maxscore))

    elif len(results) == 0:
        raise ValueError('crossref fulltext: no results')

    else:
        result = results[0]

    # convert to bibtex
    return crossref_to_bibtex(result).strip() 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def edit_entries(entries, diff=False, ndiff=False):
    '''edit entries and insert result in database 
    '''
    # write the listed entries to temporary file
    import tempfile
    # filename = tempfile.mktemp(prefix='.', suffix='.txt', dir=os.path.curdir)
    filename = tempfile.mktemp(suffix='.txt')

    if (diff or ndiff) and len(entries) > 1:
        if ndiff or len(entries) > 2:
            entrystring = entry_ndiff(entries, color=False)
        else:
            entrystring = entry_diff(*entries, color=False)
    else:
        db = bibtexparser.bibdatabase.BibDatabase()
        db.entries.extend(entries)
        entrystring = bibtexparser.dumps(db)

    if six.PY2:
        entrystring = entrystring.encode('utf-8')

    with open(filename, 'w') as f:
        f.write(entrystring)

    res = os.system('%s %s' % (os.getenv('EDITOR'), filename))

    if res == 0:
        logger.info('sucessfully edited file, insert edited entries')
        db = bibtexparser.loads(open(filename).read())
        return db.entries

        raise ValueError('error when editing entries file: '+filename) 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def loads(cls, bibtex, filesdir):
        db = bibtexparser.loads(bibtex)
        return cls(db, filesdir) 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def add_bibtex(self, bibtex, **kw):
        bib = bibtexparser.loads(bibtex)
        for e in bib.entries:
            self.insert_entry(e, **kw) 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def add_from_source(self, bibtex_source):
        '''
        Add source to bibliography.

        Arguments:
            bibtex_source (str, or list) : bibtex string, bibtex file
            name, path to bibtex file, or list of such arguments.
        '''

        if isinstance(bibtex_source, str):
            bibtex_sources = [bibtex_source]
        else:
            bibtex_sources = bibtex_source

        for bibtex_source in bibtex_sources:

            new_references = bibtexparser_to_references(bibtexparser.loads(bibtex_source))

            if len(new_references) == 0:
                try:
                    with open(bibtex_source) as source_file:
                        new_references = bibtexparser_to_references(bibtexparser.load(source_file))
                except Exception as e:
                    _log.warning(e)

                if len(new_references) == 0:

                    for source_file_name in glob(bibtex_source + '*.bib'):

                        with open(source_file_name) as source_file:
                            new_references = bibtexparser_to_references(bibtexparser.load(source_file))


            if len(new_references) > 0:
                self.references.update(new_references)

            else:
                warn('Cannot load bibliography.')
                _log.warning('Bibliography source %s not found' % bibtex_source)
                sys.exit(1) 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def merge_data(paper_list, scholar_data_list):
    # Merge yml data with google scholar data
    assert(len(paper_list) == len(scholar_data_list))
    papers = []
    for yaml_paper_info, scholar_data in zip(paper_list, scholar_data_list):
        paper = dict()

        # see __getitem__ of ScholarArticle
        attrs = dict([(key, scholar_data.attrs[key][0]) for key in scholar_data.attrs.keys()])
        paper.update(attrs)

        if scholar_data.citation_data:
            paper['citation_data'] = scholar_data.citation_data
            print 'citation data %s' % scholar_data.citation_data
            bibdata = bibtexparser.loads(scholar_data.citation_data)
            bibinfo = bibdata.entries[0]
            paper.update(bibdata.entries[0])
        else:
            print 'Warning: %s does not have citation_data' % yaml_paper_info['title']

        paper.update(yaml_paper_info)
        # This should have the highest priority and overwrite others

        # if len(papers) == 0:
        #     # Only do it once
        #     print 'Scholar data field %s' % attrs.keys()
        #     print 'Bib data fields %s' % bibinfo.keys()

        if paper.get('author'):
            paper['first_author'] = paper['author'].split('and')[0].strip()
        papers.append(paper)


    print 'Available data fields %s' % papers[0].keys()
    return papers 

# 需要导入模块: import bibtexparser [as 别名]
# 或者: from bibtexparser import loads [as 别名]
def download_from_title(title, location="", use_libgen=False):
    found, bib_string = get_bib_from_title(title)
    if found:
        bib = bibtexparser.loads(bib_string).entries[0]
        if "doi" in bib:
            pdf_name = "{}.pdf".format(
                bib["doi"].replace("/", "_")
            )
            bib["pdf_file"] = location+pdf_name
            if use_libgen:
                download_from_libgen(bib["doi"], bib["pdf_file"])
            else:
                found, bib = download_from_scihub(bib["doi"], bib["pdf_file"])
        else:
            print("\tAbsent DOI")