commonmeta-py 0.106__py3-none-any.whl → 0.108__py3-none-any.whl

commonmeta/utils.py

@@ -408,14 +408,52 @@ def openalex_api_url(id: str, identifier_type: str, **kwargs) -> str:
 
 def openalex_api_query_url(query: dict) -> str:
     """Return the OpenAlex API query URL"""
+    # Define allowed types
+    types = [
+        "article",
+        "book-chapter",
+        "dataset",
+        "preprint",
+        "dissertation",
+        "book",
+        "review",
+        "paratext",
+        "libguides",
+        "letter",
+        "other",
+        "reference-entry",
+        "report",
+        "editorial",
+        "peer-review",
+        "erratum",
+        "standard",
+        "grant",
+        "supplementary-materials",
+        "retraction",
+    ]
+
     url = "https://api.openalex.org/works"
     f = furl(url)
-    rows = min(int(query.get("rows", 20)), 1000)
-    queries = []
+
+    # Handle pagination and sample parameters
+    number = max(1, min(1000, int(query.get("number", query.get("rows", 10)))))
+    page = max(1, int(query.get("page", 1)))
+
+    sample = query.get("sample", False)
+    if sample:
+        f.args["sample"] = str(number)
+    else:
+        f.args["per-page"] = str(number)
+        f.args["page"] = str(page)
+        # Sort results by published date in descending order
+        f.args["sort"] = "publication_date:desc"
+
+    # Build filters
     filters = []
+    queries = []
     _query = None
-    _filter = None
 
+    # Handle query parameters
     if query.get("query", None) is not None:
         queries += [query.get("query")]
     for key, value in query.items():
@@ -428,23 +466,60 @@ def openalex_api_query_url(query: dict) -> str:
             queries += [f"{key}:{value}"]
     if queries:
         _query = ",".join(queries)
+        f.args["query"] = _query
+
+    # Member/IDs filter
+    ids = query.get("ids", query.get("member", ""))
+    if ids:
+        filters.append(f"member:{ids}")
+
+    # Type filter
+    type_ = query.get("type_", query.get("type", ""))
+    if type_ and type_ in types:
+        filters.append(f"type:{type_}")
 
+    # ROR filter
+    ror = query.get("ror", "")
+    if ror:
+        r = validate_ror(ror)
+        if r:
+            filters.append(f"authorships.institutions.ror:{r}")
+
+    # ORCID filter
+    orcid = query.get("orcid", "")
+    if orcid:
+        o = validate_orcid(orcid)
+        if o:
+            filters.append(f"authorships.author.orcid:{o}")
+
+    # Year filter
+    year = query.get("year", query.get("publication_year", ""))
+    if year:
+        filters.append(f"publication_year:{year}")
+
+    # Other filters from the original function
     for key, value in query.items():
         if key in [
             "prefix",
-            "member",
-            "type",
             "has-full-text",
-            "has-references",
-            "has-orcid",
             "has-funder",
             "has-license",
         ]:
-            filters += [f"{key}:{value}"]
-    if filters:
-        _filter = ",".join(filters)
+            filters.append(f"{key}:{value}")
+
+    # Boolean filters
+    # if query.get("hasORCID", query.get("has-orcid", False)):
+    #     filters.append("has-orcid:true")
+
+    # if query.get("hasReferences", query.get("has-references", False)):
+    #     filters.append("has-references:true")
 
-    f.args.update(compact({"rows": rows, "query": _query, "filter": _filter}))
+    # if query.get("hasAbstract", query.get("has-abstract", False)):
+    #     filters.append("has-abstract:true")
+
+    # Add filters to params if any exist
+    if filters:
+        f.args["filter"] = ",".join(filters)
 
     return f.url
 
@@ -579,7 +654,7 @@ def dict_to_spdx(dct: dict) -> dict:
     # end
 
 
-def from_json_feed(elements: list) -> list:
+def from_jsonfeed(elements: list) -> list:
     """Convert from JSON Feed elements"""
 
     def format_element(element):
@@ -878,7 +953,7 @@ def find_from_format_by_id(pid: str) -> Optional[str]:
     if re.match(r"\A(http|https):/(/)?github\.com/(.+)\Z", pid) is not None:
         return "cff"
     if re.match(r"\Ahttps:/(/)?api\.rogue-scholar\.org/posts/(.+)\Z", pid) is not None:
-        return "json_feed_item"
+        return "jsonfeed"
     if re.match(r"\Ahttps:/(/)(.+)/api/records/(.+)\Z", pid) is not None:
         return "inveniordm"
     return "schema_org"
@@ -906,7 +981,7 @@ def find_from_format_by_dict(dct: dict) -> Optional[str]:
     ]:
         return "codemeta"
     if dct.get("guid", None) is not None:
-        return "json_feed_item"
+        return "jsonfeed"
     if dct.get("schemaVersion", "").startswith("http://datacite.org/schema/kernel"):
         return "datacite"
     if dct.get("source", None) == "Crossref":
@@ -939,7 +1014,7 @@ def find_from_format_by_string(string: str) -> Optional[str]:
         ]:
             return "codemeta"
         if data.get("guid", None) is not None:
-            return "json_feed_item"
+            return "jsonfeed"
         if data.get("schemaVersion", "").startswith(
             "http://datacite.org/schema/kernel"
         ):

commonmeta/writers/bibtex_writer.py

@@ -1,15 +1,15 @@
 """Bibtex writer for commonmeta-py"""
 
-from bibtexparser.bwriter import BibTexWriter
 from bibtexparser.bibdatabase import BibDatabase
+from bibtexparser.bwriter import BibTexWriter
 from bibtexparser.customization import page_double_hyphen
 
-from ..utils import pages_as_string, get_language
-from ..base_utils import compact
 from ..author_utils import authors_as_string
-from ..date_utils import get_month_from_date, get_iso8601_date, MONTH_SHORT_NAMES
-from ..doi_utils import doi_from_url
+from ..base_utils import compact
 from ..constants import CM_TO_BIB_TRANSLATIONS, Commonmeta
+from ..date_utils import MONTH_SHORT_NAMES, get_iso8601_date, get_month_from_date
+from ..doi_utils import doi_from_url
+from ..utils import get_language, pages_as_string
 
 
 def write_bibtex(metadata: Commonmeta) -> str:

commonmeta/writers/citation_writer.py

@@ -1,13 +1,18 @@
 """Citation writer for commonmeta-py"""
 
-import orjson as json
 import re
-from pydash import py_
-from citeproc import CitationStylesStyle, CitationStylesBibliography
-from citeproc import Citation, CitationItem
-from citeproc import formatter
+
+import orjson as json
+from citeproc import (
+    Citation,
+    CitationItem,
+    CitationStylesBibliography,
+    CitationStylesStyle,
+    formatter,
+)
 from citeproc.source.json import CiteProcJSON
 from citeproc_styles import get_style_filepath
+from pydash import py_
 
 
 def write_citation(metadata):

commonmeta/writers/commonmeta_writer.py

@@ -1,8 +1,7 @@
 """Commonmeta writer for commonmeta-py"""
 
-import orjson as json
-import orjsonl
 import pydash as py_
+
 from ..base_utils import compact
 
 
@@ -32,12 +31,12 @@ def write_commonmeta(metadata):
             "funding_references": "fundingReferences",
         },
     )
-    return json.dumps(compact(data), option=json.OPT_INDENT_2)
+    return compact(data)
 
 
 def write_commonmeta_list(metalist):
-    """Write commonmeta list. If filename is provided,
-    write to file. Optionally, use JSON Lines format."""
+    """Write commonmeta list. If file is provided,
+    write to file. Supports JSON, JSON Lines and YAML format."""
     if metalist is None:
         return None
 
@@ -47,7 +46,7 @@ def write_commonmeta_list(metalist):
         return compact(item)
 
     items = [format_item(item) for item in metalist.items]
-    output = compact(
+    return compact(
         {
             "id": metalist.id,
             "title": metalist.title,
@@ -55,14 +54,3 @@ def write_commonmeta_list(metalist):
             "items": items,
         }
     )
-
-    if metalist.filename and metalist.filename.rsplit(".", 1)[1] in ["jsonl", "json"]:
-        if metalist.jsonlines:
-            orjsonl.save(metalist.filename, items)
-        else:
-            json_output = json.dumps(output).decode("utf-8")
-            with open(metalist.filename, "w") as file:
-                file.write(json_output)
-        return metalist.filename
-    else:
-        return json.dumps(output).decode("utf-8")