refactor ui to fix import cycle and continue adding type annotations

Author: amogus07

beets/dbcore/db.py

@@ -322,7 +322,7 @@ def _queries(cls) -> dict[str, type[Query]]:
     @cached_classproperty
     def _relation(cls) -> type[Model[D]]:
         """The model that this model is closely related to."""
-        return cls
+        return cls  # type: ignore[return-value]
 
     @cached_classproperty
     def relation_join(cls) -> str:
@@ -419,15 +419,15 @@ def _check_db(self, need_id: bool = True) -> D:
 
         return self._db
 
-    def copy(self) -> Model:
+    def copy(self) -> Model[D]:
         """Create a copy of the model object.
 
         The field values and other state is duplicated, but the new copy
         remains associated with the same database as the old object.
         (A simple `copy.deepcopy` will not work because it would try to
         duplicate the SQLite connection.)
         """
-        new = self.__class__()
+        new: Model[D] = type(self)()
         new._db = self._db
         new._values_fixed = self._values_fixed.copy()
         new._values_flex = self._values_flex.copy()
@@ -535,7 +535,7 @@ def update(self, values):
         for key, value in values.items():
             self[key] = value
 
-    def items(self) -> Iterator[tuple[str, Any]]:
+    def items(self) -> Iterator[tuple[str, AnyModel]]:
         """Iterate over (key, value) pairs that this object contains.
         Computed fields are not included.
         """
@@ -1013,7 +1013,7 @@ class Database:
     data is written in a transaction.
     """
 
-    def __init__(self, path, timeout: float = 5.0):
+    def __init__(self, path: bytes | str, timeout: float | int = 5.0) -> None:
         if sqlite3.threadsafety == 0:
             raise RuntimeError(
                 "sqlite3 must be compiled with multi-threading support"
@@ -1026,8 +1026,8 @@ def __init__(self, path, timeout: float = 5.0):
         if hasattr(sqlite3, "enable_callback_tracebacks"):
             sqlite3.enable_callback_tracebacks(True)
 
-        self.path = path
-        self.timeout = timeout
+        self.path: bytes | str = path
+        self.timeout: float = float(timeout)
 
         self._connections: dict[int, sqlite3.Connection] = {}
         self._tx_stacks: defaultdict[int, list[Transaction]] = defaultdict(list)

beets/dbcore/queryparse.py

@@ -40,12 +40,12 @@
 
 PARSE_QUERY_PART_REGEX = re.compile(
     # Non-capturing optional segment for the keyword.
-    r"(-|\^)?"  # Negation prefixes. #  noqa: ISC003
-    + r"(?:"
-    + r"(\S+?)"  # The field key.
-    + r"(?<!\\):"  # Unescaped :
-    + r")?"
-    + r"(.*)",  # The term itself.
+    r"(-|\^)?"  # Negation prefixes.
+    r"(?:"
+    r"(\S+?)"  # The field key.
+    r"(?<!\\):"  # Unescaped :
+    r")?"
+    r"(.*)",  # The term itself.
     re.I,  # Case-insensitive.
 )
 

beets/library/library.py

@@ -13,8 +13,12 @@
 from .queries import PF_KEY_DEFAULT, parse_query_parts, parse_query_string
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from re import Pattern
+
     from beets.dbcore import Results
     from beets.dbcore.query import Query, Sort
+    from beets.util.functemplate import Template
 
 if not sys.version_info < (3, 12):
     pass  # pyright: ignore[reportUnreachable]
@@ -29,18 +33,20 @@ class Library(dbcore.Database):
 
     def __init__(
         self,
-        path="library.blb",
+        path: bytes | str = "library.blb",
         directory: str | None = None,
-        path_formats=((PF_KEY_DEFAULT, "$artist/$album/$track $title"),),
-        replacements=None,
-    ):
-        timeout = beets.config["timeout"].as_number()
+        path_formats: Iterable[tuple[str, str | Template]] = (
+            (PF_KEY_DEFAULT, "$artist/$album/$track $title"),
+        ),
+        replacements: list[tuple[Pattern[str], str]] | None = None,
+    ) -> None:
+        timeout: int | float = beets.config["timeout"].as_number()
         super().__init__(path, timeout=timeout)
 
         self.directory = normpath(directory or platformdirs.user_music_path())
 
-        self.path_formats = path_formats
-        self.replacements = replacements
+        self.path_formats: Iterable[tuple[str, str | Template]] = path_formats
+        self.replacements: list[tuple[Pattern[str], str]] | None = replacements
 
         # Used for template substitution performance.
         self._memotable: dict[tuple[str, ...], str] = {}
@@ -91,7 +97,7 @@ def _fetch(
         model_cls: type[AnyLibModel],
         query: list[str] | Query | str | tuple[str] | None = None,
         sort: Sort | None = None,
-    ) -> Results[AnyLibModel]:
+    ) -> Results[AnyLibModel, dbcore.Database]:
         """Parse a query and fetch.
 
         If an order specification is present in the query string

