feat(sql): Rename filter attributes

housekeeper/store/crud/read.py

@@ -46,7 +46,7 @@ def get_bundle_by_id(self, bundle_id: int) -> Bundle:
         LOG.debug(f"Fetching bundle with id: {bundle_id}")
         return apply_bundle_filter(
             bundles=self._get_query(table=Bundle),
-            filter_functions=[BundleFilters.FILTER_BY_ID],
+            filter_functions=[BundleFilters.BY_ID],
             bundle_id=bundle_id,
         ).first()
 
@@ -55,7 +55,7 @@ def get_bundle_by_name(self, bundle_name: str) -> Bundle:
         LOG.debug(f"Fetching bundle with name: {bundle_name}")
         return apply_bundle_filter(
             bundles=self._get_query(table=Bundle),
-            filter_functions=[BundleFilters.FILTER_BY_NAME],
+            filter_functions=[BundleFilters.BY_NAME],
             bundle_name=bundle_name,
         ).first()
 
@@ -64,7 +64,7 @@ def get_version_by_date_and_bundle_name(
     ) -> Version:
         return apply_version_bundle_filter(
             version_bundles=self._get_join_version_bundle_query(),
-            filter_functions=[VersionBundleFilters.FILTER_BY_DATE_AND_NAME],
+            filter_functions=[VersionBundleFilters.BY_DATE_AND_NAME],
             version_date=version_date,
             bundle_name=bundle_name,
         ).first()
@@ -74,7 +74,7 @@ def get_version_by_id(self, version_id: int) -> Version:
         LOG.debug(f"Fetching version with id: {version_id}")
         return apply_version_filter(
             versions=self._get_query(table=Version),
-            filter_functions=[VersionFilter.FILTER_BY_ID],
+            filter_functions=[VersionFilter.BY_ID],
             version_id=version_id,
         ).first()
 
@@ -83,7 +83,7 @@ def get_tag(self, tag_name: str = None) -> Tag:
         LOG.debug(f"Fetching tag with name: {tag_name}")
         return apply_tag_filter(
             tags=self._get_query(table=Tag),
-            filter_functions=[TagFilter.FILTER_BY_NAME],
+            filter_functions=[TagFilter.BY_NAME],
             tag_name=tag_name,
         ).first()
 
@@ -96,7 +96,7 @@ def get_file_by_id(self, file_id: int) -> File | None:
         """Get a file by record id."""
         return apply_file_filter(
             files=self._get_query(table=File),
-            filter_functions=[FileFilter.FILTER_BY_ID],
+            filter_functions=[FileFilter.BY_ID],
             file_id=file_id,
         ).first()
 
