ayon-python-api 1.2.23__tar.gz → 1.2.24__tar.gz

{ayon_python_api-1.2.23 → ayon_python_api-1.2.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ayon_python_api
-Version: 1.2.23
+Version: 1.2.24
 Summary: AYON Python API
 Home-page: https://github.com/ynput/ayon-python-api
 Author: ynput.io

{ayon_python_api-1.2.23 → ayon_python_api-1.2.24}/ayon_api/_api.py

@@ -1943,6 +1943,7 @@ def create_dependency_package(
     checksum: str,
     checksum_algorithm: str,
     file_size: int,
+    python_version: str | None = None,
     sources: Optional[list[dict[str, Any]]] = None,
     platform_name: Optional[str] = None,
 ) -> None:
@@ -1968,6 +1969,8 @@ def create_dependency_package(
         checksum (str): Checksum of archive file where dependencies are.
         checksum_algorithm (str): Algorithm used to calculate checksum.
         file_size (Optional[int]): Size of file.
+        python_version (str | None): Python version for which
+            is dependency package created.
         sources (Optional[list[dict[str, Any]]]): Information about
             sources from where it is possible to get file.
         platform_name (Optional[str]): Name of platform for which is
@@ -1984,6 +1987,7 @@ def create_dependency_package(
         checksum=checksum,
         checksum_algorithm=checksum_algorithm,
         file_size=file_size,
+        python_version=python_version,
         sources=sources,
         platform_name=platform_name,
     )

{ayon_python_api-1.2.23 → ayon_python_api-1.2.24}/ayon_api/_api_helpers/dependency_packages.py

@@ -57,6 +57,7 @@ class DependencyPackagesAPI(BaseServerAPI):
         checksum: str,
         checksum_algorithm: str,
         file_size: int,
+        python_version: str | None = None,
         sources: Optional[list[dict[str, Any]]] = None,
         platform_name: Optional[str] = None,
     ) -> None:
@@ -82,6 +83,8 @@ class DependencyPackagesAPI(BaseServerAPI):
             checksum (str): Checksum of archive file where dependencies are.
             checksum_algorithm (str): Algorithm used to calculate checksum.
             file_size (Optional[int]): Size of file.
+            python_version (str | None): Python version for which
+                is dependency package created.
             sources (Optional[list[dict[str, Any]]]): Information about
                 sources from where it is possible to get file.
             platform_name (Optional[str]): Name of platform for which is
@@ -99,6 +102,9 @@ class DependencyPackagesAPI(BaseServerAPI):
             "size": file_size,
             "platform": platform_name or platform.system().lower(),
         }
+        if python_version:
+            post_body["pythonVersion"] = python_version
+
         if sources:
             post_body["sources"] = sources
 

{ayon_python_api-1.2.23 → ayon_python_api-1.2.24}/ayon_api/graphql.py

@@ -353,6 +353,25 @@ class GraphQlQuery:
         for child in self._children:
             child.parse_result(data, output, progress_data)
 
