Upload 124 files

.gitattributes

@@ -33,3 +33,15 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+static/img/badges/buzz.psd filter=lfs diff=lfs merge=lfs -text
+static/img/badges/fun.psd filter=lfs diff=lfs merge=lfs -text
+static/img/badges/geo.psd filter=lfs diff=lfs merge=lfs -text
+static/img/badges/influence.psd filter=lfs diff=lfs merge=lfs -text
+static/img/badges/openness.psd filter=lfs diff=lfs merge=lfs -text
+static/img/badges/timeline.psd filter=lfs diff=lfs merge=lfs -text
+static/img/gif/orcid-import-scopus-from-nothing.gif filter=lfs diff=lfs merge=lfs -text
+static/img/gif/orcid-import-scopus.gif filter=lfs diff=lfs merge=lfs -text
+static/img/gif/orcid-set-public.gif filter=lfs diff=lfs merge=lfs -text
+static/img/heather.jpg filter=lfs diff=lfs merge=lfs -text
+static/img/layout[[:space:]]ideas.psd filter=lfs diff=lfs merge=lfs -text
+static/img/science.psd filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,92 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+
+# jason commented this one out because breaks static/dist
+# dist/
+
+local_data/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+*.temp*
+
+# 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
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# venv
+venv/
+
+# IDE (added by jason)
+.idea/
+
+# sqlite (added by heather)
+*.sqlite
+
+# env setup (added by heather)
+tng-env.sh
+
+# node modules used in Grunt
+static/node_modules
+
+# CodeKit. Cannot seem to make this work :(
+*codekit*
+codekit*
+codekit-config.json
+static/codekit-config.json
+
+# for markdown previews
+README_cache
+
+# local environment files (added by heather)
+*.env
+
+# raw doaj files (added by heather)
+data/doaj_20*.csv

Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3.8-slim-buster
+WORKDIR /app
+COPY requirements.txt requirements.txt
+RUN pip install -r requirements.txt
+COPY . .
+EXPOSE 8000
+CMD ["gunicorn" , "--bind", "0.0.0.0:8000", "views:app", "-w", "3"]

LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 OurResearch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

Procfile

@@ -0,0 +1 @@
+web: gunicorn views:app -w 3 --timeout 60 --reload

app.py

@@ -0,0 +1,42 @@
+import logging
+import os
+import sys
+
+from flask import Flask
+import requests
+import requests_cache
+import sentry_sdk
+from sentry_sdk.integrations.flask import FlaskIntegration
+
+requests_cache.install_cache(
+    "my_requests_cache", expire_after=60 * 60 * 24 * 1
+)  # expire_after is in seconds
+requests_cache.clear()
+
+# set up logging
+# see http://wiki.pylonshq.com/display/pylonscookbook/Alternative+logging+configuration
+logging.basicConfig(
+    stream=sys.stdout, level=logging.DEBUG, format="%(name)s - %(message)s"
+)
+logger = logging.getLogger("citeas")
+
+libraries_to_mum = [
+    "requests.packages.urllib3",
+    "requests.packages.urllib3.connectionpool",
+    "requests_oauthlib",
+    "urllib3.connectionpool",
+    "oauthlib",
+    "citeproc",
+]
+
+for a_library in libraries_to_mum:
+    the_logger = logging.getLogger(a_library)
+    the_logger.setLevel(logging.WARNING)
+    the_logger.propagate = True
+
+requests.packages.urllib3.disable_warnings()
+
+# error reporting with sentry
+sentry_sdk.init(dsn=os.environ.get("SENTRY_DSN"), integrations=[FlaskIntegration()])
+
+app = Flask(__name__)

bibtex.py

