def bibtex(value, format): if format == "latex": result = [] for ref in Style().format_entries(value): result.append(ref.text.render(latex.Backend())) return result elif format == "html": print "test" for ref in Style().format_entries(value): print ref.text.render(html.Backend()) else: raise Exception("Unrecognised output format given to bibtex filter")
def run(self): refs_file = self.arguments[0].strip() try: bibdata_all = Parser().parse_file(refs_file) except PybtexError as e: logger.warn('`pelican_bibtex` failed to parse file %s: %s' % (refs_file, str(e))) return # format entries jo_style = jo.Style() jo_style.strong = 'Razik' html_backend = html.Backend() formatted_entries = jo_style.format_entries( bibdata_all.entries.values()) publications = [] for formatted_entry in formatted_entries: key = formatted_entry.key entry = bibdata_all.entries[key] year = entry.fields.get('year') # This shouldn't really stay in the field dict # but new versions of pybtex don't support pop pdf = entry.fields.get('pdf', None) slides = entry.fields.get('slides', None) poster = entry.fields.get('poster', None) # render the bibtex string for the entry bib_buf = StringIO() bibdata_this = BibliographyData(entries={key: entry}) Writer().write_stream(bibdata_this, bib_buf) text = formatted_entry.text.render(html_backend) publications.append( (key, year, text, bib_buf.getvalue(), pdf, slides, poster)) # Load the publications template if 'template' in self.options: template_path = self.options['template'] template_dir, template_name = os.path.split(template_path) env = Environment(loader=FileSystemLoader(template_dir)) template = env.get_template(template_name) else: # Use template from the Pelican theme template = pelican_generator.get_template('publications') rendered_template = template.render(publications=publications) return [nodes.raw('', rendered_template, format='html')]
def get_formatted_citation(e, key='k', format='html'): '''Return a string containing a formatted citation for a given _PybTeX_ entry (not a PieObject)''' formatter = Formatter() # ents = ((key, e),) ents = (e,) formatted_data = formatter.format_entries(ents) for d in formatted_data: if format == 'html': rendered_data = d.text.render(html.Backend()) else: rendered_data = d.text.render(plaintext.Backend()) # get hrefs in order href_search = re_href.search(rendered_data) output_data = None if format == 'html': if e.fields.has_key('url') and e.fields.has_key('howpublished'): output_data = rendered_data.replace( e.fields['howpublished'], '<a href="%s">%s</a>' % ( ublc(e.fields['url']), e.fields['howpublished'] ) ) elif format == 'plaintext': pass #nothing to be done in this case elif format == 'urlplaintext': if e.fields.has_key('url') and e.fields.has_key('howpublished'): output_data = '%s\n%s' % ( rendered_data, e.fields['url'] ) elif format == 'org': if e.fields.has_key('url') and e.fields.has_key('howpublished'): output_data = rendered_data.replace( e.fields['howpublished'], '[[%s][%s]]' % ( ublc(e.fields['url']), e.fields['howpublished'] ) ) else: raise Exception, 'Invalid format request' if not output_data: output_data = rendered_data #obliterate curly brackets transtbl = {ord('{'): None, ord('}'): None} output_data = output_data.translate(transtbl) return output_data
self.label_style = LabelStyle() self.sorting_style = find_plugin( 'pybtex.style.sorting', sorting_style or self.default_sorting_style)() self.format_name = self.name_style.format self.format_labels = self.label_style.format_labels self.sort = self.sorting_style.sort self.abbreviate_names = abbreviate_names logger = logging.getLogger(__name__) global_bib = None content_path = None if pyb_imported: style = Style() backend = html.Backend() else: style = None backend = None def get_bib_file(article): """ If a bibliography file is specified for this article/page, parse it and return the parsed object. """ if 'publications_src' in article.metadata: refs_file = article.metadata['publications_src'] refs_file = os.path.join(content_path, refs_file) try: local_bib = Parser().parse_file(refs_file)
def add_publications(generator): """ Populates context with a list of BibTeX publications. Configuration ------------- generator.settings['PUBLICATIONS']: Dictionary that contains bibliographies: The key denotes the bibliographies name to use in headers The values describe the BibTeX files to read Mandatory for this plugin. generator.settings['PUBLICATIONS_NAVBAR']: Bool denoting whether a navigation bar containing links to each bibliography should be produced. Defaults to 'True'. generator.settings['PUBLICATIONS_HEADER']: Bool denoting whether a header (h2) should be produced for each bibliography. Defaults to 'True'. generator.settings['PUBLICATIONS_SPLIT']: Bool denoting whether bibliographies should be split by year (h3). Defaults to 'True'. generator.settings['PUBLICATIONS_HIGHLIGHTs']: String, e.g., a name, that will be entailed in a <strong> tag to highlight. Default: empty Output ------ generator.context['publications']: Dictionary containing the name of the publication list a a key, bibliography entries as a value. A bibliography entry contains of a list of tuples (key, year, text, bibtex, pdf, slides, poster). See Readme.md for more details. """ if 'PUBLICATIONS' not in generator.settings: return if 'PUBLICATIONS_NAVBAR' not in generator.settings: generator.context['PUBLICATIONS_NAVBAR'] = True try: from StringIO import StringIO except ImportError: from io import StringIO try: from pybtex.database.input.bibtex import Parser from pybtex.database.output.bibtex import Writer from pybtex.database import BibliographyData, PybtexError from pybtex.backends import html from pybtex.style.formatting import plain except ImportError: logger.warn('`pelican_bibtex` failed to load dependency `pybtex`') return refs = generator.settings['PUBLICATIONS'] generator.context['publications'] = collections.OrderedDict() for rid in refs: ref = refs[rid] bibfile = os.path.join(generator.settings['PATH'], ref['file']) try: bibdata_all = Parser().parse_file(bibfile) except PybtexError as e: logger.warn('`pelican_bibtex` failed to parse file %s: %s' % (bibfile, str(e))) return if 'title' in ref: title = ref['title'] else: title = rid if 'header' in ref: header = ref['header'] else: header = True if 'split' in ref: split = ref['split'] else: split = True if 'split_link' in ref: split_link = ref['split_link'] else: split_link = True if 'bottom_link' in ref: bottom_link = ref['bottom_link'] else: bottom_link = True if 'all_bibtex' in ref: all_bibtex = ref['all_bibtex'] else: all_bibtex = False if 'highlight' in ref: highlights = ref['highlight'] else: highlights = [] if 'group_type' in ref: group_type = ref['group_type'] else: group_type = False publications = [] # format entries plain_style = plain.Style() html_backend = html.Backend() formatted_entries = plain_style.format_entries( bibdata_all.entries.values()) for formatted_entry in formatted_entries: key = formatted_entry.key entry = bibdata_all.entries[key] year = entry.fields.get('year') typee = entry.type if entry.fields.get('tags'): tags = [ tag.strip() for tag in entry.fields.get('tags').split(';') ] else: tags = [] display_tags = [ x for x in tags if x != "doi-open" and x != "url-open" ] # This shouldn't really stay in the field dict # but new versions of pybtex don't support pop pdf = entry.fields.get('pdf', None) slides = entry.fields.get('slides', None) poster = entry.fields.get('poster', None) doi = entry.fields.get('doi', None) url = entry.fields.get('url', None) #clean fields from appearing in bibtex and on website entry_tmp = entry for to_del in ['pdf', 'slides', 'poster', 'tags']: entry_tmp.fields.pop(to_del, None) #render the bibtex string for the entry bib_buf = StringIO() bibdata_this = BibliographyData(entries={key: entry_tmp}) Writer().write_stream(bibdata_this, bib_buf) #clean more fields from appearing on website for to_del in ['doi', 'url']: entry_tmp.fields.pop(to_del, None) entry_clean = next( plain_style.format_entries(bibdata_this.entries.values()), None) # apply highlight (strong) text = entry_clean.text.render(html_backend) for replace in highlights: text = text.replace(replace, '<strong>' + replace + '</strong>') publications.append( (key, typee, year, text, tags, display_tags, bib_buf.getvalue(), pdf, slides, poster, doi, url)) generator.context['publications'][rid] = {} generator.context['publications'][rid]['title'] = title generator.context['publications'][rid]['path'] = os.path.basename( bibfile) generator.context['publications'][rid]['header'] = header generator.context['publications'][rid]['split'] = split generator.context['publications'][rid]['bottom_link'] = bottom_link generator.context['publications'][rid]['split_link'] = split_link generator.context['publications'][rid]['all_bibtex'] = all_bibtex generator.context['publications'][rid][ 'data'] = collections.OrderedDict() if group_type: generator.context['publications'][rid]['data'] = sorted( publications, key=lambda pub: (-int(pub[2].replace("in press", "9999")), pub[1])) else: generator.context['publications'][rid]['data'] = sorted( publications, key=lambda pub: -int(pub[2].replace("in press", "9999")))
def add_publications(generator): """ Populates context with a list of BibTeX publications. Configuration ------------- generator.settings['PUBLICATIONS_SRC']: Local path to the BibTeX file to read. generator.settings['PUBLICATIONS_SPLIT_BY']: The name of the bibtex field used for splitting the publications. No splitting if title is not provided. generator.settings['PUBLICATIONS_UNTAGGED_TITLE']: The title of the header for all untagged entries. No such list if title is not provided. Output ------ generator.context['publications_lists']: A map with keys retrieved from the field named in PUBLICATIONS_SPLIT_TAG. Values are lists of tuples (key, year, text, bibtex, pdf, slides, poster) See Readme.md for more details. generator.context['publications']: Contains all publications as a list of tuples (key, year, text, bibtex, pdf, slides, poster). See Readme.md for more details. """ if 'PUBLICATIONS_SRC' not in generator.settings: return try: from StringIO import StringIO except ImportError: from io import StringIO try: from pybtex.database.input.bibtex import Parser from pybtex.database.output.bibtex import Writer from pybtex.database import BibliographyData, PybtexError from pybtex.backends import html from pybtex.style.formatting import plain except ImportError: logger.warn('`pelican_bib` failed to load dependency `pybtex`') return refs_file = generator.settings['PUBLICATIONS_SRC'] try: bibdata_all = Parser().parse_file(refs_file) except PybtexError as e: logger.warn('`pelican_bib` failed to parse file %s: %s' % (refs_file, str(e))) return publications = [] publications_lists = {} publications_untagged = [] split_by = None untagged_title = None if 'PUBLICATIONS_SPLIT_BY' in generator.settings: split_by = generator.settings['PUBLICATIONS_SPLIT_BY'] if 'PUBLICATIONS_UNTAGGED_TITLE' in generator.settings: untagged_title = generator.settings['PUBLICATIONS_UNTAGGED_TITLE'] # format entries plain_style = plain.Style() html_backend = html.Backend() formatted_entries = plain_style.format_entries( bibdata_all.entries.values()) for formatted_entry in formatted_entries: key = formatted_entry.key entry = bibdata_all.entries[key] year = entry.fields.get('year') # This shouldn't really stay in the field dict # but new versions of pybtex don't support pop pdf = entry.fields.get('pdf', None) slides = entry.fields.get('slides', None) poster = entry.fields.get('poster', None) tags = [] if split_by: tags = entry.fields.get(split_by, []) # parse to list, and trim each string if tags: tags = [tag.strip() for tag in tags.split(',')] # create keys in publications_lists if at least one # tag is given for tag in tags: publications_lists[tag] = publications_lists.get(tag, []) #render the bibtex string for the entry bib_buf = StringIO() bibdata_this = BibliographyData(entries={key: entry}) Writer().write_stream(bibdata_this, bib_buf) text = formatted_entry.text.render(html_backend) entry_tuple = { 'key': key, 'year': year, 'text': text, 'bibtex': bib_buf.getvalue(), 'pdf': pdf, 'slides': slides, 'poster': poster } publications.append(entry_tuple) for tag in tags: publications_lists[tag].append(entry_tuple) if not tags and untagged_title: publications_untagged.append(entry_tuple) # append untagged list if title is given if untagged_title and publications_untagged: publications_lists[untagged_title] = publications_untagged # output generator.context['publications'] = publications generator.context['publications_lists'] = publications_lists
def add_publications(generator): """ Populates context with a list of BibTeX publications. Configuration ------------- generator.settings['PUBLICATIONS_SRC']: local path to the BibTeX file to read. Output ------ generator.context['publications']: List of tuples (key, year, text, bibtex, pdf, slides, poster). See Readme.md for more details. """ if 'PUBLICATIONS_SRC' not in generator.settings: return try: from StringIO import StringIO except ImportError: from io import StringIO try: from pybtex.database.input.bibtex import Parser from pybtex.database.output.bibtex import Writer from pybtex.database import BibliographyData, PybtexError from pybtex.backends import html from pybtex.style.formatting import plain except ImportError: logger.warn('`pelican_bibtex` failed to load dependency `pybtex`') return refs_file = generator.settings['PUBLICATIONS_SRC'] try: bibdata_all = Parser().parse_file(refs_file) except PybtexError as e: logger.warn('`pelican_bibtex` failed to parse file %s: %s' % ( refs_file, str(e))) return publications = [] # format entries plain_style = plain.Style() html_backend = html.Backend() formatted_entries = plain_style.format_entries(bibdata_all.entries.values()) for formatted_entry in formatted_entries: key = formatted_entry.key entry = bibdata_all.entries[key] year = entry.fields.get('year') # This shouldn't really stay in the field dict # but new versions of pybtex don't support pop pdf = entry.fields.get('pdf', None) slides = entry.fields.get('slides', None) poster = entry.fields.get('poster', None) #render the bibtex string for the entry bib_buf = StringIO() bibdata_this = BibliographyData(entries={key: entry}) Writer().write_stream(bibdata_this, bib_buf) text = formatted_entry.text.render(html_backend) publications.append((key, year, text, bib_buf.getvalue(), pdf, slides, poster)) generator.context['publications'] = publications
def add_publications(generator): """ Populates context with a list of BibTeX publications. Configuration ------------- generator.settings['PUBLICATIONS_SRC']: local path to the BibTeX file to read. Output ------ generator.context['publications']: List of tuples (key, year, text, bibtex, pdf, slides, poster). See Readme.md for more details. """ if 'PUBLICATIONS_SRC' not in generator.settings: return try: from StringIO import StringIO except ImportError: from io import StringIO try: from pybtex.database.input.bibtex import Parser from pybtex.database.output.bibtex import Writer from pybtex.database import BibliographyData, PybtexError from pybtex.backends import html #from pybtex.style.formatting import plain from rahul_style import Style as RahulStyle except ImportError: logger.warn('`pelican_bibtex` failed to load dependency `pybtex`') return refs_file = generator.settings['PUBLICATIONS_SRC'] try: bibdata_all = Parser().parse_file(refs_file) except PybtexError as e: logger.warn('`pelican_bibtex` failed to parse file %s: %s' % (refs_file, str(e))) return publications = [] # format entries plain_style = RahulStyle() #plain_style = plain.Style() html_backend = html.Backend() html_backend.symbols['br'] = u'<BR/>' all_entries = bibdata_all.entries.values() # remove URL field if DOI is present for entry in all_entries: if "doi" in entry.fields.keys(): entry.fields._dict["url"] = "" formatted_entries = plain_style.format_entries(all_entries) for formatted_entry in formatted_entries: key = formatted_entry.key entry = bibdata_all.entries[key] pub_type = entry.type year = entry.fields.get('year') # This shouldn't really stay in the field dict # but new versions of pybtex don't support pop pdf = entry.fields.get('pdf', None) #slides = entry.fields.get('slides', None) #poster = entry.fields.get('poster', None) doi = entry.fields.get('doi', None) url = entry.fields.get('url', None) arxiv = entry.fields.get('arxiv', None) #render the bibtex string for the entry bib_buf = StringIO() bibdata_this = BibliographyData(entries={key: entry}) Writer().write_stream(bibdata_this, bib_buf) text = formatted_entry.text.render(html_backend) # prettify entries # remove BibTeX's {} text = text.replace("\{", "") text = text.replace("{", "") text = text.replace("\}", "") text = text.replace("}", "") # remove textbf used for cv text = text.replace("\\textbf ", "") # remove \ that comes after Proc. text = text.replace("\\", "") publications.append((pub_type, key, year, text, bib_buf.getvalue(), pdf, doi, url, arxiv)) generator.context['publications'] = publications
def add_publications_to_context(generator, refs_files, refs_string=None, pybtex_style_args={}): """ Populates context with a list of BibTeX publications. """ try: from StringIO import StringIO except ImportError: from io import StringIO try: from pybtex.database.input.bibtex import Parser from pybtex.database.output.bibtex import Writer from pybtex.database import BibliographyData, PybtexError from pybtex.backends import html from pybtex.style.formatting import BaseStyle, plain except ImportError: logger.warn('`pelican_bib` failed to load dependency `pybtex`') return decorate_html = generator.settings.get('PUBLICATIONS_DECORATE_HTML', False) plugin_path = generator.settings.get('PUBLICATIONS_PLUGIN_PATH', 'plugins') import sys sys.path.append(plugin_path) kwargs = generator.settings.get('PUBLICATIONS_STYLE_ARGS', {}) kwargs.update(pybtex_style_args) style_type = get_style_type(plain.Style, decorate_html) style = style_type(**kwargs) if generator.settings.get('PUBLICATIONS_CUSTOM_STYLE', False): try: from pybtex_plugins import PelicanStyle if not isinstance(PelicanStyle, type) or not issubclass(PelicanStyle, BaseStyle): raise TypeError() style_type = get_style_type(PelicanStyle, decorate_html) style = style_type(**kwargs) except ImportError as e: logger.warn(str(e)) logger.warn('pybtex_plugins.PelicanStyle not found, using Pybtex plain style') except TypeError: logger.warn('PelicanStyle must be a subclass of pybtex.style.formatting.BaseStyle') # collect entries bibdata_entries = {} for file in refs_files: bibdata_entries.update(Parser().parse_file(file).entries) if refs_string: bibdata_entries.update(Parser().parse_string(refs_string).entries) publications = [] publications_lists = {} publications_untagged = [] split_by = generator.settings.get('PUBLICATIONS_SPLIT_BY', None) untagged_title = generator.settings.get('PUBLICATIONS_UNTAGGED_TITLE', None) # format entries html_backend = html.Backend() formatted_entries = style.format_entries(bibdata_entries.values()) for formatted_entry in formatted_entries: key = formatted_entry.key entry = bibdata_entries[key] year = entry.fields.get('year') # This shouldn't really stay in the field dict # but new versions of pybtex don't support pop pdf = entry.fields.get('pdf', None) slides = entry.fields.get('slides', None) poster = entry.fields.get('poster', None) tags = [] if split_by: tags = entry.fields.get(split_by, []) # parse to list, and trim each string if tags: tags = [tag.strip() for tag in tags.split(',')] # create keys in publications_lists if at least one # tag is given for tag in tags: publications_lists[tag] = publications_lists.get(tag, []) #render the bibtex string for the entry bib_buf = StringIO() bibdata_this = BibliographyData(entries={key: entry}) Writer().write_stream(bibdata_this, bib_buf) # convert decorated html tags # `<:bib-xyz>abc</:bib-xyz>` => `<span class="bib-xyz">abc</span>` text = formatted_entry.text.render(html_backend) text = replace(r'<:([^>]*)>', r'<span class="\1">', text) text = replace(r'</:([^>]*)>', r'</span>', text) entry_tuple = {'key': key, 'year': year, 'text': text, 'bibtex': bib_buf.getvalue(), 'pdf': pdf, 'slides': slides, 'poster': poster} entry_tuple.update(entry.fields) publications.append(entry_tuple) for tag in tags: publications_lists[tag].append(entry_tuple) if not tags and untagged_title: publications_untagged.append(entry_tuple) # append untagged list if title is given if untagged_title and publications_untagged: publications_lists[untagged_title] = publications_untagged # output generator.context['publications'] = publications generator.context['publications_lists'] = publications_lists
def add_publications(generator): """ Populates context with a list of BibTeX publications. Configuration ------------- generator.settings['PUBLICATIONS_SRC']: local path to the BibTeX file to read. Output ------ generator.context['publications']: List of tuples (key, year, text, bibtex, pdf, slides, poster). See Readme.md for more details. """ # check if settings are provided via pelicanconf.py settings_present = False for s in ['PUBLICATIONS_SRC', 'PRESENTATIONS_SRC', 'POSTERS_SRC']: if s in generator.settings: settings_present = True if not settings_present: return try: from StringIO import StringIO except ImportError: from io import StringIO try: from pybtex.database.input.bibtex import Parser from pybtex.database.output.bibtex import Writer from pybtex.database import BibliographyData, PybtexError from pybtex.backends import html from pybtex.style.formatting import plain except ImportError: logger.warn('`pelican_bibtex` failed to load dependency `pybtex`') return for s, c in zip(['PUBLICATIONS_SRC', 'PRESENTATIONS_SRC', 'POSTERS_SRC'], ['publications', 'presentations', 'posters']): if s not in generator.settings: continue refs_file = generator.settings[s] try: bibdata_all = Parser().parse_file(refs_file) except PybtexError as e: logger.warn('`pelican_bibtex` failed to parse file %s: %s' % (refs_file, str(e))) continue publications = [] # format entries plain_style = plain.Style() html_backend = html.Backend() all_entries = bibdata_all.entries.values() # remove URL field if DOI is present for entry in all_entries: if "doi" in entry.fields.keys(): entry.fields._dict["url"] = "" formatted_entries = plain_style.format_entries(all_entries) for formatted_entry in formatted_entries: key = formatted_entry.key entry = bibdata_all.entries[key] year = entry.fields.get('year') slides = entry.fields.pop('slides', None) poster = entry.fields.pop('poster', None) # add PDF link if file is present # Zotero exports a 'file' field, which contains the 'Zotero' and # 'Filesystem' filenames, seperated by ':' try: filename = entry.fields['file'].split(':')[0] if os.access(os.path.join('content', 'download', filename), os.R_OK): pdf = os.path.join('download', filename) else: pdf = None except KeyError: pdf = None #render the bibtex string for the entry bib_buf = StringIO() bibdata_this = BibliographyData(entries={key: entry}) Writer().write_stream(bibdata_this, bib_buf) text = formatted_entry.text.render(html_backend) doi = (entry.fields.get('doi') if 'doi' in entry.fields.keys() else "") url = (entry.fields.get('url') if 'url' in entry.fields.keys() else "") # prettify entries # remove BibTeX's {} text = text.replace("\{", "") text = text.replace("{", "") text = text.replace("\}", "") text = text.replace("}", "") # subscript 2 in NO2, CO2, SO2 text = text.replace("NO2", "NO<sub>2</sub>") text = text.replace("CO2", "CO<sub>2</sub>") text = text.replace("CO2", "CO<sub>2</sub>") # for posters and presentations, make for nicer printing text = text.replace("In <em>", "Presented at <em>") # remove empty URL link text = text.replace("<a href=\"\">URL:</a>, ", "") publications.append((key, year, text, bib_buf.getvalue(), doi, url, pdf, slides, poster)) # store the list of artifacts in the generator context generator.context[c] = publications
def add_publications(generator): """ Populates context with a list of BibTeX publications. Configuration ------------- generator.settings['PUBLICATIONS_SRC']: local path to the BibTeX file to read. Output ------ generator.context['publications']: List of tuples (key, year, text, bibtex, pdf, slides, poster). See Readme.md for more details. """ if 'PUBLICATIONS_SRC' not in generator.settings: return try: from StringIO import StringIO except ImportError: from io import StringIO try: from pybtex.database.input.bibtex import Parser from pybtex.database.output.bibtex import Writer from pybtex.database import BibliographyData, PybtexError from pybtex.backends import html from pybtex.style.formatting import plain except ImportError: LOGGER.warn('`pelican_bibtex` failed to load dependency `pybtex`') return try: bib_items = Parser().parse_file(generator.settings['PUBLICATIONS_SRC']) except PybtexError as err: LOGGER.warn('`pelican_bibtex` failed to parse file %s: %s', generator.settings['PUBLICATIONS_SRC'], str(err)) return publications = [] for fmt_entry in plain.Style().format_entries(bib_items.entries.values()): key = fmt_entry.key entry = bib_items.entries[key] # Render the bibtex string for the entry buf = StringIO() Writer().write_stream(BibliographyData(entries={key: entry}), buf) # Prettify BibTeX entries text = fmt_entry.text.render(html.Backend()) text = text.replace(r"\{", "").replace(r"\}", "") text = text.replace("{", "").replace("}", "") publications.append({'bibtex' : buf.getvalue(), 'doi' : get_field(entry, 'doi'), 'entry' : entrytype(entry.type), 'key' : key, 'pdf' : get_field(entry, 'pdf'), 'poster' : get_field(entry, 'poster'), 'slides' : get_field(entry, 'slides'), 'text' : text, 'url' : get_field(entry, 'url'), 'note' : get_field(entry, 'note'), 'year' : entry.fields.get('year'), 'authorizer': get_field(entry, 'authorizer'), 'acceptance': get_field(entry, 'acceptance'), 'stats': get_field(entry, 'stats') }) generator.context['publications'] = publications
def add_publications(generator): """ Populates context with a list of BibTeX publications. Configuration ------------- generator.settings['PUBLICATIONS_SRC']: local path to the BibTeX file to read. Output ------ generator.context['publications']: List of tuples (key, year, text, bibtex, pdf, slides, poster). See Readme.md for more details. """ if 'PUBLICATIONS_SRC' not in generator.settings: return try: from StringIO import StringIO except ImportError: from io import StringIO try: from pybtex.database.input.bibtex import Parser from pybtex.database.output.bibtex import Writer from pybtex.database import BibliographyData, PybtexError from pybtex.backends import html from pybtex.style.formatting import plain except ImportError: logger.warn('`pelican_bibtex` failed to load dependency `pybtex`') return refs_file = generator.settings['PUBLICATIONS_SRC'] try: bibdata_all = Parser().parse_file(refs_file) except PybtexError as e: logger.error('`pelican_bibtex` failed to parse file %s: %s' % ( refs_file, str(e))) exit(1) return publications = [] # format entries plain_style = plain.Style() html_backend = html.Backend() formatted_entries = plain_style.format_entries(bibdata_all.entries.values()) for formatted_entry in formatted_entries: key = formatted_entry.key entry = bibdata_all.entries[key] year = entry.fields.get('year') XEcategory = entry.fields.get('XEcategory') XEmember = entry.fields.get('XEmember') XEProject = entry.fields.get('XEProject') url = entry.fields.get('XEurl') #render the bibtex string for the entry bib_buf = StringIO() bibdata_this = BibliographyData(entries={key: entry}) Writer().write_stream(bibdata_this, bib_buf) text = formatted_entry.text.render(html_backend) # publications.append((key, # year, # text, # url, # XEmember, # XEcategory, # XEProject # )) publications.append({'key' : key, 'year' : year, 'text' : text, 'url' : url, 'XEmember' : XEmember, 'XEcategory' : XEcategory, 'XEProject' : XEProject}) generator.context['publications'] = publications
def add_publications(generator): """ Populates context with a list of BibTeX publications. Configuration ------------- generator.settings['PUBLICATIONS_SRC']: local path to the BibTeX file to read. Output ------ generator.context['publications']: List of tuples (key, year, text, bibtex, pdf, slides, poster). See Readme.md for more details. """ if 'PUBLICATIONS_SRC' not in generator.settings: return try: from StringIO import StringIO except ImportError: from io import StringIO try: from pybtex.database.input.bibtex import Parser from pybtex.database.output.bibtex import Writer from pybtex.database import BibliographyData, PybtexError from pybtex.backends import html from pybtex.style.formatting import plain, toplevel from pybtex.style.template import (sentence, words, optional, optional_field, field, tag) from pybtex.richtext import Symbol except ImportError: logger.warn('`pelican_bibtex` failed to load dependency `pybtex`') return refs_file = generator.settings['PUBLICATIONS_SRC'] try: bibdata_all = Parser().parse_file(refs_file) except PybtexError as e: logger.warning('`pelican_bibtex` failed to parse file %s: %s' % ( refs_file, str(e))) return class CustomStyle(plain.Style): def format_bold_title(self, e, which_field, as_sentence=True): formatted_title = tag('strong')[field(which_field)] if as_sentence: return sentence[formatted_title] else: return formatted_title def get_inproceedings_template(self, e): template = toplevel[ self.format_bold_title(e, 'title'), Symbol('newline'), sentence[self.format_names('author')], Symbol('newline'), words[ 'In', sentence[ optional[self.format_editor(e, as_sentence=False)], self.format_btitle(e, 'booktitle', as_sentence=False), self.format_volume_and_series(e, as_sentence=False), ], self.format_address_organization_publisher_date(e), ], sentence[optional_field('note')], self.format_web_refs(e), ] return template def get_article_template(self, e): volume_and_pages = first_of[ # volume and pages, with optional issue number optional[ join[ field('volume'), optional['(', field('number'), ')'], ':', pages ], ], # pages only words['pages', pages], ] template = toplevel[ self.format_bold_title(e, 'title'), Symbol('newline'), self.format_names('author'), Symbol('newline'), sentence[ tag('em')[field('journal')], optional[volume_and_pages], date], sentence[optional_field('note')], self.format_web_refs(e), ] return template def get_techreport_template(self, e): template = toplevel[ self.format_bold_title(e, 'title'), Symbol('newline'), sentence[self.format_names('author')], Symbol('newline'), sentence[ words[ first_of[ optional_field('type'), 'Technical Report', ], optional_field('number'), ], field('institution'), optional_field('address'), date, ], sentence[optional_field('note')], self.format_web_refs(e), ] return template def format_entry(self, label, entry, bib_data=None): return super().format_entry(label, entry, bib_data) publications = [] # format entries my_style = CustomStyle() html_backend = html.Backend() html_backend.symbols.update({'newline': '<br>'}) formatted_entries = my_style.format_entries(bibdata_all.entries.values()) for formatted_entry in formatted_entries: key = formatted_entry.key entry = bibdata_all.entries[key] year = entry.fields.get('year') # This shouldn't really stay in the field dict # but new versions of pybtex don't support pop pdf = entry.fields.get('pdf', None) slides = entry.fields.get('slides', None) poster = entry.fields.get('poster', None) entrytype = entry.fields.get('type', None) # render the bibtex string for the entry bib_buf = StringIO() bibdata_this = BibliographyData(entries={key: entry}) Writer().write_stream(bibdata_this, bib_buf) text = formatted_entry.text.render(html_backend) publications.append((key, year, text, bib_buf.getvalue(), pdf, slides, poster, entrytype)) publications.sort(key=itemgetter(1), reverse=True) generator.context['publications'] = publications
def add_publications(generator): """ Populates context with a list of BibTeX publications. Configuration ------------- generator.settings['PUBLICATIONS_SRC']: local path to the BibTeX file to read. Output ------ generator.context['publications']: List of tuples (key, year, text, bibtex, url, slides, poster). See Readme.md for more details. """ if 'PUBLICATIONS_SRC' not in generator.settings: return refs_file = generator.settings['PUBLICATIONS_SRC'] try: bibdata_all = Parser().parse_file(refs_file) except PybtexError as e: logger.warn('`pelican_bibtex` failed to parse file %s: %s' % (refs_file, str(e))) return # format entries plain_style = MyStyle() html_backend = html.Backend() formatted_entries = plain_style.format_entries( bibdata_all.entries.values()) publications = [] reports = [] unpublished = [] for formatted_entry in formatted_entries: key = formatted_entry.key entry = bibdata_all.entries[key] try: year = int(entry.fields.get('year', None)) except TypeError: year = None journal = entry.fields.get('journal', "") sort_key = (year, journal) # Render the bibtex string for the entry. bib_buf = StringIO() bibdata_this = BibliographyData(entries={key: entry}) Writer().write_stream(bibdata_this, bib_buf) text = formatted_entry.text.render(html_backend) entry_res = (key, text, bib_buf.getvalue(), sort_key) if entry.type == 'article': publications.append(entry_res) elif entry.type == 'unpublished': unpublished.append(entry_res) else: reports.append(entry_res) generator.context['publications'] = sorted(publications, key=itemgetter(-1), reverse=True) generator.context['reports'] = sorted(reports, key=itemgetter(-1), reverse=True) generator.context['unpublished'] = sorted(unpublished, key=itemgetter(-1), reverse=True)