def savebib(bib_parser,filename):
""" Saves a pybtex.database.BibliographyData in a file"""
writer = Writer()
strm = StringIO()
writer.write_stream(bib_parser, strm)
# Assume the input is utf8 encoded
f = open(filename,"w")
f.write(strm.getvalue().encode('utf8'))
f.close()
def load_bib(self, filename='IMSfull.bib'):
parser = bibtex.Parser()
bib_data = parser.parse_file(filename)
self.lastload = os.path.getmtime(filename)
self.filename = filename
pubs = []
index_keys = {}
index_bibkeys = {}
for key, elem in bib_data.entries.iteritems():
entry = elem.fields
# generate original bibtex
# using StringIO and bibtex.writer
a = BibliographyData()
a.add_entry(key, elem)
output = StringIO.StringIO()
w = Writer()
w.write_stream(a, output)
entry['bibtex'] = output.getvalue()
# sha1 for absolute unique keys
x = hashlib.sha1(simplejson.dumps(entry))
entry['key'] = x.hexdigest()
entry['authors'] = self.parse_authors(elem.persons)
entry['bibkey'] = elem.key
# keywords
entry['keywords'] = []
if entry.get('keyword'):
for i in entry['keyword'].split(','):
entry['keywords'].append(i.strip())
entry['reference'] = self.render_references(elem.type, entry)
# append to pubs
pubs.append(entry)
index_keys[x.hexdigest()] = len(pubs) - 1
index_bibkeys[elem.key] = len(pubs) - 1
if 'year' not in entry:
entry['year'] = ''
# set at end -> less time for threading problems
self.index_keys = index_keys
self.index_bibkeys = index_bibkeys
self.pubs = pubs
def load_bib(self, filename="IMSfull.bib"):
parser = bibtex.Parser()
bib_data = parser.parse_file(filename)
self.lastload = os.path.getmtime(filename)
self.filename = filename
pubs = []
index_keys = {}
index_bibkeys = {}
for key, elem in bib_data.entries.iteritems():
entry = elem.fields
# generate original bibtex
# using StringIO and bibtex.writer
a = BibliographyData()
a.add_entry(key, elem)
output = StringIO.StringIO()
w = Writer()
w.write_stream(a, output)
entry["bibtex"] = output.getvalue()
# sha1 for absolute unique keys
x = hashlib.sha1(simplejson.dumps(entry))
entry["key"] = x.hexdigest()
entry["authors"] = self.parse_authors(elem.persons)
entry["bibkey"] = elem.key
# keywords
entry["keywords"] = []
if entry.get("keyword"):
for i in entry["keyword"].split(","):
entry["keywords"].append(i.strip())
entry["reference"] = self.render_references(elem.type, entry)
# append to pubs
pubs.append(entry)
index_keys[x.hexdigest()] = len(pubs) - 1
index_bibkeys[elem.key] = len(pubs) - 1
if "year" not in entry:
entry["year"] = ""
# set at end -> less time for threading problems
self.index_keys = index_keys
self.index_bibkeys = index_bibkeys
self.pubs = pubs
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 write(self, backup=True):
'''Write to file. 'types' is a tuple of "contexts" to exclude
from the write-out process, such as submissions.'''
if os.path.exists(self._location):
try:
# backup
f = open(self._location, 'r')
if backup:
b = open(os.path.join(os.path.split(self._location)[0], 'backup.bib'), 'w')
b.write(f.read())
b.close()
f.close()
except:
raise _('Could not open file')
# wipe the file clean
f = open(self._location, 'w')
f.write('')
f.close()
# import additional pybtex modules
parser = bibtex.Parser(encoding='utf-8')
bib_object = parser.parse_file(self._location)
for bib_key, ent in self._entries:
bib_object.add_entry(bib_key, ent)
writer = Writer(encoding='utf-8')
try:
writer.write_file(bib_object, self._location)
except Exception, exc:
traceback.print_exc()
# restore backed up bibliography file
shutil.copyfile(
os.path.join(os.path.split(self._location)[0], 'backup.bib'),
self._location)
raise IOError, _('Saving of the bibliography file failed,\nmost likely because of invalid data.')
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 onBibDataAvailable(self, bibdata):
if bibdata:
writer = Writer()
bibdata_str = io.StringIO()
writer.write_stream(bibdata, bibdata_str)
self.ui.tb_preview.setPlainText(bibdata_str.getvalue())
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 is_int(a):
try:
int (a)
return True
except:
return False
## setup access to pubmed
Entrez.email='*****@*****.**'
database='pubmed'
## setup bibtex parser
parser = bibtex.Parser()
## setup bibtex write
w = Writer();
bib_data=parser.parse_file('cmi_library.bib')
id_num=0
for k in bib_data.entries.keys():
if not 'pmid' in bib_data.entries[k].fields.keys():
title="%s"% \
(re.sub('[\{\}\\\\]','',bib_data.entries[k].fields['title']))
#print "Searching for %s in pubmed."%(title)
result = Entrez.esearch(db=database,term=(title))
try:
record=Entrez.read(result)
except:
print "Error"
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.
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.
"""
# 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']:
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.
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)