@@ -0,0 +1,420 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from citeproc.py2compat import *
+
+# copied from https://github.com/brechtm/citeproc-py/blob/master/citeproc/source/bibtex/bibtex.py
+# then modified to fix bugs.  search for "hap" to see mods
+
+import re
+import unicodedata
+
+from warnings import warn
+
+from citeproc.types import (
+    ARTICLE,
+    ARTICLE_JOURNAL,
+    BOOK,
+    CHAPTER,
+    MANUSCRIPT,
+    PAMPHLET,
+    PAPER_CONFERENCE,
+    REPORT,
+    THESIS,
+)
+from citeproc.string import String, MixedString, NoCase
+from citeproc.source import BibliographySource, Reference, Name, Date, DateRange
+from citeproc.source.bibtex.bibparse import BibTeXParser
+from citeproc.source.bibtex.latex import parse_latex
+from citeproc.source.bibtex.latex.macro import NewCommand, Macro
+
+
+class BibTeX(BibliographySource):
+    fields = {
+        "address": "publisher_place",
+        "annote": "annote",
+        "author": "author",
+        "booktitle": "container_title",
+        "chapter": "chapter_number",
+        "edition": "edition",
+        "editor": "editor",
+        #              'howpublished': None,
+        #              'institution': None,
+        "journal": "container_title",
+        #              'month': None,
+        "note": "note",
+        "number": "issue",
+        #              'organization': None,
+        "pages": "page",
+        "publisher": "publisher",
+        #              'school': None,
+        "series": "collection_title",
+        "title": "title",
+        #              'type': None,
+        #              'year': None,
+        "volume": "volume",
+        # hap added doi and url
+        "doi": "doi",
+        "url": "url",
+        # non-standard fields
+        "isbn": "ISBN",
+        "issn": "ISSN",
+    }
+
+    types = {  # standard entry types
+        "article": ARTICLE_JOURNAL,
+        "book": BOOK,
+        "booklet": PAMPHLET,
+        "conference": PAPER_CONFERENCE,
+        "inbook": CHAPTER,
+        "incollection": ARTICLE_JOURNAL,
+        "inproceedings": PAPER_CONFERENCE,
+        "manual": BOOK,
+        "mastersthesis": THESIS,
+        "misc": ARTICLE,
+        "phdthesis": THESIS,
+        "proceedings": BOOK,
+        "techreport": REPORT,
+        "unpublished": MANUSCRIPT,
+        # non-standard entry types
+        "thesis": THESIS,
+        "report": REPORT,
+    }
+
+    def __init__(self, filename, encoding="ascii"):
+        bibtex_database = BibTeXParser(filename)
+        bibtex_database.encoding = encoding
+        self.preamble_macros = {}
+        parse_latex(
+            bibtex_database.preamble,
+            {
+                "newcommand": NewCommand(self.preamble_macros),
+                "mbox": Macro(1, "{0}"),
+                "cite": Macro(1, "CITE({0})"),
+            },
+        )
+        for key, entry in bibtex_database.items():
+            self.add(self.create_reference(key, entry))
+
+    def _bibtex_to_csl(self, bibtex_entry):
+        csl_dict = {}
+        for field, value in bibtex_entry.items():
+            try:
+                value = value.strip()
+            except AttributeError:
+                pass
+
+            try:
+                csl_field = self.fields[field]
+            except KeyError:
+                csl_field = field
+
+            if field in ("number", "volume"):
+                try:
+                    value = int(value)
+                except ValueError:
+                    pass
+            elif field == "pages":
+                value = self._bibtex_to_csl_pages(value)
+            elif field in ("author", "editor"):
+                try:
+                    value = [name for name in self._parse_author(value)]
+                except RuntimeError:
+                    pass
+            else:
+                try:
+                    value = self._parse_string(value)
+                except TypeError:
+                    value = str(value)
+
+            csl_dict[csl_field] = value
+            # print("csl_dict: {}".format(csl_dict))
+        return csl_dict
+
+    @staticmethod
+    def _bibtex_to_csl_pages(value):
+        value = value.replace(" ", "")
+        if "-" in value:
+            try:
+                first, last = value.split("--")
+            except ValueError:
+                first, last = value.split("-")
+            pages = "-".join((first, last))
+        else:
+            pages = value[:-1] if value.endswith("+") else value
+        return pages
+
+    def _bibtex_to_csl_date(self, bibtex_entry):
+        # hap commented out the month section on feb 18, 2017 because was causing bugs,
+        # if 'month' in bibtex_entry:
+        #     begin_dict, end_dict = self._parse_month(bibtex_entry['month'])
+        # else:
+        #     begin_dict, end_dict = {}, {}
+
+        # hap replaced section above with this, ignoring the month.
+        begin_dict, end_dict = {}, {}
+
+        if "year" in bibtex_entry:
+            begin_dict["year"], end_dict["year"] = self._parse_year(
+                bibtex_entry["year"]
+            )
+        if not begin_dict:
+            return None
+        if begin_dict == end_dict:
+            return Date(**begin_dict)
+        else:
+            return DateRange(begin=Date(**begin_dict), end=Date(**end_dict))
+
+    def _parse_year(self, year):
+        try:
+            year_str = parse_latex(year, self.preamble_macros)
+        except TypeError:
+            year_str = str(year)
+        if EN_DASH in year_str:
+            begin_year, end_year = year_str.split(EN_DASH)
+            begin_len, end_len = len(begin_year), len(end_year)
+            if end_len < begin_len:
+                end_year = begin_year[: begin_len - end_len] + end_year
+        else:
+            begin_year = end_year = int(year_str)
+        return begin_year, end_year
+
+    MONTHS = (
+        "jan",
+        "feb",
+        "mar",
+        "apr",
+        "may",
+        "jun",
+        "jul",
+        "aug",
+        "sep",
+        "oct",
+        "nov",
+        "dec",
+    )
+    RE_DAY = "(?P<day>\d+)"
+    RE_MONTH = "(?P<month>\w+)"
+
+    @staticmethod
+    def _parse_month(month):
+        def month_name_to_index(name):
+            try:
+                return BibTeX.MONTHS.index(name[:3].lower()) + 1
+            except ValueError:
+                return int(name)
+
+        begin = {}
+        end = {}
+        month = month.strip()
+        month = month.replace(", ", "-")
+        if month.isdecimal():
+            begin["month"] = end["month"] = month
+        elif month.replace("-", "").isalpha():
+            if "-" in month:
+                begin["month"], end["month"] = month.split("-")
+            else:
+                begin["month"] = end["month"] = month
+        else:
+            m = re.match(BibTeX.RE_DAY + "[ ~]*" + BibTeX.RE_MONTH, month)
+            if m is None:
+                m = re.match(BibTeX.RE_MONTH + "[ ~]*" + BibTeX.RE_DAY, month)
+            begin["day"] = end["day"] = int(m.group("day"))
+            begin["month"] = end["month"] = m.group("month")
+        begin["month"] = month_name_to_index(begin["month"])
+        end["month"] = month_name_to_index(end["month"])
+        return begin, end
+
+    def _parse_string(self, title):
+        def make_string(string, top_level_group=False):
+            unlatexed = parse_latex(string, self.preamble_macros)
+            fixed_case = top_level_group and not string.startswith("\\")
+            string_cls = NoCase if fixed_case else String
+            return string_cls(unlatexed)
+
+        title = str(title)
+        title = title.replace("\n", "")
+        title = " ".join(title.split())
+
+        output = MixedString()
+        level = 0
+        string = ""
+        for char in title:
+            if char == "{":
+                if level == 0:
+                    if string:
+                        output += make_string(string)
+                        string = ""
+                level += 1
+            elif char == "}":
+                level -= 1
+                if level == 0:
+                    output += make_string(string, True)
+                    string = ""
+            else:
+                string += char
+        if level != 0:
+            raise SyntaxError('Non-matching braces in "{}"'.format(title))
+        if string:
+            output += make_string(string)
+        return output
+
+    def _parse_author(self, authors):
+        csl_authors = []
+        for author in split_names(authors):
+            first, von, last, jr = parse_name(author)
+            csl_parts = {}
+            for part, csl_label in [
+                (first, "given"),
+                (von, "non-dropping-particle"),
+                (last, "family"),
+                (jr, "suffix"),
+            ]:
+                if part is not None:
+                    csl_parts[csl_label] = parse_latex(part, self.preamble_macros)
+            name = Name(**csl_parts)
+            csl_authors.append(name)
+        return csl_authors
+
+    def create_reference(self, key, bibtex_entry):
+        csl_type = self.types[bibtex_entry.document_type]
+        csl_fields = self._bibtex_to_csl(bibtex_entry)
+        csl_date = self._bibtex_to_csl_date(bibtex_entry)
+        if csl_date:
+            csl_fields["issued"] = csl_date
+        ref = Reference(key, csl_type, **csl_fields)
+        return ref
+
+
+# BibTeX name handling
+#
+# references
+#  - BibTeXing by Oren Patashnik (Feb 8, 1988), 4. Helpful Hints, item 18
+#    (BibTeX 0.99d - http://www.ctan.org/tex-archive/biblio/bibtex/base/btxdoc.pdf)
+#  - A summary of BibTex by Xavier Décoret
+#    (http://maverick.inria.fr/~Xavier.Decoret/resources/xdkbibtex/bibtex_summary.html)
+#  - Tame the BeaST by Nicolas Markey
+#    (http://tug.ctan.org/info/bibtex/tamethebeast/ttb_en.pdf)
+
+AND = " and "
+
+
+def split_names(string):
+    """Split a string of names separated by 'and' into a list of names."""
+    brace_level = 0
+    names = []
+    last_index = 0
+    for i in range(len(string)):
+        char = string[i]
+        if brace_level == 0 and string[i:].startswith(AND):
+            names.append(string[last_index:i])
+            last_index = i + len(AND)
+        elif char == "{":
+            brace_level += 1
+        elif char == "}":
+            brace_level -= 1
+    last_name = string[last_index:]
+    if last_name:
+        names.append(last_name)
+    return names
+
+
+def parse_name(name):
+    """Parse a BibTeX name string and split it into First, von, Last and Jr
+    parts.
+    """
+    parts = split_name(name)
+    if len(parts) == 1:  # First von Last
+        (first_von_last,) = parts
+        index = 0
+        first, jr = [], []
+        for word in first_von_last[:-1]:
+            if is_capitalized(word) not in (True, None):
+                break
+            first.append(word)
+            index += 1
+        von_last = first_von_last[index:]
+    elif len(parts) == 2:  # von Last, First
+        jr = []
+        von_last, first = parts
+    elif len(parts) == 3:  # von Last, Jr, First
+        von_last, jr, first = parts
+    von, last = split_von_last(von_last)
+    join = " ".join
+    return join(first) or None, join(von) or None, join(last), join(jr) or None
+
+
+def split_name(name):
+    """Split a name in into parts delimited by commas (at brace-level 0), and
+    each part into words.
+
+    Returns a list of of lists of words.
+    """
+    brace_level = 0
+    parts = []
+    current_part = []
+    word = ""
+    for char in name:
+        if char in " \t,":
+            if brace_level == 0:
+                if word:
+                    current_part.append(word)
+                    word = ""
+                if char == ",":
+                    parts.append(current_part)
+                    current_part = []
+                continue
+        elif char == "{":
+            brace_level += 1
+        elif char == "}":
+            brace_level -= 1
+        word += char
+    if word:
+        current_part.append(word)
+        parts.append(current_part)
+    return parts
+
+
+def is_capitalized(string):
+    """Check if a BibTeX substring is capitalized.
+
+    A string can be "case-less", in which case `None` is returned.
+    """
+    brace_level = 0
+    special_char = False
+    for char, next_char in lookahead_iter(string):
+        if (brace_level == 0 or special_char) and char.isalpha():
+            return char.isupper()
+        elif char == "{":
+            brace_level += 1
+            if brace_level == 1 and next_char == "\\":
+                special_char = True
+        elif char == "}":
+            brace_level -= 1
+            if brace_level == 0:
+                special_char = False
+    return None  # case-less
+
+
+def split_von_last(words):
+    """Split "von Last" name into von and Last parts."""
+    if len(words) > 1 and is_capitalized(words[0]) is False:
+        for j, word in enumerate(reversed(words[:-1])):
+            if is_capitalized(word) not in (True, None):
+                return words[: -j - 1], words[-j - 1 :]
+    return [], words
+
+
+def lookahead_iter(iterable):
+    """Iterator that also yields the next item along with each item. The next
+    item is `None` when yielding the last item.
+    """
+    items = iter(iterable)
+    item = next(items)
+    for next_item in items:
+        yield item, next_item
+        item = next_item
+    yield item, None
+
+
+EN_DASH = unicodedata.lookup("EN DASH")

