commonmeta-py 0.122__py3-none-any.whl → 0.124__py3-none-any.whl

commonmeta/__init__.py

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

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/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,12 +462,15 @@ 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":

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/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/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/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/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/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:

commonmeta/readers/kbase_reader.py

@@ -2,15 +2,15 @@
 
 from pydash import py_
 
-from ..utils import normalize_url, normalize_doi, from_curie, from_kbase
-from ..base_utils import compact, wrap, presence, sanitize
 from ..author_utils import get_authors
-from ..date_utils import normalize_date_dict
-from ..doi_utils import doi_from_url, validate_doi
+from ..base_utils import compact, presence, sanitize, wrap
 from ..constants import (
     COMMONMETA_RELATION_TYPES,
     Commonmeta,
 )
+from ..date_utils import normalize_date_dict
+from ..doi_utils import doi_from_url, validate_doi
+from ..utils import from_curie, from_kbase, normalize_doi, normalize_url
 
 
 def read_kbase(data: dict, **kwargs) -> Commonmeta:
@@ -70,32 +70,35 @@ def read_kbase(data: dict, **kwargs) -> Commonmeta:
     state = "findable" if meta 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": titles,
-        "publisher": publisher,
-        "date": compact(date),
-        # recommended and optional properties
-        "additional_type": None,
-        "subjects": None,
-        "language": language,
-        "identifiers": None,
-        "version": py_.get(meta, "metadata.version"),
-        "license": presence(license_),
-        "descriptions": descriptions,
-        "geo_locations": None,
-        "fundingReferences": presence(funding_references),
-        "references": presence(references),
-        "relations": presence(relations),
-        # other properties
-        "files": presence(files),
-        "container": container,
-        "provider": "DataCite",
-    } | read_options
+        **{
+            # required properties
+            "id": _id,
+            "type": _type,
+            "doi": doi_from_url(_id),
+            "url": normalize_url(meta.get("url", None)),
+            "contributors": presence(contributors),
+            "titles": titles,
+            "publisher": publisher,
+            "date": compact(date),
+            # recommended and optional properties
+            "additional_type": None,
+            "subjects": None,
+            "language": language,
+            "identifiers": None,
+            "version": py_.get(meta, "metadata.version"),
+            "license": presence(license_),
+            "descriptions": descriptions,
+            "geo_locations": None,
+            "fundingReferences": presence(funding_references),
+            "references": presence(references),
+            "relations": presence(relations),
+            # other properties
+            "files": presence(files),
+            "container": container,
+            "provider": "DataCite",
+        },
+        **read_options,
+    }
 
 
 def format_title(title: dict) -> dict:

commonmeta/readers/ris_reader.py

@@ -67,21 +67,24 @@ def read_ris(data: Optional[str], **kwargs) -> Commonmeta:
     state = "findable" if meta.get("DO", None) or read_options else "not_found"
 
     return {
-        "id": _id,
-        "type": _type,
-        "doi": doi_from_url(_id),
-        "url": normalize_url(meta.get("UR", None)),
-        "titles": [{"title": meta.get("T1", None)}],
-        "descriptions": descriptions,
-        "contributors": presence(contributors),
-        "publisher": presence(publisher),
-        "container": container,
-        # 'related_identifiers': related_identifiers,
-        "date": date,
-        "subjects": subjects,
-        "language": meta.get("LA", None),
-        "state": state,
-    } | read_options
+        **{
+            "id": _id,
+            "type": _type,
+            "doi": doi_from_url(_id),
+            "url": normalize_url(meta.get("UR", None)),
+            "titles": [{"title": meta.get("T1", None)}],
+            "descriptions": descriptions,
+            "contributors": presence(contributors),
+            "publisher": presence(publisher),
+            "container": container,
+            # 'related_identifiers': related_identifiers,
+            "date": date,
+            "subjects": subjects,
+            "language": meta.get("LA", None),
+            "state": state,
+        },
+        **read_options,
+    }
 
 
 def ris_meta(data):

commonmeta/schema_utils.py

@@ -1,13 +1,14 @@
 """Schema utils for commonmeta-py"""
 
 from os import path
+from typing import Any, Dict, Optional, Union
 
 import orjson as json
 import xmlschema
 from jsonschema import Draft202012Validator, ValidationError
 
 
