PyLinks 0.0.0.dev46__tar.gz → 0.0.0.dev48__tar.gz

{pylinks-0.0.0.dev46 → pylinks-0.0.0.dev48}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: PyLinks
-Version: 0.0.0.dev46
+Version: 0.0.0.dev48
 Requires-Python: >=3.10
 Requires-Dist: requests<3,>=2.31.0
-Requires-Dist: ExceptionMan==0.0.0.dev33
-Requires-Dist: MDit==0.0.0.dev33
+Requires-Dist: ExceptionMan==0.0.0.dev35
+Requires-Dist: MDit==0.0.0.dev35

{pylinks-0.0.0.dev46 → pylinks-0.0.0.dev48}/pyproject.toml

@@ -17,12 +17,12 @@ namespaces = true
 # ----------------------------------------- Project Metadata -------------------------------------
 #
 [project]
-version = "0.0.0.dev46"
+version = "0.0.0.dev48"
 name = "PyLinks"
 dependencies = [
     "requests >= 2.31.0, < 3",
-    "ExceptionMan == 0.0.0.dev33",
-    "MDit == 0.0.0.dev33",
+    "ExceptionMan == 0.0.0.dev35",
+    "MDit == 0.0.0.dev35",
 ]
 requires-python = ">=3.10"
 

{pylinks-0.0.0.dev46 → pylinks-0.0.0.dev48}/src/PyLinks.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: PyLinks
-Version: 0.0.0.dev46
+Version: 0.0.0.dev48
 Requires-Python: >=3.10
 Requires-Dist: requests<3,>=2.31.0
-Requires-Dist: ExceptionMan==0.0.0.dev33
-Requires-Dist: MDit==0.0.0.dev33
+Requires-Dist: ExceptionMan==0.0.0.dev35
+Requires-Dist: MDit==0.0.0.dev35

pylinks-0.0.0.dev48/src/PyLinks.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests<3,>=2.31.0
+ExceptionMan==0.0.0.dev35
+MDit==0.0.0.dev35

{pylinks-0.0.0.dev46 → pylinks-0.0.0.dev48}/src/pylinks/api/github.py

@@ -1,5 +1,6 @@
 # Standard libraries
-from typing import Optional, Literal
+from __future__ import annotations as _annotations
+from typing import TYPE_CHECKING as _TYPE_CHECKING
 from pathlib import Path
 import re
 import mimetypes
@@ -7,6 +8,9 @@ import mimetypes
 # Non-standard libraries
 import pylinks as _pylinks
 
+if _TYPE_CHECKING:
+    from typing import Optional, Literal, Any
+
 
 class GitHub:
     """GitHub API
@@ -38,13 +42,22 @@ class GitHub:
     def graphql_query(
         self,
         query: str,
+        variables: dict[str, tuple[Any, str, bool]] | None = None,
         extra_headers: dict | None = None,
     ) -> dict:
         headers = self._headers | extra_headers if extra_headers else self._headers
+        if variables:
+            args = ", ".join(
+                f"${name}:{typ}{"!" if required else ""}" for name, (_, typ, required) in variables.items()
+            )
+            sig = f"query({args})"
+        else:
+            sig = "query"
         response = _pylinks.http.graphql_query(
             url=self._endpoint["api"] / "graphql",
-            query=f"{{{query}}}",
+            query=f"{sig} {{{query}}}",
             headers=headers,
+            variables={name: value for name, (value, _, _) in variables.items()} if variables else None
         )
         return response
 
@@ -166,6 +179,18 @@ class Repo:
             endpoint=endpoint
         )
 
+    def _graphql_query(
+        self,
+        payload: str,
+        variables: dict[str, tuple[Any, str, bool]] | None = None,
+        extra_headers: dict | None = None,
+    ) -> dict:
+        return self._github.graphql_query(
+            query=f'repository(name: "{self._name}", owner: "{self._username}") {{{payload}}}',
+            variables=variables,
+            extra_headers=extra_headers,
+        )["repository"]
+
     @property
     def username(self) -> str:
         return self._username
@@ -412,13 +437,9 @@ class Repo:
         - [GitHub Docs](https://docs.github.com/en/graphql/guides/using-the-graphql-api-for-discussions)
         -
         """
