Commit ddf1aeb2 authored by Léo's avatar Léo
Browse files

Initial commit

parents
# Created by https://www.gitignore.io/api/python
### Python ###
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
target/
# Jupyter Notebook
.ipynb_checkpoints
# pyenv
.python-version
# celery beat schedule file
celerybeat-schedule
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
### Python Patch ###
.venv/
# End of https://www.gitignore.io/api/python
\ No newline at end of file
import re
from pybtex.style.formatting import BaseStyle, toplevel
from pybtex.style.template import (
field, first_of, href, join, names, optional, optional_field, sentence,
tag, together, words, node, FieldIsMissing
)
from pybtex.richtext import Text, Symbol
def format_pages(text):
dash_re = re.compile(r'-+')
pages = Text(Symbol('ndash')).join(text.split(dash_re))
if re.search('[-‒–—―]', str(text)):
return Text("pp.", Symbol('nbsp'), pages)
return Text("p.", Symbol('nbsp'), pages)
pages = field('pages', apply_func=format_pages)
date = words[field('year'), optional[", ", field('month')]]
@node
def apa_names(children, context, role, **kwargs):
"""Return formatted names as an APA compliant reference list citation."""
assert not children
try:
persons = context['entry'].persons[role]
except KeyError:
raise FieldIsMissing(role, context['entry'])
style = context['style']
if len(persons) > 7:
persons = persons[:6] + persons[-1:]
formatted_names = [style.format_name(
person, style.abbreviate_names) for person in persons]
return join(sep=', ', last_sep=', … ')[
formatted_names].format_data(context)
else:
formatted_names = [style.format_name(
person, style.abbreviate_names) for person in persons]
return join(sep=', ', sep2=', & ', last_sep=', & ')[
formatted_names].format_data(context)
class APAStyle(BaseStyle):
name = 'apa'
default_name_style = 'lastfirst'
default_sorting_style = 'author_year_title'
default_label_style = 'alpha'
def __init__(self, *args, **kwargs):
super(APAStyle, self).__init__(*args, **kwargs)
self.abbreviate_names = True
def format_names(self, role, as_sentence=True):
formatted_names = apa_names(role)
if as_sentence:
return sentence(capfirst=False)[formatted_names]
else:
return formatted_names
def format_author_or_editor_and_date(self, e):
if 'author' in e.persons and 'editor' in e.persons:
return sentence(sep=' ')[
self.format_names('author'), together["(", date, ")."],
self.format_editor(e, as_sentence=False)]
elif 'author' in e.persons:
return sentence(sep=' ')[
self.format_names('author'), together["(", date, ")"]]
else:
return sentence(sep=' ')[
self.format_editor(e, as_sentence=False),
together["(", date, ")"]]
def format_editor(self, e, as_sentence=True):
editors = self.format_names('editor', as_sentence=False)
if 'editor' not in e.persons:
# when parsing the template, a FieldIsMissing exception
# will be thrown anyway; no need to do anything now,
# just return the template that will throw the exception
return editors
if len(e.persons['editor']) > 1:
word = '(Eds.)'
else:
word = '(Ed.)'
result = join(sep=' ')[editors, word]
if as_sentence:
return sentence[result]
else:
return result
def format_volume(self, e, for_article=False):
prefix = "Vol."
if for_article:
return optional[
tag('em')[field('volume')],
optional['(', field('number'), ')'],
]
else:
return optional[together[prefix, field('volume')]]
def format_title(self, e, which_field, as_sentence=True):
formatted_title = field(
which_field, apply_func=lambda text: text.capitalize()
)
if as_sentence:
return sentence[formatted_title]
else:
return formatted_title
def format_btitle(self, e, which_field, as_sentence=True):
formatted_title = tag('em')[field(which_field)]
if as_sentence:
return sentence[formatted_title]
else:
return formatted_title
def format_web_refs(self, e):
# Based on urlbst output.web.refs
return sentence[
optional[self.format_url(e)],
optional[self.format_eprint(e)],
optional[self.format_pubmed(e)],
optional[self.format_doi(e)],
]
def format_url(self, e):
# Based on urlbst format.url
return words[
'URL:',
href[
field('url', raw=True),
field('url', raw=True)
]
]
def format_pubmed(self, e):
# Based on urlbst format.pubmed
return href[
join[
'https://www.ncbi.nlm.nih.gov/pubmed/',
field('pubmed', raw=True)
],
join[
'PMID:',
field('pubmed', raw=True)
]
]
def format_doi(self, e):
# Based on urlbst format.doi
return href[
join[
'https://doi.org/',
field('doi', raw=True)
],
join[
'doi:',
field('doi', raw=True)
]
]
def format_eprint(self, e):
# Based on urlbst format.eprint
return href[
join[
'https://arxiv.org/abs/',
field('eprint', raw=True)
],
join[
'arXiv:',
field('eprint', raw=True)
]
]
def get_article_template(self, e):
# Required fields: author, title, journal, year
# Optional fields: volume, number, pages, month, note, key
volume_and_pages = first_of[
# volume and pages, with optional issue number
optional[
join[
self.format_volume(e, for_article=True),
optional[', ', pages]
],
],
# pages only
pages,
]
template = toplevel[
self.format_names('author'),
join["(", date, ")"],
self.format_title(e, 'title'),
words[
tag('em')[field('journal')],
optional["(", volume_and_pages, ")"],
],
self.format_web_refs(e),
]
return template
def get_book_template(self, e):
# Required fields: author/editor, title, publisher, year
# Optional fields: volume, series, address, edition, month, note, key,
# isbn
return toplevel[
self.format_author_or_editor_and_date(e),
join(sep=' ')[
self.format_btitle(e, 'title'),
optional[
sentence[
optional_field('edition'),
self.format_volume(e),
]
]
],
join(sep=': ')[
optional_field('address'),
field('publisher'),
]
]
def get_booklet_template(self, e):
# Required fields: title
# Optional fields: author, howpublished, address, month, year, note,
# key
return toplevel[
optional[self.format_names('author')],
join["(", first_of[optional[date], "n.d."], ")"],
self.format_btitle(e, 'title'),
optional_field('address'),
]
def get_inbook_template(self, e):
# Required fields: author/editor, title, chapter/pages, publisher, year
# Optional fields: volume, series, address, edition, month, note, key
return toplevel[
self.format_author_or_editor_and_date(e),
sentence(sep=' ')[
self.format_btitle(e, 'title', as_sentence=False),
optional[
join[
"(",
sentence(add_period=False)[
optional_field('edition'),
self.format_volume(e),
pages,
],
")"
]
]
],
sentence(sep=': ')[
optional_field('address'),
field('publisher'),
]
]
def get_incollection_template(self, e):
# Required fields: author, title, booktitle, year
# Optional fields: editor, pages, organization, publisher, address,
# month, note, key
return toplevel[
self.format_author_or_editor_and_date(e),
self.format_title(e, 'title'),
sentence(sep=' ')[
self.format_btitle(e, 'booktitle'),
optional["(", pages, ")"]
],
sentence(sep=': ')[
optional_field('address'),
field('publisher'),
]
]
def get_inproceedings_template(self, e):
# Required fields: author, title, booktitle, year
# Optional fields: editor, pages, organization, publisher, address,
# month, note, key
return toplevel[
self.format_author_or_editor_and_date(e),
self.format_title(e, 'title'),
sentence(sep=' ')[
self.format_btitle(e, 'booktitle'),
optional["(", pages, ")"]
],
sentence(sep=': ')[
optional_field('address'),
field('publisher'),
],
self.format_web_refs(e)
]
def get_manual_template(self, e):
# Required fields: title
# Optional fields: author, organization, address, edition, month, year,
# note, key
return toplevel[
join[
first_of[
optional[self.format_names('author')],
optional[field('organization')],
"None to claim their bones"
], " (", date, ")"
],
self.format_btitle(e, 'title'),
optional_field('address'),
self.format_web_refs(e)
]
def get_mastersthesis_template(self, e):
# Required fields: author, title, school, year
# Optional fields: address, month, note, key
return toplevel[
join[self.format_names('author'), " (", date, ")"],
words[
self.format_btitle(e, 'title'),
"(Master's thesis)"
],
sentence[
field('school'),
optional_field('address'),
],
]
def get_misc_template(self, e):
# Required fields: aucun
# Optional fields: author, title, howpublished, month, year, note, key,
# type
template = toplevel[
optional[self.format_names('author')],
optional[date],
optional[self.format_btitle(e, 'title')],
]
return template
def get_phdthesis_template(self, e):
# Required fields: author, title, school, year
# Optional fields: address, month, note, key
return toplevel[
words[self.format_names('author'), join["(", date, ")"]],
words[
self.format_btitle(e, 'title'),
"(Doctoral dissertation)"
],
sentence[
field('school'),
optional_field('address'),
],
]
def get_proceedings_template(self, e):
# Required fields: title, year
# Optional fields: editor, publisher, organization, address, month, note, key
if 'editor' in e.persons:
return toplevel[
words[
self.format_editor(e, as_sentence=False),
join["(", date, ")"]
],
self.format_btitle(e, 'title', as_sentence=False)
]
else:
return toplevel[
words[
optional_field('organization'),
join["(", date, ")"]
],
self.format_btitle(e, 'title', as_sentence=False),
]
def get_techreport_template(self, e):
# Required fields: author, title, institution, year
# Optional fields: type, number, address, month, note, key
return toplevel[
words[self.format_names('author'), join["(", date, ")"]],
self.format_btitle(e, 'title'),
field('institution')
]
def get_unpublished_template(self, e):
# Required fields: author, title, note
# Optional fields: month, year, key
template = toplevel[
words[
self.format_names('author'),
optional[date]
],
self.format_btitle(e, 'title'),
field('note')
]
return template
from setuptools import setup
setup(
name='Pybtex APA-like style',
author='Naeka',
py_modules=['apastyle'],
entry_points={
'pybtex.style.formatting': 'apa = apastyle:APAStyle',
},
)
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment