commonmeta-py 0.22__py3-none-any.whl → 0.24__py3-none-any.whl

commonmeta/writers/__init__.py

@@ -0,0 +1 @@
+"""Writers for different metadata formats"""

commonmeta/writers/bibtex_writer.py

@@ -0,0 +1,149 @@
+"""Bibtex writer for commonmeta-py"""
+from bibtexparser.bwriter import BibTexWriter
+from bibtexparser.bibdatabase import BibDatabase
+from bibtexparser.customization import page_double_hyphen
+
+from ..utils import pages_as_string, get_language
+from ..base_utils import compact
+from ..author_utils import authors_as_string
+from ..date_utils import get_month_from_date, get_iso8601_date, MONTH_SHORT_NAMES
+from ..doi_utils import doi_from_url
+from ..constants import CM_TO_BIB_TRANSLATIONS, Commonmeta
+
+
+def write_bibtex(metadata: Commonmeta) -> str:
+    """Write bibtex"""
+    if metadata.write_errors is not None:
+        return None
+    item = write_bibtex_item(metadata)
+    bibtex_str = """
+    @comment{
+        BibTeX entry created by commonmeta-py
+    }
+    """
+    bib_database = BibDatabase()
+    bib_database.entries = [item]
+    bib_database.entries[0] = page_double_hyphen(bib_database.entries[0])
+    writer = BibTexWriter()
+    writer.common_strings = True
+    writer.indent = "    "
+    bibtex_str = writer.write(bib_database)
+
+    # Hack to remove curly braces around month names
+    for month_name in MONTH_SHORT_NAMES:
+        bibtex_str = bibtex_str.replace(f"{{{month_name}}}", month_name)
+    return bibtex_str
+
+
+def write_bibtex_item(metadata: Commonmeta) -> dict:
+    """Write bibtex item"""
+    container = metadata.container if metadata.container else {}
+    date_published = get_iso8601_date(metadata.date.get("published", None))
+    authors = authors_as_string(metadata.contributors)
+    if metadata.titles and len(metadata.titles) > 1:
+        title = ": ".join(
+            [
+                metadata.titles[0].get("title", None),
+                metadata.titles[1].get("title", None),
+            ]
+        )
+    elif metadata.titles and len(metadata.titles) == 1:
+        title = metadata.titles[0].get("title", None)
+    else:
+        title = None
+    doi = doi_from_url(metadata.id)
+    _id = doi if doi else metadata.id
+    _type = CM_TO_BIB_TRANSLATIONS.get(metadata.type, "misc")
+    abstract = (
+        metadata.descriptions[0].get("description", None)
+        if metadata.descriptions
+        else None
+    )
+    author = authors if authors and len(authors) > 0 else None
+    license_ = str(metadata.license.get("url")) if metadata.license else None
+    institution = metadata.publisher.get("name", None) if _type == "phdthesis" else None
+    issn = (
+        container.get("identifier", None)
+        if container.get("identifierType", None) == "ISSN"
+        else None
+    )
+    isbn = (
+        container.get("identifier", None)
+        if container.get("identifierType", None) == "ISBN"
+        else None
+    )
+    issue = container.get("issue", None)
+    journal = (
+        container.get("title", None)
+        if _type not in ["inbook", "inproceedings"]
+        and container.get("type") in ["Journal", "Periodical"]
+        else None
+    )
+    booktitle = (
+        container.get("title", None) if _type in ["inbook", "inproceedings"] else None
+    )
+    language = get_language(metadata.language)
+    location = (
+        container.get("location", None)
+        if _type not in ["article", "phdthesis"]
+        else None
+    )
+    month = get_month_from_date(date_published)
+    pages = pages_as_string(container)
+    publisher = (
+        metadata.publisher.get("name", None)
+        if _type not in ["article", "phdthesis"]
+        else None
+    )
+    series = container.get("series", None)
+    url = metadata.url
+    year = date_published[:4] if date_published else None
+
+    return compact(
+        {
+            "ID": _id,
+            "ENTRYTYPE": _type,
+            "abstract": abstract,
+            "author": author,
+            "copyright": license_,
+            "doi": doi,
+            "institution": institution,
+            "isbn": isbn,
+            "issn": issn,
+            "issue": issue,
+            "journal": journal,
+            "booktitle": booktitle,
+            "language": language,
+            "location": location,
+            "month": month,
+            "pages": pages,
+            "publisher": publisher,
+            "series": series,
+            "title": title,
+            "url": url,
+            "urldate": date_published,
+            "year": year,
+        }
+    )
+
+
+def write_bibtex_list(metalist):
+    """Write bibtex list"""
+    if metalist is None:
+        return None
+
+    bib_database = BibDatabase()
+    bib_database.entries = [write_bibtex_item(item) for item in metalist.items]
+
+    # TODO: Fix page_double_hyphen in write_bibtex_item
+    bib_database.entries = [page_double_hyphen(entry) for entry in bib_database.entries]
+    writer = BibTexWriter()
+    writer.common_strings = True
+    writer.indent = "    "
+    bibtex_str = writer.write(bib_database)
+
+    # Hack to remove curly braces around month names
+    # TODO: Fix this in write_bibtex_item
+    for month_name in MONTH_SHORT_NAMES:
+        bibtex_str = bibtex_str.replace(f"{{{month_name}}}", month_name)
+    return bibtex_str