@@ -122,7 +122,7 @@ def get_files(
             LOG.debug(f"Fetching files from bundle {bundle_name}")
             query = apply_bundle_filter(
                 bundles=query.join(File.version).join(Version.bundle),
-                filter_functions=[BundleFilters.FILTER_BY_NAME],
+                filter_functions=[BundleFilters.BY_NAME],
                 bundle_name=bundle_name,
             )
 
@@ -132,23 +132,23 @@ def get_files(
 
             query = apply_file_filter(
                 files=query.join(File.tags),
-                filter_functions=[FileFilter.FILTER_FILES_BY_TAGS],
+                filter_functions=[FileFilter.FILES_BY_TAGS],
                 tag_names=tag_names,
             )
 
         if version_id:
             LOG.debug(f"Fetching files from version {version_id}")
             query = apply_version_filter(
                 versions=query.join(File.version),
-                filter_functions=[VersionFilter.FILTER_BY_ID],
+                filter_functions=[VersionFilter.BY_ID],
                 version_id=version_id,
             )
 
         if file_path:
             LOG.debug(f"Fetching file with path {file_path}")
             query = apply_file_filter(
                 files=query,
-                filter_functions=[FileFilter.FILTER_BY_PATH],
+                filter_functions=[FileFilter.BY_PATH],
                 file_path=file_path,
             )
 
@@ -165,7 +165,7 @@ def get_files_before(
         if before_date:
             query = apply_version_filter(
                 versions=self._get_join_version_query(query),
-                filter_functions=[VersionFilter.FILTER_BY_DATE],
+                filter_functions=[VersionFilter.BY_DATE],
                 before_date=before_date,
             )
         return query.all()
@@ -184,13 +184,13 @@ def get_archived_files_for_bundle(self, bundle_name: str, tags: list | None) ->
         files_filtered_on_bundle: Query = apply_bundle_filter(
             bundles=self._get_join_file_tags_archive_query(),
             bundle_name=bundle_name,
-            filter_functions=[BundleFilters.FILTER_BY_NAME],
+            filter_functions=[BundleFilters.BY_NAME],
         )
         return apply_file_filter(
             files=files_filtered_on_bundle,
             filter_functions=[
-                FileFilter.FILTER_FILES_BY_TAGS,
-                FileFilter.FILTER_FILES_BY_IS_ARCHIVED,
+                FileFilter.FILES_BY_TAGS,
+                FileFilter.FILES_BY_IS_ARCHIVED,
             ],
             is_archived=True,
             tag_names=tags,
@@ -201,13 +201,13 @@ def get_non_archived_files_for_bundle(self, bundle_name: str, tags: list | None)
         files_filtered_on_bundle: Query = apply_bundle_filter(
             bundles=self._get_join_file_tags_archive_query(),
             bundle_name=bundle_name,
-            filter_functions=[BundleFilters.FILTER_BY_NAME],
+            filter_functions=[BundleFilters.BY_NAME],
         )
         return apply_file_filter(
             files=files_filtered_on_bundle,
             filter_functions=[
-                FileFilter.FILTER_FILES_BY_TAGS,
-                FileFilter.FILTER_FILES_BY_IS_ARCHIVED,
+                FileFilter.FILES_BY_TAGS,
+                FileFilter.FILES_BY_IS_ARCHIVED,
             ],
             is_archived=False,
             tag_names=tags,
@@ -218,15 +218,15 @@ def get_ongoing_archivals(self) -> list[Archive]:
         field is empty."""
         return apply_archive_filter(
             archives=self._get_query(table=Archive),
-            filter_functions=[ArchiveFilter.FILTER_ARCHIVING_ONGOING],
+            filter_functions=[ArchiveFilter.ARCHIVING_ONGOING],
         ).all()
 
     def get_ongoing_retrievals(self) -> list[Archive]:
         """Returns all retrieval tasks in the archive table, for entries where the retrieved_at
         field is empty."""
         return apply_archive_filter(
             archives=self._get_query(table=Archive),
-            filter_functions=[ArchiveFilter.FILTER_RETRIEVAL_ONGOING],
+            filter_functions=[ArchiveFilter.RETRIEVAL_ONGOING],
         ).all()
 
     def get_bundle_name_from_file_path(self, file_path: str) -> str:
@@ -239,8 +239,8 @@ def get_non_archived_files(self, tag_names: list[str], limit: int | None = None)
             apply_file_filter(
                 self._get_join_file_tags_archive_query(),
                 filter_functions=[
-                    FileFilter.FILTER_FILES_BY_TAGS,
-                    FileFilter.FILTER_FILES_BY_IS_ARCHIVED,
+                    FileFilter.FILES_BY_TAGS,
+                    FileFilter.FILES_BY_IS_ARCHIVED,
                 ],
                 tag_names=tag_names,
                 is_archived=False,
@@ -259,22 +259,22 @@ def get_archives(
             return apply_archive_filter(
                 archives=apply_archive_filter(
                     archives=self._get_query(table=Archive),
-                    filter_functions=[ArchiveFilter.FILTER_BY_ARCHIVING_TASK_ID],
+                    filter_functions=[ArchiveFilter.BY_ARCHIVING_TASK_ID],
                     task_id=archival_task_id,
                 ),
-                filter_functions=[ArchiveFilter.FILTER_BY_RETRIEVAL_TASK_ID],
+                filter_functions=[ArchiveFilter.BY_RETRIEVAL_TASK_ID],
                 task_id=retrieval_task_id,
             ).all()
         if archival_task_id:
             return apply_archive_filter(
                 archives=self._get_query(table=Archive),
-                filter_functions=[ArchiveFilter.FILTER_BY_ARCHIVING_TASK_ID],
+                filter_functions=[ArchiveFilter.BY_ARCHIVING_TASK_ID],
                 task_id=archival_task_id,
             ).all()
 
         return apply_archive_filter(
             archives=self._get_query(table=Archive),
-            filter_functions=[ArchiveFilter.FILTER_BY_RETRIEVAL_TASK_ID],
+            filter_functions=[ArchiveFilter.BY_RETRIEVAL_TASK_ID],
             task_id=retrieval_task_id,
         ).all()
 
@@ -284,13 +284,13 @@ def get_files_retrieved_before(
         """Returns all files which were retrieved before the given date."""
         old_enough_files: Query = apply_archive_filter(
             archives=self._get_join_file_tags_archive_query(),
-            filter_functions=[ArchiveFilter.FILTER_BY_RETRIEVED_BEFORE],
+            filter_functions=[ArchiveFilter.BY_RETRIEVED_BEFORE],
             retrieved_before=date,
         )
         if tag_names:
             return apply_file_filter(
                 files=old_enough_files,
-                filter_functions=[FileFilter.FILTER_FILES_BY_TAGS],
+                filter_functions=[FileFilter.FILES_BY_TAGS],
                 tag_names=tag_names,
             ).all()
         return old_enough_files.all()

housekeeper/store/crud/update.py

@@ -43,7 +43,7 @@ def update_finished_archival_task(self, archiving_task_id: int) -> None:
         """Sets the archived_at field to now for all archives with the given archiving task id."""
         completed_archives: list[Archive] = apply_archive_filter(
             archives=self._get_query(table=Archive),
-            filter_functions=[ArchiveFilter.FILTER_BY_ARCHIVING_TASK_ID],
+            filter_functions=[ArchiveFilter.BY_ARCHIVING_TASK_ID],
             task_id=archiving_task_id,
         ).all()
         for archive in completed_archives:
@@ -53,7 +53,7 @@ def update_finished_retrieval_task(self, retrieval_task_id: int) -> None:
         """Sets the archived_at field to now for all archives with the given archiving task id."""
         completed_archives: list[Archive] = apply_archive_filter(
             archives=self._get_query(table=Archive),
-            filter_functions=[ArchiveFilter.FILTER_BY_RETRIEVAL_TASK_ID],
+            filter_functions=[ArchiveFilter.BY_RETRIEVAL_TASK_ID],
             task_id=retrieval_task_id,
         ).all()
         for archive in completed_archives:

housekeeper/store/filters/archive_filters.py

@@ -40,11 +40,11 @@ def filter_by_retrieved_before(archives: Query, retrieved_before: datetime, **kw
 class ArchiveFilter(Enum):
     """Define Archive filter functions."""
 
-    FILTER_ARCHIVING_ONGOING: Callable = filter_archiving_ongoing
-    FILTER_RETRIEVAL_ONGOING: Callable = filter_retrieval_ongoing
-    FILTER_BY_ARCHIVING_TASK_ID: Callable = filter_by_archiving_task_id
-    FILTER_BY_RETRIEVAL_TASK_ID: Callable = filter_by_retrieval_task_id
-    FILTER_BY_RETRIEVED_BEFORE: Callable = filter_by_retrieved_before
+    ARCHIVING_ONGOING: Callable = filter_archiving_ongoing
+    RETRIEVAL_ONGOING: Callable = filter_retrieval_ongoing
+    BY_ARCHIVING_TASK_ID: Callable = filter_by_archiving_task_id
+    BY_RETRIEVAL_TASK_ID: Callable = filter_by_retrieval_task_id
+    BY_RETRIEVED_BEFORE: Callable = filter_by_retrieved_before
 
 
 def apply_archive_filter(

housekeeper/store/filters/bundle_filters.py

@@ -19,8 +19,8 @@ def filter_bundle_by_id(bundles: Query, bundle_id: int, **kwargs) -> Query:
 class BundleFilters(Enum):
     """Define Bundle filter functions."""
 
-    FILTER_BY_NAME: Callable = filter_bundle_by_name
-    FILTER_BY_ID: Callable = filter_bundle_by_id
+    BY_NAME: Callable = filter_bundle_by_name
+    BY_ID: Callable = filter_bundle_by_id
 
 
 def apply_bundle_filter(

housekeeper/store/filters/file_filters.py

@@ -34,10 +34,10 @@ def filter_files_by_is_archived(files: Query, is_archived: bool, **kwargs) -> Qu
 class FileFilter(Enum):
     """Define filter functions for Files joined tables."""
 
-    FILTER_BY_ID: Callable = filter_files_by_id
-    FILTER_BY_PATH: Callable = filter_files_by_path
-    FILTER_FILES_BY_TAGS: Callable = filter_files_by_tags
-    FILTER_FILES_BY_IS_ARCHIVED: Callable = filter_files_by_is_archived
+    BY_ID: Callable = filter_files_by_id
+    BY_PATH: Callable = filter_files_by_path
+    FILES_BY_TAGS: Callable = filter_files_by_tags
+    FILES_BY_IS_ARCHIVED: Callable = filter_files_by_is_archived
 
 
 def apply_file_filter(

housekeeper/store/filters/tag_filters.py

@@ -14,7 +14,7 @@ def filter_tag_by_name(tags: Query, tag_name: str) -> Query:
 class TagFilter(Enum):
     """Define Tag filter functions."""
 
-    FILTER_BY_NAME: Callable = filter_tag_by_name
+    BY_NAME: Callable = filter_tag_by_name
 
 
 def apply_tag_filter(

housekeeper/store/filters/version_bundle_filters.py

@@ -17,7 +17,7 @@ def filter_version_by_name_and_bundle_date(
 class VersionBundleFilters(Enum):
     """Define Version filter functions."""
 
-    FILTER_BY_DATE_AND_NAME: Callable = filter_version_by_name_and_bundle_date
+    BY_DATE_AND_NAME: Callable = filter_version_by_name_and_bundle_date
 
 
 def apply_version_bundle_filter(

housekeeper/store/filters/version_filters.py

@@ -20,8 +20,8 @@ def filter_version_by_date(versions: Query, before_date: datetime, **kwargs) ->
 class VersionFilter(Enum):
     """Define Version filter functions."""
 
-    FILTER_BY_ID: Callable = filter_version_by_id
-    FILTER_BY_DATE: Callable = filter_version_by_date
+    BY_ID: Callable = filter_version_by_id
+    BY_DATE: Callable = filter_version_by_date
 
 
 def apply_version_filter(

tests/store/filters/test_tag_filters.py

@@ -74,7 +74,7 @@ def test_apply_tag_filter_without_tag_name(populated_store: Store):
     # WHEN trying to retrieve a tag with None as name
     tag_query: Query = apply_tag_filter(
         tags=populated_store._get_query(table=Tag),
-        filter_functions=[TagFilter.FILTER_BY_NAME],
+        filter_functions=[TagFilter.BY_NAME],
     )
     assert isinstance(tag_query, Query)