commonmeta-py 0.100__py3-none-any.whl → 0.103__py3-none-any.whl

commonmeta/metadata.py

@@ -1,56 +1,61 @@
 """Metadata"""
 
 from os import path
-import orjson as json
 from typing import Optional, Union
+
+import orjson as json
 import yaml
 from pydash import py_
 
+from .base_utils import parse_xml, wrap
+from .constants import CM_TO_CR_TRANSLATIONS
+from .doi_utils import doi_from_url
+from .readers.cff_reader import get_cff, read_cff
+from .readers.codemeta_reader import (
+    get_codemeta,
+    read_codemeta,
+)
+from .readers.commonmeta_reader import read_commonmeta
 from .readers.crossref_reader import (
     get_crossref,
     read_crossref,
 )
-from .readers.datacite_reader import (
-    get_datacite,
-    read_datacite,
-)
-from .readers.datacite_xml_reader import read_datacite_xml
 from .readers.crossref_xml_reader import (
     get_crossref_xml,
     read_crossref_xml,
 )
-from .readers.schema_org_reader import (
-    get_schema_org,
-    read_schema_org,
-)
-from .readers.codemeta_reader import (
-    get_codemeta,
-    read_codemeta,
-)
 from .readers.csl_reader import read_csl
-from .readers.cff_reader import get_cff, read_cff
-from .readers.json_feed_reader import get_json_feed_item, read_json_feed_item
+from .readers.datacite_reader import (
+    get_datacite,
+    read_datacite,
+)
+from .readers.datacite_xml_reader import read_datacite_xml
 from .readers.inveniordm_reader import (
     get_inveniordm,
     read_inveniordm,
 )
+from .readers.json_feed_reader import get_json_feed_item, read_json_feed_item
 from .readers.kbase_reader import read_kbase
-from .readers.commonmeta_reader import read_commonmeta
+from .readers.openalex_reader import (
+    get_openalex,
+    read_openalex,
+)
 from .readers.ris_reader import read_ris
-from .writers.datacite_writer import write_datacite
+from .readers.schema_org_reader import (
+    get_schema_org,
+    read_schema_org,
+)
+from .schema_utils import json_schema_errors
+from .utils import find_from_format, normalize_id
 from .writers.bibtex_writer import write_bibtex, write_bibtex_list
 from .writers.citation_writer import write_citation, write_citation_list
+from .writers.commonmeta_writer import write_commonmeta, write_commonmeta_list
 from .writers.crossref_xml_writer import write_crossref_xml, write_crossref_xml_list
 from .writers.csl_writer import write_csl, write_csl_list
+from .writers.datacite_writer import write_datacite
+from .writers.inveniordm_writer import write_inveniordm
 from .writers.ris_writer import write_ris, write_ris_list
 from .writers.schema_org_writer import write_schema_org
-from .writers.commonmeta_writer import write_commonmeta, write_commonmeta_list
-from .writers.inveniordm_writer import write_inveniordm
-from .utils import normalize_id, find_from_format
-from .base_utils import parse_xml, wrap
-from .doi_utils import doi_from_url
-from .schema_utils import json_schema_errors
-from .constants import CM_TO_CR_TRANSLATIONS
 
 
 # pylint: disable=R0902
@@ -122,35 +127,68 @@ class Metadata:
         )
 
     def get_metadata(self, pid, string) -> dict:
+        """Get metadata from various sources based on pid or string input."""
         via = self.via
+
+        # Handle pid-based metadata retrieval
         if pid is not None:
-            if via == "schema_org":
-                return get_schema_org(pid)
-            elif via == "datacite":
-                return get_datacite(pid)
-            elif via in ["crossref", "op"]:
-                return get_crossref(pid)
-            elif via == "crossref_xml":
-                return get_crossref_xml(pid)
-            elif via == "codemeta":
-                return get_codemeta(pid)
-            elif via == "cff":
-                return get_cff(pid)
-            elif via == "json_feed_item":
-                return get_json_feed_item(pid)
-            elif via == "inveniordm":
-                return get_inveniordm(pid)
+            return self._get_metadata_from_pid(pid, via)
+        # Handle string-based metadata parsing
         elif string is not None:
+            return self._get_metadata_from_string(string, via)
+
+        # Default fallback
+        raise ValueError("No metadata found")
+
+    def _get_metadata_from_pid(self, pid, via) -> dict:
+        """Helper method to get metadata from a PID."""
+        if via == "schema_org":
+            return get_schema_org(pid)
+        elif via == "datacite":
+            return get_datacite(pid)
+        elif via in ["crossref", "op"]:
+            return get_crossref(pid)
+        elif via == "crossref_xml":
+            return get_crossref_xml(pid)
+        elif via == "codemeta":
+            return get_codemeta(pid)
+        elif via == "cff":
+            return get_cff(pid)
+        elif via == "json_feed_item":
+            return get_json_feed_item(pid)
+        elif via == "inveniordm":
+            return get_inveniordm(pid)
+        elif via == "openalex":
+            return get_openalex(pid)
+        else:
+            return {"pid": pid}
+
+    def _get_metadata_from_string(self, string, via) -> dict:
+        """Helper method to get metadata from a string."""
+        try:
+            # XML formats
             if via == "datacite_xml":
-                return parse_xml(string)
+                result = parse_xml(string)
+                if isinstance(result, (dict, list)):
+                    return (
+                        dict(result) if isinstance(result, dict) else {"items": result}
+                    )
+                return {}
             elif via == "crossref_xml":
-                return parse_xml(string, dialect="crossref")
+                result = parse_xml(string, dialect="crossref")
+                if isinstance(result, (dict, list)):
+                    return (
+                        dict(result) if isinstance(result, dict) else {"items": result}
+                    )
+                return {}
+            # YAML and other plain text formats
             elif via == "cff":
-                return yaml.safe_load(string)
+                return dict(yaml.safe_load(string) or {})
             elif via == "bibtex":
                 raise ValueError("Bibtex not supported")
             elif via == "ris":
-                return string
+                return {"data": string}
+            # JSON-based formats
             elif via in [
                 "commonmeta",
                 "crossref",
@@ -165,81 +203,152 @@ class Metadata:
                 return json.loads(string)
             else:
                 raise ValueError("No input format found")
-        else:
-            raise ValueError("No metadata found")
+        except (TypeError, json.JSONDecodeError) as error:
+            return {"error": str(error)}
 
     def read_metadata(self, data: dict, **kwargs) -> dict:
-        """get_metadata"""
-        via = isinstance(data, dict) and data.get("via", None) or self.via
+        """Read and parse metadata from various formats."""
+        via = (isinstance(data, dict) and data.get("via")) or self.via
+
+        # All these reader methods should return a dict,
+        # even though some may return Commonmeta objects that can be treated as dicts
         if via == "commonmeta":
-            return read_commonmeta(data, **kwargs)
+            return dict(read_commonmeta(data, **kwargs))
         elif via == "schema_org":
-            return read_schema_org(data)
+            return dict(read_schema_org(data))
         elif via == "datacite":
-            return read_datacite(data)
+            return dict(read_datacite(data))
         elif via == "datacite_xml":
-            return read_datacite_xml(data)
+            return dict(read_datacite_xml(data))
         elif via in ["crossref", "op"]:
-            return read_crossref(data)
+            return dict(read_crossref(data))
         elif via == "crossref_xml":
-            return read_crossref_xml(data)
+            return dict(read_crossref_xml(data))
         elif via == "csl":
-            return read_csl(data, **kwargs)
+            return dict(read_csl(data, **kwargs))
         elif via == "codemeta":
-            return read_codemeta(data)
+            return dict(read_codemeta(data))
         elif via == "cff":
-            return read_cff(data)
+            return dict(read_cff(data))
         elif via == "json_feed_item":
-            return read_json_feed_item(data, **kwargs)
+            return dict(read_json_feed_item(data, **kwargs))
         elif via == "inveniordm":
-            return read_inveniordm(data)
+            return dict(read_inveniordm(data))
         elif via == "kbase":
-            return read_kbase(data)
+            return dict(read_kbase(data))
+        elif via == "openalex":
+            return read_openalex(data)
         elif via == "ris":
-            return read_ris(data)
+            return dict(read_ris(data["data"] if isinstance(data, dict) else data))
         else:
             raise ValueError("No input format found")
 
     def write(self, to: str = "commonmeta", **kwargs) -> str:
-        """convert metadata into different formats"""
+        """Convert metadata into different formats."""
         try:
-            if to == "commonmeta":
-                return write_commonmeta(self)
-            elif to == "bibtex":
-                return write_bibtex(self)
-            elif to == "csl":
-                instance = py_.omit(json.loads(write_csl(self)), [])
-                self.errors = json_schema_errors(instance, schema="csl")
-                return write_csl(self)
-            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)
-            elif to == "schema_org":
-                return write_schema_org(self)
-            elif to == "inveniordm":
-                return write_inveniordm(self)
-            elif to == "datacite":
-                instance = json.loads(write_datacite(self))
-                self.write_errors = json_schema_errors(instance, schema="datacite")
-                print(self.write_errors)
-                return write_datacite(self)
-            elif to == "crossref_xml":
-                doi = doi_from_url(self.id)
-                _type = CM_TO_CR_TRANSLATIONS.get(self.type, None)
-                url = self.url
-                instance = {"doi": doi, "type": _type, "url": url}
-                self.depositor = kwargs.get("depositor", None)
-                self.email = kwargs.get("email", None)
-                self.registrant = kwargs.get("registrant", None)
-                self.write_errors = json_schema_errors(instance, schema="crossref")
-                return write_crossref_xml(self)
-            else:
-                raise ValueError("No output format found")
-        except json.JSONDecodeError:
-            raise ValueError("Invalid JSON")
+            result = self._write_format(to, **kwargs)
+            if result is None or result == "":
+                return "{}"
+            return result
+        except json.JSONDecodeError as e:
+            # More specific error message including the original JSONDecodeError details
+            raise ValueError(f"Invalid JSON: {str(e)}")
+
+    def _write_format(self, to: str, **kwargs) -> str:
+        """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."""
+        if to == "commonmeta":
+            result = write_commonmeta(self)
+        elif to == "datacite":
+            result = write_datacite(self)
+        elif to == "inveniordm":
+            result = write_inveniordm(self)
+        elif to == "schema_org":
+            result = write_schema_org(self)
+        else:
+            return "{}"
+
+        if isinstance(result, str):
+            # Verify it's valid JSON
+            try:
+                json.loads(result)
+                return result
+            except json.JSONDecodeError:
+                return "{}"
+        elif result is not None:
+            try:
+                decoded = result.decode("utf-8")
+                # Verify it's valid JSON
+                json.loads(decoded)
+                return decoded
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                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)
+        if csl_output:
+            instance = py_.omit(json.loads(csl_output), [])
+            self.errors = json_schema_errors(instance, schema="csl")
+            return csl_output
+        return ""
+
+    def _write_datacite(self) -> str:
+        """Write in DataCite format with error checking."""
+        datacite_output = write_datacite(self)
+        if not datacite_output:
+            return ""
+        try:
+            instance = json.loads(datacite_output)
+            self.write_errors = json_schema_errors(instance, schema="datacite")
+            return str(datacite_output)
+        except (json.JSONDecodeError, TypeError):
+            return "{}" if not datacite_output else str(datacite_output)
+
+    def _write_crossref_xml(self, **kwargs) -> str:
+        """Write in Crossref XML format with error checking."""
+        doi = doi_from_url(self.id)
+        _type = CM_TO_CR_TRANSLATIONS.get(str(self.type or ""), None)
+        url = self.url
+        instance = {"doi": doi, "type": _type, "url": url}
+        self.depositor = kwargs.get("depositor", None)
+        self.email = kwargs.get("email", None)
+        self.registrant = kwargs.get("registrant", None)
+        self.write_errors = json_schema_errors(instance, schema="crossref")
+        result = write_crossref_xml(self)
+        return result if result is not None else ""
 
 
 class MetadataList:

commonmeta/readers/cff_reader.py

@@ -1,4 +1,5 @@
 """cff reader for commonmeta-py"""
+
 from typing import Optional
 from urllib.parse import urlparse
 import httpx

commonmeta/readers/codemeta_reader.py

@@ -1,4 +1,5 @@
 """codemeta reader for commonmeta-py"""
+
 from typing import Optional
 from collections import defaultdict
 import httpx

commonmeta/readers/commonmeta_reader.py

@@ -1,4 +1,5 @@
 """Commonmeta reader for commonmeta-py"""
+
 from ..constants import Commonmeta
 
 

commonmeta/readers/crossref_reader.py

@@ -1,32 +1,33 @@
 """crossref reader for commonmeta-py"""
 
 from typing import Optional
+
 import httpx
 from pydash import py_
 
-from ..utils import (
-    dict_to_spdx,
-    normalize_cc_url,
-    normalize_url,
-    normalize_doi,
-    normalize_issn,
-    issn_as_url,
-)
-from ..base_utils import wrap, compact, presence, sanitize, parse_attributes
 from ..author_utils import get_authors
+from ..base_utils import compact, parse_attributes, presence, sanitize, wrap
+from ..constants import (
+    CR_TO_CM_CONTAINER_TRANSLATIONS,
+    CR_TO_CM_TRANSLATIONS,
+    CROSSREF_CONTAINER_TYPES,
+    Commonmeta,
+)
 from ..date_utils import get_date_from_date_parts
 from ..doi_utils import (
-    doi_as_url,
-    doi_from_url,
-    crossref_api_url,
     crossref_api_query_url,
     crossref_api_sample_url,
+    crossref_api_url,
+    doi_as_url,
+    validate_doi,
 )
