Source code for pybamm.citations

#
# Bibliographical information for PyBaMM
# Inspired by firedrake/PETSc citation workflow
# https://firedrakeproject.org/citing.html
#
import pybamm
import os
import warnings
from sys import _getframe
from pybamm.util import have_optional_dependency


[docs] class Citations: """Entry point to citations management. This object may be used to record BibTeX citation information and then register that a particular citation is relevant for a particular simulation. Citations listed in `pybamm/CITATIONS.bib` can be registered with their citation key. For all other works provide a BibTeX Citation to :meth:`register`. Examples -------- >>> pybamm.citations.register("Sulzer2021") >>> pybamm.citations.register("@misc{Newton1687, title={Mathematical...}}") >>> pybamm.print_citations("citations.txt") """ def __init__(self): # Set of citation keys that have been registered self._papers_to_cite = set() # Dict mapping citations keys to BibTex entries self._all_citations: dict[str, str] = dict() # Set of unknown citations to parse with pybtex self._unknown_citations = set() # Dict mapping citation tags for use when registering citations self._citation_tags = dict() # store citation error self._citation_err_msg = None try: self.read_citations() self._reset() except Exception as e: # pragma: no cover self._citation_err_msg = e def _reset(self): """Reset citations to default only (only for testing purposes)""" # Initialize empty papers to cite self._papers_to_cite = set() # Initialize empty set of unknown citations self._unknown_citations = set() # Initialize empty citation tags self._citation_tags = dict() # Register the PyBaMM paper and the NumPy paper self.register("Sulzer2021") self.register("Harris2020") @staticmethod def _caller_name(): """ Returns the qualified name of classes that call :meth:`register` internally. Gets cached in order to reduce the number of calls. """ # Attributed to https://stackoverflow.com/a/53490973 caller_name = _getframe().f_back.f_back.f_locals["self"].__class__.__qualname__ return caller_name
[docs] def read_citations(self): """Reads the citations in `pybamm.CITATIONS.bib`. Other works can be cited by passing a BibTeX citation to :meth:`register`. """ parse_file = have_optional_dependency("pybtex.database", "parse_file") citations_file = os.path.join(pybamm.root_dir(), "pybamm", "CITATIONS.bib") bib_data = parse_file(citations_file, bib_format="bibtex") for key, entry in bib_data.entries.items(): self._add_citation(key, entry)
def _add_citation(self, key, entry): """Adds `entry` to `self._all_citations` under `key`, warning the user if a previous entry is overwritten """ Entry = have_optional_dependency("pybtex.database", "Entry") # Check input types are correct if not isinstance(key, str) or not isinstance(entry, Entry): raise TypeError() # Warn if overwriting a previous citation new_citation = entry.to_string("bibtex") if key in self._all_citations and new_citation != self._all_citations[key]: warnings.warn(f"Replacing citation for {key}") # Add to database self._all_citations[key] = new_citation def _add_citation_tag(self, key, entry): """Adds a tag for a citation key in the dict, which represents the name of the class that called :meth:`register`""" self._citation_tags[key] = entry @property def _cited(self): """Return a list of the BibTeX entries that have been cited""" return [self._all_citations[key] for key in self._papers_to_cite]
[docs] def register(self, key): """Register a paper to be cited, one at a time. The intended use is that :meth:`register` should be called only when the referenced functionality is actually being used. .. warning:: Registering a BibTeX citation, with the same key as an existing citation, will overwrite the current citation. Parameters ---------- key : str - The citation key for an entry in `pybamm/CITATIONS.bib` or - A BibTeX formatted citation """ if self._citation_err_msg is None: # Check if citation is a known key if key in self._all_citations: self._papers_to_cite.add(key) # Add citation tags for the key for verbose output, but # don't if they already exist in _citation_tags dict if key not in self._citation_tags: try: caller = Citations._caller_name() self._add_citation_tag(key, entry=caller) # Don't add citation tags if the citation is registered manually except KeyError: # pragma: no cover pass else: # If citation is unknown, parse it later with pybtex self._unknown_citations.add(key) return
def _parse_citation(self, key): """ Parses a citation with pybtex and adds it to the _papers_to_cite set. This method is called when a citation is unknown at the time of registration. Parameters ---------- key: str A BibTeX formatted citation """ PybtexError = have_optional_dependency("pybtex.scanner", "PybtexError") parse_string = have_optional_dependency("pybtex.database", "parse_string") try: # Parse string as a bibtex citation, and check that a citation was found bib_data = parse_string(key, bib_format="bibtex") if not bib_data.entries: raise PybtexError("no entries found") # Add and register all citations for key, entry in bib_data.entries.items(): # Add to _all_citations dictionary self._add_citation(key, entry) # Add to _papers_to_cite set self._papers_to_cite.add(key) return except PybtexError: # Unable to parse / unknown key raise KeyError(f"Not a bibtex citation or known citation: {key}") def _tag_citations(self): """Prints the citation tags for the citations that have been registered (non-manually) in the code, for verbose output purposes """ if self._citation_tags: # pragma: no cover print("\nCitations registered: \n") for key, entry in self._citation_tags.items(): print(f"{key} was cited due to the use of {entry}")
[docs] def print(self, filename=None, output_format="text", verbose=False): """Print all citations that were used for running simulations. The verbose option is provided to print tags for citations in the output such that it can can be seen where the citations were registered due to the use of PyBaMM models and solvers in the code. .. note:: If a citation is registered manually, it will not be tagged. .. warning:: This function will notify the user if a citation that has been previously registered is invalid or cannot be parsed. Parameters ---------- filename : str, optional Filename to which to print citations. If None, citations are printed to the terminal. verbose: bool, optional If True, prints the citation tags for the citations that have been registered. An example of the output is shown below. Examples -------- .. code-block:: python pybamm.lithium_ion.SPM() pybamm.Citations.print(verbose=True) or pybamm.print_citations(verbose=True) will append the following at the end of the list of citations: .. code-block:: Citations registered: Marquis2019 was cited due to the use of SPM """ # Parse citations that were not known keys at registration, but do not # fail if they cannot be parsed pybtex = have_optional_dependency("pybtex") try: for key in self._unknown_citations: self._parse_citation(key) except KeyError: # pragma: no cover warnings.warn( message=f'\nCitation with key "{key}" is invalid. Please try again\n', category=UserWarning, ) # delete the invalid citation from the set self._unknown_citations.remove(key) if output_format == "text": citations = pybtex.format_from_strings( self._cited, style="plain", output_backend="plaintext" ) elif output_format == "bibtex": citations = "\n".join(self._cited) else: raise pybamm.OptionError( f"Output format {output_format} not recognised." "It should be 'text' or 'bibtex'." ) if filename is None: print(citations) if verbose: self._tag_citations() # pragma: no cover else: with open(filename, "w") as f: f.write(citations)
citations = Citations()