Added additional sorting tests

Author: kzscisoft

simvue/api/objects/folder.py

@@ -94,7 +94,12 @@ def get(
         sorting: list[FolderSort] | None = None,
         **kwargs,
     ) -> typing.Generator[tuple[str, T | None], None, None]:
-        return super().get(count=count, offset=offset, sorting=sorting)
+        _params: dict[str, str] = kwargs
+
+        if sorting:
+            _params["sorting"] = json.dumps([i.to_params() for i in sorting])
+
+        return super().get(count=count, offset=offset, **_params)
 
     @property
     @staging_check

simvue/api/objects/run.py

@@ -338,7 +338,7 @@ def get(
             id of run
             Run object representing object on server
         """
-        _params: dict[str, str] = {}
+        _params: dict[str, str] = kwargs
 
         if sorting:
             _params["sorting"] = json.dumps([i.to_params() for i in sorting])

simvue/client.py

@@ -222,6 +222,11 @@ def get_runs(
             either the JSON response from the runs request or the results in the
             form of a Pandas DataFrame
 
+        Yields
+        ------
+        tuple[str, Run]
+            identifier and Run object
+
         Raises
         ------
         ValueError
@@ -434,13 +439,19 @@ def delete_alert(self, alert_id: str) -> None:
 
     @prettify_pydantic
     @pydantic.validate_call
-    def list_artifacts(self, run_id: str) -> typing.Generator[Artifact, None, None]:
+    def list_artifacts(
+        self, run_id: str, sort_by_columns: list[tuple[str, bool]] | None = None
+    ) -> typing.Generator[Artifact, None, None]:
         """Retrieve artifacts for a given run
 
         Parameters
         ----------
         run_id : str
             unique identifier for the run
+        sort_by_columns : list[tuple[str, bool]], optional
+            sort by columns in the order given,
+            list of tuples in the form (column_name: str, sort_descending: bool),
+            default is None.
 
         Yields
         ------
@@ -452,7 +463,12 @@ def list_artifacts(self, run_id: str) -> typing.Generator[Artifact, None, None]:
         RuntimeError
             if retrieval of artifacts failed when communicating with the server
         """
-        return Artifact.get(runs=json.dumps([run_id]))  # type: ignore
+        return Artifact.get(
+            runs=json.dumps([run_id]),
+            sorting=[dict(zip(("column", "descending"), a)) for a in sort_by_columns]
+            if sort_by_columns
+            else None,
+        )  # type: ignore
 
     def _retrieve_artifacts_from_server(
         self, run_id: str, name: str, count: int | None = None
@@ -582,7 +598,7 @@ def get_artifacts_as_files(
                 * input - this file is an input file.
                 * output - this file is created by the run.
                 * code - this file represents an executed script
-        output_dir : str | None, optional
+        output_dir : str | None, optTODOional
             location to download files to, the default of None will download
             them to the current working directory
 
@@ -649,6 +665,7 @@ def get_folders(
         filters: list[str] | None = None,
         count: pydantic.PositiveInt = 100,
         start_index: pydantic.NonNegativeInt = 0,
+        sort_by_columns: list[tuple[str, bool]] | None = None,
     ) -> typing.Generator[tuple[str, Folder], None, None]:
         """Retrieve folders from the server
 
@@ -660,6 +677,10 @@ def get_folders(
             maximum number of entries to return. Default is 100.
         start_index : int, optional
             the index from which to count entries. Default is 0.
+        sort_by_columns : list[tuple[str, bool]], optional
+            sort by columns in the order given,
+            list of tuples in the form (column_name: str, sort_descending: bool),
+            default is None.
 
         Returns
         -------
@@ -672,7 +693,12 @@ def get_folders(
             if there was a failure retrieving data from the server
         """
         return Folder.get(
-            filters=json.dumps(filters or []), count=count, offset=start_index
+            filters=json.dumps(filters or []),
+            count=count,
+            offset=start_index,
+            sorting=[dict(zip(("column", "descending"), a)) for a in sort_by_columns]
+            if sort_by_columns
+            else None,
         )  # type: ignore
 
     @prettify_pydantic
@@ -981,6 +1007,7 @@ def get_alerts(
         names_only: bool = True,
         start_index: pydantic.NonNegativeInt | None = None,
         count_limit: pydantic.PositiveInt | None = None,
+        sort_by_columns: list[tuple[str, bool]] | None = None,
     ) -> list[AlertBase] | list[str | None]:
         """Retrieve alerts for a given run
 
@@ -996,6 +1023,10 @@ def get_alerts(
             slice results returning only those above this index, by default None
         count_limit : typing.int, optional
             limit number of returned results, by default None
+        sort_by_columns : list[tuple[str, bool]], optional
+            sort by columns in the order given,
+            list of tuples in the form (column_name: str, sort_descending: bool),
+            default is None.
 
         Returns
         -------
@@ -1012,7 +1043,22 @@ def get_alerts(
                 raise RuntimeError(
                     "critical_only is ambiguous when returning alerts with no run ID specified."
                 )
-            return [alert.name if names_only else alert for _, alert in Alert.get()]  # type: ignore
+            return [
+                alert.name if names_only else alert
+                for _, alert in Alert.get(
+                    sorting=[
+                        dict(zip(("column", "descending"), a)) for a in sort_by_columns
+                    ]
+                    if sort_by_columns
+                    else None,
+                )
+            ]  # type: ignore
+
+        if sort_by_columns:
+            logger.warning(
+                "Run identifier specified for alert retrieval,"
+                " argument 'sort_by_columns' will be ignored"
+            )
 
         _alerts = [
             Alert(identifier=alert.get("id"), **alert)
@@ -1032,6 +1078,7 @@ def get_tags(
         *,
         start_index: pydantic.NonNegativeInt | None = None,
         count_limit: pydantic.PositiveInt | None = None,
+        sort_by_columns: list[tuple[str, bool]] | None = None,
     ) -> typing.Generator[Tag, None, None]:
         """Retrieve tags
 
@@ -1041,18 +1088,29 @@ def get_tags(
             slice results returning only those above this index, by default None
         count_limit : typing.int, optional
             limit number of returned results, by default None
+        sort_by_columns : list[tuple[str, bool]], optional
+            sort by columns in the order given,
+            list of tuples in the form (column_name: str, sort_descending: bool),
+            default is None.
 
         Returns
         -------
-        list[Tag]
-            a list of all tags for this run
+        yields
+            tag identifier
+            tag object
 
         Raises
         ------
         RuntimeError
             if there was a failure retrieving data from the server
         """
-        return Tag.get(count=count_limit, offset=start_index)
+        return Tag.get(
+            count=count_limit,
+            offset=start_index,
+            sorting=[dict(zip(("column", "descending"), a)) for a in sort_by_columns]
+            if sort_by_columns
+            else None,
+        )
 
     @prettify_pydantic
     @pydantic.validate_call

tests/functional/test_client.py

@@ -33,7 +33,12 @@ def test_get_events(create_test_run: tuple[sv_run.Run, dict]) -> None:
 @pytest.mark.parametrize(
     "critical_only", (True, False), ids=("critical_only", "all_states")
 )
-def test_get_alerts(create_plain_run: tuple[sv_run.Run, dict], from_run: bool, names_only: bool, critical_only: bool) -> None:
+def test_get_alerts(
+    create_plain_run: tuple[sv_run.Run, dict],
+    from_run: bool,
+    names_only: bool,
+    critical_only: bool,
+) -> None:
     run, run_data = create_plain_run
     run_id = run.id
     unique_id = f"{uuid.uuid4()}".split("-")[0]
@@ -52,13 +57,19 @@ def test_get_alerts(create_plain_run: tuple[sv_run.Run, dict], from_run: bool, n
     run.close()
 
     client = svc.Client()
-    
+
     if critical_only and not from_run:
         with pytest.raises(RuntimeError) as e:
-            _alerts = client.get_alerts(run_id=run_id if from_run else None, critical_only=critical_only, names_only=names_only)
+            _alerts = client.get_alerts(critical_only=critical_only, names_only=names_only)
         assert "critical_only is ambiguous when returning alerts with no run ID specified." in str(e.value)
     else:
-        _alerts = client.get_alerts(run_id=run_id if from_run else None, critical_only=critical_only, names_only=names_only)
+        sorting = None if run_id else [("name", True), ("created", True)]
+        _alerts = client.get_alerts(
+            run_id=run_id if from_run else None,
+            critical_only=critical_only,
+            names_only=names_only,
+            sort_by_columns=sorting
+        )
 
         if names_only:
             assert all(isinstance(item, str) for item in _alerts)
@@ -145,9 +156,16 @@ def test_plot_metrics(create_test_run: tuple[sv_run.Run, dict]) -> None:
 
 @pytest.mark.dependency
 @pytest.mark.client
-def test_get_artifacts_entries(create_test_run: tuple[sv_run.Run, dict]) -> None:
+@pytest.mark.parametrize(
+    "sorting", ([("metadata.test_identifier", True)], [("name", True), ("created", True)], None),
+    ids=("sorted-metadata", "sorted-name-created", None)
+)
+def test_get_artifacts_entries(create_test_run: tuple[sv_run.Run, dict], sorting: list[tuple[str, bool]] | None) -> None:
+    # TODO: Reinstate this test once server bug fixed
+    if any("metadata" in a[0] for a in sorting or []):
+        pytest.skip(reason="Server bug fix required for metadata sorting.")
     client = svc.Client()
-    assert dict(client.list_artifacts(create_test_run[1]["run_id"]))
+    assert dict(client.list_artifacts(create_test_run[1]["run_id"], sort_by_columns=sorting))
     assert client.get_artifact(create_test_run[1]["run_id"], name="test_attributes")
 
 
@@ -229,9 +247,16 @@ def test_get_run(create_test_run: tuple[sv_run.Run, dict]) -> None:
 
 @pytest.mark.dependency
 @pytest.mark.client
-def test_get_folder(create_test_run: tuple[sv_run.Run, dict]) -> None:
+@pytest.mark.parametrize(
+    "sorting", (None, [("metadata.test_identifier", True), ("path", True)], [("modified", False)]),
+    ids=("no-sort", "sort-path-metadata", "sort-modified")
+)
+def test_get_folders(create_test_run: tuple[sv_run.Run, dict], sorting: list[tuple[str, bool]] | None) -> None:
+    #TODO: Once server is fixed reinstate this test
+    if "modified" in (a[0] for a in sorting or []):
+        pytest.skip(reason="Server bug when sorting by 'modified'")
     client = svc.Client()
-    assert (folders := client.get_folders())
+    assert (folders := client.get_folders(sort_by_columns=sorting))
     _id, _folder = next(folders)
     assert _folder.path
     assert client.get_folder(_folder.path)