commonmeta-py 0.123__py3-none-any.whl → 0.125__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.123"
+__version__ = "0.125"
 __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,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/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,16 @@
 """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 +33,9 @@ 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 +45,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/crossref_xml_writer.py

@@ -385,7 +385,9 @@ def write_crossref_xml_list(metalist) -> Optional[str]:
     return unparse_xml_list(crossref_xml_list, dialect="crossref", head=head)
 
 
-def push_crossref_xml_list(metalist, login_id: str, login_passwd: str, legacy_key:str=None) -> bytes:
+def push_crossref_xml_list(
+    metalist, login_id: str, login_passwd: str, legacy_key: str = None
+) -> bytes:
     """Push crossref_xml list to Crossref API, returns the API response."""
 
     input = write_crossref_xml_list(metalist)
@@ -426,28 +428,21 @@ def push_crossref_xml_list(metalist, login_id: str, login_passwd: str, legacy_ke
     items = []
     for item in metalist.items:
         record = {
-                "doi": item.id,
-                "updated": datetime.now().isoformat("T", "seconds"),
-                "status": "submitted",
-            }
+            "doi": item.id,
+            "updated": datetime.now().isoformat("T", "seconds"),
+            "status": "submitted",
+        }
 
         # update rogue-scholar legacy record if legacy_key is provided
         if is_rogue_scholar_doi(item.id, ra="crossref") and legacy_key is not None:
-             record["uuid"] = py_.get(item, "identifiers.0.identifier")
-             record = update_legacy_record(record, legacy_key=legacy_key, field="doi")
+            record["uuid"] = py_.get(item, "identifiers.0.identifier")
+            record = update_legacy_record(record, legacy_key=legacy_key, field="doi")
         items.append(record)
 
     # Return JSON response
     return json.dumps(items, option=json.OPT_INDENT_2)
 
 
-
-
-
-
-
-
-
 def get_attributes(obj, **kwargs) -> dict:
     """Get root attributes"""
     return compact(

commonmeta/writers/inveniordm_writer.py

@@ -4,7 +4,6 @@ import logging
 import re
 from time import time
 from typing import Dict, Optional
-from urllib.parse import urlparse
 
 import orjson as json
 import pydash as py_
@@ -32,6 +31,7 @@ from ..utils import (
 
 logger = logging.getLogger(__name__)
 
+
 def write_inveniordm(metadata):
     """Write inveniordm"""
     if metadata is None or metadata.write_errors is not None:
@@ -387,123 +387,161 @@ def write_inveniordm_list(metalist):
     return [write_inveniordm(item) for item in metalist.items]
 
 
-def push_inveniordm(
-        metadata: Commonmeta,
-        host: str,
-        token: str,
-        legacy_key: str
-    ) -> Dict:
+def push_inveniordm(metadata: Commonmeta, host: str, token: str, **kwargs) -> Dict:
     """Push record to InvenioRDM"""
 
-    record = {}
-    output = write_inveniordm(metadata)
-
     try:
-        # Remove IsPartOf relation with InvenioRDM community identifier after storing it
-        # community_index = None
-        # if hasattr(metadata, "relations") and metadata.relations:
-        #     for i, relation in enumerate(metadata.relations):
-        #         if relation.get("type") == "IsPartOf" and relation.get(
-        #             "id", ""
-        #         ).startswith("https://rogue-scholar.org/api/communities/"):
-        #             slug = relation.get("id").split("/")[5]
-        #             community_id, _ = search_by_slug(slug, "blog", host, token)
-        #             if community_id:
-        #                 record["community"] = slug
-        #                 record["community_id"] = community_id
-        #                 community_index = i
-
-        #     # Remove the relation if we found and processed it
-        #     if community_index is not None and hasattr(metadata, "relations"):
-        #         metadata.relations.pop(community_index)
-
-        # Remove InvenioRDM rid after storing it
-        # rid_index = None
-        # if hasattr(metadata, "identifiers") and metadata.identifiers:
-        #     for i, identifier in enumerate(metadata.identifiers):
-        #         if identifier.get("identifierType") == "RID" and identifier.get("identifier"):
-        #             record["id"] = identifier.get("identifier")
-        #             rid_index = i
-        #         elif identifier.get("identifierType") == "UUID" and identifier.get("identifier"):
-        #             record["uuid"] = identifier.get("identifier")
-
-        # # Remove the identifier if we found and processed it
-        # if rid_index is not None and hasattr(metadata, "identifiers"):
-        #     metadata.identifiers.pop(rid_index)
-
-        # Check if record already exists in InvenioRDM
-        record["id"] = search_by_doi(doi_from_url(metadata.id), host, token)
-
-        if record["id"] is not None:
-            # Create draft record from published record
-            record = edit_published_record(record, host, token)
-
-            # Update draft record
-            record = update_draft_record(record, host, token, output)
-        else:
-            # Create draft record
-            record = create_draft_record(record, host, token, output)
-
-        # Publish draft record
-        record = publish_draft_record(record, host, token)
-
-        # Add record to blog community if blog community is specified and exists
-        if record.get("community_id", None) is not None:
-            record = add_record_to_community(
-                record, host, token, record["community_id"]
-            )
-
-        # Add record to subject area community if subject area community is specified and exists
-        # Subject area communities should exist for all subjects in the FOSMappings
-
-        if hasattr(metadata, "subjects"):
-            for subject in metadata.subjects:
-                subject_name = subject.get("subject", "")
-                slug = string_to_slug(subject_name)
-                if slug in COMMUNITY_TRANSLATIONS:
-                    slug = COMMUNITY_TRANSLATIONS[slug]
-
-                community_id = search_by_slug(slug, "topic", host, token)
-                if community_id:
-                    record = add_record_to_community(record, host, token, community_id)
-
-        # Add record to communities defined as IsPartOf relation in inveniordm metadata's RelatedIdentifiers
-        related_identifiers = py_.get(input, "metadata.related_identifiers")
+        doi = normalize_doi(metadata.id)
+        if doi is None:
+            raise ValueError("no doi provided")
 
-        for identifier in wrap(related_identifiers):
-            if py_.get(identifier, "relation_type.id") == "ispartof":
-                parsed_url = urlparse(identifier.get("identifier", ""))
-                path_parts = parsed_url.path.split("/")
+        record = {
+            "doi": doi,
+        }
 
-                if (
-                    parsed_url.netloc == urlparse(host).netloc
-                    and len(path_parts) == 3
-                    and path_parts[1] == "communities"
+        # extract optional information needed but not upserted to the InvenioRDM API:
+        # rid is the InvenioRDM record id,
+        # uuid is the Rogue Scholar uuid,
+        # community_id is the id of the primary community of the record
+        if hasattr(metadata, "identifiers") and metadata.identifiers:
+            rid_index = None
+            uuid_index = None
+            for i, identifier in enumerate(metadata.identifiers):
+                if identifier.get("identifierType") == "RID" and identifier.get(
+                    "identifier"
+                ):
+                    record["id"] = identifier.get("identifier")
+                    rid_index = i
+                elif identifier.get("identifierType") == "UUID" and identifier.get(
+                    "identifier"
                 ):
-                    record = add_record_to_community(record, host, token, path_parts[2])
+                    record["uuid"] = identifier.get("identifier")
+                    uuid_index = i
+            if rid_index is not None:
+                metadata.identifiers.pop(rid_index)
+            if uuid_index is not None:
+                metadata.identifiers.pop(rid_index)
+
+        if hasattr(metadata, "relations") and metadata.relations:
+            community_index = None
+            for i, relation in enumerate(metadata.relations):
+                if relation.get("type") == "IsPartOf" and relation.get(
+                    "id", ""
+                ).startswith(f"https://{host}/api/communities/"):
+                    slug = relation.get("id").split("/")[5]
+                    community_id = search_by_slug(slug, "blog", host, token)
+                    if community_id:
+                        record["community"] = slug
+                        record["community_id"] = community_id
+                        community_index = i
+
+            if community_index is not None:
+                metadata.relations.pop(community_index)
+
+        # upsert record via the InvenioRDM API
+        record = upsert_record(metadata, host, token, record)
+
+        # optionally add record to InvenioRDM communities
+        record = add_record_to_communities(metadata, host, token, record)
+
+        # optionally update external services
+        record = update_external_services(metadata, host, token, record, **kwargs)
 
-        # optionally update rogue-scholar legacy record
-        if host == "rogue-scholar.org" and legacy_key is not None:
-            record = update_legacy_record(record, legacy_key=legacy_key, field="rid")
     except Exception as e:
-        logger.error(f"Unexpected error in push_inveniordm: {str(e)}", exc_info=True, extra={
-            "host": host,
-            "record_id": record.get("id")
-        })
+        logger.error(
+            f"Unexpected error in push_inveniordm: {str(e)}",
+            exc_info=True,
+            extra={"host": host, "record_id": record.get("id")},
+        )
         record["status"] = "error"
 
     return record
 
 
-def push_inveniordm_list(metalist, host: str, token: str, legacy_key: str) -> list:
+def push_inveniordm_list(metalist, host: str, token: str, **kwargs) -> list:
     """Push inveniordm list to InvenioRDM, returns list of push results."""
 
     if metalist is None:
         return None
-    items = [push_inveniordm(item, host, token, legacy_key) for item in metalist.items]
+    items = [push_inveniordm(item, host, token, **kwargs) for item in metalist.items]
     return json.dumps(items, option=json.OPT_INDENT_2)
 
 
+def upsert_record(metadata: Commonmeta, host: str, token: str, record: dict) -> dict:
+    """Upsert InvenioRDM record, based on DOI"""
+
+    output = write_inveniordm(metadata)
+
+    # Check if record already exists in InvenioRDM
+    record["id"] = search_by_doi(doi_from_url(record.get("doi")), host, token)
+
+    if record["id"] is not None:
+        # Create draft record from published record
+        record = edit_published_record(record, host, token)
+
+        # Update draft record
+        record = update_draft_record(record, host, token, output)
+    else:
+        # Create draft record
+        record = create_draft_record(record, host, token, output)
+
+    # Publish draft record
+    record = publish_draft_record(record, host, token)
+
+    return record
+
+
+def add_record_to_communities(
+    metadata: Commonmeta, host: str, token: str, record: dict
+) -> dict:
+    """Add record to one or more InvenioRDM communities"""
+
+    # Add record to primary community if primary community is specified
+    if record.get("community_id", None) is not None:
+        record = add_record_to_community(record, host, token, record["community_id"])
+
+    # Add record to subject area community if subject area community is specified
+    # Subject area communities should exist for all OECD subject areas
+
+    if hasattr(metadata, "subjects"):
+        for subject in metadata.subjects:
+            subject_name = subject.get("subject", "")
+            slug = string_to_slug(subject_name)
+            if slug in COMMUNITY_TRANSLATIONS:
+                slug = COMMUNITY_TRANSLATIONS[slug]
+
+            community_id = search_by_slug(slug, "topic", host, token)
+            if community_id:
+                record = add_record_to_community(record, host, token, community_id)
+
+    # Add record to communities defined as IsPartOf relation in InvenioRDM RelatedIdentifiers
+    if hasattr(metadata, "related_identifiers") and metadata.related_identifiers:
+        for identifier in metadata.related_identifiers:
+            if py_.get(identifier, "relation_type.id") == "ispartof" and identifier.get(
+                "identifier", ""
+            ).startswith(f"https://{host}/api/communities/"):
+                slug = identifier.get("identifier").split("/")[5]
+                community_id = search_by_slug(slug, "topic", host, token)
+                if community_id:
+                    record = add_record_to_community(record, host, token, community_id)
+
+    return record
+
+
+def update_external_services(
+    metadata: Commonmeta, host: str, token: str, record: dict, **kwargs
+) -> dict:
+    """Update external services with changes in InvenioRDM"""
+
+    # optionally update rogue-scholar legacy record
+    if host == "rogue-scholar.org" and kwargs.get("legacy_key", None) is not None:
+        record = update_legacy_record(
+            record, legacy_key=kwargs.get("legacy_key"), field="rid"
+        )
+
+    return record
+
+
 def search_by_doi(doi, host, token) -> Optional[str]:
     """Search for a record by DOI in InvenioRDM"""
     headers = {
@@ -539,7 +577,9 @@ def create_draft_record(record, host, token, output):
             record["status"] = "failed_rate_limited"
             return record
         if response.status_code != 201:
-            logger.error(f"Failed to create draft record: {response.status_code} - {response.json()}")
+            logger.error(
+                f"Failed to create draft record: {response.status_code} - {response.json()}"
+            )
             record["status"] = "failed_create_draft"
             return record
         data = response.json()
@@ -570,7 +610,9 @@ def edit_published_record(record, host, token):
         record["status"] = "edited"
         return record
     except requests.exceptions.RequestException as e:
-        logger.error(f"Error creating draft from published record: {str(e)}", exc_info=True)
+        logger.error(
+            f"Error creating draft from published record: {str(e)}", exc_info=True
+        )
         record["status"] = "error_edit_published_record"
         return record
 
@@ -616,12 +658,14 @@ def publish_draft_record(record, host, token):
             record["status"] = "failed_rate_limited"
             return record
         if response.status_code != 202:
-            logger.error(f"Failed to publish draft record: {response.status_code} - {response.json()}")
+            logger.error(
+                f"Failed to publish draft record: {response.status_code} - {response.json()}"
+            )
             record["status"] = "error_publish_draft_record"
             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["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"
@@ -651,7 +695,7 @@ def add_record_to_community(record, host, token, community_id):
         return record
 
 
-def update_legacy_record(record, legacy_key: str, field:str=None) -> dict:
+def update_legacy_record(record, legacy_key: str, field: str = None) -> dict:
     """Update corresponding record in Rogue Scholar legacy database."""
 
     legacy_host = "bosczcmeodcrajtcaddf.supabase.co"
@@ -677,8 +721,8 @@ 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")}")
-            return record # nothing to update
+            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']}"
         headers = {
@@ -700,7 +744,7 @@ def update_legacy_record(record, legacy_key: str, field:str=None) -> dict:
         return record
 
 
-def search_by_slug(slug, type_value, host, token) -> Optional[str]:
+def search_by_slug(slug: str, type_value: str, host: str, token: str) -> Optional[str]:
     """Search for a community by slug in InvenioRDM"""
     headers = {
         "Authorization": f"Bearer {token}",

{commonmeta_py-0.123.dist-info → commonmeta_py-0.125.dist-info}/METADATA

@@ -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.dist-info → commonmeta_py-0.125.dist-info}/RECORD

@@ -1,5 +1,5 @@
-commonmeta/__init__.py,sha256=X_mzqU-r9CtyULs66FmHskXoSh9s5lyZVR2mmzTOoV0,2098
-commonmeta/api_utils.py,sha256=y5KLfIOWOjde7LXZ36u-eneQJ-Q53yXUZg3hWpCBS2E,2685
+commonmeta/__init__.py,sha256=kDEzO2vW7BmMnXyZBc8T6XAN6gxwn0MRTRDOeTYdME8,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=90aTe47d071wHxwcNsOqU5lSVPKP8wAPnPHhddj3Fuo,18443
+commonmeta/schema_utils.py,sha256=zn3gqAHciUOQmrw9okR68weFs-yqPPyORFt-Zl1D3Lw,1924
 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
@@ -77,14 +77,14 @@ commonmeta/writers/__init__.py,sha256=47-snms6xBHkoEXKYV1DBtH1npAtlVtvY29Z4Zr45q
 commonmeta/writers/bibtex_writer.py,sha256=doAdyl1NEp60mPkHPo3GMH8B-HA6MzLAdlyNsIecTzU,4972
 commonmeta/writers/citation_writer.py,sha256=qs_4X3BjrSqHexmJFPvPDTp0mRIqzb0F70_Wuc7S9x0,2343
 commonmeta/writers/commonmeta_writer.py,sha256=QpfyhG__7o_XpsOTCPWxGymO7YKwZi2LQh8Zic44bdc,1365
-commonmeta/writers/crossref_xml_writer.py,sha256=cGrX9vacNwDdK7TbH1RWig68SH8hg5VusuqkI9gU1DY,33931
+commonmeta/writers/crossref_xml_writer.py,sha256=rcPOfrGxU4mX7_fFywYWDW2FFUoKW9wD-JzW8nX1ipI,33915
 commonmeta/writers/csl_writer.py,sha256=4gDYs1EzK4_L2UIRTfs25wgHmYRwdRP2zmfxF9387oU,2779
 commonmeta/writers/datacite_writer.py,sha256=bcinpwhq7XnVthKHH8-sdXA34dSlvFH4ImYH768iaQU,6428
-commonmeta/writers/inveniordm_writer.py,sha256=Bm0gSNndX-jbGwd0O162Bq_C97QNegRZbTdP_tXxzVc,25772
+commonmeta/writers/inveniordm_writer.py,sha256=ARNssMUhwckAGwzz2ugJoLjVSTezbyLrK2c-utdmins,26795
 commonmeta/writers/ris_writer.py,sha256=3SdyEvMRaPRP1SV1MB-MXBlunE7x6og7RF1zuWtetPc,2094
 commonmeta/writers/schema_org_writer.py,sha256=s18_x0ReXwAGBoEAwp2q-HCgFQ-h5qRg6JyAlqCoSFE,5871
-commonmeta_py-0.123.dist-info/METADATA,sha256=-lwvx310XyyLy8ZHJfrkraQmCdbf7kao6vsnwyX57e4,7656
-commonmeta_py-0.123.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-commonmeta_py-0.123.dist-info/entry_points.txt,sha256=U4w4BoRuS3rN5t5Y-uYSyOeU5Lh_VRVMS9OIDzIgw4w,50
-commonmeta_py-0.123.dist-info/licenses/LICENSE,sha256=wsIvxF9Q9GC9vA_s79zTWP3BkXJdfUNRmALlU8GbW1s,1074
-commonmeta_py-0.123.dist-info/RECORD,,
+commonmeta_py-0.125.dist-info/METADATA,sha256=x7HcPVeiOM03np_p5URA_xH84RGt-8HO7tF3oV7xoB4,7656
+commonmeta_py-0.125.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+commonmeta_py-0.125.dist-info/entry_points.txt,sha256=U4w4BoRuS3rN5t5Y-uYSyOeU5Lh_VRVMS9OIDzIgw4w,50
+commonmeta_py-0.125.dist-info/licenses/LICENSE,sha256=wsIvxF9Q9GC9vA_s79zTWP3BkXJdfUNRmALlU8GbW1s,1074
+commonmeta_py-0.125.dist-info/RECORD,,