-def json_schema_errors(instance, schema: str = "commonmeta"):
+def json_schema_errors(instance: Dict[str, Any], schema: str = "commonmeta") -> Optional[str]:
     """validate against JSON schema"""
     schema_map = {
         "commonmeta": "commonmeta_v0.16",
@@ -30,7 +31,7 @@ def json_schema_errors(instance, schema: str = "commonmeta"):
         return error.message
 
 
-def xml_schema_errors(instance, schema: str = "crossref_xml"):
+def xml_schema_errors(instance: Union[str, bytes], schema: str = "crossref_xml") -> Optional[Union[bool, Exception]]:
     """validate against XML schema"""
     schema_map = {
         "crossref_xml": "crossref5.4.0",
@@ -40,8 +41,8 @@ def xml_schema_errors(instance, schema: str = "crossref_xml"):
             raise ValueError("No schema found")
         base_dir = path.join(path.dirname(__file__), "resources", "crossref")
         schema_path = path.join(base_dir, "crossref5.4.0.xsd")
-        schema = xmlschema.XMLSchema(schema_path)
-        return schema.validate(instance)
+        schema_obj = xmlschema.XMLSchema(schema_path)
+        return schema_obj.validate(instance)
     except xmlschema.validators.exceptions.XMLSchemaValidationError as error:
         print(error)
         return error

commonmeta/writers/inveniordm_writer.py

@@ -19,7 +19,7 @@ from ..constants import (
     Commonmeta,
 )
 from ..date_utils import get_iso8601_date
-from ..doi_utils import doi_from_url, normalize_doi
+from ..doi_utils import doi_as_url, doi_from_url, normalize_doi
 from ..utils import (
     FOS_MAPPINGS,
     get_language,
@@ -589,7 +589,6 @@ def update_draft_record(record, host, token, inveniordm_data):
         )
         response.raise_for_status()
         data = response.json()
-        record["created"] = data.get("created", None)
         record["updated"] = data.get("updated", None)
         record["status"] = "updated"
         return record
@@ -622,6 +621,7 @@ def publish_draft_record(record, host, token):
             return record
         data = response.json()
         record["uuid"] = py_.get(data, "metadata.identifiers.0.identifier")
+        record["doi"] =  doi_as_url(py_.get(data, "pids.doi.identifier")),
         record["created"] = data.get("created", None)
         record["updated"] = data.get("updated", None)
         record["status"] = "published"
@@ -677,7 +677,7 @@ def update_legacy_record(record, legacy_key: str, field:str=None) -> dict:
                 "archived": "true",
             }
         else:
-            print(f"nothing to update for id {record.get("uuid")}")
+            print(f"nothing to update for id {record.get('uuid')}")
             return record # nothing to update
 
         request_url = f"https://{legacy_host}/rest/v1/posts?id=eq.{record['uuid']}"

{commonmeta_py-0.122.dist-info → commonmeta_py-0.124.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commonmeta-py
-Version: 0.122
+Version: 0.124
 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.122.dist-info → commonmeta_py-0.124.dist-info}/RECORD

@@ -1,5 +1,5 @@
-commonmeta/__init__.py,sha256=fyxBqzJ7zieudPfK0XMHzZNoQxSdDQOzAMj5O5rPVqU,2098
-commonmeta/api_utils.py,sha256=y5KLfIOWOjde7LXZ36u-eneQJ-Q53yXUZg3hWpCBS2E,2685
+commonmeta/__init__.py,sha256=pp3RcQ6mEgusaIHYnKMwYYMDh-6dGBRUhu2jP0ecdHw,2098
+commonmeta/api_utils.py,sha256=P8LMHHYiF4OTi97_5k4KstcBreooMkOAKZ4ebxsAv4o,2691
 commonmeta/author_utils.py,sha256=3lYW5s1rOUWNTKs1FP6XLfEUY3yCLOe_3L_VdJTDMp0,8585
 commonmeta/base_utils.py,sha256=-MGy9q2uTiJEkPWQUYOJMdq-3tRpNnvBwlLjvllQ5g8,11164
 commonmeta/cli.py,sha256=pdBpBosLNq3RS9buO-Voqawc9Ay1eSt-xP5O97iOft4,8480
@@ -7,25 +7,25 @@ commonmeta/constants.py,sha256=wSTEUiHeRdXLwjXEQD9AU2hxFyEKi5OTX2iHOKO6nF0,19844
 commonmeta/date_utils.py,sha256=H2cCobX0JREIUOT_cCigGd3MG7prGiQpXk1m4ZNrFwU,6318
 commonmeta/doi_utils.py,sha256=cOogLatKg6qea2jgMd3yLALSTfaTNUgr-IkBXIK4xZw,11498
 commonmeta/file_utils.py,sha256=eFYDWyR8Gr722nvFmp542hCm-TGmO_q4ciZ85IPHpjA,2893
-commonmeta/metadata.py,sha256=m9UtE95t9awrlo9w9qZtwF7Y9sRfABpA5JKUZdyz5b4,18921
-commonmeta/schema_utils.py,sha256=WGpmMj9cfNMg_55hhgwY9qpO0A1HSvTLQC2equjBftI,1770
+commonmeta/metadata.py,sha256=_N9suKA10uiWU5-3a349x-H9VbhzEZ6rQ1PqXOCiinA,18408
+commonmeta/schema_utils.py,sha256=O6OxiySUrvnNJvslJLY86RFu2HldrZFi21OaLXnV3mA,1912
 commonmeta/translators.py,sha256=CBMK4jrXRmGZiAhCh6wsJjhbDJWbcsda8UvXFXxccAw,1363
 commonmeta/utils.py,sha256=pJnh3EzOU1E2nutnAZsopY_NsUX6zYmxoj5bIYqqWvE,50574
 commonmeta/readers/__init__.py,sha256=vOf7UsOKNoh_ZCuyexxhAmPMt8wjB-pF_CfpWRaN8pk,45
 commonmeta/readers/bibtex_reader.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-commonmeta/readers/cff_reader.py,sha256=kIG-OKGQz37oWL6cU3Cz7HQ83DnRCmQ2PKSjIDodSp8,6152
-commonmeta/readers/codemeta_reader.py,sha256=fF0bIYf3J2mpgfdtM0C1lbDexUuoVO7JS1cFf7P--2E,3655
+commonmeta/readers/cff_reader.py,sha256=HMFK6QIg_XIlhmYIWL4EfIyuidYl5L_0TAwyG78XPlU,6244
+commonmeta/readers/codemeta_reader.py,sha256=QmJjh9f6kLxOWCBaZqdqY-LPlA0g2cX90yvPt0p1Nw8,3743
 commonmeta/readers/commonmeta_reader.py,sha256=46XrCr2whkUP4uiaNiFXS7ABwowcRdWcLG-3OcfhVdk,303
-commonmeta/readers/crossref_reader.py,sha256=qdHI7PV2rHcwxxnL-xlpF_U-4Tedwolm0SiHWp2mEhQ,13138
+commonmeta/readers/crossref_reader.py,sha256=ydyiFw3m4P8LgMuornQrwJPds8bWPBGR03wtUG3Or-Y,13273
 commonmeta/readers/crossref_xml_reader.py,sha256=A2iAFT2IbhTNcfL-Dx4xO2SFSNOu_HNyPisus0u4UJI,18719
 commonmeta/readers/csl_reader.py,sha256=OxzC2AZKfv43BCah4XGYvlK_LUK-5mxXFcjdzB5vv_o,3216
-commonmeta/readers/datacite_reader.py,sha256=M6gznf1kisR1WzDZaoR0pLJC6Q4Rtnerodfs8lU2khI,12094
-commonmeta/readers/datacite_xml_reader.py,sha256=zJSuN9pnWplYFH7V1eneh0OjKTFCNkOLmEMf6fU6_xg,13048
-commonmeta/readers/inveniordm_reader.py,sha256=6LkT6R20jSFqDdZqAzcREHbdAcIPHiYJvxKsK_mpDdw,8374
+commonmeta/readers/datacite_reader.py,sha256=4b_AP8m_aOUNVnVB0nU9j4-a8WTpmYJA8QPr5v35qyw,12219
+commonmeta/readers/datacite_xml_reader.py,sha256=nsPc7JBbIKgx6Yaauq8vmhUE-o6K0t_MAuExv6FO2AU,13205
+commonmeta/readers/inveniordm_reader.py,sha256=DtSloEZDu8bL-QLQAqAW1aDsS6ESTDZyhme379IekjY,8502
 commonmeta/readers/jsonfeed_reader.py,sha256=zcPxxuyAGW8W7w0-VwP9AhpX97qVWHQJUIJ5p4bBbfE,15655
-commonmeta/readers/kbase_reader.py,sha256=KH3loJvuq2bm8zAYIUG7hTsr5-2Anj3NQvoJUDiqmss,6764
+commonmeta/readers/kbase_reader.py,sha256=0Y9cHRNs_7kHyocN4IESXbgmXJiq4TXoxvGeUYGml1s,6896
 commonmeta/readers/openalex_reader.py,sha256=4HUkBsut_iUjhUcC5c1GHgxnKsYQc-fgY43QILgVZEg,12826
-commonmeta/readers/ris_reader.py,sha256=oQ3G7qQmNwhr4cNp-Gv5UW28J2K1oKpBlPh-tjRtnpQ,3678
+commonmeta/readers/ris_reader.py,sha256=nwK8Eux0wPjwKqXFWS4Cfd6FAY7Id4Mi_hgkTwPntHs,3766
 commonmeta/readers/schema_org_reader.py,sha256=AlFMmuUovqlMYkwL9F1Um6bX5vIWzhqmreHCrzsC3rU,17275
 commonmeta/resources/cff_v1.2.0.json,sha256=MpfjDYgX7fN9PLiG54ISZ2uu9WItNqfh-yaRuTf6Ptg,46691
 commonmeta/resources/commonmeta_v0.12.json,sha256=HUSNReXh2JN3Q6YWSt7CE69js8dh50OlpMYGTyU98oU,16762
@@ -80,11 +80,11 @@ commonmeta/writers/commonmeta_writer.py,sha256=QpfyhG__7o_XpsOTCPWxGymO7YKwZi2LQ
 commonmeta/writers/crossref_xml_writer.py,sha256=cGrX9vacNwDdK7TbH1RWig68SH8hg5VusuqkI9gU1DY,33931
 commonmeta/writers/csl_writer.py,sha256=4gDYs1EzK4_L2UIRTfs25wgHmYRwdRP2zmfxF9387oU,2779
 commonmeta/writers/datacite_writer.py,sha256=bcinpwhq7XnVthKHH8-sdXA34dSlvFH4ImYH768iaQU,6428
-commonmeta/writers/inveniordm_writer.py,sha256=eLllddYulFqg8qfRIScpYpnAJ82NCHXotCFJb09mHX8,25739
+commonmeta/writers/inveniordm_writer.py,sha256=2CD2XYThHgZhUUeVVzZU6A_p6lOz7Xdt0Ij4Zy_E1PM,25772
 commonmeta/writers/ris_writer.py,sha256=3SdyEvMRaPRP1SV1MB-MXBlunE7x6og7RF1zuWtetPc,2094
 commonmeta/writers/schema_org_writer.py,sha256=s18_x0ReXwAGBoEAwp2q-HCgFQ-h5qRg6JyAlqCoSFE,5871
-commonmeta_py-0.122.dist-info/METADATA,sha256=b_2hi3K4fN7myJ6K0EzSivSHHrTP22iEpFLeFEPGe4Y,7656
-commonmeta_py-0.122.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-commonmeta_py-0.122.dist-info/entry_points.txt,sha256=U4w4BoRuS3rN5t5Y-uYSyOeU5Lh_VRVMS9OIDzIgw4w,50
-commonmeta_py-0.122.dist-info/licenses/LICENSE,sha256=wsIvxF9Q9GC9vA_s79zTWP3BkXJdfUNRmALlU8GbW1s,1074
-commonmeta_py-0.122.dist-info/RECORD,,
+commonmeta_py-0.124.dist-info/METADATA,sha256=t0hoWqdbSD8HDjdOpJtoxhjb9_coYI_z9wBMgN5VZIU,7656
+commonmeta_py-0.124.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+commonmeta_py-0.124.dist-info/entry_points.txt,sha256=U4w4BoRuS3rN5t5Y-uYSyOeU5Lh_VRVMS9OIDzIgw4w,50
+commonmeta_py-0.124.dist-info/licenses/LICENSE,sha256=wsIvxF9Q9GC9vA_s79zTWP3BkXJdfUNRmALlU8GbW1s,1074
+commonmeta_py-0.124.dist-info/RECORD,,