-        payload = "{discussionCategories(first: 100) {edges {node {name, slug, id}}}}"
-        query = f'repository(name: "{self._name}", owner: "{self._username}") {payload}'
-        data = self._github.graphql_query(query)
-        discussions = [
-            entry["node"]
-            for entry in data["repository"]["discussionCategories"]["edges"]
-        ]
+        payload = "discussionCategories(first: 100) {edges {node {name, slug, id}}}"
+        data = self._graphql_query(payload)
+        discussions = [entry["node"] for entry in data["discussionCategories"]["edges"]]
         return discussions
 
     def issue(self, number: int) -> dict:
@@ -610,7 +631,14 @@ class Repo:
         """
         return self._rest_query(f"pulls/{number}")
 
-    def pull_commits(self, number: int) -> list[dict]:
+    def pull_commits(
+        self,
+        number: int,
+        count: int = 0,
+        cursor_before: str | None = None,
+        cursor_after: str | None = None,
+        sort: Literal["first", "last"] = "last",
+    ) -> list[dict]:
         """
         Get a list of commits for a pull request.
 
@@ -629,15 +657,52 @@ class Repo:
         ----------
         - [GitHub API Docs](https://docs.github.com/en/rest/pulls/commits?apiVersion=2022-11-28#list-commits-on-a-pull-request)
         """
-        commits = []
-        page = 1
+        def post_process():
+            out = []
+            for datum in data:
+                commits = datum["pullRequest"]["commits"]["nodes"]
+                if sort == "last":
+                    commits = reversed(commits)
+                for commit in commits:
+                    commit["commit"]["authors"] = commit["commit"]["authors"]["nodes"]
+                    out.append(commit)
+            return out
+
+        git_actor_fields = "{name, email, date user {id, login}}"
+        commit_fields = f"{{abbreviatedOid, additions, deletions, authors(first: 100) {{nodes {git_actor_fields}}}, committer {git_actor_fields}, authoredByCommitter, authoredDate, committedDate, message, messageBody, messageHeadline, oid, id, resourcePath, url}}"
+        page_info_fields = "pageInfo {startCursor, endCursor, hasNextPage, hasPreviousPage}"
+        commits_args = ["after: $after", "before: $before", f"{sort}: {100 if count <= 0 else min(count, 100)}"]
+        commits_fields = f"nodes {{id, resourcePath, url, commit {commit_fields} }}"
+        commits_sig = f"commits({", ".join(commits_args)})"
+        payload = f"pullRequest(number: {number}) {{ {commits_sig} {{ {commits_fields} {page_info_fields} }} }}"
+        variables = {
+            "after": (cursor_after, "String", False),
+            "before": (cursor_before, "String", False),
+        }
+        data = [self._graphql_query(payload, variables)]
+        total_downloaded = 100
         while True:
-            response = self._rest_query(f"pulls/{number}/commits?per_page=100&page={page}")
-            commits.extend(response)
-            page += 1
-            if len(response) < 100:
-                break
-        return commits
+            page_info = data[-1]["pullRequest"]["commits"]["pageInfo"]
+            if count <= 0:
+                must_continue = page_info["hasNextPage" if sort == "first" else "hasPreviousPage"]
+                if not must_continue:
+                    return post_process()
+            elif total_downloaded >= count:
+                return post_process()
+            else:
+                variables[sort] = page_info["endCursor" if sort == "first" else "startCursor"]
+                data.append(self._graphql_query(payload, variables))
+                total_downloaded += 100
+
+        # commits = []
+        # page = 1
+        # while True:
+        #     response = self._rest_query(f"pulls/{number}/commits?per_page=100&page={page}")
+        #     commits.extend(response)
+        #     page += 1
+        #     if len(response) < 100:
+        #         break
+        # return commits
 
     def pull_create(
         self,
@@ -1030,15 +1095,22 @@ class Repo:
             raise ValueError("At least one of 'new_name', 'color', or 'description' must be specified.")
         return self._rest_query(query=f"labels/{name}", verb="PATCH", json=data)
 
+    def release_get(self, release_id: int) -> dict:
+        return self._rest_query(query=f"releases/{release_id}")
+
+    def release_delete(self, release_id: int) -> None:
+        self._rest_query(query=f"releases/{release_id}", verb="DELETE", response_type=None)
+        return
+
     def release_create(
         self,
         tag_name: str,
-        name: str,
-        body: str,
-        target_commitish: str = "",
+        name: str | None = None,
+        body: str | None = None,
+        target_commitish: str | None = None,
         draft: bool = False,
         prerelease: bool = False,
-        discussion_category_name: str = "",
+        discussion_category_name: str | None = None,
         generate_release_notes: bool = False,
         make_latest: Literal['true', 'false', 'legacy'] = 'true'
     ):
@@ -1078,22 +1150,62 @@ class Repo:
         ----------
         [GitHub API Docs](https://docs.github.com/en/rest/releases/releases?apiVersion=2022-11-28#create-a-release)
         """
-        data = {
-            "tag_name": tag_name,
-            "draft": draft,
-            "prerelease": prerelease,
-            "generate_release_notes": generate_release_notes,
-            "make_latest": make_latest,
-        }
-        if name:
-            data["name"] = name
-        if body:
-            data["body"] = body
-        if target_commitish:
-            data["target_commitish"] = target_commitish
-        if discussion_category_name:
-            data["discussion_category_name"] = discussion_category_name
-        return self._rest_query(query="releases", verb="POST", json=data)
+        data = {k: v for k, v in locals().items() if k != "self" and v is not None}
+        return self._rest_query(query=f"releases", verb="POST", json=data)
+
+    def release_update(
+        self,
+        release_id: int,
+        tag_name: str | None = None,
+        name: str | None = None,
+        body: str | None = None,
+        target_commitish: str | None = None,
+        draft: bool | None = None,
+        prerelease: bool | None = None,
+        discussion_category_name: str | None = None,
+        make_latest: Literal['true', 'false', 'legacy'] | None = None
+    ):
+        """Update a release.
+
+        Parameters
+        ----------
+        tag_name : str
+            The name of the tag.
+        name : str
+            The name of the release.
+        body : str
+            The body of the release post, i.e. text describing the release.
+        target_commitish : str, optional
+            The commitish value that determines where the Git tag is created from.
+            Can be any branch or commit SHA. Unused if the Git tag already exists.
+            The default is the repository's default branch.
+        draft : bool, optional
+            `True` to create a draft (unpublished) release, `False` to create a published one.
+        prerelease : bool, default: False
+            `True` to identify the release as a prerelease, `False` to identify it as a full release.
+        discussion_category_name : str, optional
+            The name of the discussion category for the release, to be created and linked to the release.
+            The value must be a category that already exists in the repository.
+        make_latest : {'true', 'false', 'legacy'}, optional
+            Whether this release should be set as the latest release for the repository.
+            Drafts and prereleases cannot be set as latest.
+            Defaults to 'true' for newly published releases.
+            'legacy' specifies that the latest release should be determined based on
+            the release creation date and higher semantic version.
+
+        References
+        ----------
+        [GitHub API Docs](https://docs.github.com/en/rest/releases/releases?apiVersion=2022-11-28#create-a-release)
+        """
+        data = {k: v for k, v in locals().items() if k not in ("self", "release_id") and v is not None}
+        return self._rest_query(query=f"releases/{release_id}", verb="PATCH", json=data)
+
+    def release_asset_list(self, release_id: int) -> list[dict]:
+        return self._rest_query(query=f"releases/{release_id}/assets")
+
+    def release_asset_delete(self, asset_id: int) -> None:
+        self._rest_query(query=f"releases/assets/{asset_id}", verb="DELETE", response_type=None)
+        return
 
     def release_asset_upload(
         self,
@@ -1683,10 +1795,9 @@ class Repo:
         ----------
         - [GitHub API Docs](https://docs.github.com/en/graphql/reference/objects#branchprotectionruleconnection)
         """
-        payload = "{branchProtectionRules(first: 100) {nodes {id, pattern}}}"
-        query = f'repository(name: "{self._name}", owner: "{self._username}") {payload}'
-        data = self._github.graphql_query(query)
-        return data["repository"]["branchProtectionRules"]["nodes"]
+        payload = "branchProtectionRules(first: 100) {nodes {id, pattern}}"
+        data = self._graphql_query(payload)
+        return data["branchProtectionRules"]["nodes"]
 
     def branch_protection_rule_create(
         self,

{pylinks-0.0.0.dev46 → pylinks-0.0.0.dev48}/src/pylinks/api/zenodo.py

@@ -18,37 +18,90 @@ class Zenodo:
     """
     def __init__(self, token: str, sandbox: bool = False):
         self._sandbox = sandbox
-        self._url = _pylinks.url.create("https://zenodo.org/api")
-        self._url_sandbox = _pylinks.url.create("https://sandbox.zenodo.org/api")
-        self._headers = {"Authorization": token}
+        self._url = _pylinks.url.create(
+            "https://sandbox.zenodo.org/api" if sandbox else "https://zenodo.org/api"
+        )
+        self._headers = {"Authorization": f"Bearer {token}"}
         return
 
     def rest_query(
         self,
         query: str,
         verb: Literal["GET", "POST", "PUT", "PATCH", "OPTIONS", "DELETE"] = "GET",
+        params: dict | None = None,
         data = None,
         json = None,
         content_type: str | None = "application/json",
-        sandbox: bool | None = None,
+        response_type: Literal["str", "json", "bytes"] | None = "json"
     ) -> dict | list:
-        sandbox = sandbox if sandbox is not None else self._sandbox
-        base_url = self._url_sandbox if sandbox else self._url
         content_header = {"Content-Type": content_type} if content_type else {}
         return _pylinks.http.request(
-            url=base_url / query,
+            url=self._url / query,
             verb=verb,
+            params=params,
             data=data,
             json=json,
             headers=self._headers | content_header,
-            response_type="json", # All responses are JSON (https://developers.zenodo.org/#responses)
+            response_type=response_type, # All responses are JSON (https://developers.zenodo.org/#responses)
         )
 
-    def deposition_create(
+    def create_and_publish(
         self,
-        metadata: dict | None = None,
-        sandbox: bool | None = None,
-    ) -> dict:
+        metadata: dict,
+        files: list[str | _Path | tuple[str | _Path, str]],
+        previous_id: str | int | None = None
+    ):
+        def add_files(bucket_id: str):
+            for file in files:
+                if not isinstance(file, (str, _Path)):
+                    filepath = file[0]
+                    name = file[1]
+                else:
+                    filepath = file
+                    name = None
+                self.file_create(
+                    bucket_id=bucket_id,
+                    filepath=filepath,
+                    name=name,
+                )
+            return
+
+        if not previous_id:
+            new_depo = self.deposition_create(metadata=metadata)
+            add_files(bucket_id=new_depo["links"]["bucket"])
+            return self.deposition_publish(new_depo["id"])
+        new_ver = self.deposition_new_version(deposition_id=previous_id)
+        for previous_file in new_ver["files"]:
+            self.file_delete(deposition_id=new_ver["id"], file_id=previous_file["id"])
+        add_files(new_ver["links"]["bucket"])
+        return self.deposition_publish(new_ver["id"])
+
+
+    def deposition_list(
+        self,
+        query: str | None = None,
+        status: Literal["draft", "published"] | None = None,
+        sort: Literal["bestmatch", "mostrecent", "-bestmatch", "-mostrecent"] | None = None,
+        page: int | None = None,
+        size: int | None = None,
+        all_versions: bool | None = None,
+    ):
+        params = {k: v for k, v in locals().items() if k not in ("self", "query") and v}
+        if query:
+            params["q"] = query
+        return self.rest_query(
+            "deposit/depositions",
+            verb="GET",
+            params=params,
+        )
+
+    def deposition_retrieve(self, deposition_id: str | int):
+        return self.rest_query(
+            f"deposit/depositions/{deposition_id}",
+            verb="GET",
+        )
+
+    def deposition_create(self, metadata: dict | None = None) -> dict:
         """Create a new deposition.
 
         Returns
@@ -91,25 +144,51 @@ class Zenodo:
         return self.rest_query(
             query="deposit/depositions",
             verb="POST",
-            json=metadata or {},
-            sandbox=sandbox,
+            json={"metadata": metadata} if metadata else {},
         )
 
-    def deposition_publish(self, deposition_id: str) -> dict:
+    def deposition_new_version(self, deposition_id: int | str):
+        """Create a new version of a deposition as a draft."""
+        return self.rest_query(
+            query=f"deposit/depositions/{deposition_id}/actions/newversion",
+            verb="POST",
+        )
+
+    def deposition_update(self, deposition_id: int | str, metadata: dict):
+        """Update and existing deposition."""
+        return self.rest_query(
+            query=f"deposit/depositions/{deposition_id}",
+            verb="PUT",
+            json={"metadata": metadata},
+        )
+
+    def deposition_publish(self, deposition_id: int | str) -> dict:
         """Publish a deposition."""
         return self.rest_query(
             query=f"deposit/depositions/{deposition_id}/actions/publish",
             verb="POST",
         )
 
+    def file_list(self, deposition_id: str | int):
+        return self.rest_query(
+            f"deposit/depositions/{deposition_id}/files",
+            verb="GET"
+        )
+
     def file_create(
         self,
-        bucket_url: str | _pylinks.url.URL,
+        bucket_id: str,
         filepath: str | _Path,
-        upload_path: str | None = None,
+        name: str | None = None,
     ) -> dict:
         """Upload a file to a Zenodo bucket.
 
+        Parameters
+        ----------
+        bucket_id
+            Bucket ID (e.g., `"d7524553-7f8c-4632-bffb-8bea6a90b88b"`)
+            or bucket URL (e.g., `"https://zenodo.org/api/files/d7524553-7f8c-4632-bffb-8bea6a90b88b"`)
+
         Returns
         -------
 
@@ -134,14 +213,20 @@ class Zenodo:
         }
         :::
         """
-        if not isinstance(bucket_url, _pylinks.url.URL):
-            bucket_url = _pylinks.url.create(bucket_url)
+        bucket_id = bucket_id.removeprefix(f"{self._url}/files/")
         filepath = _Path(filepath)
-        upload_path = upload_path or filepath.name
+        name = name or filepath.name
         with open(filepath, "rb") as file:
             return self.rest_query(
-                query=bucket_url / upload_path,
+                query=f"files/{bucket_id}/{name}",
                 verb="PUT",
                 data=file,
                 content_type=None,
-            )
+            )
+
+    def file_delete(self, deposition_id: str | int, file_id: str | int):
+        return self.rest_query(
+            f"deposit/depositions/{deposition_id}/files/{file_id}",
+            verb="DELETE",
+            response_type=None,
+        )

{pylinks-0.0.0.dev46 → pylinks-0.0.0.dev48}/src/pylinks/exception/api.py

@@ -101,7 +101,7 @@ class GraphQLResponseError(WebAPIError):
     Exception class for GraphQL
     """
 
-    def __init__(self, response: dict):
+    def __init__(self, response: dict, query: str):
         if "errors" in response:
             intro = "GraphQL response contains errors."
         elif "data" not in response:
@@ -109,10 +109,16 @@ class GraphQLResponseError(WebAPIError):
         super().__init__(
             title="GraphQL Response Error",
             intro=intro,
-            details=_mdit.element.code_block(
-                json.dumps(response, indent=3), language="json", caption="GraphQL Response"
-            ),
+            details=_mdit.block_container(
+                _mdit.element.code_block(
+                    json.dumps(response, indent=3), language="json", caption="GraphQL Response"
+                ),
+                _mdit.element.code_block(
+                    query, language="graphql", caption="GraphQL Query"
+                ),
+            )
         )
+        self.query = query
         return
 
 

{pylinks-0.0.0.dev46 → pylinks-0.0.0.dev48}/src/pylinks/http.py

@@ -277,9 +277,9 @@ def graphql_query(
     if isinstance(response, dict):
         error_title = "GraphQL API Error"
         if "errors" in response:
-            raise _exception.GraphQLResponseError(response)
+            raise _exception.GraphQLResponseError(response, query)
         elif "data" not in response:
-            raise _exception.GraphQLResponseError(response)
+            raise _exception.GraphQLResponseError(response, query)
         else:
             response = response["data"]
     return response

pylinks-0.0.0.dev46/src/PyLinks.egg-info/requires.txt

@@ -1,3 +0,0 @@
-requests<3,>=2.31.0
-ExceptionMan==0.0.0.dev33
-MDit==0.0.0.dev33