beets/library/models.py

@@ -1206,9 +1206,9 @@ def move(
 
     def destination(
         self,
-        relative_to_libdir=False,
-        basedir=None,
-        path_formats=None,
+        relative_to_libdir: bool = False,
+        basedir: bytes | None = None,
+        path_formats: Iterable[tuple[str, str | Template]] | None = None,
     ) -> bytes:
         """Return the path in the library directory designated for the item
         (i.e., where the file ought to be).
@@ -1218,12 +1218,14 @@ def destination(
         is true, returns just the fragment of the path underneath the library
         base directory.
         """
-        db = self._check_db()
+        db: Library = self._check_db()
         basedir = basedir or db.directory
         path_formats = path_formats or db.path_formats
 
         # Use a path format based on a query, falling back on the
         # default.
+        query: str | Query
+        path_format: Template | str
         for query, path_format in path_formats:
             if query == PF_KEY_DEFAULT:
                 continue

beets/library/queries.py

@@ -5,6 +5,7 @@
 
 import beets
 from beets import dbcore, logging, plugins
+from beets.util import PathLike
 
 if TYPE_CHECKING:
     from typing_extensions import LiteralString
@@ -59,7 +60,7 @@ def parse_query_parts(
 
 
 def parse_query_string(
-    s: str, model_cls: type[LibModel]
+    s: PathLike, model_cls: type[LibModel]
 ) -> tuple[dbcore.Query, Sort]:
     """Given a beets query string, return the `Query` and `Sort` they
     represent.

beets/metadata_plugins.py

@@ -16,7 +16,6 @@
 from confuse import NotFoundError
 from typing_extensions import NotRequired
 
-from beets.util import cached_classproperty
 from beets.util.id_extractors import extract_release_id
 
 from .plugins import BeetsPlugin, find_plugins, notify_info_yielded, send
@@ -95,15 +94,12 @@ class MetadataSourcePlugin(BeetsPlugin, metaclass=abc.ABCMeta):
     and tracks, and to retrieve album and track information by ID.
     """
 
-    DEFAULT_DATA_SOURCE_MISMATCH_PENALTY = 0.5
+    DEFAULT_DATA_SOURCE_MISMATCH_PENALTY: float = 0.5
+    data_source: str = NotImplemented
+    """The data source name for this plugin.
 
-    @cached_classproperty
-    def data_source(cls) -> str:
-        """The data source name for this plugin.
-
-        This is inferred from the plugin name.
-        """
-        return cls.__name__.replace("Plugin", "")  # type: ignore[attr-defined]
+    This is inferred from the plugin name.
+    """
 
     @cached_property
     def data_source_mismatch_penalty(self) -> float:
@@ -112,15 +108,19 @@ def data_source_mismatch_penalty(self) -> float:
         except NotFoundError:
             return self.config["data_source_mismatch_penalty"].as_number()
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
+    def __init__(self, name: str | None = None) -> None:
+        super().__init__(name)
         self.config.add(
             {
                 "search_limit": 5,
                 "data_source_mismatch_penalty": self.DEFAULT_DATA_SOURCE_MISMATCH_PENALTY,  # noqa: E501
             }
         )
 
+    def __init_subclass__(cls) -> None:
+        super().__init_subclass__()
+        cls.data_source = cls.__name__.replace("Plugin", "")  # type: ignore[attr-defined]
+
     @abc.abstractmethod
     def album_for_id(self, album_id: str) -> AlbumInfo | None:
         """Return :py:class:`AlbumInfo` object or None if no matching release was

beets/plugins.py

@@ -33,15 +33,14 @@
 
 import beets
 from beets import logging
-from beets.dbcore import Query
 from beets.util import unique_list
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Sequence
 
     from confuse import ConfigView
 
-    from beets.dbcore import Type
+    from beets.dbcore import Query, Type
     from beets.dbcore.queryparse import Prefixes
     from beets.importer import ImportSession, ImportTask
     from beets.library import Album, Item, Library