citation.py

@@ -0,0 +1,232 @@
+import html
+
+from citeproc import formatter, CitationStylesBibliography, Citation, CitationItem
+from citeproc.source.json import CiteProcJSON
+
+from enhanced_citation_style import EnhancedCitationStyle, get_style_name
+from steps.utils import author_name_as_dict
+
+
+def display_citation(bibtex_metadata, bib_stylename, formatter=formatter.html):
+    # valid style names: plos, apa, pnas, nature, bmj, harvard1
+    # full list is here: https://github.com/citation-style-language/styles
+
+    bib_style = EnhancedCitationStyle(bib_stylename)
+    bibliography = CitationStylesBibliography(
+        bib_style, bibtex_metadata, formatter
+    )  # could be formatter.html
+    citation = Citation([CitationItem("ITEM-1")])
+    bibliography.register(citation)
+
+    citation_parts = "".join(bibliography.bibliography()[0])
+    citation_text = "".join(citation_parts)
+
+    if bib_stylename == "apa":
+        # strip extra periods and spaces that can occur in APA format
+        citation_text = citation_text.replace("..", ".")
+        citation_text = citation_text.replace("  ", " ")
+
+        citation_text = citation_text.strip()
+
+        # strip leading comma
+        if citation_text.startswith(","):
+            citation_text = citation_text.lstrip(",").strip()
+
+        citation_text = strip_duplicate_apa_title(bibtex_metadata, citation_text)
+
+    citation_text = html.unescape(citation_text)
+    return citation_text
+
+
+def get_author_list(data_author):
+    author_list = []
+    for name_dict in data_author:
+        new_name_dict = {}
+        if "family" not in name_dict:
+            if "name" in name_dict:
+                new_name_dict["family"] = name_dict["name"]
+            else:
+                new_name_dict["family"] = ""
+        for name_k, name_v in name_dict.items():
+            if name_k == "literal":
+                new_name_dict = author_name_as_dict(name_v)
+            else:
+                new_name_dict[name_k] = name_v
+        author_list.append(new_name_dict)
+    return author_list
+
+
+def build_bibtex_author_list(authors):
+    author_list = ""
+    for i, author in enumerate(authors):
+        if i > 0:
+            author_list += " and "
+
+        if author.get("family"):
+            author_list += author.get("family")
+
+        if author.get("given"):
+            author_list += ", " + author.get("given")
+
+    return author_list
+
+
+def bibtex_pages_format(pages):
+    return pages.replace("-", "--")
+
+
+def get_bib_source_from_dict(data):
+    data["id"] = "ITEM-1"
+
+    if "author" in data:
+        data["author"] = get_author_list(data["author"])
+
+    if "type" not in data:
+        data["type"] = "misc"
+
+    if data["type"] != "software":
+        for k, val in data.items():
+            if val and (k in ["title", "container-title"]):
+                num_upper = sum([1 for c in val if c.isupper()])
+                if num_upper > 0.75 * len(val):
+                    data[k] = val.title()
+
+    if "page" in data and data["page"] == "-":
+        del data["page"]
+
+    if "bibtex" in data:
+        del data["bibtex"]
+
+    if "issued" in data:
+        if data["issued"]["date-parts"][0][0] is None:
+            del data["issued"]
+
+    bib_source = CiteProcJSON([data])
+
+    return bib_source
+
+
+def strip_duplicate_apa_title(bibtex_metadata, citation_text):
+    item = bibtex_metadata.get("item-1")
+    title = item.get("title")
+    if title and "Retrieved from https://github.com" not in citation_text:
+        title = "".join(title).replace("  ", " ")
+        if citation_text.count(title) == 2:
+            citation_text = citation_text.replace(title, "", 1)
+        if citation_text[0] == ".":
+            citation_text = citation_text.replace(".", "", 1)
+            citation_text = citation_text.lstrip()
+    return citation_text
+
+
+def citations(bibtex_metadata):
+    response = []
+    # full list of possible citation formats is here: https://github.com/citation-style-language/styles
+    for bib_stylename in [
+        "apa",
+        "harvard1",
+        "nature",
+        "modern-language-association-with-url",
+        "chicago-author-date",
+        "vancouver",
+    ]:
+        citation_style_object = {
+            "style_shortname": bib_stylename,
+            "citation": display_citation(bibtex_metadata, bib_stylename),
+            "style_fullname": get_style_name(bib_stylename),
+        }
+        response.append(citation_style_object)
+    return response
+
+
+def export_contents(export_type, metadata_dict):
+    if export_type == "csv":
+        items = list(metadata_dict.items())
+        header_row = ",".join([name for (name, value) in items])
+        try:
+            value_row = ",".join([str(value) for (name, value) in items])
+        except UnicodeEncodeError:
+            value_row = ""
+        response = "{}\n{}".format(header_row, value_row)
+        return response
+    elif export_type == "ris":
+        response_list = []
+        response_list.append(("TY", "JOUR"))
+        response_list.append(("T1", metadata_dict.get("title", "")))
+        response_list.append(("JO", metadata_dict.get("container-title", "")))
+        response_list.append(("VL", metadata_dict.get("volume", "")))
+        response_list.append(("IS", metadata_dict.get("issue", "")))
+        response_list.append(("SP", metadata_dict.get("page", "")))
+        response_list.append(("V1", metadata_dict.get("year", "")))
+        response_list.append(("PB", metadata_dict.get("publisher", "")))
+        for author in metadata_dict.get("author", []):
+            response_list.append(
+                ("A1", ", ".join([author.get("family", ""), author.get("given", "")]))
+            )
+        response = "\n".join("{} - {}".format(k, v) for (k, v) in response_list)
+        response += "\nER - "
+        return response
+    elif export_type == "enw":
+        response_list = []
+        response_list.append(("%T", metadata_dict.get("title", "")))
+        response_list.append(("%J", metadata_dict.get("container-title", "")))
+        response_list.append(("%V", metadata_dict.get("volume", "")))
+        response_list.append(("%N", metadata_dict.get("issue", "")))
+        response_list.append(("%P", metadata_dict.get("page", "")))
+        response_list.append(("%D", metadata_dict.get("year", "")))
+        response_list.append(("%I", metadata_dict.get("publisher", "")))
+        response_list.append(("0%", "Journal Article"))
+        for author in metadata_dict.get("author", []):
+            response_list.append(
+                ("%A", ", ".join([author.get("family", ""), author.get("given", "")]))
+            )
+        response = "\n".join("{} {}".format(k, v) for (k, v) in response_list)
+        return response
+    elif export_type == "bibtex":
+        if metadata_dict.get("type"):
+            response = "@" + metadata_dict.get("type") + "{ITEM1, "
+        else:
+            response = "@article{ITEM1, "
+
+        response_list = []
+
+        response_list.append(("title", metadata_dict.get("title", "")))
+
+        # handle book type differently
+        if metadata_dict.get("type") == "book":
+            response_list.append(("isbn", metadata_dict.get("isbn", "")))
+        elif metadata_dict.get("type") == "software":
+            response_list.append(("url", metadata_dict.get("URL", "")))
+            response_list.append(("journal", metadata_dict.get("container-title", "")))
+            response_list.append(("volume", metadata_dict.get("volume", "")))
+            response_list.append(("number", metadata_dict.get("number", "")))
+        else:
+            response_list.append(("journal", metadata_dict.get("container-title", "")))
+            response_list.append(("volume", metadata_dict.get("volume", "")))
+            response_list.append(("number", metadata_dict.get("number", "")))
+
+        response_list.append(
+            ("pages", bibtex_pages_format(metadata_dict.get("page", "")))
+        )
+        response_list.append(("year", metadata_dict.get("year", "")))
+        response_list.append(("publisher", metadata_dict.get("publisher", "")))
+        author_list = build_bibtex_author_list(metadata_dict.get("author", []))
+        response_list.append(("author", author_list))
+
+        response += ",\n".join("{}={{{}}}".format(k, v) for (k, v) in response_list)
+        response += "}"
+
+        return response
+
+    return None
+
+
+def reference_manager_exports(metadata_dict):
+    response = []
+    for export_name in ["csv", "enw", "ris", "bibtex"]:
+        export_object = {
+            "export_name": export_name,
+            "export": export_contents(export_name, metadata_dict),
+        }
+        response.append(export_object)
+    return response

