commonmeta-py 0.123__tar.gz → 0.125__tar.gz

{commonmeta_py-0.123 → commonmeta_py-0.125}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commonmeta-py
-Version: 0.123
+Version: 0.125
 Summary: Library for conversions to/from the Commonmeta scholarly metadata format
 Project-URL: Homepage, https://python.commonmeta.org
 Project-URL: Repository, https://github.com/front-matter/commonmeta-py

{commonmeta_py-0.123 → commonmeta_py-0.125}/commonmeta/__init__.py

@@ -10,7 +10,7 @@ commonmeta-py is a Python library to convert scholarly metadata
 """
 
 __title__ = "commonmeta-py"
-__version__ = "0.123"
+__version__ = "0.125"
 __author__ = "Martin Fenner"
 __license__ = "MIT"
 

{commonmeta_py-0.123 → commonmeta_py-0.125}/commonmeta/api_utils.py

@@ -1,7 +1,7 @@
 """API Utils module for commonmeta-py"""
 
 from datetime import datetime as date
-from typing import Optional
+from typing import Dict, Optional
 
 import jwt
 import requests
@@ -31,7 +31,7 @@ def generate_ghost_token(key: str) -> str:
 
 def update_ghost_post_via_api(
     _id: str, api_key: Optional[str] = None, api_url: Optional[str] = None
-) -> dict[str, str]:
+) -> Dict[str, str]:
     """Update Ghost post via API"""
     # get post doi and url from Rogue Scholar API
     # post url is needed to find post via Ghost API

{commonmeta_py-0.123 → commonmeta_py-0.125}/commonmeta/metadata.py

@@ -1,7 +1,7 @@
 """Metadata"""
 
 from os import path
-from typing import Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 import orjson as json
 import yaml
@@ -69,7 +69,7 @@ from .writers.schema_org_writer import write_schema_org, write_schema_org_list
 class Metadata:
     """Metadata"""
 
-    def __init__(self, string: Optional[Union[str, dict]], **kwargs):
+    def __init__(self, string: Optional[Union[str, Dict[str, Any]]], **kwargs):
         if string is None or not isinstance(string, (str, dict)):
             raise ValueError("No input found")
         self.via = kwargs.get("via", None)
@@ -147,7 +147,7 @@ class Metadata:
         # Default fallback
         raise ValueError("No metadata found")
 
-    def _get_metadata_from_pid(self, pid, via) -> dict:
+    def _get_metadata_from_pid(self, pid, via) -> Dict[str, Any]:
         """Helper method to get metadata from a PID."""
         if via == "schema_org":
             return get_schema_org(pid)
@@ -170,7 +170,7 @@ class Metadata:
         else:
             return {"pid": pid}
 
-    def _get_metadata_from_string(self, string, via) -> dict:
+    def _get_metadata_from_string(self, string, via) -> Dict[str, Any]:
         """Helper method to get metadata from a string."""
         try:
             # XML formats
@@ -214,7 +214,7 @@ class Metadata:
         except (TypeError, json.JSONDecodeError) as error:
             return {"error": str(error)}
 
-    def read_metadata(self, data: dict, **kwargs) -> dict:
+    def read_metadata(self, data: Dict[str, Any], **kwargs) -> Dict[str, Any]:
         """Read and parse metadata from various formats."""
         via = (isinstance(data, dict) and data.get("via")) or self.via
 
@@ -251,8 +251,8 @@ class Metadata:
         else:
             raise ValueError("No input format found")
 
-    def write(self, to: str = "commonmeta", **kwargs) -> str:
-        """Convert metadata into different formats."""
+    def write(self, to: str = "commonmeta", **kwargs) -> Union[str, bytes]:
+        """convert metadata list into different formats"""
         try:
             result = self._write_format(to, **kwargs)
             if result is None or result == "":
@@ -262,20 +262,9 @@ class Metadata:
             # More specific error message including the original JSONDecodeError details
             raise ValueError(f"Invalid JSON: {str(e)}")
 
-    def _write_format(self, to: str, **kwargs) -> str:
+    def _write_format(self, to: str, **kwargs) -> Union[str, bytes]:
         """Helper method to handle writing to different formats."""
-        # Split the format handling into multiple methods to reduce cyclomatic complexity
-        if to in ["commonmeta", "datacite", "inveniordm", "schema_org"]:
-            return self._write_json_format(to)
-        elif to in ["bibtex", "csl", "citation", "ris"]:
-            return self._write_text_format(to, **kwargs)
-        elif to in ["crossref_xml"]:
-            return self._write_xml_format(to, **kwargs)
-        else:
-            raise ValueError("No output format found")
-
-    def _write_json_format(self, to: str) -> str:
-        """Handle JSON-based output formats."""
+        # JSON-based output formats
         if to == "commonmeta":
             result = json.dumps(write_commonmeta(self))
         elif to == "datacite":
@@ -284,8 +273,22 @@ class Metadata:
             result = json.dumps(write_inveniordm(self))
         elif to == "schema_org":
             result = json.dumps(write_schema_org(self))
+        # Text-based output formats
+        elif to == "bibtex":
+            return write_bibtex(self)
+        elif to == "csl":
+            return self._write_csl(**kwargs)
+        elif to == "citation":
+            self.style = kwargs.get("style", "apa")
+            self.locale = kwargs.get("locale", "en-US")
+            return write_citation(self)
+        elif to == "ris":
+            return write_ris(self)
+        # XML-based output formats
+        elif to == "crossref_xml":
+            return self._write_crossref_xml(**kwargs)
         else:
-            return "{}"
+            raise ValueError("No output format found")
 
         if isinstance(result, str):
             # Verify it's valid JSON
@@ -304,26 +307,6 @@ class Metadata:
                 return "{}"
         return "{}"
 
-    def _write_text_format(self, to: str, **kwargs) -> str:
-        """Handle text-based output formats."""
-        if to == "bibtex":
-            return write_bibtex(self)
-        elif to == "csl":
-            return self._write_csl(**kwargs)
-        elif to == "citation":
-            self.style = kwargs.get("style", "apa")
-            self.locale = kwargs.get("locale", "en-US")
-            return write_citation(self)
-        elif to == "ris":
-            return write_ris(self)
-        return ""
-
-    def _write_xml_format(self, to: str, **kwargs) -> str:
-        """Handle XML-based output formats."""
-        if to == "crossref_xml":
-            return self._write_crossref_xml(**kwargs)
-        return ""
-
     def _write_csl(self, **kwargs) -> str:
         """Write in CSL format with error checking."""
         csl_output = write_csl(self)
@@ -366,8 +349,8 @@ class MetadataList:
     """MetadataList"""
 
     def __init__(
-        self, dct: Optional[Union[str, dict]] = None, **kwargs
-    ) -> Optional[dict]:
+        self, dct: Optional[Union[str, Dict[str, Any]]] = None, **kwargs
+    ) -> None:
         if dct is None or not isinstance(dct, (str, bytes, dict)):
             raise ValueError("No input found")
         if isinstance(dct, dict):
@@ -423,12 +406,12 @@ class MetadataList:
         else:
             raise ValueError("No input format found")
 
-    def read_metadata_list(self, data: list, **kwargs) -> list:
+    def read_metadata_list(self, items, **kwargs) -> List[Metadata]:
         """read_metadata_list"""
         kwargs["via"] = kwargs.get("via", None) or self.via
-        return [Metadata(i, **kwargs) for i in data]
+        return [Metadata(i, **kwargs) for i in items]
 
-    def write(self, to: str = "commonmeta", **kwargs) -> str:
+    def write(self, to: str = "commonmeta", **kwargs) -> Union[str, bytes]:
         """convert metadata list into different formats"""
         if to == "bibtex":
             output = write_bibtex_list(self)
@@ -479,19 +462,23 @@ class MetadataList:
         else:
             raise ValueError("No valid output format found")
 
-    def push(self, to: str = "commonmeta", **kwargs) -> str:
+    def push(self, to: str = "commonmeta", **kwargs) -> Union[str, bytes]:
         """push metadata list to external APIs"""
 
         if to == "crossref_xml":
             response = push_crossref_xml_list(
-                self, login_id=self.login_id, login_passwd=self.login_passwd, legacy_key=self.legacy_key
+                self,
+                login_id=self.login_id,
+                login_passwd=self.login_passwd,
+                legacy_key=self.legacy_key,
             )
             return response
         elif to == "datacite":
             raise ValueError("Datacite not yet supported for metadata lists")
         elif to == "inveniordm":
+            kwargs = {"legacy_key": self.legacy_key}
             response = push_inveniordm_list(
-                self, host=self.host, token=self.token, legacy_key=self.legacy_key
+                self, host=self.host, token=self.token, **kwargs
             )
             return response
         else:

{commonmeta_py-0.123 → commonmeta_py-0.125}/commonmeta/readers/cff_reader.py

@@ -99,22 +99,25 @@ def read_cff(data: Optional[dict], **kwargs) -> Commonmeta:
     state = "findable" if meta or read_options else "not_found"
 
     return {
-        "id": _id,
-        "type": _type,
-        # 'identifiers' => identifiers,
-        "url": url,
-        "titles": titles,
-        "contributors": presence(contributors),
-        "publisher": publisher,
-        "references": presence(references),
-        "date": date,
-        "descriptions": presence(descriptions),
-        "license": license_,
-        "version": meta.get("version", None),
-        "subjects": presence(subjects),
-        "provider": "DataCite" if _id else "GitHub",
-        "state": state,
-    } | read_options
+        **{
+            "id": _id,
+            "type": _type,
+            # 'identifiers' => identifiers,
+            "url": url,
+            "titles": titles,
+            "contributors": presence(contributors),
+            "publisher": publisher,
+            "references": presence(references),
+            "date": date,
+            "descriptions": presence(descriptions),
+            "license": license_,
+            "version": meta.get("version", None),
+            "subjects": presence(subjects),
+            "provider": "DataCite" if _id else "GitHub",
+            "state": state,
+        },
+        **read_options,
+    }
 
 
 def cff_contributors(contributors):

{commonmeta_py-0.123 → commonmeta_py-0.125}/commonmeta/readers/codemeta_reader.py

@@ -97,18 +97,21 @@ def read_codemeta(data: Optional[dict], **kwargs) -> Commonmeta:
     state = "findable" if meta or read_options else "not_found"
 
     return {
-        "id": _id,
-        "type": _type,
-        "url": normalize_id(meta.get("codeRepository", None)),
-        "identifiers": None,
-        "titles": titles,
-        "contributors": presence(contributors),
-        "publisher": publisher,
-        "date": compact(date),
-        "descriptions": descriptions,
-        "license": license_,
-        "version": meta.get("version", None),
-        "subjects": presence(subjects),
-        "provider": provider,
-        "state": state,
-    } | read_options
+        **{
+            "id": _id,
+            "type": _type,
+            "url": normalize_id(meta.get("codeRepository", None)),
+            "identifiers": None,
+            "titles": titles,
+            "contributors": presence(contributors),
+            "publisher": publisher,
+            "date": compact(date),
+            "descriptions": descriptions,
+            "license": license_,
+            "version": meta.get("version", None),
+            "subjects": presence(subjects),
+            "provider": provider,
+            "state": state,
+        },
+        **read_options,
+    }

{commonmeta_py-0.123 → commonmeta_py-0.125}/commonmeta/readers/crossref_reader.py

@@ -1,6 +1,6 @@
 """crossref reader for commonmeta-py"""
 
-from typing import Optional
+from typing import List, Optional
 from xml.parsers.expat import ExpatError
 
 import requests
@@ -33,7 +33,7 @@ from ..utils import (
 )
 
 
-def get_crossref_list(query: dict, **kwargs) -> list[dict]:
+def get_crossref_list(query: dict, **kwargs) -> List[dict]:
     """get_crossref list from Crossref API."""
     url = crossref_api_query_url(query, **kwargs)
     response = requests.get(url, timeout=30, **kwargs)
@@ -51,7 +51,7 @@ def get_crossref(pid: str, **kwargs) -> dict:
     response = requests.get(url, timeout=10, **kwargs)
     if response.status_code != 200:
         return {"state": "not_found"}
-    return response.json().get("message", {}) | {"via": "crossref"}
+    return {**response.json().get("message", {}), "via": "crossref"}
 
 
 def read_crossref(data: Optional[dict], **kwargs) -> Commonmeta:
@@ -138,31 +138,34 @@ def read_crossref(data: Optional[dict], **kwargs) -> Commonmeta:
     )
 
     return {
-        # required properties
-        "id": _id,
-        "type": _type,
-        # recommended and optional properties
-        "additionalType": additional_type,
-        "archiveLocations": presence(archive_locations),
-        "container": presence(container),
-        "contributors": presence(contributors),
-        "date": presence(date),
-        "descriptions": presence(descriptions),
-        "files": presence(files),
-        "fundingReferences": presence(funding_references),
-        "geoLocations": None,
-        "identifiers": identifiers,
-        "language": meta.get("language", None),
-        "license": license_,
-        "provider": "Crossref",
-        "publisher": presence(publisher),
-        "references": presence(references),
-        "relations": presence(relations),
-        "subjects": presence(subjects),
-        "titles": presence(titles),
-        "url": url,
-        "version": meta.get("version", None),
-    } | read_options
+        **{
+            # required properties
+            "id": _id,
+            "type": _type,
+            # recommended and optional properties
+            "additionalType": additional_type,
+            "archiveLocations": presence(archive_locations),
+            "container": presence(container),
+            "contributors": presence(contributors),
+            "date": presence(date),
+            "descriptions": presence(descriptions),
+            "files": presence(files),
+            "fundingReferences": presence(funding_references),
+            "geoLocations": None,
+            "identifiers": identifiers,
+            "language": meta.get("language", None),
+            "license": license_,
+            "provider": "Crossref",
+            "publisher": presence(publisher),
+            "references": presence(references),
+            "relations": presence(relations),
+            "subjects": presence(subjects),
+            "titles": presence(titles),
+            "url": url,
+            "version": meta.get("version", None),
+        },
+        **read_options,
+    }
 
 
 def get_titles(meta):

{commonmeta_py-0.123 → commonmeta_py-0.125}/commonmeta/readers/datacite_reader.py

@@ -40,7 +40,7 @@ def get_datacite(pid: str, **kwargs) -> dict:
         response = requests.get(url, timeout=10, **kwargs)
         if response.status_code != 200:
             return {"state": "not_found"}
-        return py_.get(response.json(), "data.attributes", {}) | {"via": "datacite"}
+        return {**py_.get(response.json(), "data.attributes", {}), "via": "datacite"}
     except ReadTimeout:
         return {"state": "timeout"}
 
@@ -114,30 +114,33 @@ def read_datacite(data: dict, **kwargs) -> Commonmeta:
     subjects = py_.uniq([format_subject(i) for i in wrap(meta.get("subjects", None))])
 
     return {
-        # required properties
-        "id": _id,
-        "type": _type,
-        # recommended and optional properties
-        "additionalType": additional_type,
-        "container": presence(container),
-        "contributors": presence(contributors),
-        "date": compact(date),
-        "descriptions": presence(descriptions),
-        "files": presence(files),
-        "fundingReferences": presence(meta.get("fundingReferences", None)),
-        "geoLocations": presence(geo_locations),
-        "identifiers": presence(identifiers),
-        "language": meta.get("language", None),
-        "license": presence(license_),
-        "provider": "DataCite",
-        "publisher": publisher,
-        "references": presence(references),
-        "relations": presence(relations),
-        "subjects": presence(subjects),
-        "titles": presence(titles),
-        "url": normalize_url(meta.get("url", None)),
-        "version": meta.get("version", None),
-    } | read_options
+        **{
+            # required properties
+            "id": _id,
+            "type": _type,
+            # recommended and optional properties
+            "additionalType": additional_type,
+            "container": presence(container),
+            "contributors": presence(contributors),
+            "date": compact(date),
+            "descriptions": presence(descriptions),
+            "files": presence(files),
+            "fundingReferences": presence(meta.get("fundingReferences", None)),
+            "geoLocations": presence(geo_locations),
+            "identifiers": presence(identifiers),
+            "language": meta.get("language", None),
+            "license": presence(license_),
+            "provider": "DataCite",
+            "publisher": publisher,
+            "references": presence(references),
+            "relations": presence(relations),
+            "subjects": presence(subjects),
+            "titles": presence(titles),
+            "url": normalize_url(meta.get("url", None)),
+            "version": meta.get("version", None),
+        },
+        **read_options,
+    }
 
 
 def get_identifiers(identifiers: list) -> list:

{commonmeta_py-0.123 → commonmeta_py-0.125}/commonmeta/readers/datacite_xml_reader.py

@@ -22,7 +22,7 @@ def get_datacite_xml(pid: str, **kwargs) -> dict:
     response = requests.get(url, timeout=10, **kwargs)
     if response.status_code != 200:
         return {"state": "not_found"}
-    return py_.get(response.json(), "data.attributes", {}) | {"via": "datacite_xml"}
+    return {**py_.get(response.json(), "data.attributes", {}), "via": "datacite_xml"}
 
 
 def read_datacite_xml(data: dict, **kwargs) -> Commonmeta:
@@ -203,38 +203,41 @@ def read_datacite_xml(data: dict, **kwargs) -> Commonmeta:
     state = "findable" if _id or read_options else "not_found"
 
     return {
-        # required properties
-        "id": _id,
-        "type": _type,
-        "doi": doi_from_url(_id),
-        "url": normalize_url(meta.get("url", None)),
-        "contributors": presence(contributors),
-        "titles": compact(titles),
-        "publisher": publisher,
-        "date": date,
-        # recommended and optional properties
-        "additionalType": presence(additional_type),
-        "subjects": presence(subjects),
-        "language": meta.get("language", None),
-        "identifiers": identifiers,
-        "version": meta.get("version", None),
-        "license": presence(license_),
-        "descriptions": presence(descriptions),
-        "geoLocations": presence(geo_locations),
-        "fundingReferences": presence(funding_references),
-        "references": presence(references),
-        "relations": presence(relations),
-        # other properties
-        "date_created": strip_milliseconds(meta.get("created", None)),
-        "date_registered": strip_milliseconds(meta.get("registered", None)),
-        "date_published": strip_milliseconds(meta.get("published", None)),
-        "date_updated": strip_milliseconds(meta.get("updated", None)),
-        "files": presence(files),
-        "container": presence(meta.get("container", None)),
-        "provider": "DataCite",
-        "state": state,
-        "schema_version": meta.get("xmlns", None),
-    } | read_options
+        **{
+            # required properties
+            "id": _id,
+            "type": _type,
+            "doi": doi_from_url(_id),
+            "url": normalize_url(meta.get("url", None)),
+            "contributors": presence(contributors),
+            "titles": compact(titles),
+            "publisher": publisher,
+            "date": date,
+            # recommended and optional properties
+            "additionalType": presence(additional_type),
+            "subjects": presence(subjects),
+            "language": meta.get("language", None),
+            "identifiers": identifiers,
+            "version": meta.get("version", None),
+            "license": presence(license_),
+            "descriptions": presence(descriptions),
+            "geoLocations": presence(geo_locations),
+            "fundingReferences": presence(funding_references),
+            "references": presence(references),
+            "relations": presence(relations),
+            # other properties
+            "date_created": strip_milliseconds(meta.get("created", None)),
+            "date_registered": strip_milliseconds(meta.get("registered", None)),
+            "date_published": strip_milliseconds(meta.get("published", None)),
+            "date_updated": strip_milliseconds(meta.get("updated", None)),
+            "files": presence(files),
+            "container": presence(meta.get("container", None)),
+            "provider": "DataCite",
+            "state": state,
+            "schema_version": meta.get("xmlns", None),
+        },
+        **read_options,
+    }
 
 
 def get_xml_identifiers(identifiers: list) -> list:

{commonmeta_py-0.123 → commonmeta_py-0.125}/commonmeta/readers/inveniordm_reader.py

@@ -122,31 +122,34 @@ def read_inveniordm(data: dict, **kwargs) -> Commonmeta:
     files = [get_file(i) for i in wrap(meta.get("files"))]
 
     return {
-        # required properties
-        "id": _id,
-        "type": _type,
-        "doi": doi_from_url(_id),
-        "url": url,
-        "contributors": presence(contributors),
-        "titles": titles,
-        "publisher": publisher,
-        "date": compact(date),
-        # recommended and optional properties
-        # "additional_type": additional_type,
-        "subjects": presence(subjects),
-        "language": get_language(language),
-        "version": py_.get(meta, "metadata.version"),
-        "license": presence(license_),
-        "descriptions": descriptions,
-        "geoLocations": None,
-        "fundingReferences": presence(funding_references),
-        "references": presence(references),
-        "relations": presence(relations),
-        # other properties
-        "files": files,
-        "container": container,
-        "provider": "DataCite",
-    } | read_options
+        **{
+            # required properties
+            "id": _id,
+            "type": _type,
+            "doi": doi_from_url(_id),
+            "url": url,
+            "contributors": presence(contributors),
+            "titles": titles,
+            "publisher": publisher,
+            "date": compact(date),
+            # recommended and optional properties
+            # "additional_type": additional_type,
+            "subjects": presence(subjects),
+            "language": get_language(language),
+            "version": py_.get(meta, "metadata.version"),
+            "license": presence(license_),
+            "descriptions": descriptions,
+            "geoLocations": None,
+            "fundingReferences": presence(funding_references),
+            "references": presence(references),
+            "relations": presence(relations),
+            # other properties
+            "files": files,
+            "container": container,
+            "provider": "DataCite",
+        },
+        **read_options,
+    }
 
 
 def get_references(references: list) -> list: