commonmeta-py 0.16.9__tar.gz → 0.17__tar.gz

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: commonmeta-py
-Version: 0.16.9
+Version: 0.17
 Summary: Library for conversions to/from the Commonmeta scholarly metadata format
 Home-page: https://python.commonmeta.org
 License: MIT

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/author_utils.py

@@ -119,8 +119,7 @@ def get_one_author(author, **kwargs):
             "name": name if _type == "Organization" else None,
             "givenName": given_name if _type == "Person" else None,
             "familyName": family_name if _type == "Person" else None,
-            "affiliation": presence(
-                get_affiliations(wrap(author.get("affiliation", None)))
+            "affiliation": presence(get_affiliations(wrap(author.get("affiliation", None)))
             ),
         }
     )

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/constants.py

@@ -16,7 +16,7 @@ class Commonmeta(TypedDict):
     subjects: Optional[List[dict]]
     contributors: Optional[List[dict]]
     language: Optional[str]
-    alternate_identifiers: Optional[List[dict]]
+    identifiers: Optional[List[dict]]
     relations: Optional[List[dict]]
     sizes: Optional[List[dict]]
     formats: Optional[List[dict]]
@@ -30,7 +30,6 @@ class Commonmeta(TypedDict):
     files: Optional[List[dict]]
     agency: Optional[str]
     state: str
-    schema_version: Optional[str]
 
 
 # source: https://www.bibtex.com/e/entry-types/

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/crossref_utils.py

@@ -430,29 +430,29 @@ def insert_institution(metadata, xml):
 
 def insert_item_number(metadata, xml):
     """Insert item number"""
-    if metadata.alternate_identifiers is None:
+    if metadata.identifiers is None:
         return xml
-    for alternate_identifier in metadata.alternate_identifiers:
-        if alternate_identifier.get("alternateIdentifier", None) is None:
+    for identifier in metadata.identifiers:
+        if identifier.get("identifier", None) is None:
             continue
-        if alternate_identifier.get("alternateIdentifierType", None) is not None:
+        if identifier.get("identifierType", None) is not None:
             # strip hyphen from UUIDs, as item_number can only be 32 characters long (UUIDv4 is 36 characters long)
-            if alternate_identifier.get("alternateIdentifierType", None) == "UUID":
-                alternate_identifier["alternateIdentifier"] = alternate_identifier.get(
-                    "alternateIdentifier", ""
+            if identifier.get("identifierType", None) == "UUID":
+                identifier["identifier"] = identifier.get(
+                    "identifier", ""
                 ).replace("-", "")
             etree.SubElement(
                 xml,
                 "item_number",
                 {
-                    "item_number_type": alternate_identifier.get(
-                        "alternateIdentifierType", ""
+                    "item_number_type": identifier.get(
+                        "identifierType", ""
                     ).lower()
                 },
-            ).text = alternate_identifier.get("alternateIdentifier", None)
+            ).text = identifier.get("identifier", None)
         else:
-            etree.SubElement(xml, "item_number").text = alternate_identifier.get(
-                "alternateIdentifier", None
+            etree.SubElement(xml, "item_number").text = identifier.get(
+                "identifier", None
             )
     return xml
 

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/metadata.py

@@ -79,35 +79,32 @@ class Metadata:
         # required properties
         self.id = meta.get("id")  # pylint: disable=C0103
         self.type = meta.get("type")
+        # recommended and optional properties
         self.url = meta.get("url")
         self.contributors = meta.get("contributors")
         self.titles = meta.get("titles")
         self.publisher = meta.get("publisher")
         self.date = meta.get("date")
-        # recommended and optional properties
-        self.additional_type = meta.get("additional_type")
+        self.additional_type = meta.get("additionalType")
         self.subjects = meta.get("subjects")
         self.language = meta.get("language")
-        self.alternate_identifiers = meta.get("alternate_identifiers")
+        self.identifiers = meta.get("identifiers")
         self.relations = meta.get("relations")
-        self.sizes = meta.get("sizes")
-        self.formats = meta.get("formats")
         self.version = meta.get("version")
         self.license = meta.get("license")
         self.descriptions = meta.get("descriptions")
-        self.geo_locations = meta.get("geo_locations")
-        self.funding_references = meta.get("funding_references")
+        self.geo_locations = meta.get("geoLocations")
+        self.funding_references = meta.get("fundingReferences")
         self.references = meta.get("references")
+        self.files = meta.get("files")
+        self.container = meta.get("container")
+        self.provider = meta.get("provider")
+        self.archive_locations = meta.get("archiveLocations")
         # other properties
         self.date_created = meta.get("date_created")
         self.date_registered = meta.get("date_registered")
         self.date_published = meta.get("date_published")
         self.date_updated = meta.get("date_updated")
-        self.files = meta.get("files")
-        self.container = meta.get("container")
-        self.provider = meta.get("provider")
-        self.schema_version = meta.get("schema_version")
-        self.archive_locations = meta.get("archive_locations")
         self.state = meta.get("state")
 
         # Catch errors in the reader, then validate against JSON schema for Commonmeta
@@ -222,6 +219,7 @@ class Metadata:
             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)

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/readers/cff_reader.py

@@ -80,7 +80,7 @@ def read_cff(data: Optional[dict], **kwargs) -> Commonmeta:
         descriptions = [
             {
                 "description": sanitize(meta.get("abstract")),
-                "descriptionType": "Abstract",
+                "type": "Abstract",
             }
         ]
     else:

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/readers/crossref_reader.py

@@ -18,8 +18,6 @@ from ..date_utils import get_date_from_date_parts
 from ..doi_utils import (
     doi_as_url,
     doi_from_url,
-    # get_doi_ra,
-    # get_crossref_member,
     crossref_api_url,
     crossref_api_query_url,
     crossref_api_sample_url,
@@ -113,7 +111,7 @@ def read_crossref(data: Optional[dict], **kwargs) -> Commonmeta:
     description = meta.get("abstract", None)
     if description is not None:
         descriptions = [
-            {"description": sanitize(description), "descriptionType": "Abstract"}
+            {"description": sanitize(description), "type": "Abstract"}
         ]
     else:
         descriptions = None
@@ -124,43 +122,38 @@ def read_crossref(data: Optional[dict], **kwargs) -> Commonmeta:
             for i in wrap(meta.get("subject", None) or meta.get("group-title", None))
         ]
     )
-    files = [
+    files = py_.uniq([
         get_file(i)
         for i in wrap(meta.get("link", None))
         if i["content-type"] != "unspecified"
-    ]
-
-    state = "findable" if meta or read_options else "not_found"
+    ])
 
     return {
         # required properties
         "id": _id,
         "type": _type,
+        # recommended and optional properties
         "url": url,
         "contributors": presence(contributors),
         "titles": presence(titles),
         "publisher": presence(publisher),
         "date": presence(date),
-        # recommended and optional properties
-        "additional_type": None,
+        "additionalType": None,
         "subjects": presence(subjects),
         "language": meta.get("language", None),
-        "alternate_identifiers": None,
+        "identifiers": None,
         "sizes": None,
         "formats": None,
         "version": meta.get("version", None),
         "license": license_,
         "descriptions": descriptions,
-        "geo_locations": None,
-        "funding_references": presence(funding_references),
+        "geoLocations": None,
+        "fundingReferences": presence(funding_references),
         "references": presence(references),
         "relations": presence(relations),
-        # other properties
         "files": presence(files),
         "container": presence(container),
-        "provider": "Crossref",  # get_doi_ra(_id),
-        "state": state,
-        "schema_version": None,
+        "provider": "Crossref",
     } | read_options
 
 
@@ -203,7 +196,7 @@ def get_reference(reference: Optional[dict]) -> Optional[dict]:
     doi = reference.get("DOI", None)
     metadata = {
         "key": reference.get("key", None),
-        "doi": normalize_doi(doi) if doi else None,
+        "id": normalize_doi(doi) if doi else None,
         "contributor": reference.get("author", None),
         "title": reference.get("article-title", None),
         "publisher": reference.get("publisher", None),
@@ -214,7 +207,7 @@ def get_reference(reference: Optional[dict]) -> Optional[dict]:
         "lastPage": reference.get("last-page", None),
         "containerTitle": reference.get("journal-title", None),
         "edition": None,
-        "unstructured": reference.get("unstructured", None) if doi is None else None,
+        "unstructured": reference.get("unstructured", None),
     }
     return compact(metadata)
 
@@ -367,7 +360,7 @@ def from_crossref_funding(funding_references: list) -> list:
     """Get funding references from Crossref"""
     formatted_funding_references = []
     for funding in funding_references:
-        funding_reference = compact(
+        f = compact(
             {
                 "funderName": funding.get("name", None),
                 "funderIdentifier": doi_as_url(funding["DOI"])
@@ -378,18 +371,18 @@ def from_crossref_funding(funding_references: list) -> list:
                 else None,
             }
         )
-        funding_reference = py_.omit(funding_reference, "DOI", "doi-asserted-by")
+        f = py_.omit(f, "DOI", "doi-asserted-by")
         if (
             funding.get("name", None) is not None
             and funding.get("award", None) is not None
         ):
             for award in wrap(funding["award"]):
-                fund_ref = funding_reference.copy()
+                fund_ref = f.copy()
                 fund_ref["awardNumber"] = award
                 formatted_funding_references.append(fund_ref)
-        elif funding_reference != {}:
-            formatted_funding_references.append(funding_reference)
-    return formatted_funding_references
+        elif f != {}:
+            formatted_funding_references.append(f)
+    return py_.uniq(formatted_funding_references)
 
 
 def get_random_crossref_id(number: int = 1, **kwargs) -> list:

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/readers/datacite_reader.py

@@ -82,13 +82,23 @@ def read_datacite(data: dict, **kwargs) -> Commonmeta:
         license_ = dict_to_spdx({"url": license_}) if license_ else None
 
     files = [get_file(i) for i in wrap(meta.get("content_url"))]
+    
+    identifiers = get_identifiers(wrap(meta.get("alternateIdentifiers", None)))
     references = get_references(
         wrap(meta.get("relatedItems", None) or meta.get("relatedIdentifiers", None))
     )
     relations = get_relations(wrap(meta.get("relatedIdentifiers", None)))
     descriptions = get_descriptions(wrap(meta.get("descriptions", None)))
     geo_locations = get_geolocation(wrap(meta.get("geoLocations", None)))
-    formats = py_.uniq(meta.get("formats", None))
+
+    def format_subject(subject):
+        """format_subject"""
+        return compact({
+            "subject": subject.get("subject", None),
+            "language": subject.get("lang", None),
+        })
+
+    subjects = py_.uniq([format_subject(i) for i in wrap(meta.get("subjects", None))])
 
     return {
         # required properties
@@ -101,28 +111,60 @@ def read_datacite(data: dict, **kwargs) -> Commonmeta:
         "publisher": publisher,
         "date": compact(date),
         # recommended and optional properties
-        "additional_type": additional_type,
-        "subjects": presence(meta.get("subjects", None)),
+        "additionalType": additional_type,
+        "subjects": presence(subjects),
         "language": meta.get("language", None),
-        "alternate_identifiers": presence(meta.get("alternateIdentifiers", None)),
-        "sizes": presence(meta.get("sizes", None)),
-        "formats": presence(formats),
+        "identifiers": presence(identifiers),
         "version": meta.get("version", None),
         "license": presence(license_),
         "descriptions": descriptions,
-        "geo_locations": presence(geo_locations),
-        "funding_references": presence(meta.get("fundingReferences", None)),
+        "geoLocations": presence(geo_locations),
+        "fundingReferences": presence(meta.get("fundingReferences", None)),
         "references": presence(references),
         "relations": presence(relations),
         # other properties
         "files": presence(files),
         "container": presence(container),
         "provider": "DataCite",
-        "state": "findable",
-        "schema_version": meta.get("schemaVersion", None),
     } | read_options
 
 
+def get_identifiers(identifiers: list) -> list:
+    """get_identifiers"""
+    
+    def is_identifier(identifier):
+        """supported identifier types"""
+        return identifier.get("identifierType", None) in [
+                "ARK",
+                "arXiv",
+                "Bibcode",
+                "DOI",
+                "Handle",
+                "ISBN",
+                "ISSN",
+                "PMID",
+                "PMCID",
+                "PURL",
+                "URL",
+                "URN",
+                "Other"
+            ]
+        
+    def format_identifier(identifier):
+        """format_identifier"""
+        if is_identifier(identifier):
+            type_ = identifier.get("identifierType")
+        else:
+            type_ = "Other"
+            
+        return compact(
+            {
+                "identifier": identifier.get("alternateIdentifier", None),
+                "identifierType": type_,
+            }
+        )
+    return [format_identifier(i) for i in wrap(identifiers)]
+    
 def get_references(references: list) -> list:
     """get_references"""
 
@@ -181,9 +223,7 @@ def get_relations(relations: list) -> list:
             }
         )
 
-    return [
-        map_relation(i) for i in relations if is_relation(i)
-    ]
+    return [map_relation(i) for i in relations if is_relation(i)]
 
 
 def get_file(file: str) -> dict:

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/readers/datacite_xml_reader.py

@@ -72,13 +72,13 @@ def read_datacite_xml(data: dict, **kwargs) -> Commonmeta:
     def format_description(description):
         """format_description"""
         if isinstance(description, str):
-            return {"description": description, "descriptionType": "Abstract"}
+            return {"description": description, "type": "Abstract"}
         if isinstance(description, dict):
             return compact(
                 {
                     "description": sanitize(description.get("#text", None)),
-                    "descriptionType": description.get("descriptionType", "Abstract"),
-                    "lang": description.get("xml:lang", None),
+                    "type": description.get("descriptionType", "Abstract"),
+                    "language": description.get("xml:lang", None),
                 }
             )
         return None
@@ -167,18 +167,6 @@ def read_datacite_xml(data: dict, **kwargs) -> Commonmeta:
 
     geo_locations = []  # [format_geo_location(i) for i in wrap(py_.get(meta, "geoLocations.geoLocation")) if i]
 
-    def map_size(size):
-        """map_size"""
-        return size.get("#text")
-
-    sizes = [map_size(i) for i in wrap(meta.get("sizes", None))]
-
-    def map_format(format_):
-        """map_format"""
-        return format_.get("#text")
-
-    formats = [map_format(i) for i in wrap(meta.get("formats", None))]
-
     def map_rights(rights):
         """map_rights"""
         return compact(
@@ -227,17 +215,15 @@ def read_datacite_xml(data: dict, **kwargs) -> Commonmeta:
         "publisher": publisher,
         "date": date,
         # recommended and optional properties
-        "additional_type": presence(additional_type),
+        "additionalType": presence(additional_type),
         "subjects": presence(subjects),
         "language": meta.get("language", None),
-        "alternate_identifiers": presence(meta.get("alternateIdentifiers", None)),
-        "sizes": presence(sizes),
-        "formats": presence(formats),
+        "identifiers": presence(meta.get("alternateIdentifiers", None)),
         "version": meta.get("version", None),
         "license": presence(license_),
         "descriptions": presence(descriptions),
-        "geo_locations": presence(geo_locations),
-        "funding_references": presence(funding_references),
+        "geoLocations": presence(geo_locations),
+        "fundingReferences": presence(funding_references),
         "references": presence(references),
         "relations": presence(relations),
         # other properties

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/readers/inveniordm_reader.py

@@ -87,8 +87,6 @@ def read_inveniordm(data: dict, **kwargs) -> Commonmeta:
         )
     files = [get_file(i) for i in wrap(meta.get("files"))]
 
-    state = "findable" if meta or read_options else "not_found"
-
     return {
         # required properties
         "id": _id,
@@ -103,22 +101,17 @@ def read_inveniordm(data: dict, **kwargs) -> Commonmeta:
         # "additional_type": additional_type,
         "subjects": presence(subjects),
         "language": language,
-        # "alternate_identifiers": presence(meta.get("alternateIdentifiers", None)),
-        "sizes": None,
-        "formats": None,
         "version": py_.get(meta, "metadata.version"),
         "license": presence(license_),
         "descriptions": descriptions,
-        "geo_locations": None,
+        "geoLocations": None,
         # "funding_references": presence(meta.get("fundingReferences", None)),
-        # "references": presence(references),
+        "references": presence(references),
         "relations": presence(relations),
         # other properties
         "files": files,
         "container": container,
-        "provider": "InvenioRDM",
-        "state": state,
-        # "schema_version": meta.get("schemaVersion", None),
+        "provider": "DataCite",
     } | read_options
 
 
@@ -199,7 +192,7 @@ def format_descriptions(descriptions: list) -> list:
     return [
         {
             "description": sanitize(i),
-            "descriptionType": "Abstract" if index == 0 else "Other",
+            "type": "Abstract" if index == 0 else "Other",
         }
         for index, i in enumerate(descriptions)
         if i

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/readers/json_feed_reader.py

@@ -121,8 +121,8 @@ def read_json_feed_item(data: Optional[dict], **kwargs) -> Commonmeta:
                 "type": "IsPartOf",
             }
         )
-    alternate_identifiers = [
-        {"alternateIdentifier": meta.get("id"), "alternateIdentifierType": "UUID"}
+    identifiers = [
+        {"identifier": meta.get("id"), "identifierType": "UUID"}
     ]
     files = get_files(_id)
     state = "findable" if meta or read_options else "not_found"
@@ -140,14 +140,12 @@ def read_json_feed_item(data: Optional[dict], **kwargs) -> Commonmeta:
         "additional_type": None,
         "subjects": presence(subjects),
         "language": meta.get("language", None),
-        "alternate_identifiers": alternate_identifiers,
-        "sizes": None,
-        "formats": None,
+        "identifiers": identifiers,
         "version": None,
         "license": license_,
         "descriptions": descriptions,
-        "geo_locations": None,
-        "funding_references": presence(funding_references),
+        "geoLocations": None,
+        "fundingReferences": presence(funding_references),
         "references": presence(references),
         "relations": presence(relations),
         "files": files,

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/readers/kbase_reader.py

@@ -82,22 +82,18 @@ def read_kbase(data: dict, **kwargs) -> Commonmeta:
         "additional_type": None,
         "subjects": None,
         "language": language,
-        "alternate_identifiers": None,
-        "sizes": None,
-        "formats": None,
+        "identifiers": None,
         "version": py_.get(meta, "metadata.version"),
         "license": presence(license_),
         "descriptions": descriptions,
         "geo_locations": None,
-        "funding_references": presence(funding_references),
+        "fundingReferences": presence(funding_references),
         "references": presence(references),
         "relations": presence(relations),
         # other properties
         "files": presence(files),
         "container": container,
-        "provider": "KBase",
-        "state": state,
-        "schema_version": py_.get(data, "credit_metadata_schema_version"),
+        "provider": "DataCite",
     } | read_options
 
 
@@ -202,7 +198,7 @@ def format_descriptions(descriptions: list) -> list:
     return [
         {
             "description": sanitize(i),
-            "descriptionType": "Abstract" if index == 0 else "Other",
+            "type": "Abstract" if index == 0 else "Other",
         }
         for index, i in enumerate(descriptions)
         if i

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/readers/ris_reader.py

@@ -44,7 +44,7 @@ def read_ris(data: Optional[str], **kwargs) -> Commonmeta:
     #                           end
     descriptions = None
     if meta.get("AB", None) is not None:
-        descriptions = [{"description": meta.get("AB"), "descriptionType": "Abstract"}]
+        descriptions = [{"description": meta.get("AB"), "type": "Abstract"}]
     if meta.get("T2", None) is not None:
         container = compact(
             {

{commonmeta_py-0.16.9 → commonmeta_py-0.17}/commonmeta/readers/schema_org_reader.py

@@ -64,20 +64,29 @@ def get_schema_org(pid: str, **kwargs) -> dict:
             state = "bad_request"
         return {"@id": url, "@type": "WebPage", "state": state, "via": "schema_org"}
     elif response.headers.get("content-type") == "application/pdf":
-        pdf = pikepdf.Pdf.open(io.BytesIO(response.content))
-        meta = pdf.docinfo if pdf.docinfo else {}
-        if meta.get("/doi", None) is not None:
-            return get_doi_meta(meta.get("/doi"))
-        date_modified = get_datetime_from_pdf_time(meta.get("/ModDate")) if meta.get("/ModDate", None) else None
-        name = meta.get("/Title", None)
-        return compact({
-            "@id": url,
-            "@type": "DigitalDocument",
-            "via": "schema_org",
-            "name": str(name),
-            "datePublished": date_modified,
-            "dateAccessed": datetime.now().isoformat("T", "seconds") if date_modified is None else None,
-        })
+        try:
+            pdf = pikepdf.Pdf.open(io.BytesIO(response.content))
+            meta = pdf.docinfo if pdf.docinfo else {}
+            if meta.get("/doi", None) is not None:
+                return get_doi_meta(meta.get("/doi"))
+            date_modified = get_datetime_from_pdf_time(meta.get("/ModDate")) if meta.get("/ModDate", None) else None
+            name = meta.get("/Title", None)
+            return compact({
+                "@id": url,
+                "@type": "DigitalDocument",
+                "via": "schema_org",
+                "name": str(name),
+                "datePublished": date_modified,
+                "dateAccessed": datetime.now().isoformat("T", "seconds") if date_modified is None else None,
+            })
+        except Exception as error:
+            print(error)
+            return {
+                "@id": url,
+                "@type": "WebPage",
+                "state": "bad_request",
+                "via": "schema_org",
+            }
 
     soup = BeautifulSoup(response.text, "html.parser")
 
@@ -226,7 +235,7 @@ def read_schema_org(data: Optional[dict], **kwargs) -> Commonmeta:
     descriptions = [
         {
             "description": sanitize(i),
-            "descriptionType": "Abstract",
+            "type": "Abstract",
         }
         for i in wrap(meta.get("description"))
     ]
@@ -251,7 +260,7 @@ def read_schema_org(data: Optional[dict], **kwargs) -> Commonmeta:
     geo_locations = [
         schema_org_geolocation(i) for i in wrap(meta.get("spatialCoverage", None))
     ]
-    alternate_identifiers = None
+    identifiers = None
     provider = (
         get_doi_ra(_id)
         if doi_from_url(_id)
@@ -272,7 +281,7 @@ def read_schema_org(data: Optional[dict], **kwargs) -> Commonmeta:
         "additional_type": additional_type,
         "subjects": presence(subjects),
         "language": language,
-        "alternate_identifiers": alternate_identifiers,
+        "identifiers": identifiers,
         "sizes": None,
         "formats": None,
         "version": meta.get("version", None),