diff --git a/ayon_api/_api.py b/ayon_api/_api.py index c9083e65e..3fcab6f86 100644 --- a/ayon_api/_api.py +++ b/ayon_api/_api.py @@ -9348,6 +9348,7 @@ def get_entity_lists( project_name: str, *, list_ids: Optional[Iterable[str]] = None, + labels: Optional[Iterable[str]] = None, active: Optional[bool] = None, fields: Optional[Iterable[str]] = None, ) -> Generator[dict[str, Any], None, None]: @@ -9365,6 +9366,9 @@ def get_entity_lists( project_name (str): Project name where entity lists are. list_ids (Optional[Iterable[str]]): List of entity list ids to fetch. + labels (Optional[Iterable[str]]): Labels of entity lists to + fetch. Label must match exactly. Filtered on server since + AYON server 1.8.3, on client for older servers. active (Optional[bool]): Filter by active state of entity lists. fields (Optional[Iterable[str]]): Fields to fetch from server. @@ -9377,6 +9381,7 @@ def get_entity_lists( return con.get_entity_lists( project_name=project_name, list_ids=list_ids, + labels=labels, active=active, fields=fields, ) diff --git a/ayon_api/_api_helpers/lists.py b/ayon_api/_api_helpers/lists.py index 99dfec895..20808ec47 100644 --- a/ayon_api/_api_helpers/lists.py +++ b/ayon_api/_api_helpers/lists.py @@ -26,6 +26,7 @@ def get_entity_lists( project_name: str, *, list_ids: Optional[Iterable[str]] = None, + labels: Optional[Iterable[str]] = None, active: Optional[bool] = None, fields: Optional[Iterable[str]] = None, ) -> Generator[dict[str, Any], None, None]: @@ -43,6 +44,9 @@ def get_entity_lists( project_name (str): Project name where entity lists are. list_ids (Optional[Iterable[str]]): List of entity list ids to fetch. + labels (Optional[Iterable[str]]): Labels of entity lists to + fetch. Label must match exactly. Filtered on server since + AYON server 1.8.3, on client for older servers. active (Optional[bool]): Filter by active state of entity lists. fields (Optional[Iterable[str]]): Fields to fetch from server. @@ -84,9 +88,30 @@ def get_entity_lists( filters: dict[str, Any] = {"projectName": project_name} if list_ids is not None: + list_ids = set(list_ids) if not list_ids: return - filters["listIds"] = list(set(list_ids)) + filters["listIds"] = list(list_ids) + + # Labels are filtered on client for servers without 'filter' + # argument on 'entityLists' + client_labels = None + if labels is not None: + labels = set(labels) + if not labels: + return + + if self.get_server_version_tuple() < (1, 8, 3): + client_labels = labels + fields.add("label") + else: + filters["filter"] = json.dumps({ + "conditions": [{ + "key": "label", + "operator": "in", + "value": list(labels), + }], + }) query = entity_lists_graphql_query(fields) for attr, filter_value in filters.items(): @@ -97,6 +122,12 @@ def get_entity_lists( if active is not None and entity_list["active"] != active: continue + if ( + client_labels is not None + and entity_list["label"] not in client_labels + ): + continue + attributes = entity_list.get("attributes") if isinstance(attributes, str): entity_list["attributes"] = json.loads(attributes) diff --git a/ayon_api/graphql_queries.py b/ayon_api/graphql_queries.py index c3f85e977..0a72479c8 100644 --- a/ayon_api/graphql_queries.py +++ b/ayon_api/graphql_queries.py @@ -657,12 +657,14 @@ def entity_lists_graphql_query(fields): query = GraphQlQuery("EntityLists") project_name_var = query.add_variable("projectName", "String!") entity_list_ids = query.add_variable("listIds", "[String!]") + filter_var = query.add_variable("filter", "String!") project_field = query.add_field("project") project_field.set_filter("name", project_name_var) entity_lists_field = project_field.add_field_with_edges("entityLists") entity_lists_field.set_filter("ids", entity_list_ids) + entity_lists_field.set_filter("filter", filter_var) fields = set(fields) items_field_names = set() diff --git a/tests/test_entity_lists_labels.py b/tests/test_entity_lists_labels.py new file mode 100644 index 000000000..285c20e28 --- /dev/null +++ b/tests/test_entity_lists_labels.py @@ -0,0 +1,92 @@ +"""Filtering of 'get_entity_lists' by labels. + +Does not require running AYON server. +""" +import json + +import pytest + +from ayon_api.server_api import ServerAPI + +from .graphql_fake_server import FakeServer, parse_query + +PROJECT_NAME = "proj" +LABELS = ["a", "b", "c", "d"] + + +@pytest.fixture +def server(): + data = { + "project": { + "entityLists": [ + {"id": f"l{idx}", "label": label} + for idx, label in enumerate(LABELS) + ], + }, + } + return FakeServer(data) + + +def _create_con(monkeypatch, server, server_version): + con = ServerAPI("http://localhost:0", create_session=False) + monkeypatch.setattr(con, "query_graphql", server.query_graphql) + monkeypatch.setattr( + con, "get_server_version_tuple", lambda: (*server_version, "", "") + ) + return con + + +def _entity_lists_args(server): + """Arguments of 'entityLists' field for each sent query.""" + output = [] + for query_str, variables in server.calls: + root = parse_query(query_str, variables) + output.append(root.child("project").child("entityLists").args) + return output + + +def test_labels_filter_is_sent_to_server(monkeypatch, server): + con = _create_con(monkeypatch, server, (1, 8, 3)) + + list(con.get_entity_lists( + PROJECT_NAME, labels=["b", "c"], fields={"id"} + )) + + args = _entity_lists_args(server) + assert len(args) == 1 + query_filter = json.loads(args[0]["filter"]) + assert query_filter["conditions"][0]["key"] == "label" + assert query_filter["conditions"][0]["operator"] == "in" + assert set(query_filter["conditions"][0]["value"]) == {"b", "c"} + + +def test_labels_filter_on_client_for_old_server(monkeypatch, server): + con = _create_con(monkeypatch, server, (1, 8, 2)) + + entity_lists = list(con.get_entity_lists( + PROJECT_NAME, labels=["b", "c"], fields={"id"} + )) + + assert [entity_list["id"] for entity_list in entity_lists] == [ + "l1", "l2" + ] + assert "filter" not in _entity_lists_args(server)[0] + + +@pytest.mark.parametrize("server_version", [(1, 8, 2), (1, 8, 3)]) +def test_empty_labels_return_nothing(monkeypatch, server, server_version): + con = _create_con(monkeypatch, server, server_version) + + assert list(con.get_entity_lists( + PROJECT_NAME, labels=[], fields={"id"} + )) == [] + assert not server.calls + + +def test_no_labels_does_not_filter(monkeypatch, server): + con = _create_con(monkeypatch, server, (1, 8, 3)) + + entity_lists = list(con.get_entity_lists(PROJECT_NAME, fields={"id"})) + + assert len(entity_lists) == len(LABELS) + assert "filter" not in _entity_lists_args(server)[0] diff --git a/tests/test_review_tasks_lists_api.py b/tests/test_review_tasks_lists_api.py index 4b28efed9..d2b746147 100644 --- a/tests/test_review_tasks_lists_api.py +++ b/tests/test_review_tasks_lists_api.py @@ -1,4 +1,4 @@ -"""Tests of reviewables, task assignees and entity list order endpoints. +"""Tests of reviewables, task assignees and entity list endpoints. Tests run against a real AYON server and use the test project created by 'project_entity_fixture'. Every entity created by the tests is @@ -25,9 +25,11 @@ delete_entity_list, delete_folder, get_entity_list_rest, + get_entity_lists, get_folder_reviewables, get_product_reviewables, get_reviewables, + get_server_api_connection, get_server_version_tuple, get_task_by_id, get_task_reviewables, @@ -573,3 +575,55 @@ def test_materialize_entity_list(entity_list_fixture): assert summary["entityType"] == "folder" assert "label" in summary assert summary["count"] >= len(item_ids) + + +@pytest.mark.parametrize("client_filter", [False, True]) +def test_get_entity_lists_by_labels( + project_entity_fixture, # noqa: F811 + monkeypatch, + client_filter, +): + """Entity lists are filtered by exact label match. + + Filtering on client is used for servers older than 1.8.3. + + """ + if client_filter: + monkeypatch.setattr( + get_server_api_connection(), + "get_server_version_tuple", + lambda: (1, 8, 2, "", ""), + ) + elif get_server_version_tuple() < (1, 8, 3): + pytest.skip("Labels filter on server requires AYON server 1.8.3+") + + project_name = project_entity_fixture["name"] + prefix = _unique_name("label") + labels = [ + f"{prefix} a", + f"{prefix} O'Brien \"quoted\"", + f"{prefix} %_", + f"{prefix} b", + ] + list_ids = [ + create_entity_list(project_name, "folder", label) + for label in labels + ] + try: + def _get_ids(filter_labels): + return { + entity_list["id"] + for entity_list in get_entity_lists( + project_name, labels=filter_labels, fields={"id"} + ) + } + + assert _get_ids([labels[0]]) == {list_ids[0]} + assert _get_ids(iter(labels[1:3])) == set(list_ids[1:3]) + assert _get_ids([labels[3], f"{prefix} c"]) == {list_ids[3]} + assert _get_ids([f"{prefix} %"]) == set() + assert _get_ids([f"{prefix} A"]) == set() + assert _get_ids([]) == set() + finally: + for list_id in list_ids: + delete_entity_list(project_name, list_id)