-from ..constants import (
-    CR_TO_CM_TRANSLATIONS,
-    CR_TO_CM_CONTAINER_TRANSLATIONS,
-    CROSSREF_CONTAINER_TYPES,
-    Commonmeta,
+from ..utils import (
+    dict_to_spdx,
+    issn_as_url,
+    normalize_cc_url,
+    normalize_doi,
+    normalize_issn,
+    normalize_url,
 )
 
 
@@ -41,7 +42,7 @@ def get_crossref_list(query: dict, **kwargs) -> list[dict]:
 
 def get_crossref(pid: str, **kwargs) -> dict:
     """get_crossref"""
-    doi = doi_from_url(pid)
+    doi = validate_doi(pid)
     if doi is None:
         return {"state": "not_found"}
     url = crossref_api_url(doi)

commonmeta/readers/csl_reader.py

@@ -1,4 +1,5 @@
 """CSL-JSON reader for commonmeta-py"""
+
 from ..utils import dict_to_spdx, from_csl, normalize_id, name_to_fos, issn_as_url
 from ..base_utils import wrap, compact, sanitize, presence
 from ..author_utils import get_authors
@@ -18,7 +19,9 @@ def read_csl(data: dict, **kwargs) -> Commonmeta:
 
     read_options = kwargs or {}
 
-    _id = normalize_id(meta.get("id", None) or meta.get("DOI", None)) or meta.get("id", None)
+    _id = normalize_id(meta.get("id", None) or meta.get("DOI", None)) or meta.get(
+        "id", None
+    )
     _type = CSL_TO_CM_TRANSLATIONS.get(meta.get("type", None), "Other")
 
     # optionally generate a DOI if missing but a DOI prefix is provided

commonmeta/readers/inveniordm_reader.py

@@ -188,17 +188,22 @@ def get_funding_references(funding_references: list) -> list:
     def map_funding(funding: dict) -> dict:
         """map_funding"""
 
-        return compact({
-            "funderName": py_.get(funding, "funder.name"),
-            "funderIdentifier": py_.get(funding, "funder.id"),
-            "funderIdentifierType": "ROR" if validate_ror(py_.get(funding, "funder.id")) else None,
-            "awardTitle": py_.get(funding, "award.title.en"),
-            "awardNumber": py_.get(funding, "award.number"),
-            "awardUri": py_.get(funding, "award.identifiers[0].identifier"),
-        })
-    
+        return compact(
+            {
+                "funderName": py_.get(funding, "funder.name"),
+                "funderIdentifier": py_.get(funding, "funder.id"),
+                "funderIdentifierType": "ROR"
+                if validate_ror(py_.get(funding, "funder.id"))
+                else None,
+                "awardTitle": py_.get(funding, "award.title.en"),
+                "awardNumber": py_.get(funding, "award.number"),
+                "awardUri": py_.get(funding, "award.identifiers[0].identifier"),
+            }
+        )
+
     return [map_funding(i) for i in funding_references]
 
+
 def get_file(file: dict) -> str:
     """get_file"""
     _type = file.get("type", None)

commonmeta/readers/json_feed_reader.py

@@ -206,7 +206,7 @@ def get_funding_references(meta: Optional[dict]) -> Optional[list]:
 
     if meta is None or not isinstance(meta, dict):
         return None
-    
+
     def format_funding(urls: list) -> list:
         """format funding. URLs can either be a list of grant IDs or a funder identifier
         (Open Funder Registry ID or ROR), followed by a grant URL"""
@@ -288,6 +288,7 @@ def get_funding_references(meta: Optional[dict]) -> Optional[list]:
             if i.get("type", None) == "HasAward"
         ]
     )
+
     def format_funding_reference(funding: dict) -> dict:
         """format funding reference. Make sure award URI is either a DOI or URL"""
 
@@ -311,10 +312,15 @@ def get_funding_references(meta: Optional[dict]) -> Optional[list]:
                 "awardUri": award_uri,
             }
         )
+
     funding_references = py_.get(meta, "funding_references")
     if funding_references is not None:
-        awards += [format_funding_reference(i) for i in funding_references if i.get("funderName", None)]
-    
+        awards += [
+            format_funding_reference(i)
+            for i in funding_references
+            if i.get("funderName", None)
+        ]
+
     awards += wrap(py_.get(meta, "blog.funding"))
     return py_.uniq(awards)
 

commonmeta/readers/kbase_reader.py

@@ -1,4 +1,5 @@
 """kbase reader for Commonmeta"""
+
 from pydash import py_
 
 from ..utils import normalize_url, normalize_doi, from_curie, from_kbase