commonmeta/writers/citation_writer.py

@@ -0,0 +1,70 @@
+"""Citation writer for commonmeta-py"""
+import orjson as json
+import re
+from pydash import py_
+from citeproc import CitationStylesStyle, CitationStylesBibliography
+from citeproc import Citation, CitationItem
+from citeproc import formatter
+from citeproc.source.json import CiteProcJSON
+from citeproc_styles import get_style_filepath
+
+
+def write_citation(metadata):
+    """Write citation"""
+
+    # Process the JSON data to generate a citeproc-py BibliographySource.
+    item = write_citation_item(metadata)
+    style_path = get_style_filepath(metadata.style)
+    style = CitationStylesStyle(style_path, locale=metadata.locale)
+    bib = CitationStylesBibliography(style, item, formatter.html)
+    citation = Citation([CitationItem(metadata.id)])
+
+    # workaround for the issue with the vancouver style and de locale
+    try:
+        bib.register(citation)
+        return _clean_result(str(bib.bibliography()[0]))
+    except Exception as e:
+        print(e)
+        return f"Error: citation not available for style {metadata.style} and locale {metadata.locale}."
+
+
+def write_citation_item(metadata):
+    """Write citation item"""
+    if metadata.write_errors is not None:
+        return None
+    csl = json.loads(metadata.write(to="csl"))
+
+    # Remove keys that are not supported by citeproc-py.
+    csl = py_.omit(csl, "copyright", "categories")
+    return CiteProcJSON([csl])
+
+
+def write_citation_list(metalist, **kwargs):
+    """Write citation list"""
+    if metalist is None:
+        return None
+
+    style = kwargs.get("style", "apa")
+    locale = kwargs.get("locale", "en-US")
+    style_path = get_style_filepath(style)
+    style = CitationStylesStyle(style_path, locale=locale)  #
+
+    def format_citation(index, item):
+        bib = CitationStylesBibliography(style, item, formatter.html)
+        _id = metalist.items[index].id
+        citation = Citation([CitationItem(_id)])
+        bib.register(citation)
+        return _clean_result(str(bib.bibliography()[0]))
+
+    citations = [write_citation_item(item) for item in metalist.items]
+    bibliographies = [
+        format_citation(index, item) for index, item in enumerate(citations)
+    ]
+    return "\n\n".join(bibliographies)
+
+
+def _clean_result(text):
+    """Remove double spaces, punctuation."""
+    text = re.sub(r"\s\s+", " ", text)
+    text = re.sub(r"\.\.+", ".", text)
+    return text

commonmeta/writers/commonmeta_writer.py

@@ -0,0 +1,68 @@
+"""Commonmeta writer for commonmeta-py"""
+
+import orjson as json
+import orjsonl
+import pydash as py_
+from ..base_utils import compact
+
+
+def write_commonmeta(metadata):
+    """Write commonmeta"""
+    if metadata is None:
+        return None
+
+    data = py_.omit(
+        vars(metadata),
+        [
+            "via",
+            "is_valid",
+            "date_created",
+            "date_published",
+            "date_registered",
+            "date_updated",
+            "state",
+        ],
+    )
+    data = py_.rename_keys(
+        data,
+        {
+            "additional_type": "additionalType",
+            "archive_locations": "archiveLocations",
+            "geo_locations": "geoLocations",
+            "funding_references": "fundingReferences",
+        },
+    )
+    return json.dumps(compact(data))
+
+
+def write_commonmeta_list(metalist):
+    """Write commonmeta list. If filename is provided,
+    write to file. Optionally, use JSON Lines format."""
+    if metalist is None:
+        return None
+
+    def format_item(item):
+        """Format item for commonmeta list"""
+        item = py_.omit(vars(item), ["via", "is_valid"])
+        return compact(item)
+
+    items = [format_item(item) for item in metalist.items]
+    output = compact(
+        {
+            "id": metalist.id,
+            "title": metalist.title,
+            "description": metalist.description,
+            "items": items,
+        }
+    )
+
+    if metalist.filename and metalist.filename.rsplit(".", 1)[1] in ["jsonl", "json"]:
+        if metalist.jsonlines:
+            orjsonl.save(metalist.filename, items)
+        else:
+            json_output = json.dumps(output).decode("utf-8")
+            with open(metalist.filename, "w") as file:
+                file.write(json_output)
+        return metalist.filename
+    else:
+        return json.dumps(output).decode("utf-8")

