Add types to PathQuery

Author: snejus

beets/dbcore/query.py

@@ -30,8 +30,7 @@
 from beets import util
 
 if TYPE_CHECKING:
-    from beets.dbcore import Model
-    from beets.dbcore.db import AnyModel
+    from beets.dbcore.db import AnyModel, Model
 
     P = TypeVar("P", default=Any)
 else:
@@ -283,13 +282,11 @@ class PathQuery(FieldQuery[bytes]):
     and case-sensitive otherwise.
     """
 
-    def __init__(self, field, pattern, fast=True):
+    def __init__(self, field: str, pattern: bytes, fast: bool = True) -> None:
         """Create a path query.
 
         `pattern` must be a path, either to a file or a directory.
         """
-        super().__init__(field, pattern, fast)
-
         path = util.normpath(pattern)
 
         # Case sensitivity depends on the filesystem that the query path is located on.
@@ -304,13 +301,10 @@ def __init__(self, field, pattern, fast=True):
             # from `col_clause()` do the same thing.
             path = path.lower()
 
-        # Match the path as a single file.
-        self.file_path = path
-        # As a directory (prefix).
-        self.dir_path = os.path.join(path, b"")
+        super().__init__(field, path, fast)
 
-    @classmethod
-    def is_path_query(cls, query_part):
+    @staticmethod
+    def is_path_query(query_part: str) -> bool:
         """Try to guess whether a unicode query part is a path query.
 
         Condition: separator precedes colon and the file exists.
@@ -328,22 +322,20 @@ def is_path_query(cls, query_part):
 
         return os.path.exists(util.syspath(util.normpath(query_part)))
 
-    def match(self, item):
-        path = item.path if self.case_sensitive else item.path.lower()
-        return (path == self.file_path) or path.startswith(self.dir_path)
-
-    def col_clause(self):
-        file_blob = BLOB_TYPE(self.file_path)
-        dir_blob = BLOB_TYPE(self.dir_path)
+    def match(self, obj: Model) -> bool:
+        path = obj.path if self.case_sensitive else obj.path.lower()
+        return path.startswith(self.pattern)
 
+    def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
         if self.case_sensitive:
             query_part = "({0} = ?) || (substr({0}, 1, ?) = ?)"
         else:
             query_part = "(BYTELOWER({0}) = BYTELOWER(?)) || \
                          (substr(BYTELOWER({0}), 1, ?) = BYTELOWER(?))"
 
+        dir_blob = BLOB_TYPE(os.path.join(self.pattern, b""))
         return query_part.format(self.field), (
-            file_blob,
+            BLOB_TYPE(self.pattern),
             len(dir_blob),
             dir_blob,
         )