[DEV-13086] Gallery SDK update (#371)

Kevin · web-flow · commit f09feb783dfd · 2025-05-08T09:58:05.000-07:00
diff --git a/indico/client/client.py b/indico/client/client.py
@@ -17,7 +17,7 @@
 
     from typing_extensions import Self
 
-    from indico.client.request import PagedRequest
+    from indico.client.request import PagedRequest, PagedRequestV2
     from indico.typing import Payload
 
     ReturnType = TypeVar("ReturnType")
@@ -115,7 +115,9 @@ def call(
                 "Invalid request type! Must be one of HTTPRequest or RequestChain."
             )
 
-    def paginate(self, request: "PagedRequest[ReturnType]") -> "Iterator[ReturnType]":
+    def paginate(
+        self, request: "PagedRequest[ReturnType] | PagedRequestV2[ReturnType]"
+    ) -> "Iterator[ReturnType]":
         """
         Provides a generator that continues paging through responses
         Available with List<> Requests that offer pagination
diff --git a/indico/client/request.py b/indico/client/request.py
@@ -128,6 +128,64 @@ def parse_payload(
         return raw_response
 
 
+class PagedRequestV2(GraphQLRequest[ResponseType]):
+    """
+    A new version of PagedRequest that supports pagination using cursor and total.
+    The GraphQL query should follow this structure:
+        query Name(
+            ...
+            $cursor: String
+        ){
+            items(
+                ...
+                cursor: $cursor
+            ){
+                items {...}
+                cursor
+                total
+            }
+        }
+    """
+
+    def __init__(self, query: str, variables: "Optional[AnyDict]" = None):
+        if variables is None:
+            variables = {}
+
+        variables["cursor"] = None
+        self.has_next_page = True
+        self.total = 0
+        super().__init__(query, variables=variables)
+
+    def parse_payload(
+        self, response: "AnyDict", nested_keys: "Optional[List[str]]" = None
+    ) -> "Any":
+        raw_response: "AnyDict" = cast("AnyDict", super().parse_payload(response))
+
+        if nested_keys:
+            composite = raw_response
+            for key in nested_keys:
+                if key not in composite.keys():
+                    raise IndicoInputError(
+                        f"Nested key not found in response: {key}",
+                    )
+                composite = composite[key]
+
+            pagination_data = composite
+        else:
+            pagination_data = next(iter(raw_response.values()))
+
+        if "cursor" not in pagination_data or "total" not in pagination_data:
+            raise ValueError(
+                "The supplied GraphQL query should respond with 'cursor' and 'total' fields."
+            )
+
+        self.total = pagination_data["total"]
+        self.has_next_page = pagination_data["cursor"] is not None
+        cast("AnyDict", self.variables)["cursor"] = pagination_data["cursor"]
+
+        return raw_response
+
+
 class RequestChain(Generic[ResponseType]):
     previous: "Any" = None
     result: "Optional[ResponseType]" = None
diff --git a/indico/queries/gallery.py b/indico/queries/gallery.py
@@ -1,38 +1,36 @@
 from typing import TYPE_CHECKING
 
-from indico.client.request import GraphQLRequest, PagedRequest
+from indico.client.request import GraphQLRequest, PagedRequestV2
 from indico.types.component_blueprint import BlueprintPage, BlueprintTags
 
 if TYPE_CHECKING:  # pragma: no cover
     from typing import Any, Optional
 
-    from indico.filters import ComponentBlueprintFilter
     from indico.typing import Payload
 
 
-class ListGallery(PagedRequest[BlueprintPage]):
+class ListGallery(PagedRequestV2[BlueprintPage]):
     """
     List all blueprints available in the gallery.
 
     Args:
-        filters (ComponentBlueprintFilter): filters to apply to the blueprints
+        filter (GenericScalar): filters to apply to the blueprints
         limit (int): maximum number of blueprints to return
         order_by (str): order to sort the blueprints by
         desc (bool): whether to sort the blueprints in descending order
+        cursor (str): cursor to start the pagination from
     """
 
     query = """
-        query getGalleryBlueprints($desc: Boolean, $orderBy: COMPONENTBLUEPRINT_COLUMN_ENUM, $skip: Int, $limit: Int, $after: Int, $before: Int, $filters: ComponentBlueprintFilter) {
+        query getGalleryBlueprints($asc: Boolean, $cursor: String, $sortBy: String, $size: Int, $filters: GenericScalar) {
             gallery {
                 component {
                     blueprintsPage(
-                        skip: $skip
-                        before: $before
-                        after: $after
-                        limit: $limit
-                        desc: $desc
-                        orderBy: $orderBy
-                        filters: $filters
+                        asc: $asc
+                        cursor: $cursor
+                        filter: $filters
+                        size: $size
+                        sortBy: $sortBy
                     ) {
                         componentBlueprints {
                             id
@@ -45,12 +43,8 @@ class ListGallery(PagedRequest[BlueprintPage]):
                             tags
                             modelOptions
                         }
-                        pageInfo {
-                            startCursor
-                            endCursor
-                            hasNextPage
-                            aggregateCount
-                        }
+                        cursor
+                        total
                     }
                 }
             }
@@ -59,19 +53,21 @@ class ListGallery(PagedRequest[BlueprintPage]):
 
     def __init__(
         self,
-        filters: "Optional[ComponentBlueprintFilter]" = None,
+        filters: "Optional[str]" = None,
         limit: int = 100,
-        order_by: str = "ID",
+        order_by: str = "name",
         desc: bool = False,
+        cursor: "Optional[str]" = None,
         **kwargs: "Any",
     ):
         super().__init__(
             self.query,
             variables={
                 "filters": filters,
-                "limit": limit,
-                "orderBy": order_by,
-                "desc": desc,
+                "size": limit,
+                "sortBy": order_by,
+                "asc": not desc,
+                "cursor": cursor,
                 **kwargs,
             },
         )
@@ -96,26 +92,36 @@ class GetGalleryTags(GraphQLRequest[BlueprintTags]):
 
     Args:
         component_family (str): the family of components to filter by
+        tag_categories (str): the category(ies) of tags to filter by
     """
 
     query = """
-        query getGalleryBlueprints($componentFamily: ComponentFamily) {
+        query getGalleryBlueprints($componentFamily: ComponentFamily, $tagCategories: [BPTagCategory]) {
             gallery {
                 component {
-                    availableTags(componentFamily: $componentFamily) {
+                    availableTags(componentFamily: $componentFamily, tagCategories: $tagCategories) {
                         tag
                         value
+                        tagCategory
                     }
                 }
             }
         }
     """
 
-    def __init__(self, component_family: "Optional[str]" = None):
+    def __init__(
+        self,
+        component_family: "Optional[str]" = None,
+        tag_categories: "Optional[list[str]]" = None,
+    ):
         self.component_family = component_family
+        self.tag_categories = tag_categories
         super().__init__(
             self.query,
-            variables={"componentFamily": component_family},
+            variables={
+                "componentFamily": component_family,
+                "tagCategories": tag_categories,
+            },
         )
 
     def process_response(self, response: "Payload") -> "BlueprintTags":
diff --git a/indico/types/component_blueprint.py b/indico/types/component_blueprint.py
@@ -74,6 +74,7 @@ def get_by_tags(self, tags: List[str]) -> Optional[ComponentBlueprint]:
 class Tag(BaseType):
     tag: str
     value: str
+    tag_category: str
 
 
 class BlueprintTags(BaseType):
diff --git a/tests/integration/queries/test_gallery.py b/tests/integration/queries/test_gallery.py
@@ -0,0 +1,117 @@
+import pytest
+from indico.client import IndicoClient
+from indico.queries.gallery import ListGallery, GetGalleryTags
+from indico.types.component_blueprint import BlueprintPage, BlueprintTags
+
+
+def test_list_gallery(indico):
+    """Test listing all blueprints from the gallery."""
+    client = IndicoClient()
+
+    bppage = client.call(ListGallery())
+    assert isinstance(bppage, BlueprintPage)
+    assert hasattr(bppage, "blueprints")
+
+    if bppage.blueprints:
+        blueprint = bppage.blueprints[0]
+        assert hasattr(blueprint, "id")
+        assert hasattr(blueprint, "name")
+        assert hasattr(blueprint, "component_type")
+        assert hasattr(blueprint, "icon")
+        assert hasattr(blueprint, "description")
+        assert hasattr(blueprint, "enabled")
+        assert hasattr(blueprint, "footer")
+        assert hasattr(blueprint, "tags")
+        assert hasattr(blueprint, "model_options")
+
+
+def test_list_gallery_with_args(indico):
+    """Test listing gallery blueprints with variables."""
+    client = IndicoClient()
+
+    limit_bppage = client.call(ListGallery(limit=5))
+    assert isinstance(limit_bppage, BlueprintPage)
+    assert len(limit_bppage.blueprints) <= 5
+
+    desc_bppage = client.call(ListGallery(order_by="name", desc=True))
+    assert isinstance(desc_bppage, BlueprintPage)
+
+    filters = {
+        "op": "and",
+        "filters": [
+            {
+                "op": "eq",
+                "field": "component_type",
+                "value": "model_group",
+            }
+        ],
+    }
+    filtered_bppage = client.call(ListGallery(filters=filters))
+    assert isinstance(filtered_bppage, BlueprintPage)
+    filtered_component_bps = filtered_bppage.blueprints
+    assert filtered_component_bps[0].component_type == "MODEL_GROUP"
+    assert filtered_component_bps[-1].component_type == "MODEL_GROUP"
+
+
+def test_list_gallery_pagination(indico):
+    """Test gallery pagination functionality using the new cursor-based pagination."""
+    client = IndicoClient()
+    blueprints = []
+    num_pages_to_check = 3  # Check 3 pages of results
+
+    # Use paginate to get multiple pages
+    for i, page in enumerate(client.paginate(ListGallery(limit=2))):
+        assert isinstance(page, BlueprintPage)
+        assert len(page.blueprints) <= 2
+        blueprints.extend(page.blueprints)
+
+        if i >= num_pages_to_check - 1:
+            break
+
+    # Verify we got results
+    assert blueprints is not None
+    assert len(blueprints) > 0
+
+    # Verify we got different results on each page
+    if len(blueprints) >= 2:
+        # Check that we have unique blueprints
+        blueprint_ids = [bp.id for bp in blueprints]
+        assert len(blueprint_ids) == len(set(blueprint_ids)), (
+            "Duplicate blueprints found in pagination"
+        )
+
+
+def test_get_gallery_tags(indico):
+    """Test retrieving gallery tags."""
+    client = IndicoClient()
+
+    # Test getting all tags
+    tags = client.call(GetGalleryTags())
+    assert isinstance(tags, BlueprintTags)
+    assert hasattr(tags, "tags")
+
+    # Verify tag structure
+    if tags.tags:
+        tag = tags.tags[0]
+        assert hasattr(tag, "tag")
+        assert hasattr(tag, "value")
+        assert hasattr(tag, "tag_category")
+
+
+def test_get_gallery_tags_with_args(indico):
+    """Test retrieving gallery tags with filters."""
+    client = IndicoClient()
+
+    # Test with component family filter
+    tags = client.call(GetGalleryTags(component_family="MODEL"))
+    assert isinstance(tags, BlueprintTags)
+
+    # Test with tag categories filter
+    tags = client.call(GetGalleryTags(tag_categories=["PROVIDER"]))
+    assert isinstance(tags, BlueprintTags)
+
+    # Test with both filters
+    tags = client.call(
+        GetGalleryTags(component_family="MODEL", tag_categories=["PROVIDER"])
+    )
+    assert isinstance(tags, BlueprintTags)