commonmeta/writers/crossref_xml_writer.py

@@ -0,0 +1,17 @@
+"""Crossref XML writer for commonmeta-py"""
+from typing import Optional
+from ..constants import Commonmeta
+from ..crossref_utils import generate_crossref_xml, generate_crossref_xml_list
+
+
+def write_crossref_xml(metadata: Commonmeta) -> Optional[str]:
+    """Write Crossref XML"""
+    return generate_crossref_xml(metadata)
+
+
+def write_crossref_xml_list(metalist):
+    """Write crossref_xml list"""
+    if metalist is None:
+        return None
+
+    return generate_crossref_xml_list(metalist)

commonmeta/writers/csl_writer.py

@@ -0,0 +1,79 @@
+"""CSL-JSON writer for commonmeta-py"""
+import orjson as json
+from typing import Optional
+
+from ..utils import pages_as_string, to_csl
+from ..base_utils import wrap, presence, parse_attributes, compact
+from ..date_utils import get_date_parts
+from ..doi_utils import doi_from_url
+from ..constants import CM_TO_CSL_TRANSLATIONS, Commonmeta
+
+
+def write_csl(metadata: Commonmeta) -> Optional[str]:
+    """Write CSL-JSON"""
+    item = write_csl_item(metadata)
+    if item is None:
+        return None
+    return json.dumps(item)
+
+
+def write_csl_item(metadata) -> Optional[dict]:
+    """Write CSL-JSON item"""
+    if metadata is None or metadata.write_errors is not None:
+        return None
+    if len(wrap(metadata.contributors)) == 0:
+        author = None
+    else:
+        author = to_csl(wrap(metadata.contributors))
+
+    if metadata.type == "Software" and metadata.version is not None:
+        _type = "book"
+    else:
+        _type = CM_TO_CSL_TRANSLATIONS.get(metadata.type, "Document")
+
+    container = metadata.container or {}
+    publisher = metadata.publisher or {}
+    return compact(
+        {
+            "type": _type,
+            "id": metadata.id,
+            "DOI": doi_from_url(metadata.id),
+            "URL": metadata.url,
+            "categories": presence(
+                parse_attributes(
+                    wrap(metadata.subjects), content="subject", first=False
+                )
+            ),
+            "language": metadata.language,
+            "author": author,
+            # "contributor": to_csl(wrap(metadata.contributors)),
+            "issued": get_date_parts(metadata.date.get("published"))
+            if metadata.date.get("published", None)
+            else None,
+            "submitted": get_date_parts(metadata.date.get("submitted"))
+            if metadata.date.get("submitted", None)
+            else None,
+            "accessed": get_date_parts(metadata.date.get("accessed"))
+            if metadata.date.get("accessed", None)
+            else None,
+            "abstract": parse_attributes(
+                metadata.descriptions, content="description", first=True
+            ),
+            "container-title": container.get("title", None),
+            "volume": container.get("volume", None),
+            "issue": container.get("issue", None),
+            "page": pages_as_string(container),
+            "publisher": publisher.get("name", None),
+            "title": parse_attributes(metadata.titles, content="title", first=True),
+            "copyright": metadata.license.get("id", None) if metadata.license else None,
+            "version": metadata.version,
+        }
+    )
+
+
+def write_csl_list(metalist):
+    """Write CSL-JSON list"""
+    if metalist is None:
+        return None
+    items = [write_csl_item(item) for item in metalist.items]
+    return json.dumps(items)

commonmeta/writers/datacite_writer.py

