commonmeta-py 0.17.3__py3-none-any.whl → 0.20__py3-none-any.whl

commonmeta/writers/__init__.py

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

commonmeta/writers/bibtex_writer.py

@@ -1,149 +0,0 @@
-"""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
-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 = 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

@@ -1,70 +0,0 @@
-"""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

@@ -1,68 +0,0 @@
-"""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

@@ -1,17 +0,0 @@
-"""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

@@ -1,78 +0,0 @@
-"""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

@@ -1,190 +0,0 @@
-"""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/ris_writer.py

@@ -1,58 +0,0 @@
-"""RIS writer for commonmeta-py"""
-from ..utils import to_ris
-from ..base_utils import compact, wrap, presence, parse_attributes
-from ..doi_utils import doi_from_url
-from ..constants import CM_TO_RIS_TRANSLATIONS
-
-
-def write_ris(metadata):
-    """Write ris"""
-    container = metadata.container or {}
-    _type = CM_TO_RIS_TRANSLATIONS.get(metadata.type, "GEN")
-    ris = compact(
-        {
-            "TY": _type,
-            "T1": parse_attributes(metadata.titles, content="title", first=True),
-            "T2": container.get("title", None),
-            "AU": to_ris(metadata.contributors),
-            "DO": doi_from_url(metadata.id),
-            "UR": metadata.url,
-            "AB": parse_attributes(
-                metadata.descriptions, content="description", first=True
-            ),
-            "KW": presence(
-                parse_attributes(
-                    wrap(metadata.subjects), content="subject", first=False
-                )
-            ),
-            "PY": metadata.date.get("published")[:4]
-            if metadata.date.get("published", None)
-            else None,
-            "PB": metadata.publisher.get("name", None),
-            "LA": metadata.language,
-            "VL": container.get("volume", None),
-            "IS": container.get("issue", None),
-            "SP": container.get("firstPage", None),
-            "EP": container.get("lastPage", None),
-            # 'SN'= > Array.wrap(related_identifiers).find do | ri |
-            # ri['relationType'] == 'IsPartOf'
-            # end.to_h.fetch('relatedIdentifier', nil),
-            "ER": "",
-        }
-    )
-    string = []
-    for key, val in ris.items():
-        if isinstance(val, list) and val not in [[], [None]]:
-            for vai in val:
-                string.append(f"{key}  - {vai}")
-        elif val not in [[], [None]]:
-            string.append(f"{key}  - {val}")
-    return "\r\n".join(string)
-
-
-def write_ris_list(metalist):
-    """Write RIS list"""
-    if metalist is None:
-        return None
-    items = [write_ris(item) for item in metalist.items]
-    return "\r\n\r\n".join(items)