Fix typing of filters

Author: kzscisoft

simvue/client.py

@@ -262,7 +262,7 @@ def get_run_name_from_id(self, run_id: str) -> str:
         return _name
 
     @prettify_pydantic
-    @pydantic.validate_call
+    @pydantic.validate_call(config={"arbitrary_types_allowed": True})
     def get_runs(
         self,
         filters: typing.Optional[typing.Union[list[str], RunsFilter]],
@@ -901,7 +901,7 @@ def get_folder(
             return None
         return _folders[0]
 
-    @pydantic.validate_call
+    @pydantic.validate_call(config={"arbitrary_types_allowed": True})
     def get_folders(
         self,
         filters: typing.Optional[typing.Union[list[str], FoldersFilter]] = None,

simvue/filter.py

@@ -153,50 +153,50 @@ def _generate_members(self) -> None:
             setattr(self, _func_name, _out_func)
 
     @pydantic.validate_call
-    def author(self, username: str = "self") -> "RunsFilter":
+    def author(self, username: str = "self") -> Self:
         self._filters.append(f"user == {username}")
         return self
 
     @pydantic.validate_call
-    def exclude_author(self, username: str = "self") -> "RunsFilter":
+    def exclude_author(self, username: str = "self") -> Self:
         self._filters.append(f"user != {username}")
         return self
 
-    def starred(self) -> "RunsFilter":
+    def starred(self) -> Self:
         self._filters.append("starred")
         return self
 
     @pydantic.validate_call
-    def has_name(self, name: str) -> "RunsFilter":
+    def has_name(self, name: str) -> Self:
         self._filters.append(f"name == {name}")
         return self
 
     @pydantic.validate_call
-    def has_name_containing(self, name: str) -> "RunsFilter":
+    def has_name_containing(self, name: str) -> Self:
         self._filters.append(f"name contains {name}")
         return self
 
     @pydantic.validate_call
-    def has_status(self, status: Status) -> "RunsFilter":
+    def has_status(self, status: Status) -> Self:
         self._filters.append(f"status == {status.value}")
         return self
 
-    def is_running(self) -> "RunsFilter":
+    def is_running(self) -> Self:
         return self.has_status(Status.Running)
 
-    def is_lost(self) -> "RunsFilter":
+    def is_lost(self) -> Self:
         return self.has_status(Status.Lost)
 
-    def has_completed(self) -> "RunsFilter":
+    def has_completed(self) -> Self:
         return self.has_status(Status.Completed)
 
-    def has_failed(self) -> "RunsFilter":
+    def has_failed(self) -> Self:
         return self.has_status(Status.Failed)
 
     @pydantic.validate_call
     def has_alert(
         self, alert_name: str, is_critical: typing.Optional[bool] = None
-    ) -> "RunsFilter":
+    ) -> Self:
         self._filters.append(f"alert.name == {alert_name}")
         if is_critical is True:
             self._filters.append("alert.status == critical")
@@ -211,7 +211,7 @@ def started_within(
         hours: pydantic.PositiveInt = 0,
         days: pydantic.PositiveInt = 0,
         years: pydantic.PositiveInt = 0,
-    ) -> "RunsFilter":
+    ) -> Self:
         return self._time_within(Time.Started, hours=hours, days=days, years=years)
 
     @pydantic.validate_call
@@ -221,7 +221,7 @@ def modified_within(
         hours: pydantic.PositiveInt = 0,
         days: pydantic.PositiveInt = 0,
         years: pydantic.PositiveInt = 0,
-    ) -> "RunsFilter":
+    ) -> Self:
         return self._time_within(Time.Modified, hours=hours, days=days, years=years)
 
     @pydantic.validate_call
@@ -231,63 +231,63 @@ def ended_within(
         hours: pydantic.PositiveInt = 0,
         days: pydantic.PositiveInt = 0,
         years: pydantic.PositiveInt = 0,
-    ) -> "RunsFilter":
+    ) -> Self:
         return self._time_within(Time.Ended, hours=hours, days=days, years=years)
 
     @pydantic.validate_call
-    def in_folder(self, folder_name: str) -> "RunsFilter":
+    def in_folder(self, folder_name: str) -> Self:
         self._filters.append(f"folder.path == {folder_name}")
         return self
 
     @pydantic.validate_call
-    def has_metadata_attribute(self, attribute: str) -> "RunsFilter":
+    def has_metadata_attribute(self, attribute: str) -> Self:
         self._filters.append(f"metadata.{attribute} exists")
         return self
 
     @pydantic.validate_call
-    def exclude_metadata_attribute(self, attribute: str) -> "RunsFilter":
+    def exclude_metadata_attribute(self, attribute: str) -> Self:
         self._filters.append(f"metadata.{attribute} not exists")
         return self
 
     def _value_eq(
         self, category: str, attribute: str, value: typing.Union[str, int, float]
-    ) -> "RunsFilter":
+    ) -> Self:
         self._filters.append(f"{category}.{attribute} == {value}")
         return self
 
     def _value_neq(
         self, category: str, attribute: str, value: typing.Union[str, int, float]
-    ) -> "RunsFilter":
+    ) -> Self:
         self._filters.append(f"{category}.{attribute} != {value}")
         return self
 
     def _value_contains(
         self, category: str, attribute: str, value: typing.Union[str, int, float]
-    ) -> "RunsFilter":
+    ) -> Self:
         self._filters.append(f"{category}.{attribute} contains {value}")
         return self
 
     def _value_leq(
         self, category: str, attribute: str, value: typing.Union[int, float]
-    ) -> "RunsFilter":
+    ) -> Self:
         self._filters.append(f"{category}.{attribute} <= {value}")
         return self
 
     def _value_geq(
         self, category: str, attribute: str, value: typing.Union[int, float]
-    ) -> "RunsFilter":
+    ) -> Self:
         self._filters.append(f"{category}.{attribute} >= {value}")
         return self
 
     def _value_lt(
         self, category: str, attribute: str, value: typing.Union[int, float]
-    ) -> "RunsFilter":
+    ) -> Self:
         self._filters.append(f"{category}.{attribute} < {value}")
         return self
 
     def _value_gt(
         self, category: str, attribute: str, value: typing.Union[int, float]
-    ) -> "RunsFilter":
+    ) -> Self:
         self._filters.append(f"{category}.{attribute} > {value}")
         return self