@@ -0,0 +1,193 @@
+"""DataCite writer for commonmeta-py"""
+import orjson as json
+from typing import Optional, Union
+
+from ..base_utils import wrap, compact
+from ..doi_utils import doi_from_url, normalize_doi
+from ..constants import (
+    CM_TO_BIB_TRANSLATIONS,
+    CM_TO_CSL_TRANSLATIONS,
+    CM_TO_CR_TRANSLATIONS,
+    CM_TO_DC_TRANSLATIONS,
+    CM_TO_RIS_TRANSLATIONS,
+    CM_TO_SO_TRANSLATIONS,
+    Commonmeta,
+)
+
+
+def write_datacite(metadata: Commonmeta) -> Optional[Union[str, dict]]:
+    """Write datacite. Make sure JSON Schema validates before writing"""
+    if metadata.write_errors is not None:
+        return "{}"
+
+    alternate_identifiers = [
+        {
+            "alternateIdentifier": i.get("identifier", None),
+            "alternateIdentifierType": i.get("identifierType", None),
+        }
+        for i in wrap(metadata.identifiers)
+        if i.get("id", None) != metadata.id
+    ]
+
+    creators = [
+        to_datacite_creator(i)
+        for i in wrap(metadata.contributors)
+        if i.get("contributorRoles", None) == ["Author"]
+    ]
+    contributors = [
+        to_datacite_creator(i)
+        for i in wrap(metadata.contributors)
+        if i.get("contributorRoles", None) != ["Author"]
+    ]
+    related_identifiers = [
+        to_datacite_related_identifier(i)
+        for i in wrap(metadata.references)
+        if i.get("id", None)
+    ]
+
+    resource__typegeneral = CM_TO_DC_TRANSLATIONS.get(metadata.type, "Other")
+    resource_type = CM_TO_CR_TRANSLATIONS.get(metadata.type, "Other")
+    if resource__typegeneral == resource_type or resource__typegeneral in [
+        "Dataset",
+        "JournalArticle",
+        "Other",
+        "Preprint",
+        "Software",
+    ]:
+        resource_type = None
+    types = compact(
+        {
+            "resourceTypeGeneral": resource__typegeneral,
+            "resourceType": resource_type,
+            "schemaOrg": CM_TO_SO_TRANSLATIONS.get(metadata.type, "CreativeWork"),
+            "citeproc": CM_TO_CSL_TRANSLATIONS.get(metadata.type, "article"),
+            "bibtex": CM_TO_BIB_TRANSLATIONS.get(metadata.type, "misc"),
+            "ris": CM_TO_RIS_TRANSLATIONS.get(metadata.type, "GEN"),
+        }
+    )
+    publication_year = (
+        metadata.date.get("published")[:4]
+        if metadata.date.get("published", None)
+        else None
+    )
+
+    def to_datacite_date(date: dict) -> dict:
+        """Convert dates to datacite dates"""
+        for k, v in date.items():
+            if k == "published":
+                k = "issued"
+            return {
+                "date": v,
+                "dateType": k.title(),
+            }
+
+    dates = [to_datacite_date(i) for i in wrap(metadata.date)]
+
+    license_ = (
+        [
+            compact(
+                {
+                    "rightsIdentifier": metadata.license.get("id").lower()
+                    if metadata.license.get("id", None)
+                    else None,
+                    "rightsIdentifierScheme": "SPDX",
+                    "rightsUri": metadata.license.get("url", None),
+                    "schemeUri": "https://spdx.org/licenses/",
+                }
+            )
+        ]
+        if metadata.license
+        else None
+    )
+
+    descriptions = [
+        compact(
+            {
+                "description": i.get("description", None),
+                "descriptionType": i.get("type", None) or "Other",
+                "lang": i.get("language", None),
+            }
+        )
+        for i in wrap(metadata.descriptions)
+    ]
+
+    data = compact(
+        {
+            "id": metadata.id,
+            "doi": doi_from_url(metadata.id),
+            "url": metadata.url,
+            "creators": creators,
+            "titles": metadata.titles,
+            "publisher": metadata.publisher,
+            "publicationYear": publication_year,
+            "subjects": metadata.subjects,
+            "contributors": contributors,
+            "dates": dates,
+            "language": metadata.language,
+            "types": types,
+            "alternateIdentifiers": alternate_identifiers,
+            "relatedIdentifiers": related_identifiers,
+            "version": metadata.version,
+            "rightsList": license_,
+            "descriptions": descriptions,
+            "geoLocations": metadata.geo_locations,
+            "fundingReferences": metadata.funding_references,
+            "schemaVersion": "http://datacite.org/schema/kernel-4",
+        }
+    )
+    return json.dumps(data)
+
+
+def to_datacite_creator(creator: dict) -> dict:
+    """Convert creators to datacite creators"""
+    _type = creator.get("type", None)
+    if creator.get("familyName", None):
+        name = ", ".join([creator.get("familyName", ""), creator.get("givenName", "")])
+    elif creator.get("name", None):
+        name = creator.get("name", None)
+    name_identifiers = creator.get("id", None)
+    if name_identifiers:
+
+        def format_name_identifier(name_identifier):
+            return {
+                "nameIdentifier": name_identifier,
+                "nameIdentifierScheme": "ORCID",
+                "schemeUri": "https://orcid.org",
+            }
+
+        name_identifiers = [format_name_identifier(i) for i in wrap(name_identifiers)]
+    return compact(
+        {
+            "name": name,
+            "givenName": creator.get("givenName", None),
+            "familyName": creator.get("familyName", None),
+            "nameType": _type + "al" if _type else None,
+            "nameIdentifiers": name_identifiers,
+            "affiliation": creator.get("affiliations", None),
+        }
+    )
+
+
+def to_datacite_titles(titles: list) -> list:
+    """Convert titles to datacite titles"""
+    return [
+        {
+            "title": title.get("title", None),
+            "titleType": title.get("type", None),
+            "lang": title.get("language", None),
+        }
+        for title in titles
+    ]
+
+
+def to_datacite_related_identifier(reference: dict) -> dict:
+    """Convert reference to datacite related_identifier"""
+    _id = normalize_doi(reference.get("id", None))
+    url = reference.get("id", None)
+    return compact(
+        {
+            "relatedIdentifier": _id if _id else url,
+            "relatedIdentifierType": "DOI" if _id else "URL",
+            "relationType": "References",
+        }
+    )