enhanced_citation_style.py

@@ -0,0 +1,24 @@
+from citeproc import CitationStylesStyle
+from citeproc_styles import get_style_filepath
+
+
+class EnhancedCitationStyle(CitationStylesStyle):
+    def __init__(self, bib_stylename):
+        # valid style names: plos, apa, pnas, nature, bmj, harvard1
+        # full list is here: https://github.com/citation-style-language/styles
+
+        self.style_path = get_style_filepath(bib_stylename)
+        super(EnhancedCitationStyle, self).__init__(self.style_path, validate=False)
+
+    @property
+    def name(self):
+        info = self.root.find("{http://purl.org/net/xbiblio/csl}info")
+        if info is not None:
+            title = info.find("{http://purl.org/net/xbiblio/csl}title")
+            return title.text
+        return self.style_path
+
+
+def get_style_name(bib_stylename):
+    style_obj = EnhancedCitationStyle(bib_stylename)
+    return style_obj.name

pytest.ini

@@ -0,0 +1,5 @@
+[pytest]
+addopts = -v
+filterwarnings =
+    ignore::UserWarning
+    ignore::DeprecationWarning

requirements.txt

@@ -0,0 +1,16 @@
+arxiv2bib==1.0.8
+black==21.7b0
+citeproc-py==0.5.1
+citeproc-py-styles==0.1.2
+Flask==2.0.1
+Flask-DebugToolbar==0.11.0
+google==3.0.0
+gunicorn==20.1.0
+json5==0.9.6
+nameparser==1.0.6
+pytest==6.2.5
+requests==2.26.0
+requests-cache==0.8.1
+sentry-sdk==1.3.1
+unidecode==1.3.2
+validators==0.18.2