+    def _query_data(self, con: ServerAPI) -> dict[str, Any]:
+        """Send single query to server and return 'data' of the response."""
+        query_str = self.calculate_query()
+        variables = self.get_variables_values()
+        response = con.query_graphql(query_str, variables)
+        if response.errors:
+            raise GraphQlQueryFailed(response.errors, query_str, variables)
+
+        data = response.data.get("data")
+        if data is None:
+            # Parsing 'None' would not change pagination state and the same
+            #   query would be sent again in an infinite loop.
+            raise GraphQlQueryError(
+                f"GraphQl query '{self._name}' response does not contain"
+                f" 'data'. Response: {str(response.data)[:1000]}"
+                f"\nQuery:\n{query_str}\nVariables: {variables}"
+            )
+        return data
+
     def query(self, con: ServerAPI) -> dict[str, Any]:
         """Do a query from server.
 
@@ -366,15 +385,8 @@ class GraphQlQuery:
         progress_data = {}
         output = {}
         while self.need_query:
-            query_str = self.calculate_query()
-            variables = self.get_variables_values()
-            response = con.query_graphql(
-                query_str,
-                variables
-            )
-            if response.errors:
-                raise GraphQlQueryFailed(response.errors, query_str, variables)
-            self.parse_result(response.data["data"], output, progress_data)
+            data = self._query_data(con)
+            self.parse_result(data, output, progress_data)
 
         return output
 
@@ -394,30 +406,16 @@ class GraphQlQuery:
         if self.has_multiple_edge_fields:
             output = {}
             while self.need_query:
-                query_str = self.calculate_query()
-                variables = self.get_variables_values()
-
-                response = con.query_graphql(query_str, variables)
-                if response.errors:
-                    raise GraphQlQueryFailed(
-                        response.errors, query_str, variables
-                    )
-                self.parse_result(response.data["data"], output, progress_data)
+                data = self._query_data(con)
+                self.parse_result(data, output, progress_data)
 
             yield output
 
         else:
             while self.need_query:
                 output = {}
-                query_str = self.calculate_query()
-                variables = self.get_variables_values()
-                response = con.query_graphql(query_str, variables)
-                if response.errors:
-                    raise GraphQlQueryFailed(
-                        response.errors, query_str, variables
-                    )
-
-                self.parse_result(response.data["data"], output, progress_data)
+                data = self._query_data(con)
+                self.parse_result(data, output, progress_data)
 
                 yield output
 
@@ -903,11 +901,13 @@ class GraphQlQueryEdgeField(BaseGraphQlQueryField):
                 progress_data[cursor_key] = nodes_by_cursor
 
         page_info = value["pageInfo"]
+        # Continue from the last received edge for both orders. Server
+        #   returns edges of 'last' page from the newest item, so
+        #   'startCursor' would move the cursor back only by one item.
+        new_cursor = page_info["endCursor"]
         if self._order == SortOrder.ascending:
-            new_cursor = page_info["endCursor"]
             self._need_query = page_info["hasNextPage"]
         else:
-            new_cursor = page_info["startCursor"]
             self._need_query = page_info["hasPreviousPage"]
 
         edges = value["edges"]
@@ -943,6 +943,14 @@ class GraphQlQueryEdgeField(BaseGraphQlQueryField):
                 change_cursor = False
 
         if change_cursor and self._need_query:
+            if new_cursor is None:
+                # Without cursor the pagination would start from beginning
+                raise GraphQlQueryError(
+                    f"Field '{self.path}' reported another page without"
+                    " a cursor. Stopped pagination after"
+                    f" {self._fetched_counter} items."
+                )
+
             if new_cursor == self._cursor:
                 raise GraphQlQueryError(
                     "Cursor didn't change during pagination."
@@ -1016,11 +1024,7 @@ class GraphQlQueryEdgeField(BaseGraphQlQueryField):
         # Add page information
         output.append(edges_offset + "pageInfo {")
         for page_key in (
-            (
-                "endCursor"
-                if self._order == SortOrder.ascending
-                else "startCursor"
-            ),
+            "endCursor",
             (
                 "hasNextPage"
                 if self._order == SortOrder.ascending

{ayon_python_api-1.2.23 → ayon_python_api-1.2.24}/ayon_api/server_api.py

@@ -1489,6 +1489,8 @@ class ServerAPI(
         response = self.raw_get(
             "info",
             handle_invalid_token=False,
+            verify=self.ssl_verify,
+            cert=self.cert
         )
         response.raise_for_status()
         return response.data
@@ -1519,7 +1521,7 @@ class ServerAPI(
         **kwargs
     ) -> RestApiResponse:
         kwargs.setdefault("timeout", self.timeout)
-        max_retries = kwargs.get("max_retries", self.max_retries)
+        max_retries = kwargs.pop("max_retries", self.max_retries)
         if max_retries < 1:
             max_retries = 1
 
@@ -1558,6 +1560,7 @@ class ServerAPI(
         response = None
         new_response = None
         for retry_idx in reversed(range(max_retries)):
+            new_response = None
             try:
                 response = function(url, **kwargs)
 
@@ -1658,7 +1661,7 @@ class ServerAPI(
         url = self._endpoint_to_url(endpoint, use_rest=False)
         progress.set_source_url(url)
 
-        retries = self.get_default_max_retries()
+        retries = max(self.max_retries, 1)
         api_prepended = False
         for attempt in range(retries):
             # Continue in download
@@ -1684,6 +1687,14 @@ class ServerAPI(
                             progress.set_destination_url(url)
                             continue
                     response.raise_for_status()
+                    if offset > 0 and response.status_code != 206:
+                        # Server ignored 'Range' and sends whole file again,
+                        #   already downloaded content must be discarded
+                        stream.seek(0)
+                        stream.truncate()
+                        progress.reset_transferred()
+                        headers.pop("Range", None)
+
                     if progress.get_content_size() is None:
                         progress.set_content_size(
                             response.headers["Content-length"]
@@ -1692,11 +1703,21 @@ class ServerAPI(
                     for chunk in response.iter_content(chunk_size=chunk_size):
                         stream.write(chunk)
                         progress.add_transferred_chunk(len(chunk))
+
+                content_size = progress.get_content_size()
+                transferred = progress.get_transferred_size()
+                if content_size is not None and transferred != content_size:
+                    # Connection was closed before all content was received
+                    raise requests.exceptions.ConnectionError(
+                        f"Downloaded {transferred} out of {content_size}"
+                        f" bytes from '{url}'."
+                    )
                 break
 
             except (
                 requests.exceptions.Timeout,
                 requests.exceptions.ConnectionError,
+                requests.exceptions.ChunkedEncodingError,
             ):
                 if attempt == retries - 1:
                     raise
@@ -2093,7 +2114,7 @@ class ServerAPI(
                 headers.pop(orig_key)
             headers[key] = value
 
-        retries = self.get_default_max_retries()
+        retries = max(self.max_retries, 1)
         response = None
 
         # Get size of file
@@ -2676,24 +2697,32 @@ class ServerAPI(
         if result.get("success"):
             return None
 
-        print(result)
-        for op_result in result["operations"]:
+        self.log.warning(
+            "Operations failed. Server response:\n%s",
+            json.dumps(result, indent=4, default=str),
+        )
+        for op_result in result.get("operations") or []:
             if op_result["success"]:
                 continue
 
             operation_id = op_result["id"]
             operation = next(
-                op
-                for op in operations_body
-                if op["id"] == operation_id
+                (op for op in operations_body if op["id"] == operation_id),
+                op_result,
             )
             detail = op_result["detail"]
             raise FailedOperations(
                 f"Operation \"{operation_id}\" failed with data:"
-                f"\n{json.dumps(operation, indent=4)}"
+                f"\n{json.dumps(operation, indent=4, default=str)}"
                 f"\nDetail: {detail}."
             )
 
+        # Server did not report which operation failed
+        raise FailedOperations(
+            "Operations failed. Server response:"
+            f"\n{json.dumps(result, indent=4, default=str)}"
+        )
+
     def _prepare_fields(
         self,
         entity_type: str,

{ayon_python_api-1.2.23 → ayon_python_api-1.2.24}/ayon_api/utils.py

@@ -955,7 +955,7 @@ class TransferProgress:
         """
         return self._content_size
 