commonmeta/writers/inveniordm_writer.py

@@ -0,0 +1,94 @@
+"""InvenioRDM writer for commonmeta-py"""
+
+import orjson as json
+
+from ..utils import to_inveniordm
+from ..base_utils import compact, wrap, presence, parse_attributes
+from ..doi_utils import doi_from_url, validate_suffix
+from ..constants import CM_TO_INVENIORDM_TRANSLATIONS
+from ..utils import pages_as_string, get_language, validate_orcid
+
+
+def write_inveniordm(metadata):
+    """Write inveniordm"""
+    if metadata is None or metadata.write_errors is not None:
+        return None
+    _type = CM_TO_INVENIORDM_TRANSLATIONS.get(metadata.type, "Other")
+    creators = [
+        to_inveniordm_creator(i)
+        for i in wrap(metadata.contributors)
+        if i.get("contributorRoles", None) == ["Author"]
+    ]
+    identifiers = [
+        {
+            "identifier": i.get("identifier", None),
+            "scheme": i.get("identifierType", None),
+        }
+        for i in wrap(metadata.identifiers)
+        if i.get("id", None) != metadata.id
+    ]
+    publisher = metadata.publisher or {}
+    data = compact(
+        {
+            "metadata": {
+                "resource_type": {"id": _type},
+                "doi": doi_from_url(metadata.id),
+                "creators": creators,
+                "title": parse_attributes(metadata.titles, content="title", first=True),
+                "publisher": publisher.get("name", None),
+                "publication_date": metadata.date.get("published")
+                if metadata.date.get("published", None)
+                else None,
+                "subjects": parse_attributes(
+                    wrap(metadata.subjects), content="subject", first=False
+                ),
+                "contributors": to_inveniordm(wrap(metadata.contributors)),
+                "description": parse_attributes(
+                    metadata.descriptions, content="description", first=True
+                ),
+                "license": metadata.license.get("id", None)
+                if metadata.license
+                else None,
+                "languages": [{"id": get_language(metadata.language, format="alpha_3")}]
+                if metadata.language
+                else None,
+                "identifiers": identifiers,
+                "version": metadata.version,
+            },
+        }
+    )
+    return json.dumps(data)
+
+
+def to_inveniordm_creator(creator: dict) -> dict:
+    """Convert creators to inveniordm creators"""
+
+    def format_identifier(id):
+        identifier = validate_orcid(id)
+        if identifier:
+            return [
+                {
+                    "identifier": identifier,
+                    "scheme": "orcid",
+                }
+            ]
+        return None
+
+    _type = creator.get("type", None)
+    if creator.get("familyName", None):
+        name = ", ".join([creator.get("familyName", ""), creator.get("givenName", "")])
+    elif creator.get("name", None):
+        name = creator.get("name", None)
+
+    return {
+        "person_or_org": compact(
+            {
+                "name": name,
+                "given_name": creator.get("givenName", None),
+                "family_name": creator.get("familyName", None),
+                "type": _type.lower() + "al" if _type else None,
+                "identifiers": format_identifier(creator.get("id", None)),
+                "affiliation": creator.get("affiliations", None),
+            }
+        )
+    }