runtime.txt

@@ -0,0 +1 @@
+python-3.8.12

software.py

@@ -0,0 +1,84 @@
+from citation import get_bib_source_from_dict, citations, reference_manager_exports
+from steps.user_input import UserInputStep
+from steps.exceptions import NoChildrenException
+
+
+class Software(object):
+    def __init__(self, user_supplied_id):
+        self.user_supplied_id = user_supplied_id
+        self.completed_steps = []
+
+    def find_metadata(self):
+        my_step = UserInputStep()
+        my_step.set_content_url(self.user_supplied_id)
+        my_step.set_content(self.user_supplied_id)
+        self.completed_steps.append(my_step)
+
+        cursor = 0
+        while not self.completed_steps[-1].is_metadata:
+            current_step = self.completed_steps[cursor]
+
+            try:
+                next_step = current_step.get_child()
+                self.completed_steps.append(next_step)
+                cursor = len(self.completed_steps) - 1
+            except NoChildrenException:
+                cursor -= 1
+
+    @property
+    def name(self):
+        if self.metadata and self.metadata.get("title", ""):
+            response = self.metadata.get("title", "")
+            if response.__class__.__name__ == "MixedString":
+                return response.pop()
+            else:
+                return response
+        return self.display_url
+
+    @property
+    def display_url(self):
+        return self.completed_steps[0].content_url
+
+    @property
+    def metadata(self):
+        metadata_step = self.completed_steps[-1]
+        if metadata_step.content.get("issued"):
+            try:
+                year = metadata_step.content["issued"]["date-parts"][0][0]
+            except IndexError:
+                year = ""
+            metadata_step.content["year"] = year
+
+        metadata_dict = metadata_step.content
+
+        for step in reversed(self.completed_steps):
+            if step.url and step.content:
+                metadata_dict["URL"] = step.url
+                break
+
+        return metadata_dict
+
+    def get_provenance(self):
+        ret = [s.to_dict() for s in self.completed_steps]
+        return ret
+
+    @property
+    def citation_plain(self):
+        citations = self.to_dict()["citations"]
+        return next(
+            (i["citation"] for i in citations if i["style_shortname"] == "harvard1"),
+            None,
+        )
+
+    def to_dict(self):
+        bibtex_metadata = get_bib_source_from_dict(self.metadata)
+
+        ret = {
+            "url": self.display_url,
+            "name": self.name,
+            "citations": citations(bibtex_metadata),
+            "exports": reference_manager_exports(self.metadata),
+            "metadata": self.metadata,
+            "provenance": self.get_provenance(),
+        }
+        return ret