-    def set_content_size(self, content_size: int) -> None:
+    def set_content_size(self, content_size: int | str) -> None:
         """Set content size in bytes.
 
         Args:
@@ -967,7 +967,7 @@ class TransferProgress:
         """
         if self._content_size is not None:
             raise ValueError("Content size was set more then once")
-        self._content_size = content_size
+        self._content_size = int(content_size)
 
     def get_started(self) -> bool:
         """Transfer was started.

{ayon_python_api-1.2.23 → ayon_python_api-1.2.24}/ayon_api/version.py

@@ -1,2 +1,2 @@
 """Package declaring Python API for AYON server."""
-__version__ = "1.2.23"
+__version__ = "1.2.24"

{ayon_python_api-1.2.23 → ayon_python_api-1.2.24}/ayon_python_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ayon_python_api
-Version: 1.2.23
+Version: 1.2.24
 Summary: AYON Python API
 Home-page: https://github.com/ynput/ayon-python-api
 Author: ynput.io

{ayon_python_api-1.2.23 → ayon_python_api-1.2.24}/ayon_python_api.egg-info/SOURCES.txt

@@ -40,8 +40,14 @@ ayon_python_api.egg-info/SOURCES.txt
 ayon_python_api.egg-info/dependency_links.txt
 ayon_python_api.egg-info/requires.txt
 ayon_python_api.egg-info/top_level.txt
+tests/test_download_resume.py
 tests/test_entity_hub.py
 tests/test_folder_hierarchy.py
 tests/test_get_events.py
+tests/test_graphql_descending_pagination.py
+tests/test_graphql_infinite_loop.py
 tests/test_graphql_queries.py
+tests/test_operations_result.py
+tests/test_request_max_retries_kwarg.py
+tests/test_request_retries.py
 tests/test_server.py

{ayon_python_api-1.2.23 → ayon_python_api-1.2.24}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ayon_python_api"
-version = "1.2.23"
+version = "1.2.24"
 description = "AYON Python API"
 license = {file = "LICENSE"}
 readme = {file = "README.md", content-type = "text/markdown"}
@@ -28,7 +28,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "ayon_python_api"
-version = "1.2.23"
+version = "1.2.24"
 description = "AYON Python API"
 authors = [
     "ynput.io <info@ynput.io>"

ayon_python_api-1.2.24/tests/test_download_resume.py

@@ -0,0 +1,53 @@
+"""Interrupted downloads. Does not require running AYON server."""
+import io
+
+import pytest
+
+from ayon_api.server_api import ServerAPI
+from ayon_api.utils import RequestTypes
+
+from .fake_transfer import FakeResponse
+
+CONTENT = b"0123456789"
+SIZE_HEADER = {"Content-Length": str(len(CONTENT))}
+
+
+@pytest.fixture
+def con(monkeypatch):
+    monkeypatch.setattr("time.sleep", lambda *args, **kwargs: None)
+    return ServerAPI("http://localhost:0", create_session=False, max_retries=3)
+
+
+def _download(con, get_func):
+    con._base_functions_mapping[RequestTypes.get] = get_func
+    stream = io.BytesIO()
+    progress = con.download_file_to_stream("api/file", stream)
+    return stream.getvalue(), progress
+
+
+def test_incomplete_download_is_continued(con):
+    def get_func(url, **kwargs):
+        if "Range" not in kwargs["headers"]:
+            # Connection closed after 4 bytes without an exception
+            return FakeResponse(200, CONTENT[:4], SIZE_HEADER)
+        assert kwargs["headers"]["Range"] == "bytes=4-"
+        return FakeResponse(206, CONTENT[4:], {"Content-Length": "6"})
+
+    content, progress = _download(con, get_func)
+    assert content == CONTENT
+    assert progress.transferred_size == len(CONTENT)
+
+
+def test_resume_without_range_support_does_not_duplicate(con):
+    calls = []
+
+    def get_func(url, **kwargs):
+        calls.append(url)
+        if len(calls) == 1:
+            return FakeResponse(200, CONTENT[:4], SIZE_HEADER)
+        # Server ignores 'Range' header and sends whole file again
+        return FakeResponse(200, CONTENT, SIZE_HEADER)
+
+    content, progress = _download(con, get_func)
+    assert content == CONTENT
+    assert progress.transferred_size == len(CONTENT)

ayon_python_api-1.2.24/tests/test_graphql_descending_pagination.py

@@ -0,0 +1,21 @@
+"""Descending GraphQl pagination must not return duplicates.
+
+Does not require running AYON server.
+"""
+from ayon_api.graphql_queries import events_graphql_query
+from ayon_api.utils import SortOrder
+
+from .graphql_fake_server import FakeServer
+
+
+def test_descending_pagination_has_no_duplicates():
+    data = {"events": [{"id": f"e{idx}"} for idx in range(700)]}
+    query = events_graphql_query({"id"}, SortOrder.descending)
+    # AYON server returns edges of a page queried with 'last' from newest
+    server = FakeServer(data, max_page_size=300, reverse_last_pages=True)
+
+    output = query.query(server)
+
+    ids = [event["id"] for event in output["events"]]
+    assert ids == [f"e{idx}" for idx in reversed(range(700))]
+    assert len(server.queries) == 3

ayon_python_api-1.2.24/tests/test_graphql_infinite_loop.py

@@ -0,0 +1,46 @@
+"""Unexpected GraphQl responses must not cause infinite loop.
+
+Does not require running AYON server.
+"""
+import pytest
+
+from ayon_api.exceptions import GraphQlQueryError
+from ayon_api.graphql_queries import events_graphql_query
+from ayon_api.utils import SortOrder
+
+from .graphql_fake_server import FakeResponse
+
+
+class _ScriptedServer:
+    """Return prepared responses, fail if queried too many times."""
+    def __init__(self, responses):
+        self._responses = responses
+        self.queries = []
+
+    def query_graphql(self, query_str, variables):
+        self.queries.append(query_str)
+        if len(self.queries) > 10:
+            raise RuntimeError("Infinite query loop")
+        idx = min(len(self.queries), len(self._responses)) - 1
+        return FakeResponse(self._responses[idx])
+
+
+def test_null_data_raises_instead_of_infinite_loop():
+    server = _ScriptedServer([{"data": None}])
+    query = events_graphql_query({"id"}, SortOrder.ascending)
+    with pytest.raises(GraphQlQueryError, match="does not contain 'data'"):
+        query.query(server)
+
+
+def test_missing_cursor_stops_pagination():
+    def page(ids, end_cursor):
+        return {"data": {"events": {
+            "edges": [{"node": {"id": id_}} for id_ in ids],
+            "pageInfo": {"endCursor": end_cursor, "hasNextPage": True},
+        }}}
+
+    server = _ScriptedServer([page(["e0"], "c0"), page([], None)])
+    query = events_graphql_query({"id"}, SortOrder.ascending)
+
+    with pytest.raises(GraphQlQueryError, match="page without a cursor"):
+        query.query(server)

ayon_python_api-1.2.24/tests/test_operations_result.py

@@ -0,0 +1,26 @@
+"""Validation of operations result. Does not require running AYON server."""
+import pytest
+
+from ayon_api.exceptions import FailedOperations
+from ayon_api.server_api import ServerAPI
+
+
+@pytest.fixture
+def con():
+    return ServerAPI("http://localhost:0", create_session=False)
+
+
+def test_failed_result_without_failed_operation_raises(con, capsys):
+    result = {"success": False, "operations": [{"id": "a", "success": True}]}
+    with pytest.raises(FailedOperations, match="Server response"):
+        con._validate_operations_result(result, [{"id": "a"}])
+    assert capsys.readouterr().out == ""
+
+
+def test_failed_operation_raises_with_detail(con):
+    result = {
+        "success": False,
+        "operations": [{"id": "a", "success": False, "detail": "Boom"}],
+    }
+    with pytest.raises(FailedOperations, match="Boom"):
+        con._validate_operations_result(result, [{"id": "a", "type": "x"}])

ayon_python_api-1.2.24/tests/test_request_max_retries_kwarg.py

@@ -0,0 +1,26 @@
+"""'max_retries' request argument. Does not require running AYON server."""
+import requests
+
+from ayon_api.server_api import ServerAPI
+
+
+def test_max_retries_kwarg_is_not_passed_to_request(monkeypatch):
+    monkeypatch.setattr("time.sleep", lambda *args, **kwargs: None)
+    con = ServerAPI("http://localhost:0", create_session=False, max_retries=5)
+    calls = []
+
+    def request_func(url, **kwargs):
+        # Real request functions raise TypeError on unknown arguments
+        if "max_retries" in kwargs:
+            raise TypeError("unexpected keyword argument 'max_retries'")
+        calls.append(kwargs)
+        raise requests.exceptions.ConnectionError("down")
+
+    response = con._do_rest_request(
+        request_func,
+        "http://localhost:0/api/x",
+        handle_invalid_token=False,
+        max_retries=2,
+    )
+    assert len(calls) == 2
+    assert response.status_code == 500

ayon_python_api-1.2.24/tests/test_request_retries.py

@@ -0,0 +1,35 @@
+"""Retries of REST requests. Does not require running AYON server."""
+import pytest
+import requests
+
+from ayon_api.server_api import ServerAPI
+
+from .fake_transfer import FakeResponse
+
+
+@pytest.fixture
+def con(monkeypatch):
+    monkeypatch.setattr("time.sleep", lambda *args, **kwargs: None)
+    return ServerAPI("http://localhost:0", create_session=False, max_retries=3)
+
+
+@pytest.mark.parametrize(
+    "failure",
+    [requests.exceptions.ConnectionError("down"), FakeResponse(503)],
+)
+def test_successful_retry_returns_successful_response(con, failure):
+    responses = [failure, FakeResponse(200, json_data={"ok": True})]
+
+    # `_do_rest_request` expects a callable that takes a URL and returns a
+    # response. So we just return fake responses to simulate it.
+    def request_func(url, **kwargs):
+        item = responses.pop(0)
+        if isinstance(item, Exception):
+            raise item
+        return item
+
+    response = con._do_rest_request(
+        request_func, "http://localhost:0/api/x", handle_invalid_token=False
+    )
+    assert response.status_code == 200
+    assert response.data == {"ok": True}