SYMBOL INDEX (5087 symbols across 264 files)

FILE: beets/__init__.py
  function __getattr__ (line 26) | def __getattr__(name: str):
  class IncludeLazyConfig (line 35) | class IncludeLazyConfig(confuse.LazyConfig):
    method read (line 40) | def read(self, user: bool = True, defaults: bool = True) -> None:

FILE: beets/autotag/__init__.py
  function __getattr__ (line 37) | def __getattr__(name: str):
  function _apply_metadata (line 113) | def _apply_metadata(
  function correct_list_fields (line 136) | def correct_list_fields(m: LibModel) -> None:
  function apply_item_metadata (line 178) | def apply_item_metadata(item: Item, track_info: TrackInfo):
  function apply_album_metadata (line 201) | def apply_album_metadata(album_info: AlbumInfo, album: Album):
  function apply_metadata (line 207) | def apply_metadata(

FILE: beets/autotag/distance.py
  function _string_dist_basic (line 47) | def _string_dist_basic(str1: str, str2: str) -> float:
  function string_dist (line 64) | def string_dist(str1: str | None, str2: str | None) -> float:
  class Distance (line 123) | class Distance:
    method __init__ (line 129) | def __init__(self) -> None:
    method _weights (line 134) | def _weights(cls) -> dict[str, float]:
    method distance (line 145) | def distance(self) -> float:
    method max_distance (line 155) | def max_distance(self) -> float:
    method raw_distance (line 163) | def raw_distance(self) -> float:
    method items (line 170) | def items(self) -> list[tuple[str, float]]:
    method __hash__ (line 187) | def __hash__(self) -> int:
    method __eq__ (line 190) | def __eq__(self, other) -> bool:
    method __lt__ (line 195) | def __lt__(self, other) -> bool:
    method __float__ (line 198) | def __float__(self) -> float:
    method __sub__ (line 201) | def __sub__(self, other) -> float:
    method __rsub__ (line 204) | def __rsub__(self, other) -> float:
    method __str__ (line 207) | def __str__(self) -> str:
    method __getitem__ (line 212) | def __getitem__(self, key) -> float:
    method __iter__ (line 220) | def __iter__(self) -> Iterator[tuple[str, float]]:
    method __len__ (line 223) | def __len__(self) -> int:
    method keys (line 226) | def keys(self) -> list[str]:
    method update (line 229) | def update(self, dist: Distance):
    method _eq (line 240) | def _eq(self, value1: re.Pattern[str] | Any, value2: Any) -> bool:
    method add (line 249) | def add(self, key: str, dist: float):
    method add_equality (line 259) | def add_equality(
    method add_expr (line 280) | def add_expr(self, key: str, expr: bool):
    method add_number (line 289) | def add_number(self, key: str, number1: int, number2: int):
    method add_priority (line 302) | def add_priority(
    method add_ratio (line 325) | def add_ratio(
    method add_string (line 341) | def add_string(self, key: str, str1: str | None, str2: str | None):
    method add_data_source (line 348) | def add_data_source(self, before: str | None, after: str | None) -> None:
  function get_track_length_grace (line 356) | def get_track_length_grace() -> float:
  function get_track_length_max (line 362) | def get_track_length_max() -> float:
  function track_index_changed (line 367) | def track_index_changed(item: Item, track_info: TrackInfo) -> bool:
  function track_distance (line 374) | def track_distance(
  function distance (line 422) | def distance(

FILE: beets/autotag/hooks.py
  class AttrDict (line 39) | class AttrDict(dict[str, V]):
    method copy (line 42) | def copy(self) -> Self:
    method __getattr__ (line 45) | def __getattr__(self, attr: str) -> V:
    method __setattr__ (line 53) | def __setattr__(self, key: str, value: V) -> None:
    method __hash__ (line 56) | def __hash__(self) -> int:  # type: ignore[override]
  class Info (line 60) | class Info(AttrDict[Any]):
    method id (line 66) | def id(self) -> str | None:
    method identifier (line 71) | def identifier(self) -> Identifier:
    method name (line 76) | def name(self) -> str:
    method __init__ (line 79) | def __init__(
  class AlbumInfo (line 126) | class AlbumInfo(Info):
    method id (line 135) | def id(self) -> str | None:
    method name (line 139) | def name(self) -> str:
    method __init__ (line 142) | def __init__(
  class TrackInfo (line 206) | class TrackInfo(Info):
    method id (line 215) | def id(self) -> str | None:
    method name (line 219) | def name(self) -> str:
    method __init__ (line 222) | def __init__(
  class Match (line 270) | class Match:
    method type (line 275) | def type(cls) -> str:
  class AlbumMatch (line 280) | class AlbumMatch(Match):
    method __post_init__ (line 286) | def __post_init__(self) -> None:
    method item_info_pairs (line 291) | def item_info_pairs(self) -> list[tuple[Item, TrackInfo]]:
    method items (line 295) | def items(self) -> list[Item]:
  class TrackMatch (line 300) | class TrackMatch(Match):

FILE: beets/autotag/match.py
  class Recommendation (line 51) | class Recommendation(IntEnum):
  class Proposal (line 67) | class Proposal(NamedTuple):
  function assign_items (line 75) | def assign_items(
  function match_by_id (line 107) | def match_by_id(album_id: str | None, consensus: bool) -> Iterable[Album...
  function _recommendation (line 124) | def _recommendation(
  function _sort_candidates (line 181) | def _sort_candidates(candidates: Iterable[AnyMatch]) -> Sequence[AnyMatch]:
  function _add_candidate (line 186) | def _add_candidate(
  function tag_album (line 240) | def tag_album(
  function tag_item (line 328) | def tag_item(

FILE: beets/dbcore/db.py
  class DBAccessError (line 74) | class DBAccessError(Exception):
  class DBCustomFunctionError (line 83) | class DBCustomFunctionError(Exception):
    method __init__ (line 86) | def __init__(self):
  class NotFoundError (line 93) | class NotFoundError(LookupError):
  class FormattedMapping (line 97) | class FormattedMapping(Mapping[str, str]):
    method __init__ (line 115) | def __init__(
    method __getitem__ (line 129) | def __getitem__(self, key: str) -> str:
    method __iter__ (line 135) | def __iter__(self) -> Iterator[str]:
    method __len__ (line 138) | def __len__(self) -> int:
    method get (line 143) | def get(  # type: ignore
    method _get_formatted (line 153) | def _get_formatted(self, model: Model, key: str) -> str:
  class LazyConvertDict (line 181) | class LazyConvertDict:
    method __init__ (line 184) | def __init__(self, model_cls: Model):
    method init (line 191) | def init(self, data: dict[str, Any]):
    method _convert (line 195) | def _convert(self, key: str, value: Any):
    method __setitem__ (line 199) | def __setitem__(self, key: str, value: Any):
    method __getitem__ (line 203) | def __getitem__(self, key: str) -> Any:
    method __delitem__ (line 214) | def __delitem__(self, key: str):
    method keys (line 221) | def keys(self) -> list[str]:
    method copy (line 225) | def copy(self) -> LazyConvertDict:
    method update (line 234) | def update(self, values: Mapping[str, Any]):
    method items (line 239) | def items(self) -> Iterable[tuple[str, Any]]:
    method get (line 246) | def get(self, key: str, default: Any | None = None):
    method __contains__ (line 255) | def __contains__(self, key: Any) -> bool:
    method __iter__ (line 259) | def __iter__(self) -> Iterator[str]:
    method __len__ (line 270) | def __len__(self) -> int:
  class Model (line 278) | class Model(ABC, Generic[D]):
    method _types (line 328) | def _types(cls) -> dict[str, types.Type]:
    method _queries (line 338) | def _queries(cls) -> dict[str, FieldQueryType]:
    method _relation (line 356) | def _relation(cls):
    method relation_join (line 361) | def relation_join(cls) -> str:
    method all_db_fields (line 369) | def all_db_fields(cls) -> set[str]:
    method shared_db_fields (line 373) | def shared_db_fields(cls) -> set[str]:
    method other_db_fields (line 377) | def other_db_fields(cls) -> set[str]:
    method db (line 382) | def db(self) -> D:
    method get_fresh_from_db (line 389) | def get_fresh_from_db(self) -> Self:
    method _getters (line 398) | def _getters(cls: type[Model]):
    method _template_funcs (line 404) | def _template_funcs(self) -> Mapping[str, Callable[[str], str]]:
    method __init__ (line 413) | def __init__(self, db: D | None = None, **values):
    method _awaken (line 427) | def _awaken(
    method __repr__ (line 445) | def __repr__(self) -> str:
    method clear_dirty (line 451) | def clear_dirty(self):
    method _check_db (line 459) | def _check_db(self, need_id: bool = True) -> D:
    method copy (line 471) | def copy(self) -> Model:
    method _type (line 489) | def _type(cls, key) -> types.Type:
    method _get (line 497) | def _get(self, key, default: Any = None, raise_: bool = False):
    method __getitem__ (line 518) | def __getitem__(self, key):
    method _setitem (line 524) | def _setitem(self, key, value):
    method __setitem__ (line 546) | def __setitem__(self, key, value):
    method __delitem__ (line 550) | def __delitem__(self, key):
    method keys (line 562) | def keys(self, computed: bool = False):
    method all_keys (line 574) | def all_keys(cls):
    method update (line 582) | def update(self, values):
    method items (line 587) | def items(self) -> Iterator[tuple[str, Any]]:
    method __contains__ (line 594) | def __contains__(self, key) -> bool:
    method __iter__ (line 598) | def __iter__(self) -> Iterator[str]:
    method __getattr__ (line 606) | def __getattr__(self, key):
    method __setattr__ (line 615) | def __setattr__(self, key, value):
    method __delattr__ (line 621) | def __delattr__(self, key):
    method store (line 629) | def store(self, fields: Iterable[str] | None = None):
    method load (line 675) | def load(self):
    method remove (line 688) | def remove(self):
    method add (line 696) | def add(self, db: D | None = None):
    method formatted (line 723) | def formatted(
    method evaluate_template (line 733) | def evaluate_template(
    method _parse (line 755) | def _parse(cls, key, string: str) -> Any:
    method set_parse (line 762) | def set_parse(self, key, string: str):
    method __getstate__ (line 766) | def __getstate__(self):
  class Results (line 782) | class Results(Generic[AnyModel]):
    method __init__ (line 787) | def __init__(
    method _get_objects (line 827) | def _get_objects(self) -> Iterator[AnyModel]:
    method __iter__ (line 862) | def __iter__(self) -> Iterator[AnyModel]:
    method _get_indexed_flex_attrs (line 875) | def _get_indexed_flex_attrs(self) -> dict[int, FlexAttrs]:
    method _make_model (line 886) | def _make_model(
    method __len__ (line 897) | def __len__(self) -> int:
    method __nonzero__ (line 914) | def __nonzero__(self) -> bool:
    method __bool__ (line 918) | def __bool__(self) -> bool:
    method __getitem__ (line 922) | def __getitem__(self, n):
    method get (line 939) | def get(self) -> AnyModel | None:
  class Transaction (line 950) | class Transaction:
    method __init__ (line 960) | def __init__(self, db: Database):
    method __enter__ (line 963) | def __enter__(self) -> Transaction:
    method __exit__ (line 976) | def __exit__(
    method query (line 1005) | def query(
    method _handle_mutate (line 1015) | def _handle_mutate(self) -> Iterator[None]:
    method mutate (line 1036) | def mutate(self, statement: str, subvals: Sequence[SQLiteType] = ()) -...
    method mutate_many (line 1041) | def mutate_many(
    method script (line 1050) | def script(self, statements: str):
  class Migration (line 1058) | class Migration(ABC):
    method name (line 1064) | def name(cls) -> str:
    method with_row_factory (line 1070) | def with_row_factory(self, factory: type[NamedTuple]) -> Iterator[None]:
    method migrate_model (line 1079) | def migrate_model(self, model_cls: type[Model], *args, **kwargs) -> None:
    method _migrate_data (line 1087) | def _migrate_data(
  class TableInfo (line 1093) | class TableInfo(TypedDict):
  class Database (line 1098) | class Database:
    method __init__ (line 1118) | def __init__(self, path, timeout: float = 5.0):
    method db_tables (line 1162) | def db_tables(self) -> dict[str, TableInfo]:
    method _connection (line 1189) | def _connection(self) -> Connection:
    method _create_connection (line 1207) | def _create_connection(self) -> Connection:
    method add_functions (line 1247) | def add_functions(self, conn):
    method _close (line 1277) | def _close(self):
    method _tx_stack (line 1288) | def _tx_stack(self) -> Generator[list[Transaction]]:
    method transaction (line 1302) | def transaction(self) -> Transaction:
    method load_extension (line 1308) | def load_extension(self, path: str):
    method _make_table (line 1323) | def _make_table(self, table: str, fields: Mapping[str, types.Type]):
    method _make_attribute_table (line 1347) | def _make_attribute_table(self, flex_table: str):
    method _create_indices (line 1363) | def _create_indices(
    method _ensure_migration_state_table (line 1378) | def _ensure_migration_state_table(self) -> None:
    method _migrate (line 1388) | def _migrate(self) -> None:
    method migration_exists (line 1397) | def migration_exists(self, name: str, table: str) -> bool:
    method record_migration (line 1401) | def record_migration(self, name: str, table: str) -> None:
    method _fetch (line 1411) | def _fetch(
    method _get (line 1469) | def _get(self, model_cls: type[AnyModel], id_: int) -> AnyModel | None:
  class Index (line 1474) | class Index(NamedTuple):

FILE: beets/dbcore/query.py
  class ParsingError (line 50) | class ParsingError(ValueError):
  class InvalidQueryError (line 56) | class InvalidQueryError(ParsingError):
    method __init__ (line 62) | def __init__(self, query, explanation):
  class InvalidQueryArgumentValueError (line 69) | class InvalidQueryArgumentValueError(ParsingError):
    method __init__ (line 76) | def __init__(self, what, expected, detail=None):
  class Query (line 83) | class Query(ABC):
    method field_names (line 87) | def field_names(self) -> set[str]:
    method clause (line 92) | def clause(self) -> tuple[str | None, Sequence[Any]]:
    method match (line 104) | def match(self, obj: Model):
    method __and__ (line 109) | def __and__(self, other: Query) -> AndQuery:
    method __repr__ (line 112) | def __repr__(self) -> str:
    method __eq__ (line 115) | def __eq__(self, other) -> bool:
    method __hash__ (line 118) | def __hash__(self) -> int:
  class FieldQuery (line 132) | class FieldQuery(Query, Generic[P]):
    method field (line 141) | def field(self) -> str:
    method field_names (line 147) | def field_names(self) -> set[str]:
    method __init__ (line 151) | def __init__(self, field_name: str, pattern: P, fast: bool = True):
    method col_clause (line 156) | def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
    method clause (line 159) | def clause(self) -> tuple[str | None, Sequence[SQLiteType]]:
    method value_match (line 167) | def value_match(cls, pattern: P, value: Any):
    method match (line 171) | def match(self, obj: Model) -> bool:
    method __repr__ (line 174) | def __repr__(self) -> str:
    method __eq__ (line 180) | def __eq__(self, other) -> bool:
    method __hash__ (line 187) | def __hash__(self) -> int:
  class MatchQuery (line 191) | class MatchQuery(FieldQuery[AnySQLiteType]):
    method col_clause (line 194) | def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
    method value_match (line 198) | def value_match(cls, pattern: AnySQLiteType, value: Any) -> bool:
  class NoneQuery (line 202) | class NoneQuery(FieldQuery[None]):
    method __init__ (line 205) | def __init__(self, field, fast: bool = True):
    method col_clause (line 208) | def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
    method match (line 211) | def match(self, obj: Model) -> bool:
    method __repr__ (line 214) | def __repr__(self) -> str:
  class StringFieldQuery (line 218) | class StringFieldQuery(FieldQuery[P]):
    method value_match (line 224) | def value_match(cls, pattern: P, value: Any):
    method string_match (line 231) | def string_match(
  class StringQuery (line 242) | class StringQuery(StringFieldQuery[str]):
    method col_clause (line 245) | def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
    method string_match (line 256) | def string_match(cls, pattern: str, value: str) -> bool:
  class SubstringQuery (line 260) | class SubstringQuery(StringFieldQuery[str]):
    method col_clause (line 263) | def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
    method string_match (line 275) | def string_match(cls, pattern: str, value: str) -> bool:
  class PathQuery (line 279) | class PathQuery(FieldQuery[bytes]):
    method __init__ (line 287) | def __init__(self, field: str, pattern: bytes, fast: bool = True) -> N...
    method dir_path (line 309) | def dir_path(self) -> bytes:
    method is_path_query (line 313) | def is_path_query(query_part: str) -> bool:
    method match (line 329) | def match(self, obj: Model) -> bool:
    method col_clause (line 339) | def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
    method __repr__ (line 357) | def __repr__(self) -> str:
  class RegexpQuery (line 364) | class RegexpQuery(StringFieldQuery[Pattern[str]]):
    method __init__ (line 371) | def __init__(self, field_name: str, pattern: str, fast: bool = True):
    method col_clause (line 383) | def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
    method _normalize (line 387) | def _normalize(s: str) -> str:
    method string_match (line 394) | def string_match(cls, pattern: Pattern[str], value: str) -> bool:
  class BooleanQuery (line 398) | class BooleanQuery(MatchQuery[int]):
    method __init__ (line 403) | def __init__(
  class NumericQuery (line 417) | class NumericQuery(FieldQuery[str]):
    method _convert (line 426) | def _convert(self, s: str) -> float | int | None:
    method __init__ (line 443) | def __init__(self, field_name: str, pattern: str, fast: bool = True):
    method match (line 458) | def match(self, obj: Model) -> bool:
    method col_clause (line 474) | def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
  class InQuery (line 491) | class InQuery(Generic[AnySQLiteType], FieldQuery[Sequence[AnySQLiteType]]):
    method subvals (line 499) | def subvals(self) -> Sequence[SQLiteType]:
    method col_clause (line 502) | def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
    method value_match (line 507) | def value_match(
  class CollectionQuery (line 513) | class CollectionQuery(Query):
    method field_names (line 519) | def field_names(self) -> set[str]:
    method __init__ (line 523) | def __init__(self, subqueries: Sequence[Query] = ()):
    method __len__ (line 528) | def __len__(self) -> int:
    method __getitem__ (line 531) | def __getitem__(self, key):
    method __iter__ (line 534) | def __iter__(self) -> Iterator[Query]:
    method __contains__ (line 537) | def __contains__(self, subq) -> bool:
    method clause_with_joiner (line 540) | def clause_with_joiner(
    method __repr__ (line 559) | def __repr__(self) -> str:
    method __eq__ (line 562) | def __eq__(self, other) -> bool:
    method __hash__ (line 565) | def __hash__(self) -> int:
  class MutableCollectionQuery (line 572) | class MutableCollectionQuery(CollectionQuery):
    method __setitem__ (line 579) | def __setitem__(self, key, value):
    method __delitem__ (line 582) | def __delitem__(self, key):
  class AndQuery (line 586) | class AndQuery(MutableCollectionQuery):
    method clause (line 589) | def clause(self) -> tuple[str | None, Sequence[SQLiteType]]:
    method match (line 592) | def match(self, obj: Model) -> bool:
  class OrQuery (line 596) | class OrQuery(MutableCollectionQuery):
    method clause (line 599) | def clause(self) -> tuple[str | None, Sequence[SQLiteType]]:
    method match (line 602) | def match(self, obj: Model) -> bool:
  class NotQuery (line 606) | class NotQuery(Query):
    method field_names (line 612) | def field_names(self) -> set[str]:
    method __init__ (line 616) | def __init__(self, subquery):
    method clause (line 619) | def clause(self) -> tuple[str | None, Sequence[SQLiteType]]:
    method match (line 628) | def match(self, obj: Model) -> bool:
    method __repr__ (line 631) | def __repr__(self) -> str:
    method __eq__ (line 634) | def __eq__(self, other) -> bool:
    method __hash__ (line 637) | def __hash__(self) -> int:
  class TrueQuery (line 641) | class TrueQuery(Query):
    method clause (line 644) | def clause(self) -> tuple[str, Sequence[SQLiteType]]:
    method match (line 647) | def match(self, obj: Model) -> bool:
  class FalseQuery (line 651) | class FalseQuery(Query):
    method clause (line 654) | def clause(self) -> tuple[str, Sequence[SQLiteType]]:
    method match (line 657) | def match(self, obj: Model) -> bool:
  function _parse_periods (line 664) | def _parse_periods(pattern: str) -> tuple[Period | None, Period | None]:
  class Period (line 678) | class Period:
    method __init__ (line 702) | def __init__(self, date: datetime, precision: str):
    method parse (line 713) | def parse(cls: type[Period], string: str) -> Period | None:
    method open_right_endpoint (line 774) | def open_right_endpoint(self) -> datetime:
  class DateInterval (line 799) | class DateInterval:
    method __init__ (line 806) | def __init__(self, start: datetime | None, end: datetime | None):
    method from_periods (line 813) | def from_periods(
    method contains (line 823) | def contains(self, date: datetime) -> bool:
    method __str__ (line 830) | def __str__(self) -> str:
  class DateQuery (line 834) | class DateQuery(FieldQuery[str]):
    method __init__ (line 844) | def __init__(self, field_name: str, pattern: str, fast: bool = True):
    method match (line 849) | def match(self, obj: Model) -> bool:
    method col_clause (line 856) | def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
  class DurationQuery (line 879) | class DurationQuery(NumericQuery):
    method _convert (line 888) | def _convert(self, s: str) -> float | None:
  class SingletonQuery (line 907) | class SingletonQuery(FieldQuery[str]):
    method __new__ (line 918) | def __new__(cls, field: str, value: str, *args, **kwargs):
  class Sort (line 928) | class Sort:
    method order_clause (line 933) | def order_clause(self) -> str | None:
    method sort (line 939) | def sort(self, items: list[AnyModel]) -> list[AnyModel]:
    method is_slow (line 943) | def is_slow(self) -> bool:
    method __hash__ (line 949) | def __hash__(self) -> int:
    method __eq__ (line 952) | def __eq__(self, other) -> bool:
    method __repr__ (line 955) | def __repr__(self):
  class MultipleSort (line 959) | class MultipleSort(Sort):
    method __init__ (line 962) | def __init__(self, sorts: list[Sort] | None = None):
    method add_sort (line 965) | def add_sort(self, sort: Sort):
    method order_clause (line 968) | def order_clause(self) -> str:
    method is_slow (line 986) | def is_slow(self) -> bool:
    method sort (line 992) | def sort(self, items):
    method __repr__ (line 1008) | def __repr__(self):
    method __hash__ (line 1011) | def __hash__(self):
    method __eq__ (line 1014) | def __eq__(self, other):
  class FieldSort (line 1018) | class FieldSort(Sort):
    method __init__ (line 1023) | def __init__(
    method sort (line 1033) | def sort(self, objs: list[AnyModel]) -> list[AnyModel]:
    method __repr__ (line 1053) | def __repr__(self) -> str:
    method __hash__ (line 1059) | def __hash__(self) -> int:
    method __eq__ (line 1062) | def __eq__(self, other) -> bool:
  class FixedFieldSort (line 1070) | class FixedFieldSort(FieldSort):
    method order_clause (line 1073) | def order_clause(self) -> str:
  class SlowFieldSort (line 1087) | class SlowFieldSort(FieldSort):
    method is_slow (line 1092) | def is_slow(self) -> bool:
  class NullSort (line 1096) | class NullSort(Sort):
    method sort (line 1099) | def sort(self, items: list[AnyModel]) -> list[AnyModel]:
    method __nonzero__ (line 1102) | def __nonzero__(self) -> bool:
    method __bool__ (line 1105) | def __bool__(self) -> bool:
    method __eq__ (line 1108) | def __eq__(self, other) -> bool:
    method __hash__ (line 1111) | def __hash__(self) -> int:
  class SmartArtistSort (line 1115) | class SmartArtistSort(FieldSort):
    method order_clause (line 1120) | def order_clause(self):
    method sort (line 1127) | def sort(self, objs: list[AnyModel]) -> list[AnyModel]:

FILE: beets/dbcore/queryparse.py
  function parse_query_part (line 46) | def parse_query_part(
  function construct_query_part (line 116) | def construct_query_part(
  function query_from_strings (line 169) | def query_from_strings(
  function construct_sort_part (line 187) | def construct_sort_part(
  function sort_from_strings (line 218) | def sort_from_strings(
  function parse_sorted_query (line 237) | def parse_sorted_query(

FILE: beets/dbcore/types.py
  class ModelType (line 36) | class ModelType(typing.Protocol):
    method __init__ (line 42) | def __init__(self, value: Any = None): ...
  class Type (line 56) | class Type(ABC, Generic[T, N]):
    method null (line 81) | def null(self) -> N:
    method format (line 88) | def format(self, value: N | T) -> str:
    method parse (line 102) | def parse(self, string: str) -> T | N:
    method normalize (line 111) | def normalize(self, value: Any) -> T | N:
    method from_sql (line 124) | def from_sql(self, sql_value: SQLiteType) -> T | N:
    method to_sql (line 145) | def to_sql(self, model_value: Any) -> SQLiteType:
  class Default (line 155) | class Default(Type[str, None]):
    method null (line 159) | def null(self):
  class BaseInteger (line 163) | class BaseInteger(Type[int, N]):
    method normalize (line 170) | def normalize(self, value: Any) -> int | N:
  class Integer (line 179) | class Integer(BaseInteger[int]):
    method null (line 181) | def null(self) -> int:
  class NullInteger (line 185) | class NullInteger(BaseInteger[None]):
    method null (line 187) | def null(self) -> None:
  class BasePaddedInt (line 191) | class BasePaddedInt(BaseInteger[N]):
    method __init__ (line 196) | def __init__(self, digits: int):
    method format (line 199) | def format(self, value: int | N) -> str:
  class PaddedInt (line 203) | class PaddedInt(BasePaddedInt[int]):
  class NullPaddedInt (line 207) | class NullPaddedInt(BasePaddedInt[None]):
    method null (line 211) | def null(self) -> None:
  class ScaledInt (line 215) | class ScaledInt(Integer):
    method __init__ (line 220) | def __init__(self, unit: int, suffix: str = ""):
    method format (line 224) | def format(self, value: int) -> str:
  class Id (line 228) | class Id(NullInteger):
    method null (line 234) | def null(self) -> None:
    method __init__ (line 237) | def __init__(self, primary: bool = True):
  class BaseFloat (line 242) | class BaseFloat(Type[float, N]):
    method __init__ (line 251) | def __init__(self, digits: int = 1):
    method format (line 254) | def format(self, value: float | N) -> str:
  class Float (line 258) | class Float(BaseFloat[float]):
    method null (line 262) | def null(self) -> float:
  class NullFloat (line 266) | class NullFloat(BaseFloat[None]):
    method null (line 270) | def null(self) -> None:
  class BaseString (line 274) | class BaseString(Type[T, N]):
    method normalize (line 280) | def normalize(self, value: Any) -> T | N:
  class String (line 287) | class String(BaseString[str, Any]):
  class DelimitedString (line 293) | class DelimitedString(BaseString[list, list]):  # type: ignore[type-arg]
    method __init__ (line 306) | def __init__(self, db_delimiter: str):
    method format (line 309) | def format(self, value: list[str]):
    method parse (line 312) | def parse(self, string: str):
    method to_sql (line 323) | def to_sql(self, model_value: list[str]):
  class Boolean (line 327) | class Boolean(Type):
    method format (line 334) | def format(self, value: bool) -> str:
    method parse (line 337) | def parse(self, string: str) -> bool:
  class DateType (line 341) | class DateType(Float):
    method format (line 346) | def format(self, value):
    method parse (line 351) | def parse(self, string):
  class BasePathType (line 365) | class BasePathType(Type[bytes, N]):
    method parse (line 376) | def parse(self, string: str) -> bytes:
    method normalize (line 379) | def normalize(self, value: Any) -> bytes | N:
    method from_sql (line 391) | def from_sql(self, sql_value):
    method to_sql (line 394) | def to_sql(self, value: bytes) -> BLOB_TYPE:
  class NullPathType (line 400) | class NullPathType(BasePathType[None]):
    method null (line 402) | def null(self) -> None:
    method format (line 405) | def format(self, value: bytes | None) -> str:
  class PathType (line 409) | class PathType(BasePathType[bytes]):
    method null (line 411) | def null(self) -> bytes:
    method format (line 414) | def format(self, value: bytes) -> str:
  class MusicalKey (line 418) | class MusicalKey(String):
    method parse (line 434) | def parse(self, key):
    method normalize (line 442) | def normalize(self, key):
  class DurationType (line 449) | class DurationType(Float):
    method format (line 454) | def format(self, value):
    method parse (line 460) | def parse(self, string):

FILE: beets/importer/session.py
  class ImportAbortError (line 42) | class ImportAbortError(Exception):
  class ImportSession (line 48) | class ImportSession:
    method __init__ (line 61) | def __init__(
    method _setup_logging (line 92) | def _setup_logging(self, loghandler: logging.Handler | None):
    method set_config (line 100) | def set_config(self, config):
    method tag_log (line 152) | def tag_log(self, status, paths: Sequence[PathBytes]):
    method log_choice (line 158) | def log_choice(self, task: ImportTask, duplicate=False):
    method should_resume (line 179) | def should_resume(self, path: PathBytes):
    method choose_match (line 182) | def choose_match(self, task: ImportTask):
    method resolve_duplicate (line 185) | def resolve_duplicate(self, task: ImportTask, found_duplicates):
    method choose_item (line 188) | def choose_item(self, task: ImportTask):
    method run (line 191) | def run(self):
    method already_imported (line 246) | def already_imported(self, toppath: PathBytes, paths: Sequence[PathByt...
    method history_dirs (line 262) | def history_dirs(self) -> set[tuple[PathBytes, ...]]:
    method already_merged (line 268) | def already_merged(self, paths: Sequence[PathBytes]):
    method mark_merged (line 277) | def mark_merged(self, paths: Sequence[PathBytes]):
    method is_resuming (line 286) | def is_resuming(self, toppath: PathBytes):
    method ask_resume (line 293) | def ask_resume(self, toppath: PathBytes):

FILE: beets/importer/stages.py
  function read_tasks (line 46) | def read_tasks(session: ImportSession):
  function query_tasks (line 70) | def query_tasks(session: ImportSession):
  function group_albums (line 102) | def group_albums(session: ImportSession):
  function lookup_candidates (line 130) | def lookup_candidates(session: ImportSession, task: ImportTask):
  function user_query (line 150) | def user_query(session: ImportSession, task: ImportTask):
  function import_asis (line 222) | def import_asis(session: ImportSession, task: ImportTask):
  function plugin_stage (line 238) | def plugin_stage(
  function log_files (line 259) | def log_files(session: ImportSession, task: ImportTask):
  function manipulate_files (line 276) | def manipulate_files(session: ImportSession, task: ImportTask):
  function _apply_choice (line 314) | def _apply_choice(session: ImportSession, task: ImportTask):
  function _resolve_duplicates (line 337) | def _resolve_duplicates(session: ImportSession, task: ImportTask):
  function _freshen_items (line 377) | def _freshen_items(items):
  function _extend_pipeline (line 385) | def _extend_pipeline(tasks, *stages):

FILE: beets/importer/state.py
  class ImportState (line 35) | class ImportState:
    method __init__ (line 64) | def __init__(self, readonly=False, path: PathBytes | None = None):
    method __enter__ (line 70) | def __enter__(self):
    method __exit__ (line 73) | def __exit__(self, exc_type, exc_val, exc_tb):
    method _open (line 76) | def _open(
    method _save (line 92) | def _save(self):
    method progress_add (line 107) | def progress_add(self, toppath: PathBytes, *paths: PathBytes):
    method progress_has_element (line 119) | def progress_has_element(self, toppath: PathBytes, path: PathBytes) ->...
    method progress_has (line 125) | def progress_has(self, toppath: PathBytes) -> bool:
    method progress_reset (line 131) | def progress_reset(self, toppath: PathBytes | None):
    method history_add (line 139) | def history_add(self, paths: list[PathBytes]):

FILE: beets/importer/tasks.py
  class ImportAbortError (line 72) | class ImportAbortError(Exception):
  class Action (line 78) | class Action(Enum):
  class BaseImportTask (line 92) | class BaseImportTask:
    method __init__ (line 102) | def __init__(
  class ImportTask (line 129) | class ImportTask(BaseImportTask):
    method __init__ (line 170) | def __init__(
    method set_choice (line 181) | def set_choice(
    method save_progress (line 207) | def save_progress(self):
    method save_history (line 214) | def save_history(self):
    method apply (line 221) | def apply(self):
    method skip (line 225) | def skip(self):
    method chosen_info (line 230) | def chosen_info(self):
    method imported_items (line 243) | def imported_items(self):
    method apply_metadata (line 258) | def apply_metadata(self):
    method duplicate_items (line 266) | def duplicate_items(self, lib: library.Library):
    method remove_duplicates (line 272) | def remove_duplicates(self, lib: library.Library):
    method set_fields (line 282) | def set_fields(self, lib: library.Library):
    method finalize (line 303) | def finalize(self, session: ImportSession):
    method cleanup (line 323) | def cleanup(self, copy=False, delete=False, move=False):
    method _emit_imported (line 345) | def _emit_imported(self, lib: library.Library):
    method handle_created (line 348) | def handle_created(self, session: ImportSession):
    method lookup_candidates (line 362) | def lookup_candidates(self, search_ids: list[str]) -> None:
    method find_duplicates (line 372) | def find_duplicates(self, lib: library.Library) -> list[library.Album]:
    method align_album_level_fields (line 405) | def align_album_level_fields(self):
    method manipulate_files (line 446) | def manipulate_files(
    method add (line 494) | def add(self, lib: library.Library):
    method record_replaced (line 514) | def record_replaced(self, lib: library.Library):
    method reimport_metadata (line 537) | def reimport_metadata(self, lib: library.Library):
    method remove_replaced (line 615) | def remove_replaced(self, lib):
    method choose_match (line 629) | def choose_match(self, session):
    method reload (line 635) | def reload(self):
    method prune (line 643) | def prune(self, filename):
  class SingletonImportTask (line 658) | class SingletonImportTask(ImportTask):
    method __init__ (line 661) | def __init__(self, toppath: util.PathBytes | None, item: library.Item):
    method chosen_info (line 667) | def chosen_info(self):
    method imported_items (line 679) | def imported_items(self):
    method apply_metadata (line 682) | def apply_metadata(self):
    method _emit_imported (line 687) | def _emit_imported(self, lib):
    method lookup_candidates (line 691) | def lookup_candidates(self, search_ids: list[str]) -> None:
    method find_duplicates (line 696) | def find_duplicates(self, lib: library.Library) -> list[library.Item]:...
    method add (line 719) | def add(self, lib):
    method infer_album_fields (line 726) | def infer_album_fields(self):
    method choose_match (line 729) | def choose_match(self, session: ImportSession):
    method reload (line 735) | def reload(self):
    method set_fields (line 738) | def set_fields(self, lib):
  class SentinelImportTask (line 757) | class SentinelImportTask(ImportTask):
    method __init__ (line 766) | def __init__(self, toppath, paths):
    method save_history (line 773) | def save_history(self):
    method save_progress (line 776) | def save_progress(self):
    method skip (line 785) | def skip(self) -> bool:
    method set_choice (line 788) | def set_choice(self, choice):
    method cleanup (line 791) | def cleanup(self, copy=False, delete=False, move=False):
    method _emit_imported (line 794) | def _emit_imported(self, lib):
  class ArchiveImportTask (line 803) | class ArchiveImportTask(SentinelImportTask):
    method __init__ (line 816) | def __init__(self, toppath):
    method is_archive (line 821) | def is_archive(cls, path):
    method handlers (line 834) | def handlers(cls) -> list[ArchiveHandler]:
    method cleanup (line 864) | def cleanup(self, copy=False, delete=False, move=False):
    method extract (line 873) | def extract(self):
  class ImportTaskFactory (line 907) | class ImportTaskFactory:
    method __init__ (line 912) | def __init__(self, toppath: util.PathBytes, session: ImportSession):
    method tasks (line 925) | def tasks(self) -> Iterable[ImportTask]:
    method _create (line 963) | def _create(self, task: ImportTask | None):
    method paths (line 976) | def paths(self):
    method singleton (line 996) | def singleton(self, path: util.PathBytes):
    method album (line 1012) | def album(self, paths: Iterable[util.PathBytes], dirs=None):
    method sentinel (line 1039) | def sentinel(self, paths: Iterable[util.PathBytes] | None = None):
    method unarchive (line 1045) | def unarchive(self):
    method read_item (line 1074) | def read_item(self, path: util.PathBytes):
  function is_subdir_of_any_in_list (line 1098) | def is_subdir_of_any_in_list(path, dirs):
  function albums_in_dir (line 1106) | def albums_in_dir(path: util.PathBytes):

FILE: beets/library/__init__.py
  function __getattr__ (line 15) | def __getattr__(name: str):

FILE: beets/library/exceptions.py
  class FileOperationError (line 4) | class FileOperationError(Exception):
    method __init__ (line 11) | def __init__(self, path, reason):
    method __str__ (line 19) | def __str__(self):
  class ReadError (line 27) | class ReadError(FileOperationError):
    method __str__ (line 30) | def __str__(self):
  class WriteError (line 34) | class WriteError(FileOperationError):
    method __str__ (line 37) | def __str__(self):

FILE: beets/library/library.py
  class Library (line 19) | class Library(dbcore.Database):
    method __init__ (line 28) | def __init__(
    method add (line 48) | def add(self, obj):
    method add_album (line 58) | def add_album(self, items):
    method _fetch (line 87) | def _fetch(self, model_cls, query, sort=None):
    method get_default_album_sort (line 111) | def get_default_album_sort():
    method get_default_item_sort (line 118) | def get_default_item_sort():
    method albums (line 124) | def albums(self, query=None, sort=None) -> Results[Album]:
    method items (line 128) | def items(self, query=None, sort=None) -> Results[Item]:
    method get_item (line 133) | def get_item(self, id_: int) -> Item | None:
    method get_album (line 140) | def get_album(self, item_or_id: Item | int) -> Album | None:

FILE: beets/library/migrations.py
  class GenreRow (line 24) | class GenreRow(NamedTuple):
  function chunks (line 30) | def chunks(lst: list[T], n: int) -> Iterator[list[T]]:
  class MultiGenreFieldMigration (line 36) | class MultiGenreFieldMigration(Migration):
    method separators (line 40) | def separators(self) -> list[str]:
    method get_genres (line 49) | def get_genres(self, genre: str) -> str:
    method _migrate_data (line 57) | def _migrate_data(
  class LyricsRow (line 101) | class LyricsRow(NamedTuple):
  class LyricsMetadataInFlexFieldsMigration (line 106) | class LyricsMetadataInFlexFieldsMigration(Migration):
    method _migrate_data (line 109) | def _migrate_data(self, model_cls: type[Model], _: set[str]) -> None:

FILE: beets/library/models.py
  class LibModel (line 37) | class LibModel(dbcore.Model["Library"]):
    method _types (line 46) | def _types(cls) -> dict[str, types.Type]:
    method _queries (line 54) | def _queries(cls) -> dict[str, FieldQueryType]:
    method writable_media_fields (line 58) | def writable_media_fields(cls) -> set[str]:
    method filepath (line 62) | def filepath(self) -> Path:
    method _template_funcs (line 66) | def _template_funcs(self):
    method store (line 71) | def store(self, fields=None):
    method remove (line 75) | def remove(self):
    method add (line 79) | def add(self, lib=None):
    method __format__ (line 84) | def __format__(self, spec):
    method __str__ (line 90) | def __str__(self):
    method __bytes__ (line 93) | def __bytes__(self):
    method field_query (line 99) | def field_query(
    method any_field_query (line 113) | def any_field_query(cls, *args, **kwargs) -> dbcore.OrQuery:
    method any_writable_media_field_query (line 119) | def any_writable_media_field_query(cls, *args, **kwargs) -> dbcore.OrQ...
    method duplicates_query (line 125) | def duplicates_query(self, fields: list[str]) -> dbcore.AndQuery:
  class FormattedItemMapping (line 135) | class FormattedItemMapping(dbcore.db.FormattedMapping):
    method __init__ (line 143) | def __init__(self, item, included_keys=ALL_KEYS, for_path=False):
    method all_keys (line 156) | def all_keys(self):
    method album_keys (line 160) | def album_keys(self):
    method album (line 176) | def album(self):
    method _get (line 179) | def _get(self, key):
    method __getitem__ (line 193) | def __getitem__(self, key):
    method __iter__ (line 214) | def __iter__(self):
    method __len__ (line 217) | def __len__(self):
  class Album (line 221) | class Album(LibModel):
    method _types (line 282) | def _types(cls) -> dict[str, types.Type]:
    method _relation (line 338) | def _relation(cls) -> type[Item]:
    method relation_join (line 342) | def relation_join(cls) -> str:
    method art_filepath (line 354) | def art_filepath(self) -> Path | None:
    method _getters (line 359) | def _getters(cls):
    method items (line 367) | def items(self):
    method remove (line 378) | def remove(self, delete=False, with_items=True):
    method move_art (line 404) | def move_art(self, operation=MoveOperation.MOVE):
    method move (line 450) | def move(self, operation=MoveOperation.MOVE, basedir=None, store=True):
    method item_dir (line 480) | def item_dir(self):
    method _albumtotal (line 489) | def _albumtotal(self):
    method art_destination (line 509) | def art_destination(self, image, item_dir=None):
    method set_art (line 539) | def set_art(self, path, copy=True):
    method store (line 571) | def store(self, fields=None, inherit=True):
    method try_sync (line 607) | def try_sync(self, write, move, inherit=True):
    method length (line 621) | def length(self) -> float:  # type: ignore[override] # still writable ...
  class Item (line 626) | class Item(LibModel):
    method _queries (line 759) | def _queries(cls) -> dict[str, FieldQueryType]:
    method _relation (line 768) | def _relation(cls) -> type[Album]:
    method relation_join (line 772) | def relation_join(cls) -> str:
    method _cached_album (line 784) | def _cached_album(self):
    method _cached_album (line 800) | def _cached_album(self, album):
    method _getters (line 804) | def _getters(cls):
    method duplicates_query (line 810) | def duplicates_query(self, fields: list[str]) -> dbcore.AndQuery:
    method from_path (line 817) | def from_path(cls, path):
    method __setitem__ (line 825) | def __setitem__(self, key, value):
    method __getitem__ (line 841) | def __getitem__(self, key):
    method __repr__ (line 854) | def __repr__(self):
    method keys (line 863) | def keys(self, computed=False, with_album=True):
    method get (line 875) | def get(self, key, default=None, with_album=True):
    method update (line 888) | def update(self, values):
    method clear (line 897) | def clear(self):
    method get_album (line 902) | def get_album(self):
    method read (line 913) | def read(self, read_path=None):
    method write (line 944) | def write(self, path=None, tags=None, id3v23=None):
    method try_write (line 996) | def try_write(self, *args, **kwargs):
    method try_sync (line 1009) | def try_sync(self, write, move, with_album=True):
    method move_file (line 1032) | def move_file(self, dest, operation=MoveOperation.MOVE):
    method current_mtime (line 1084) | def current_mtime(self):
    method try_filesize (line 1090) | def try_filesize(self):
    method remove (line 1103) | def remove(self, delete=False, with_album=True):
    method move (line 1129) | def move(
    method destination (line 1182) | def destination(
  function _int_arg (line 1255) | def _int_arg(s):
  class DefaultTemplateFunctions (line 1264) | class DefaultTemplateFunctions:
    method _func_names (line 1276) | def _func_names(cls) -> list[str]:
    method __init__ (line 1280) | def __init__(self, item=None, lib=None):
    method functions (line 1289) | def functions(self):
    method tmpl_lower (line 1302) | def tmpl_lower(s):
    method tmpl_upper (line 1307) | def tmpl_upper(s):
    method tmpl_capitalize (line 1312) | def tmpl_capitalize(s):
    method tmpl_title (line 1317) | def tmpl_title(s):
    method tmpl_left (line 1322) | def tmpl_left(s, chars):
    method tmpl_right (line 1327) | def tmpl_right(s, chars):
    method tmpl_if (line 1332) | def tmpl_if(condition, trueval, falseval=""):
    method tmpl_asciify (line 1350) | def tmpl_asciify(s):
    method tmpl_time (line 1355) | def tmpl_time(s, fmt):
    method tmpl_aunique (line 1360) | def tmpl_aunique(self, keys=None, disam=None, bracket=None):
    method tmpl_sunique (line 1402) | def tmpl_sunique(self, keys=None, disam=None, bracket=None):
    method _tmpl_unique_memokey (line 1437) | def _tmpl_unique_memokey(self, name, keys, disam, item_id):
    method _tmpl_unique (line 1443) | def _tmpl_unique(
    method tmpl_first (line 1541) | def tmpl_first(s, count=1, skip=0, sep="; ", join_str="; "):
    method tmpl_ifdef (line 1556) | def tmpl_ifdef(self, field, trueval="", falseval=""):

FILE: beets/library/queries.py
  function parse_query_parts (line 17) | def parse_query_parts(parts, model_cls):
  function parse_query_string (line 49) | def parse_query_string(s, model_cls):

FILE: beets/logging.py
  function _logsafe (line 81) | def _logsafe(val: T) -> str | T:
  class StrFormatLogger (line 105) | class StrFormatLogger(Logger):
    class _LogMessage (line 117) | class _LogMessage:
      method __init__ (line 118) | def __init__(
      method __str__ (line 128) | def __str__(self):
    method _log (line 133) | def _log(
  class ThreadLocalLevelLogger (line 160) | class ThreadLocalLevelLogger(Logger):
    method __init__ (line 163) | def __init__(self, name, level=NOTSET):
    method level (line 169) | def level(self):
    method level (line 177) | def level(self, value):
    method set_global_level (line 180) | def set_global_level(self, level):
  class BeetsLogger (line 188) | class BeetsLogger(ThreadLocalLevelLogger, StrFormatLogger):
    method extra_debug (line 191) | def extra_debug(self, msg: str, *args: Any, **kwargs: Any) -> None:
  function getLogger (line 209) | def getLogger(name: str) -> BeetsLogger: ...
  function getLogger (line 211) | def getLogger(name: None = ...) -> RootLogger: ...
  function getLogger (line 212) | def getLogger(name=None) -> BeetsLogger | RootLogger:  # noqa: N802

FILE: beets/metadata_plugins.py
  function find_metadata_source_plugins (line 45) | def find_metadata_source_plugins() -> list[MetadataSourcePlugin]:
  function get_metadata_source (line 53) | def get_metadata_source(name: str) -> MetadataSourcePlugin | None:
  function maybe_handle_plugin_error (line 61) | def maybe_handle_plugin_error(plugin: MetadataSourcePlugin, method_name:...
  function _yield_from_plugins (line 75) | def _yield_from_plugins(
  function candidates (line 92) | def candidates(*args, **kwargs) -> Iterator[AlbumInfo]:
  function item_candidates (line 98) | def item_candidates(*args, **kwargs) -> Iterator[TrackInfo]:
  function albums_for_ids (line 104) | def albums_for_ids(*args, **kwargs) -> Iterator[AlbumInfo]:
  function tracks_for_ids (line 110) | def tracks_for_ids(*args, **kwargs) -> Iterator[TrackInfo]:
  function album_for_id (line 114) | def album_for_id(_id: str, data_source: str) -> AlbumInfo | None:
  function track_for_id (line 125) | def track_for_id(_id: str, data_source: str) -> TrackInfo | None:
  function get_penalty (line 137) | def get_penalty(data_source: str | None) -> float:
  class MetadataSourcePlugin (line 149) | class MetadataSourcePlugin(BeetsPlugin, metaclass=abc.ABCMeta):
    method data_source (line 160) | def data_source(cls) -> str:
    method data_source_mismatch_penalty (line 168) | def data_source_mismatch_penalty(self) -> float:
    method __init__ (line 174) | def __init__(self, *args, **kwargs) -> None:
    method album_for_id (line 184) | def album_for_id(self, album_id: str) -> AlbumInfo | None:
    method track_for_id (line 190) | def track_for_id(self, track_id: str) -> TrackInfo | None:
    method candidates (line 199) | def candidates(
    method item_candidates (line 218) | def item_candidates(
    method albums_for_ids (line 231) | def albums_for_ids(self, ids: Iterable[str]) -> Iterable[AlbumInfo | N...
    method tracks_for_ids (line 242) | def tracks_for_ids(self, ids: Iterable[str]) -> Iterable[TrackInfo | N...
    method _extract_id (line 253) | def _extract_id(self, url: str) -> str | None:
    method get_artist (line 262) | def get_artist(
  class IDResponse (line 310) | class IDResponse(TypedDict):
  class SearchParams (line 316) | class SearchParams(NamedTuple):
  class SearchApiMetadataSourcePlugin (line 332) | class SearchApiMetadataSourcePlugin(
    method __init__ (line 344) | def __init__(self, *args, **kwargs) -> None:
    method get_search_query_with_filters (line 353) | def get_search_query_with_filters(
    method get_search_response (line 376) | def get_search_response(self, params: SearchParams) -> Sequence[R]:
    method _search_api (line 388) | def _search_api(
    method _get_candidates (line 417) | def _get_candidates(
    method candidates (line 427) | def candidates(
    method item_candidates (line 437) | def item_candidates(

FILE: beets/plugins.py
  class PluginConflictError (line 104) | class PluginConflictError(Exception):
  class PluginImportError (line 112) | class PluginImportError(ImportError):
    method __init__ (line 119) | def __init__(self, name: str):
  class PluginLogFilter (line 123) | class PluginLogFilter(logging.Filter):
    method __init__ (line 128) | def __init__(self, plugin):
    method filter (line 131) | def filter(self, record):
  class BeetsPluginMeta (line 143) | class BeetsPluginMeta(abc.ABCMeta):
  class BeetsPlugin (line 149) | class BeetsPlugin(metaclass=BeetsPluginMeta):
    method __init_subclass__ (line 169) | def __init_subclass__(cls) -> None:
    method __init__ (line 223) | def __init__(self, name: str | None = None):
    method _verify_config (line 247) | def _verify_config(self, *_, **__) -> None:
    method commands (line 276) | def commands(self) -> Sequence[Subcommand]:
    method _set_stage_log_level (line 282) | def _set_stage_log_level(
    method get_early_import_stages (line 292) | def get_early_import_stages(self) -> list[ImportStageFunc]:
    method get_import_stages (line 302) | def get_import_stages(self) -> list[ImportStageFunc]:
    method _set_log_level_and_params (line 312) | def _set_log_level_and_params(
    method queries (line 341) | def queries(self) -> dict[str, type[Query]]:
    method add_media_field (line 345) | def add_media_field(
    method register_listener (line 361) | def register_listener(self, event: EventType, func: Listener) -> None:
    method template_func (line 370) | def template_func(cls, name: str) -> Callable[[TFunc[str]], TFunc[str]]:
    method template_field (line 383) | def template_field(cls, name: str) -> Callable[[TFunc[Item]], TFunc[It...
  function get_plugin_names (line 397) | def get_plugin_names() -> list[str]:
  function _get_plugin (line 438) | def _get_plugin(name: str) -> BeetsPlugin | None:
  function load_plugins (line 481) | def load_plugins() -> None:
  function find_plugins (line 496) | def find_plugins() -> Iterable[BeetsPlugin]:
  function commands (line 503) | def commands() -> list[Subcommand]:
  function queries (line 511) | def queries() -> dict[str, type[Query]]:
  function types (line 521) | def types(model_cls: type[AnyModel]) -> dict[str, Type]:
  function named_queries (line 538) | def named_queries(model_cls: type[AnyModel]) -> dict[str, FieldQueryType]:
  function notify_info_yielded (line 548) | def notify_info_yielded(
  function template_funcs (line 572) | def template_funcs() -> TFuncMap[str]:
  function early_import_stages (line 582) | def early_import_stages() -> list[ImportStageFunc]:
  function import_stages (line 590) | def import_stages() -> list[ImportStageFunc]:
  function _check_conflicts_and_merge (line 603) | def _check_conflicts_and_merge(
  function item_field_getters (line 620) | def item_field_getters() -> TFuncMap[Item]:
  function album_field_getters (line 630) | def album_field_getters() -> TFuncMap[Album]:
  function send (line 641) | def send(event: EventType, **arguments: Any) -> list[Any]:
  function feat_tokens (line 657) | def feat_tokens(
  function apply_item_changes (line 675) | def apply_item_changes(

FILE: beets/test/_common.py
  function item (line 72) | def item(lib=None, **kwargs):
  function import_session (line 115) | def import_session(lib=None, loghandler=None, paths=[], query=[], cli=Fa...
  class InputError (line 127) | class InputError(IOError):
    method __str__ (line 128) | def __str__(self) -> str:
  class DummyIn (line 132) | class DummyIn:
    method __init__ (line 135) | def __init__(self) -> None:
    method add (line 138) | def add(self, s: str) -> None:
    method close (line 141) | def close(self) -> None:
    method readline (line 144) | def readline(self) -> str:
  class DummyIO (line 151) | class DummyIO:
    method __init__ (line 154) | def __init__(
    method addinput (line 164) | def addinput(self, text: str) -> None:
    method getoutput (line 168) | def getoutput(self) -> str:
  function touch (line 181) | def touch(path):
  class Bag (line 185) | class Bag:
    method __init__ (line 191) | def __init__(self, **fields):
    method __getattr__ (line 194) | def __getattr__(self, key):
  function platform_windows (line 202) | def platform_windows():
  function platform_posix (line 214) | def platform_posix():
  function system_mock (line 226) | def system_mock(name):
  function slow_test (line 237) | def slow_test(unused=None):

FILE: beets/test/helper.py
  class LogCapture (line 63) | class LogCapture(logging.Handler):
    method __init__ (line 64) | def __init__(self):
    method emit (line 68) | def emit(self, record):
  function capture_log (line 73) | def capture_log(logger="beets"):
  function has_program (line 83) | def has_program(cmd, args=["--version"]):
  function check_reflink_support (line 99) | def check_reflink_support(path: str) -> bool:
  class ConfigMixin (line 108) | class ConfigMixin:
    method config (line 110) | def config(self) -> beets.IncludeLazyConfig:
  class RunMixin (line 128) | class RunMixin:
    method run_command (line 129) | def run_command(self, *args, **kwargs):
  class IOMixin (line 143) | class IOMixin(RunMixin):
    method run_with_output (line 146) | def run_with_output(self, *args):
  class TestHelper (line 152) | class TestHelper(RunMixin, ConfigMixin):
    method temp_dir_path (line 166) | def temp_dir_path(self) -> Path:
    method temp_dir (line 170) | def temp_dir(self) -> bytes:
    method lib_path (line 174) | def lib_path(self) -> Path:
    method libdir (line 180) | def libdir(self) -> bytes:
    method setup_beets (line 185) | def setup_beets(self):
    method teardown_beets (line 223) | def teardown_beets(self):
    method create_item (line 230) | def create_item(self, **values):
    method add_item (line 259) | def add_item(self, **values):
    method add_item_fixture (line 281) | def add_item_fixture(self, **values):
    method add_album (line 293) | def add_album(self, **values):
    method add_item_fixtures (line 297) | def add_item_fixtures(self, ext="mp3", count=1):
    method add_album_fixture (line 314) | def add_album_fixture(
    method create_mediafile_fixture (line 341) | def create_mediafile_fixture(self, ext="mp3", images=[], target_dir=No...
    method create_temp_dir (line 371) | def create_temp_dir(self, **kwargs) -> str:
    method remove_temp_dir (line 374) | def remove_temp_dir(self):
    method touch (line 378) | def touch(self, path, dir=None, content=""):
  class BeetsTestCase (line 402) | class BeetsTestCase(unittest.TestCase, TestHelper):
    method setUp (line 410) | def setUp(self):
    method tearDown (line 413) | def tearDown(self):
  class ItemInDBTestCase (line 417) | class ItemInDBTestCase(BeetsTestCase):
    method setUp (line 422) | def setUp(self):
  class PluginMixin (line 427) | class PluginMixin(ConfigMixin):
    method setup_beets (line 431) | def setup_beets(self):
    method teardown_beets (line 436) | def teardown_beets(self):
    method register_plugin (line 440) | def register_plugin(
    method load_plugins (line 445) | def load_plugins(self, *plugins: str) -> None:
    method unload_plugins (line 456) | def unload_plugins(self) -> None:
    method configure_plugin (line 465) | def configure_plugin(self, config: Any):
  class PluginTestCase (line 474) | class PluginTestCase(PluginMixin, BeetsTestCase):
  class ImportHelper (line 478) | class ImportHelper(TestHelper):
    method import_path (line 499) | def import_path(self) -> Path:
    method import_dir (line 505) | def import_dir(self) -> bytes:
    method setUp (line 508) | def setUp(self):
    method prepare_track_for_import (line 517) | def prepare_track_for_import(
    method prepare_album_for_import (line 542) | def prepare_album_for_import(
    method prepare_albums_for_import (line 567) | def prepare_albums_for_import(self, count: int = 1) -> None:
    method _get_import_session (line 574) | def _get_import_session(self, import_dir: bytes) -> ImportSession:
    method setup_importer (line 582) | def setup_importer(
    method setup_singleton_importer (line 589) | def setup_singleton_importer(self, **kwargs) -> ImportSession:
  class AsIsImporterMixin (line 593) | class AsIsImporterMixin:
    method setUp (line 594) | def setUp(self):
    method run_asis_importer (line 598) | def run_asis_importer(self, **kwargs):
  class ImportTestCase (line 604) | class ImportTestCase(ImportHelper, BeetsTestCase):
  class ImportSessionFixture (line 608) | class ImportSessionFixture(ImportSession):
    method __init__ (line 623) | def __init__(self, *args, **kwargs):
    method add_choice (line 630) | def add_choice(self, choice):
    method clear_choices (line 633) | def clear_choices(self):
    method choose_match (line 636) | def choose_match(self, task):
    method resolve_duplicate (line 655) | def resolve_duplicate(self, task, found_duplicates):
  class TerminalImportSessionFixture (line 669) | class TerminalImportSessionFixture(TerminalImportSession):
    method __init__ (line 670) | def __init__(self, *args, **kwargs):
    method add_choice (line 677) | def add_choice(self, choice):
    method clear_choices (line 680) | def clear_choices(self):
    method choose_match (line 683) | def choose_match(self, task):
    method choose_item (line 687) | def choose_item(self, task):
    method _add_choice_input (line 691) | def _add_choice_input(self):
  class TerminalImportMixin (line 713) | class TerminalImportMixin(IOMixin, ImportHelper):
    method _get_import_session (line 716) | def _get_import_session(self, import_dir: bytes) -> importer.ImportSes...
  class AutotagStub (line 727) | class AutotagStub:
    method install (line 741) | def install(self):
    method restore (line 755) | def restore(self):
    method candidates (line 759) | def candidates(self, items, artist, album, va_likely):
    method item_candidates (line 774) | def item_candidates(self, item, artist, title):
    method _make_track_match (line 784) | def _make_track_match(self, artist, album, number):
    method _make_album_match (line 793) | def _make_album_match(self, artist, album, tracks, distance=0, missing...
  class AutotagImportTestCase (line 819) | class AutotagImportTestCase(ImportTestCase):
    method setUp (line 822) | def setUp(self):
  class FetchImageHelper (line 828) | class FetchImageHelper:
    method run (line 834) | def run(self, *args, **kwargs):
    method mock_response (line 849) | def mock_response(
  class CleanupModulesMixin (line 877) | class CleanupModulesMixin:
    method tearDownClass (line 881) | def tearDownClass(cls) -> None:

FILE: beets/ui/__init__.py
  class UserError (line 71) | class UserError(Exception):
  function _in_encoding (line 80) | def _in_encoding():
  function _out_encoding (line 85) | def _out_encoding():
  function _stream_encoding (line 90) | def _stream_encoding(stream, default="utf-8"):
  function decargs (line 111) | def decargs(arglist):
  function print_ (line 122) | def print_(*strings: str, end: str = "\n") -> None:
  function _bool_fallback (line 150) | def _bool_fallback(a, b):
  function should_write (line 160) | def should_write(write_opt=None):
  function should_move (line 167) | def should_move(move_opt=None):
  function input_ (line 187) | def input_(prompt=None):
  function input_options (line 207) | def input_options(
  function input_yn (line 383) | def input_yn(prompt, require=False):
  function input_select_objects (line 395) | def input_select_objects(prompt, objs, rep, prompt_all=None):
  function get_path_formats (line 433) | def get_path_formats(subview=None):
  function get_replacements (line 445) | def get_replacements():
  function term_width (line 460) | def term_width() -> int:
  function show_model_changes (line 466) | def show_model_changes(
  class CommonOptionsParser (line 498) | class CommonOptionsParser(optparse.OptionParser):
    method __init__ (line 514) | def __init__(self, *args, **kwargs):
    method add_album_option (line 521) | def add_album_option(self, flags=("-a", "--album")):
    method _set_format (line 534) | def _set_format(
    method add_path_option (line 571) | def add_path_option(self, flags=("-p", "--path")):
    method add_format_option (line 591) | def add_format_option(self, flags=("-f", "--format"), target=None):
    method add_all_common_options (line 621) | def add_all_common_options(self):
  class Subcommand (line 637) | class Subcommand:
    method __init__ (line 644) | def __init__(self, name, parser=None, help="", aliases=(), hide=False):
    method print_help (line 658) | def print_help(self):
    method parse_args (line 661) | def parse_args(self, args):
    method root_parser (line 665) | def root_parser(self):
    method root_parser (line 669) | def root_parser(self, root_parser):
  class SubcommandsOptionParser (line 676) | class SubcommandsOptionParser(CommonOptionsParser):
    method __init__ (line 681) | def __init__(self, *args, **kwargs):
    method add_subcommand (line 701) | def add_subcommand(self, *cmds):
    method format_help (line 708) | def format_help(self, formatter=None):
    method _subcommand_for_name (line 760) | def _subcommand_for_name(self, name):
    method parse_global_options (line 770) | def parse_global_options(self, args):
    method parse_subcommand (line 783) | def parse_subcommand(self, args):
  function _setup (line 807) | def _setup(
  function _configure (line 831) | def _configure(options):
  function _ensure_db_directory_exists (line 868) | def _ensure_db_directory_exists(path):
  function _open_library (line 880) | def _open_library(config: confuse.LazyConfig) -> library.Library:
  function _raw_main (line 906) | def _raw_main(args: list[str], lib=None) -> None:
  function main (line 1000) | def main(args=None):

FILE: beets/ui/commands/__init__.py
  function __getattr__ (line 36) | def __getattr__(name: str):

FILE: beets/ui/commands/completion.py
  function print_completion (line 13) | def print_completion(*args):
  function completion_script (line 44) | def completion_script(commands):

FILE: beets/ui/commands/config.py
  function config_func (line 9) | def config_func(lib, opts, args):
  function config_edit (line 47) | def config_edit(cli_options):

FILE: beets/ui/commands/fields.py
  function _print_keys (line 8) | def _print_keys(query):
  function fields_func (line 16) | def fields_func(lib, opts, args):

FILE: beets/ui/commands/help.py
  class HelpCommand (line 6) | class HelpCommand(ui.Subcommand):
    method __init__ (line 7) | def __init__(self):
    method func (line 14) | def func(self, lib, opts, args):

FILE: beets/ui/commands/import_/__init__.py
  function paths_from_logfile (line 14) | def paths_from_logfile(path):
  function parse_logfiles (line 34) | def parse_logfiles(logfiles):
  function import_files (line 49) | def import_files(lib, paths: list[bytes], query):
  function import_func (line 81) | def import_func(lib, opts, args: list[str]):
  function _store_dict (line 134) | def _store_dict(option, opt_str, value, parser):

FILE: beets/ui/commands/import_/display.py
  class ChangeRepresentation (line 30) | class ChangeRepresentation:
    method changed_prefix (line 42) | def changed_prefix(self) -> str:
    method _indentation_config (line 46) | def _indentation_config(self) -> confuse.Subview:
    method indent_header (line 50) | def indent_header(self) -> str:
    method indent_detail (line 54) | def indent_detail(self) -> str:
    method indent_tracklist (line 58) | def indent_tracklist(self) -> str:
    method print_layout (line 61) | def print_layout(self, indent: str, left: Side, right: Side) -> None:
    method show_match_header (line 65) | def show_match_header(self) -> None:
    method show_match_details (line 99) | def show_match_details(self) -> None:
    method make_medium_info_line (line 128) | def make_medium_info_line(self, track_info: hooks.TrackInfo) -> str:
    method format_index (line 143) | def format_index(self, track_info: hooks.TrackInfo | Item) -> str:
    method make_track_numbers (line 164) | def make_track_numbers(
    method make_track_titles (line 187) | def make_track_titles(
    method make_track_lengths (line 203) | def make_track_lengths(
    method make_line (line 232) | def make_line(
    method print_tracklist (line 269) | def print_tracklist(self, lines: list[tuple[Side, Side]]) -> None:
  class AlbumChange (line 308) | class AlbumChange(ChangeRepresentation):
    method show_match_tracks (line 311) | def show_match_tracks(self) -> None:
  class TrackChange (line 366) | class TrackChange(ChangeRepresentation):
  function show_change (line 372) | def show_change(
  function show_item_change (line 391) | def show_item_change(item: Item, match: hooks.TrackMatch) -> None:
  function disambig_string (line 402) | def disambig_string(info: hooks.Info) -> str:
  function get_singleton_disambig_fields (line 417) | def get_singleton_disambig_fields(info: hooks.TrackInfo) -> Sequence[str]:
  function get_album_disambig_fields (line 445) | def get_album_disambig_fields(info: hooks.AlbumInfo) -> Sequence[str]:
  function dist_string (line 468) | def dist_string(dist: Distance) -> str:
  function penalty_string (line 476) | def penalty_string(distance: Distance, limit: int | None = None) -> str:

FILE: beets/ui/commands/import_/session.py
  class TerminalImportSession (line 21) | class TerminalImportSession(importer.ImportSession):
    method choose_match (line 24) | def choose_match(self, task):
    method choose_item (line 102) | def choose_item(self, task):
    method resolve_duplicate (line 142) | def resolve_duplicate(self, task, found_duplicates):
    method should_resume (line 206) | def should_resume(self, path):
    method _get_choices (line 212) | def _get_choices(self, task):
  function summarize_items (line 287) | def summarize_items(items, singleton):
  function _summary_judgment (line 330) | def _summary_judgment(rec: Recommendation) -> importer.Action | None:
  function choose_candidate (line 369) | def choose_candidate(
  function manual_search (line 513) | def manual_search(session, task):
  function manual_id (line 529) | def manual_id(session, task):
  function abort_action (line 544) | def abort_action(session, task):

FILE: beets/ui/commands/list.py
  function list_items (line 6) | def list_items(lib, query, album, fmt=""):
  function list_func (line 18) | def list_func(lib, opts, args):

FILE: beets/ui/commands/modify.py
  function modify_items (line 9) | def modify_items(lib, mods, dels, query, write, move, album, confirm, in...
  function print_and_modify (line 66) | def print_and_modify(obj, mods, dels):
  function modify_parse_args (line 82) | def modify_parse_args(args):
  function modify_func (line 101) | def modify_func(lib, opts, args):

FILE: beets/ui/commands/move.py
  function show_path_changes (line 21) | def show_path_changes(path_changes):
  function move_items (line 62) | def move_items(
  function move_func (line 149) | def move_func(lib, opts, args):

FILE: beets/ui/commands/remove.py
  function remove_items (line 8) | def remove_items(lib, query, album, delete, force):
  function remove_func (line 70) | def remove_func(lib, opts, args):

FILE: beets/ui/commands/stats.py
  function show_stats (line 13) | def show_stats(lib, query, exact):
  function stats_func (line 52) | def stats_func(lib, opts, args):

FILE: beets/ui/commands/update.py
  function update_items (line 15) | def update_items(lib, query, album, move, pretend, fields, exclude_field...
  function update_func (line 133) | def update_func(lib, opts, args):

FILE: beets/ui/commands/utils.py
  function do_query (line 6) | def do_query(lib, query, album, also_items=True):

FILE: beets/ui/commands/version.py
  function show_version (line 9) | def show_version(*args):

FILE: beets/ui/commands/write.py
  function write_items (line 14) | def write_items(lib, query, pretend, force):
  function write_func (line 43) | def write_func(lib, opts, args):

FILE: beets/util/__init__.py
  class HumanReadableError (line 74) | class HumanReadableError(Exception):
    method __init__ (line 90) | def __init__(self, reason, verb, tb=None):
    method _gerund (line 96) | def _gerund(self):
    method _reasonstr (line 104) | def _reasonstr(self):
    method get_message (line 115) | def get_message(self):
    method log (line 121) | def log(self, logger):
  class FilesystemError (line 130) | class FilesystemError(HumanReadableError):
    method __init__ (line 136) | def __init__(self, reason, verb, paths, tb=None):
    method get_message (line 140) | def get_message(self):
  class MoveOperation (line 158) | class MoveOperation(Enum):
  class PromptChoice (line 169) | class PromptChoice(NamedTuple):
  function normpath (line 175) | def normpath(path: PathLike) -> bytes:
  function ancestry (line 184) | def ancestry(path: AnyStr) -> list[AnyStr]:
  function sorted_walk (line 208) | def sorted_walk(
  function path_as_posix (line 273) | def path_as_posix(path: bytes) -> bytes:
  function mkdirall (line 280) | def mkdirall(path: bytes):
  function fnmatch_all (line 294) | def fnmatch_all(names: Sequence[bytes], patterns: Sequence[bytes]) -> bool:
  function prune_dirs (line 309) | def prune_dirs(
  function components (line 356) | def components(path: AnyStr) -> list[AnyStr]:
  function bytestring_path (line 380) | def bytestring_path(path: PathLike) -> bytes:
  function displayable_path (line 405) | def displayable_path(
  function syspath (line 424) | def syspath(path: PathLike, prefix: bool = True) -> str:
  function samefile (line 447) | def samefile(p1: bytes, p2: bytes) -> bool:
  function remove (line 457) | def remove(path: PathLike, soft: bool = True):
  function copy (line 472) | def copy(path: bytes, dest: bytes, replace: bool = False):
  function move (line 492) | def move(path: bytes, dest: bytes, replace: bool = False):
  function link (line 553) | def link(path: bytes, dest: bytes, replace: bool = False):
  function hardlink (line 576) | def hardlink(path: bytes, dest: bytes, replace: bool = False):
  function reflink (line 611) | def reflink(
  function unique_path (line 651) | def unique_path(path: bytes) -> bytes:
  function sanitize_path (line 688) | def sanitize_path(path: str, replacements: Replacements | None = None) -...
  function truncate_str (line 709) | def truncate_str(s: str, length: int) -> str:
  function truncate_path (line 722) | def truncate_path(str_path: str) -> str:
  function _legalize_stage (line 731) | def _legalize_stage(
  function legalize_path (line 754) | def legalize_path(
  function str2bool (line 792) | def str2bool(value: str) -> bool:
  function as_string (line 797) | def as_string(value: Any) -> str:
  function plurality (line 811) | def plurality(objs: Iterable[T]) -> tuple[T, int]:
  function get_most_common_tags (line 822) | def get_most_common_tags(
  class CommandOutput (line 862) | class CommandOutput(NamedTuple):
  function command_output (line 867) | def command_output(
  function get_max_filename_length (line 908) | def get_max_filename_length() -> int:
  function open_anything (line 929) | def open_anything() -> str:
  function editor_command (line 944) | def editor_command() -> str:
  function interactive_open (line 957) | def interactive_open(targets: Sequence[str], command: str):
  function case_sensitive (line 979) | def case_sensitive(path: bytes) -> bool:
  function asciify_path (line 1027) | def asciify_path(path: str, sep_replace: str) -> str:
  function par_map (line 1050) | def par_map(transform: Callable[[T], Any], items: Sequence[T]) -> None:
  class cached_classproperty (line 1064) | class cached_classproperty(Generic[T]):
    method __init__ (line 1090) | def __init__(self, getter: Callable[..., T]) -> None:
    method __set_name__ (line 1094) | def __set_name__(self, owner: object, name: str) -> None:
    method __get__ (line 1098) | def __get__(self, instance: object, owner: type[object]) -> T:
  class LazySharedInstance (line 1107) | class LazySharedInstance(Generic[T]):
    method __get__ (line 1141) | def __get__(self, instance: T | None, owner: type[T]) -> T:
  function get_module_tempdir (line 1154) | def get_module_tempdir(module: str) -> Path:
  function clean_module_tempdir (line 1166) | def clean_module_tempdir(module: str) -> None:
  function get_temp_filename (line 1175) | def get_temp_filename(
  function unique_list (line 1200) | def unique_list(elements: Iterable[T]) -> list[T]:

FILE: beets/util/artresizer.py
  function resize_url (line 49) | def resize_url(url: str, maxwidth: int, quality: int = 0) -> str:
  class LocalBackendNotAvailableError (line 64) | class LocalBackendNotAvailableError(Exception):
  class NotAvailable (line 70) | class NotAvailable(Enum):
  class LocalBackend (line 77) | class LocalBackend(ABC):
    method version (line 82) | def version(cls) -> Any:
    method available (line 89) | def available(cls) -> bool:
    method resize (line 99) | def resize(
    method get_size (line 114) | def get_size(self, path_in: bytes) -> tuple[int, int] | None:
    method deinterlace (line 119) | def deinterlace(
    method get_format (line 131) | def get_format(self, path_in: bytes) -> str | None:
    method convert_format (line 136) | def convert_format(
    method can_compare (line 149) | def can_compare(self) -> bool:
    method compare (line 153) | def compare(
    method can_write_metadata (line 168) | def can_write_metadata(self) -> bool:
    method write_metadata (line 172) | def write_metadata(self, file: bytes, metadata: Mapping[str, str]) -> ...
  class IMBackend (line 181) | class IMBackend(LocalBackend):
    method version (line 191) | def version(cls) -> tuple[int, int, int]:
    method __init__ (line 225) | def __init__(self) -> None:
    method resize (line 245) | def resize(
    method get_size (line 302) | def get_size(self, path_in: bytes) -> tuple[int, int] | None:
    method deinterlace (line 334) | def deinterlace(
    method get_format (line 357) | def get_format(self, path_in: bytes) -> str | None:
    method convert_format (line 369) | def convert_format(
    method can_compare (line 392) | def can_compare(self) -> bool:
    method compare (line 395) | def compare(
    method can_write_metadata (line 489) | def can_write_metadata(self) -> bool:
    method write_metadata (line 492) | def write_metadata(self, file: bytes, metadata: Mapping[str, str]) -> ...
  class PILBackend (line 502) | class PILBackend(LocalBackend):
    method version (line 506) | def version(cls) -> None:
    method __init__ (line 512) | def __init__(self) -> None:
    method resize (line 519) | def resize(
    method get_size (line 595) | def get_size(self, path_in: bytes) -> tuple[int, int] | None:
    method deinterlace (line 607) | def deinterlace(
    method get_format (line 625) | def get_format(self, path_in: bytes) -> str | None:
    method convert_format (line 640) | def convert_format(
    method can_compare (line 663) | def can_compare(self) -> bool:
    method compare (line 666) | def compare(
    method can_write_metadata (line 676) | def can_write_metadata(self) -> bool:
    method write_metadata (line 679) | def write_metadata(self, file: bytes, metadata: Mapping[str, str]) -> ...
  class ArtResizer (line 697) | class ArtResizer:
    method __init__ (line 702) | def __init__(self) -> None:
    method method (line 729) | def method(self) -> str:
    method resize (line 735) | def resize(
    method deinterlace (line 760) | def deinterlace(
    method proxy_url (line 775) | def proxy_url(self, maxwidth: int, url: str, quality: int = 0) -> str:
    method local (line 787) | def local(self) -> bool:
    method get_size (line 793) | def get_size(self, path_in: bytes) -> tuple[int, int] | None:
    method get_format (line 806) | def get_format(self, path_in: bytes) -> str | None:
    method reformat (line 817) | def reformat(
    method can_compare (line 855) | def can_compare(self) -> bool:
    method compare (line 863) | def compare(
    method can_write_metadata (line 880) | def can_write_metadata(self) -> bool:
    method write_metadata (line 888) | def write_metadata(self, file: bytes, metadata: Mapping[str, str]) -> ...

FILE: beets/util/bluelet.py
  class Event (line 21) | class Event:
  class WaitableEvent (line 30) | class WaitableEvent(Event):
    method waitables (line 36) | def waitables(self):
    method fire (line 44) | def fire(self):
  class ValueEvent (line 51) | class ValueEvent(Event):
    method __init__ (line 54) | def __init__(self, value):
  class ExceptionEvent (line 58) | class ExceptionEvent(Event):
    method __init__ (line 61) | def __init__(self, exc_info):
  class SpawnEvent (line 65) | class SpawnEvent(Event):
    method __init__ (line 68) | def __init__(self, coro):
  class JoinEvent (line 72) | class JoinEvent(Event):
    method __init__ (line 77) | def __init__(self, child):
  class KillEvent (line 81) | class KillEvent(Event):
    method __init__ (line 84) | def __init__(self, child):
  class DelegationEvent (line 88) | class DelegationEvent(Event):
    method __init__ (line 94) | def __init__(self, coro):
  class ReturnEvent (line 98) | class ReturnEvent(Event):
    method __init__ (line 103) | def __init__(self, value):
  class SleepEvent (line 107) | class SleepEvent(WaitableEvent):
    method __init__ (line 110) | def __init__(self, duration):
    method time_left (line 113) | def time_left(self):
  class ReadEvent (line 117) | class ReadEvent(WaitableEvent):
    method __init__ (line 120) | def __init__(self, fd, bufsize):
    method waitables (line 124) | def waitables(self):
    method fire (line 127) | def fire(self):
  class WriteEvent (line 131) | class WriteEvent(WaitableEvent):
    method __init__ (line 134) | def __init__(self, fd, data):
    method waitable (line 138) | def waitable(self):
    method fire (line 141) | def fire(self):
  function _event_select (line 148) | def _event_select(events):
  class ThreadError (line 206) | class ThreadError(Exception):
    method __init__ (line 207) | def __init__(self, coro, exc_info):
    method reraise (line 211) | def reraise(self):
  class Delegated (line 218) | class Delegated(Event):
    method __init__ (line 223) | def __init__(self, child):
  function run (line 227) | def run(root_coro):
  class SocketClosedError (line 402) | class SocketClosedError(Exception):
  class Listener (line 406) | class Listener:
    method __init__ (line 409) | def __init__(self, host, port):
    method accept (line 419) | def accept(self):
    method close (line 428) | def close(self):
  class Connection (line 434) | class Connection:
    method __init__ (line 437) | def __init__(self, sock, addr):
    method close (line 443) | def close(self):
    method recv (line 448) | def recv(self, size):
    method send (line 461) | def send(self, data):
    method sendall (line 469) | def sendall(self, data):
    method readline (line 475) | def readline(self, terminator=b"\n", bufsize=1024):
  class AcceptEvent (line 496) | class AcceptEvent(WaitableEvent):
    method __init__ (line 501) | def __init__(self, listener):
    method waitables (line 504) | def waitables(self):
    method fire (line 507) | def fire(self):
  class ReceiveEvent (line 512) | class ReceiveEvent(WaitableEvent):
    method __init__ (line 517) | def __init__(self, conn, bufsize):
    method waitables (line 521) | def waitables(self):
    method fire (line 524) | def fire(self):
  class SendEvent (line 528) | class SendEvent(WaitableEvent):
    method __init__ (line 533) | def __init__(self, conn, data, sendall=False):
    method waitables (line 538) | def waitables(self):
    method fire (line 541) | def fire(self):
  function null (line 552) | def null():
  function spawn (line 557) | def spawn(coro):
  function call (line 566) | def call(coro):
  function end (line 576) | def end(value=None):
  function read (line 583) | def read(fd, bufsize=None):
  function write (line 602) | def write(fd, data):
  function connect (line 607) | def connect(host, port):
  function sleep (line 616) | def sleep(duration):
  function join (line 621) | def join(coro):
  function kill (line 628) | def kill(coro):
  function server (line 636) | def server(host, port, func):

FILE: beets/util/color.py
  function get_color_config (line 120) | def get_color_config() -> dict[ColorName, str]:
  function _colorize (line 148) | def _colorize(color_name: ColorName, text: str) -> str:
  function colorize (line 154) | def colorize(color_name: ColorName, text: str) -> str:
  function dist_colorize (line 162) | def dist_colorize(string: str, dist: Distance) -> str:
  function uncolorize (line 175) | def uncolorize(colored_text: str) -> str:
  function color_split (line 188) | def color_split(colored_text: str, index: int) -> tuple[str, str]:
  function color_len (line 224) | def color_len(colored_text: str) -> int:

FILE: beets/util/config.py
  function sanitize_choices (line 9) | def sanitize_choices(
  function sanitize_pairs (line 29) | def sanitize_pairs(

FILE: beets/util/deprecation.py
  function _format_message (line 15) | def _format_message(old: str, new: str | None = None) -> str:
  function deprecate_for_user (line 24) | def deprecate_for_user(
  function deprecate_for_maintainers (line 30) | def deprecate_for_maintainers(
  function deprecate_imports (line 44) | def deprecate_imports(

FILE: beets/util/diff.py
  function colordiff (line 15) | def colordiff(a: str, b: str) -> tuple[str, str]:
  function _multi_value_diff (line 37) | def _multi_value_diff(field: str, oldset: set[str], newset: set[str]) ->...
  function _field_diff (line 49) | def _field_diff(
  function get_model_changes (line 87) | def get_model_changes(

FILE: beets/util/functemplate.py
  class Environment (line 46) | class Environment:
    method __init__ (line 51) | def __init__(self, values, functions):
  function ex_rvalue (line 59) | def ex_rvalue(name):
  function ex_literal (line 64) | def ex_literal(val):
  function ex_call (line 71) | def ex_call(func, args):
  function compile_func (line 87) | def compile_func(arg_names, statements, name="_the_func", debug=False):
  class Symbol (line 129) | class Symbol:
    method __init__ (line 132) | def __init__(self, ident, original):
    method __repr__ (line 136) | def __repr__(self):
    method evaluate (line 139) | def evaluate(self, env):
    method translate (line 150) | def translate(self):
  class Call (line 157) | class Call:
    method __init__ (line 160) | def __init__(self, ident, args, original):
    method __repr__ (line 165) | def __repr__(self):
    method evaluate (line 168) | def evaluate(self, env):
    method translate (line 184) | def translate(self):
  class Expression (line 216) | class Expression:
    method __init__ (line 221) | def __init__(self, parts):
    method __repr__ (line 224) | def __repr__(self):
    method evaluate (line 227) | def evaluate(self, env):
    method translate (line 239) | def translate(self):
  class ParseError (line 260) | class ParseError(Exception):
  class Parser (line 264) | class Parser:
    method __init__ (line 278) | def __init__(self, string, in_argument=False):
    method parse_expression (line 300) | def parse_expression(self):
    method parse_symbol (line 377) | def parse_symbol(self):
    method parse_call (line 423) | def parse_call(self):
    method parse_argument_list (line 461) | def parse_argument_list(self):
    method _parse_ident (line 492) | def _parse_ident(self):
  function _parse (line 502) | def _parse(template):
  function template (line 517) | def template(fmt):
  class Template (line 522) | class Template:
    method __init__ (line 525) | def __init__(self, template):
    method __eq__ (line 530) | def __eq__(self, other):
    method interpret (line 533) | def interpret(self, values={}, functions={}):
    method substitute (line 541) | def substitute(self, values={}, functions={}):
    method translate (line 550) | def translate(self):

FILE: beets/util/hidden.py
  function is_hidden (line 25) | def is_hidden(path: bytes | Path) -> bool:

FILE: beets/util/id_extractors.py
  function extract_release_id (line 50) | def extract_release_id(source: str, id_: str) -> str | None:

FILE: beets/util/layout.py
  class Side (line 19) | class Side(NamedTuple):
    method rendered (line 33) | def rendered(self) -> str:
    method prefix_width (line 38) | def prefix_width(self) -> int:
    method suffix_width (line 43) | def suffix_width(self) -> int:
    method rendered_width (line 48) | def rendered_width(self) -> int:
  function indent (line 53) | def indent(count: int) -> str:
  function split_into_lines (line 58) | def split_into_lines(string: str, first_width: int, width: int) -> list[...
  function get_column_layout (line 183) | def get_column_layout(
  function get_newline_layout (line 296) | def get_newline_layout(
  function get_layout_method (line 343) | def get_layout_method() -> Callable[[str, Side, Side, int, str], Iterato...
  function get_layout_lines (line 349) | def get_layout_lines(

FILE: beets/util/lyrics.py
  class Lyrics (line 20) | class Lyrics:
    method __post_init__ (line 39) | def __post_init__(self) -> None:
    method from_legacy_text (line 69) | def from_legacy_text(cls, text: str) -> Lyrics:
    method from_item (line 84) | def from_item(cls, item: Item) -> Lyrics:
    method original_text (line 93) | def original_text(self) -> str:
    method _split_lines (line 99) | def _split_lines(self) -> list[tuple[str, str]]:
    method timestamps (line 111) | def timestamps(self) -> list[str]:
    method text_lines (line 116) | def text_lines(self) -> list[str]:
    method synced (line 121) | def synced(self) -> bool:
    method translated (line 126) | def translated(self) -> bool:
    method full_text (line 131) | def full_text(self) -> str:

FILE: beets/util/m3u.py
  class EmptyPlaylistError (line 22) | class EmptyPlaylistError(Exception):
  class M3UFile (line 28) | class M3UFile:
    method __init__ (line 31) | def __init__(self, path):
    method load (line 43) | def load(self):
    method set_contents (line 63) | def set_contents(self, media_list, extm3u=True):
    method write (line 77) | def write(self):

FILE: beets/util/pipeline.py
  function _invalidate_queue (line 54) | def _invalidate_queue(q, val=None, sync=True):
  class CountedQueue (line 96) | class CountedQueue(queue.Queue[Tq]):
    method __init__ (line 102) | def __init__(self, maxsize=0):
    method acquire (line 107) | def acquire(self):
    method release (line 116) | def release(self):
  class MultiMessage (line 146) | class MultiMessage:
    method __init__ (line 151) | def __init__(self, messages):
  function multiple (line 155) | def multiple(messages):
  function stage (line 172) | def stage(
  function mutator_stage (line 200) | def mutator_stage(func: Callable[[Unpack[A], T], R]):
  function _allmsgs (line 224) | def _allmsgs(obj):
  class PipelineThread (line 237) | class PipelineThread(Thread):
    method __init__ (line 240) | def __init__(self, all_threads):
    method abort (line 247) | def abort(self):
    method abort_all (line 258) | def abort_all(self, exc_info):
  class FirstPipelineThread (line 265) | class FirstPipelineThread(PipelineThread):
    method __init__ (line 270) | def __init__(self, coro, out_queue, all_threads):
    method run (line 276) | def run(self):
  class MiddlePipelineThread (line 304) | class MiddlePipelineThread(PipelineThread):
    method __init__ (line 309) | def __init__(self, coro, in_queue, out_queue, all_threads):
    method run (line 316) | def run(self):
  class LastPipelineThread (line 353) | class LastPipelineThread(PipelineThread):
    method __init__ (line 358) | def __init__(self, coro, in_queue, all_threads):
    method run (line 363) | def run(self):
  class Pipeline (line 390) | class Pipeline:
    method __init__ (line 396) | def __init__(self, stages):
    method run_sequential (line 410) | def run_sequential(self):
    method run_parallel (line 417) | def run_parallel(self, queue_size=DEFAULT_QUEUE_SIZE):
    method pull (line 473) | def pull(self):

FILE: beets/util/units.py
  function raw_seconds_short (line 4) | def raw_seconds_short(string: str) -> float:
  function human_seconds_short (line 17) | def human_seconds_short(interval):
  function human_bytes (line 25) | def human_bytes(size):
  function human_seconds (line 37) | def human_seconds(interval):

FILE: beetsplug/_typing.py
  class LRCLibAPI (line 10) | class LRCLibAPI:
    class Item (line 11) | class Item(TypedDict):
  class GeniusAPI (line 25) | class GeniusAPI:
    class DateComponents (line 33) | class DateComponents(TypedDict):
    class Artist (line 38) | class Artist(TypedDict):
    class Stats (line 48) | class Stats(TypedDict):
    class SearchResult (line 52) | class SearchResult(TypedDict):
    class SearchHit (line 79) | class SearchHit(TypedDict):
    class SearchResponse (line 82) | class SearchResponse(TypedDict):
    class Search (line 85) | class Search(TypedDict):
    class StatusResponse (line 88) | class StatusResponse(TypedDict):
    class Meta (line 92) | class Meta(TypedDict):
  class GoogleCustomSearchAPI (line 98) | class GoogleCustomSearchAPI:
    class Response (line 99) | class Response(TypedDict):
    class Item (line 107) | class Item(TypedDict):
    class Pagemap (line 121) | class Pagemap(TypedDict):
  class TranslatorAPI (line 127) | class TranslatorAPI:
    class Language (line 128) | class Language(TypedDict):
    class Translation (line 134) | class Translation(TypedDict):
    class Response (line 140) | class Response(TypedDict):

FILE: beetsplug/_utils/art.py
  function mediafile_image (line 28) | def mediafile_image(image_path, maxwidth=None):
  function get_art (line 36) | def get_art(log, item):
  function embed_item (line 47) | def embed_item(
  function embed_album (line 97) | def embed_album(
  function resize_image (line 137) | def resize_image(log, imagepath, maxwidth, quality):
  function check_art_similarity (line 152) | def check_art_similarity(
  function extract (line 178) | def extract(log, outpath, item):
  function extract_first (line 202) | def extract_first(log, outpath, items):
  function clear_item (line 209) | def clear_item(item, log):
  function clear (line 215) | def clear(log, lib, query):

FILE: beetsplug/_utils/musicbrainz.py
  class LimiterTimeoutSession (line 69) | class LimiterTimeoutSession(LimiterMixin, TimeoutAndRetrySession):
  class LookupKwargs (line 91) | class LookupKwargs(TypedDict, total=False):
  class PagingKwargs (line 95) | class PagingKwargs(TypedDict, total=False):
  class SearchKwargs (line 100) | class SearchKwargs(PagingKwargs):
  class BrowseKwargs (line 104) | class BrowseKwargs(LookupKwargs, PagingKwargs, total=False):
  class BrowseReleaseGroupsKwargs (line 108) | class BrowseReleaseGroupsKwargs(BrowseKwargs, total=False):
  class BrowseRecordingsKwargs (line 115) | class BrowseRecordingsKwargs(BrowseReleaseGroupsKwargs, total=False):
  function require_one_of (line 123) | def require_one_of(*keys: str) -> Callable[[Callable[P, R]], Callable[P,...
  class MusicBrainzAPI (line 143) | class MusicBrainzAPI(RequestHandler):
    method __post_init__ (line 159) | def __post_init__(self) -> None:
    method api_root (line 182) | def api_root(self) -> str:
    method create_session (line 185) | def create_session(self) -> LimiterTimeoutSession:
    method request (line 188) | def request(self, *args, **kwargs) -> Response:
    method _get_resource (line 194) | def _get_resource(
    method _lookup (line 210) | def _lookup(
    method _browse (line 215) | def _browse(self, entity: Entity, **kwargs) -> list[JSONDict]:
    method format_search_term (line 219) | def format_search_term(field: str, term: str) -> str:
    method search (line 233) | def search(
    method get_release (line 254) | def get_release(self, id_: str, **kwargs: Unpack[LookupKwargs]) -> JSO...
    method get_recording (line 259) | def get_recording(
    method get_work (line 266) | def get_work(self, id_: str, **kwargs: Unpack[LookupKwargs]) -> JSONDict:
    method browse_recordings (line 271) | def browse_recordings(
    method browse_release_groups (line 281) | def browse_release_groups(
    method _group_relations (line 293) | def _group_relations(cls, data: Any) -> Any:
    method _ (line 310) | def _(cls, data: list[Any]) -> list[Any]:
    method _ (line 315) | def _(cls, data: JSONDict) -> JSONDict:
  class MusicBrainzAPIMixin (line 335) | class MusicBrainzAPIMixin:
    method mb_api (line 339) | def mb_api(self) -> MusicBrainzAPI:

FILE: beetsplug/_utils/requests.py
  class BeetsHTTPError (line 20) | class BeetsHTTPError(requests.exceptions.HTTPError):
    method __init__ (line 23) | def __init__(self, *args, **kwargs) -> None:
  class HTTPNotFoundError (line 31) | class HTTPNotFoundError(BeetsHTTPError):
  class Closeable (line 35) | class Closeable(Protocol):
    method close (line 38) | def close(self) -> None: ...
  class SingletonMeta (line 44) | class SingletonMeta(type, Generic[C]):
    method __call__ (line 55) | def __call__(cls, *args: Any, **kwargs: Any) -> C:
  class TimeoutAndRetrySession (line 65) | class TimeoutAndRetrySession(requests.Session, metaclass=SingletonMeta):
    method __init__ (line 74) | def __init__(self, *args, **kwargs) -> None:
    method request (line 93) | def request(self, *args, **kwargs):
  class RequestHandler (line 106) | class RequestHandler:
    method create_session (line 133) | def create_session(self) -> TimeoutAndRetrySession:
    method session (line 141) | def session(self) -> TimeoutAndRetrySession:
    method status_to_error (line 144) | def status_to_error(
    method handle_http_error (line 157) | def handle_http_error(self) -> Iterator[None]:
    method request (line 172) | def request(self, *args, **kwargs) -> requests.Response:
    method get (line 181) | def get(self, *args, **kwargs) -> requests.Response:
    method put (line 185) | def put(self, *args, **kwargs) -> requests.Response:
    method delete (line 189) | def delete(self, *args, **kwargs) -> requests.Response:
    method get_json (line 193) | def get_json(self, *args, **kwargs):

FILE: beetsplug/_utils/vfs.py
  class Node (line 29) | class Node(NamedTuple):
  function _insert (line 37) | def _insert(node: Node, path: list[str], itemid: int):
  function libtree (line 51) | def libtree(lib: Library) -> Node:

FILE: beetsplug/absubmit.py
  class ABSubmitError (line 33) | class ABSubmitError(Exception):
  function call (line 37) | def call(args):
  class AcousticBrainzSubmitPlugin (line 48) | class AcousticBrainzSubmitPlugin(plugins.BeetsPlugin):
    method __init__ (line 49) | def __init__(self):
    method commands (line 103) | def commands(self):
    method command (line 129) | def command(self, lib, opts, args):
    method analyze_submit (line 142) | def analyze_submit(self, item):
    method _get_analysis (line 147) | def _get_analysis(self, item):
    method _submit_data (line 198) | def _submit_data(self, item, data):

FILE: beetsplug/acousticbrainz.py
  class AcousticPlugin (line 58) | class AcousticPlugin(plugins.BeetsPlugin):
    method __init__ (line 84) | def __init__(self):
    method commands (line 106) | def commands(self):
    method import_task_files (line 130) | def import_task_files(self, session, task):
    method _get_data (line 134) | def _get_data(self, mbid):
    method _fetch_info (line 162) | def _fetch_info(self, items, write, force):
    method _map_data_to_scheme (line 201) | def _map_data_to_scheme(self, data, scheme):
    method _data_to_scheme_child (line 263) | def _data_to_scheme_child(self, subdata, subscheme, composites):
  function _generate_urls (line 301) | def _generate_urls(base_url, mbid):

FILE: beetsplug/advancedrewrite.py
  function rewriter (line 30) | def rewriter(field, simple_rules, advanced_rules):
  class AdvancedRewritePlugin (line 55) | class AdvancedRewritePlugin(BeetsPlugin):
    method __init__ (line 58) | def __init__(self):
    method loaded (line 63) | def loaded(self):

FILE: beetsplug/albumtypes.py
  class AlbumTypesPlugin (line 29) | class AlbumTypesPlugin(BeetsPlugin):
    method __init__ (line 32) | def __init__(self):
    method _atypes (line 51) | def _atypes(self, item: Album):

FILE: beetsplug/aura.py
  class AURADocument (line 131) | class AURADocument:
    method from_app (line 140) | def from_app(cls) -> Self:
    method error (line 145) | def error(status, title, detail):
    method get_attribute_converter (line 160) | def get_attribute_converter(cls, beets_attr: str) -> type[SQLiteType]:
    method translate_filters (line 175) | def translate_filters(self):
    method translate_sorts (line 198) | def translate_sorts(self, sort_arg):
    method paginate (line 223) | def paginate(self, collection):
    method get_included (line 263) | def get_included(self, data, include_str):
    method all_resources (line 318) | def all_resources(self):
    method single_resource_document (line 348) | def single_resource_document(self, resource_object):
  class TrackDocument (line 365) | class TrackDocument(AURADocument):
    method get_collection (line 372) | def get_collection(self, query=None, sort=None):
    method get_attribute_converter (line 382) | def get_attribute_converter(cls, beets_attr: str) -> type[SQLiteType]:
    method get_resource_object (line 395) | def get_resource_object(lib: Library, track):
    method single_resource (line 427) | def single_resource(self, track_id):
  class AlbumDocument (line 445) | class AlbumDocument(AURADocument):
    method get_collection (line 452) | def get_collection(self, query=None, sort=None):
    method get_resource_object (line 462) | def get_resource_object(lib: Library, album):
    method single_resource (line 511) | def single_resource(self, album_id):
  class ArtistDocument (line 529) | class ArtistDocument(AURADocument):
    method get_collection (line 536) | def get_collection(self, query=None, sort=None):
    method get_resource_object (line 553) | def get_resource_object(lib: Library, artist_id):
    method single_resource (line 596) | def single_resource(self, artist_id):
  function safe_filename (line 612) | def safe_filename(fn):
  class ImageDocument (line 630) | class ImageDocument(AURADocument):
    method get_image_path (line 636) | def get_image_path(lib: Library, image_id):
    method get_resource_object (line 678) | def get_resource_object(lib: Library, image_id):
    method single_resource (line 720) | def single_resource(self, image_id):
  function server_info (line 742) | def server_info():
  function all_tracks (line 751) | def all_tracks():
  function single_track (line 757) | def single_track(track_id):
  function audio_file (line 767) | def audio_file(track_id):
  function all_albums (line 826) | def all_albums():
  function single_album (line 832) | def single_album(album_id):
  function all_artists (line 846) | def all_artists():
  function single_artist (line 853) | def single_artist(artist_id):
  function single_image (line 869) | def single_image(image_id):
  function image_file (line 880) | def image_file(image_id):
  function create_app (line 900) | def create_app():
  class AURAPlugin (line 945) | class AURAPlugin(BeetsPlugin):
    method __init__ (line 948) | def __init__(self):
    method commands (line 952) | def commands(self):

FILE: beetsplug/autobpm.py
  class AutoBPMPlugin (line 31) | class AutoBPMPlugin(BeetsPlugin):
    method __init__ (line 32) | def __init__(self) -> None:
    method commands (line 45) | def commands(self) -> list[Subcommand]:
    method command (line 52) | def command(self, lib: Library, _, args: list[str]) -> None:
    method imported (line 55) | def imported(self, _, task: ImportTask) -> None:
    method calculate_bpm (line 58) | def calculate_bpm(self, items: list[Item], write: bool = False) -> None:

FILE: beetsplug/badfiles.py
  class CheckerCommandError (line 32) | class CheckerCommandError(Exception):
    method __init__ (line 42) | def __init__(self, cmd, oserror):
  class BadFiles (line 49) | class BadFiles(BeetsPlugin):
    method __init__ (line 50) | def __init__(self):
    method run_command (line 59) | def run_command(self, cmd):
    method check_mp3val (line 76) | def check_mp3val(self, path):
    method check_flac (line 83) | def check_flac(self, path):
    method check_custom (line 86) | def check_custom(self, command):
    method get_checker (line 94) | def get_checker(self, ext):
    method check_item (line 107) | def check_item(self, item):
    method on_import_task_start (line 157) | def on_import_task_start(self, task, session):
    method on_import_task_before_choice (line 171) | def on_import_task_before_choice(self, task, session):
    method command (line 194) | def command(self, lib, opts, args):
    method commands (line 205) | def commands(self):

FILE: beetsplug/bareasc.py
  class BareascQuery (line 29) | class BareascQuery(StringFieldQuery[str]):
    method string_match (line 33) | def string_match(cls, pattern, val):
    method col_clause (line 46) | def col_clause(self):
  class BareascPlugin (line 55) | class BareascPlugin(BeetsPlugin):
    method __init__ (line 58) | def __init__(self):
    method queries (line 67) | def queries(self):
    method commands (line 72) | def commands(self):
    method unidecode_list (line 84) | def unidecode_list(self, lib, opts, args):

FILE: beetsplug/beatport.py
  class BeatportAPIError (line 52) | class BeatportAPIError(Exception):
  class BeatportClient (line 56) | class BeatportClient:
    method __init__ (line 59) | def __init__(self, c_key, c_secret, auth_key=None, auth_secret=None):
    method get_authorize_url (line 80) | def get_authorize_url(self) -> str:
    method get_access_token (line 102) | def get_access_token(self, auth_data: str) -> tuple[str, str]:
    method search (line 119) | def search(
    method search (line 127) | def search(
    method search (line 134) | def search(
    method get_release (line 165) | def get_release(self, beatport_id: str) -> BeatportRelease | None:
    method get_release_tracks (line 178) | def get_release_tracks(self, beatport_id: str) -> list[BeatportTrack]:
    method get_track (line 189) | def get_track(self, beatport_id: str) -> BeatportTrack:
    method _make_url (line 198) | def _make_url(self, endpoint: str) -> str:
    method _get (line 204) | def _get(self, endpoint: str, **kwargs) -> list[JSONDict]:
  class BeatportObject (line 221) | class BeatportObject:
    method __init__ (line 230) | def __init__(self, data: JSONDict):
    method artists_str (line 245) | def artists_str(self) -> str | None:
  class BeatportRelease (line 257) | class BeatportRelease(BeatportObject):
    method __init__ (line 265) | def __init__(self, data: JSONDict):
    method __str__ (line 277) | def __str__(self) -> str:
  class BeatportTrack (line 284) | class BeatportTrack(BeatportObject):
    method __init__ (line 293) | def __init__(self, data: JSONDict):
  class BeatportPlugin (line 313) | class BeatportPlugin(MetadataSourcePlugin):
    method __init__ (line 316) | def __init__(self):
    method client (line 331) | def client(self) -> BeatportClient:
    method setup (line 338) | def setup(self, session: ImportSession):
    method authenticate (line 355) | def authenticate(self, c_key: str, c_secret: str) -> tuple[str, str]:
    method _tokenfile (line 382) | def _tokenfile(self) -> str:
    method candidates (line 386) | def candidates(
    method item_candidates (line 403) | def item_candidates(
    method album_for_id (line 413) | def album_for_id(self, album_id: str):
    method track_for_id (line 428) | def track_for_id(self, track_id: str):
    method _get_releases (line 443) | def _get_releases(self, query: str) -> Iterator[AlbumInfo]:
    method _get_album_info (line 458) | def _get_album_info(self, release: BeatportRelease) -> AlbumInfo:
    method _get_track_info (line 490) | def _get_track_info(self, track: BeatportTrack) -> TrackInfo:
    method _get_artist (line 512) | def _get_artist(self, artists):
    method _get_tracks (line 518) | def _get_tracks(self, query):

FILE: beetsplug/bench.py
  function aunique_benchmark (line 27) | def aunique_benchmark(lib, prof):
  function match_benchmark (line 68) | def match_benchmark(lib, prof, query=None, album_id=None):
  class BenchmarkPlugin (line 97) | class BenchmarkPlugin(BeetsPlugin):
    method commands (line 100) | def commands(self):

FILE: beetsplug/bpd/__init__.py
  class BPDError (line 110) | class BPDError(Exception):
    method __init__ (line 115) | def __init__(self, code, message, cmd_name="", index=0):
    method response (line 123) | def response(self):
  function make_bpd_error (line 138) | def make_bpd_error(s_code, s_message):
  function cast_arg (line 158) | def cast_arg(t, val):
  class BPDCloseError (line 174) | class BPDCloseError(Exception):
  class BPDIdleError (line 180) | class BPDIdleError(Exception):
    method __init__ (line 185) | def __init__(self, subsystems):
  class BaseServer (line 193) | class BaseServer:
    method __init__ (line 206) | def __init__(self, host, port, password, ctrl_port, log, ctrl_host=None):
    method connect (line 241) | def connect(self, conn):
    method disconnect (line 245) | def disconnect(self, conn):
    method run (line 249) | def run(self):
    method dispatch_events (line 269) | def dispatch_events(self):
    method _ctrl_send (line 276) | def _ctrl_send(self, message):
    method _send_event (line 286) | def _send_event(self, event):
    method _item_info (line 291) | def _item_info(self, item):
    method _item_id (line 297) | def _item_id(self, item):
    method _id_to_index (line 301) | def _id_to_index(self, track_id):
    method _random_idx (line 312) | def _random_idx(self):
    method _succ_idx (line 324) | def _succ_idx(self):
    method _prev_idx (line 335) | def _prev_idx(self):
    method cmd_ping (line 346) | def cmd_ping(self, conn):
    method cmd_idle (line 350) | def cmd_idle(self, conn, *subsystems):
    method cmd_kill (line 357) | def cmd_kill(self, conn):
    method cmd_close (line 361) | def cmd_close(self, conn):
    method cmd_password (line 365) | def cmd_password(self, conn, password):
    method cmd_commands (line 373) | def cmd_commands(self, conn):
    method cmd_notcommands (line 386) | def cmd_notcommands(self, conn):
    method cmd_status (line 400) | def cmd_status(self, conn):
    method cmd_clearerror (line 446) | def cmd_clearerror(self, conn):
    method cmd_random (line 453) | def cmd_random(self, conn, state):
    method cmd_repeat (line 458) | def cmd_repeat(self, conn, state):
    method cmd_consume (line 463) | def cmd_consume(self, conn, state):
    method cmd_single (line 468) | def cmd_single(self, conn, state):
    method cmd_setvol (line 474) | def cmd_setvol(self, conn, vol):
    method cmd_volume (line 482) | def cmd_volume(self, conn, vol_delta):
    method cmd_crossfade (line 487) | def cmd_crossfade(self, conn, crossfade):
    method cmd_mixrampdb (line 496) | def cmd_mixrampdb(self, conn, db):
    method cmd_mixrampdelay (line 505) | def cmd_mixrampdelay(self, conn, delay):
    method cmd_replay_gain_mode (line 514) | def cmd_replay_gain_mode(self, conn, mode):
    method cmd_replay_gain_status (line 522) | def cmd_replay_gain_status(self, conn):
    method cmd_clear (line 526) | def cmd_clear(self, conn):
    method cmd_delete (line 533) | def cmd_delete(self, conn, index):
    method cmd_deleteid (line 549) | def cmd_deleteid(self, conn, track_id):
    method cmd_move (line 552) | def cmd_move(self, conn, idx_from, idx_to):
    method cmd_moveid (line 573) | def cmd_moveid(self, conn, idx_from, idx_to):
    method cmd_swap (line 577) | def cmd_swap(self, conn, i, j):
    method cmd_swapid (line 599) | def cmd_swapid(self, conn, i_id, j_id):
    method cmd_urlhandlers (line 604) | def cmd_urlhandlers(self, conn):
    method cmd_playlistinfo (line 608) | def cmd_playlistinfo(self, conn, index=None):
    method cmd_playlistid (line 624) | def cmd_playlistid(self, conn, track_id=None):
    method cmd_plchanges (line 630) | def cmd_plchanges(self, conn, version):
    method cmd_plchangesposid (line 639) | def cmd_plchangesposid(self, conn, version):
    method cmd_currentsong (line 648) | def cmd_currentsong(self, conn):
    method cmd_next (line 654) | def cmd_next(self, conn):
    method cmd_previous (line 676) | def cmd_previous(self, conn):
    method cmd_pause (line 689) | def cmd_pause(self, conn, state=None):
    method cmd_play (line 697) | def cmd_play(self, conn, index=-1):
    method cmd_playid (line 717) | def cmd_playid(self, conn, track_id=0):
    method cmd_stop (line 725) | def cmd_stop(self, conn):
    method cmd_seek (line 731) | def cmd_seek(self, conn, index, pos):
    method cmd_seekid (line 739) | def cmd_seekid(self, conn, track_id, pos):
    method cmd_crash (line 745) | def cmd_crash(self, conn):
  class Connection (line 754) | class Connection:
    method __init__ (line 757) | def __init__(self, server, sock):
    method debug (line 763) | def debug(self, message, kind=" "):
    method run (line 767) | def run(self):
    method send (line 770) | def send(self, lines):
    method handler (line 786) | def handler(cls, server):
  class MPDConnection (line 794) | class MPDConnection(Connection):
    method __init__ (line 797) | def __init__(self, server, sock):
    method do_command (line 804) | def do_command(self, command):
    method disconnect (line 816) | def disconnect(self):
    method notify (line 821) | def notify(self, event):
    method send_notifications (line 825) | def send_notifications(self, force_close_idle=False):
    method run (line 838) | def run(self):
  class ControlConnection (line 905) | class ControlConnection(Connection):
    method __init__ (line 908) | def __init__(self, server, sock):
    method debug (line 912) | def debug(self, message, kind=" "):
    method run (line 915) | def run(self):
    method ctrl_play_finished (line 939) | def ctrl_play_finished(self):
    method ctrl_profile (line 943) | def ctrl_profile(self):
    method ctrl_nickname (line 950) | def ctrl_nickname(self, oldlabel, newlabel):
  class Command (line 960) | class Command:
    method __init__ (line 966) | def __init__(self, s):
    method delegate (line 985) | def delegate(self, prefix, target, extra_args=0):
    method run (line 1017) | def run(self, conn):
  class CommandList (line 1064) | class CommandList(list[Command]):
    method __init__ (line 1070) | def __init__(self, sequence=None, verbose=False):
    method run (line 1079) | def run(self, conn):
  class Server (line 1099) | class Server(BaseServer):
    method __init__ (line 1104) | def __init__(self, library, host, port, password, ctrl_port, log):
    method run (line 1113) | def run(self):
    method play_finished (line 1117) | def play_finished(self):
    method _item_info (line 1124) | def _item_info(self, item):
    method _parse_range (line 1147) | def _parse_range(self, items, accept_single_number=False):
    method _item_id (line 1162) | def _item_id(self, item):
    method cmd_update (line 1167) | def cmd_update(self, conn, path="/"):
    method _resolve_path (line 1180) | def _resolve_path(self, path):
    method _path_join (line 1204) | def _path_join(self, p1, p2):
    method cmd_lsinfo (line 1209) | def cmd_lsinfo(self, conn, path="/"):
    method _listall (line 1226) | def _listall(self, basepath, node, info=False):
    method cmd_listall (line 1248) | def cmd_listall(self, conn, path="/"):
    method cmd_listallinfo (line 1252) | def cmd_listallinfo(self, conn, path="/"):
    method _all_items (line 1258) | def _all_items(self, node):
    method _add (line 1272) | def _add(self, path, send_id=False):
    method cmd_add (line 1283) | def cmd_add(self, conn, path):
    method cmd_addid (line 1289) | def cmd_addid(self, conn, path):
    method cmd_status (line 1295) | def cmd_status(self, conn):
    method cmd_stats (line 1314) | def cmd_stats(self, conn):
    method cmd_decoders (line 1336) | def cmd_decoders(self, conn):
    method cmd_tagtypes (line 1370) | def cmd_tagtypes(self, conn):
    method _tagtype_lookup (line 1377) | def _tagtype_lookup(self, tag):
    method _metadata_query (line 1389) | def _metadata_query(self, query_type, kv, allow_any_query: bool = False):
    method cmd_search (line 1416) | def cmd_search(self, conn, *kv):
    method cmd_find (line 1424) | def cmd_find(self, conn, *kv):
    method cmd_list (line 1430) | def cmd_list(self, conn, show_tag, *kv):
    method cmd_count (line 1464) | def cmd_count(self, conn, tag, value):
    method cmd_listplaylist (line 1482) | def cmd_listplaylist(self, conn, playlist):
    method cmd_listplaylistinfo (line 1485) | def cmd_listplaylistinfo(self, conn, playlist):
    method cmd_listplaylists (line 1488) | def cmd_listplaylists(self, conn):
    method cmd_load (line 1491) | def cmd_load(self, conn, playlist):
    method cmd_playlistadd (line 1494) | def cmd_playlistadd(self, conn, playlist, uri):
    method cmd_playlistclear (line 1497) | def cmd_playlistclear(self, conn, playlist):
    method cmd_playlistdelete (line 1500) | def cmd_playlistdelete(self, conn, playlist, index):
    method cmd_playlistmove (line 1503) | def cmd_playlistmove(self, conn, playlist, from_index, to_index):
    method cmd_rename (line 1506) | def cmd_rename(self, conn, playlist, new_name):
    method cmd_rm (line 1509) | def cmd_rm(self, conn, playlist):
    method cmd_save (line 1512) | def cmd_save(self, conn, playlist):
    method cmd_outputs (line 1518) | def cmd_outputs(self, conn):
    method cmd_enableoutput (line 1526) | def cmd_enableoutput(self, conn, output_id):
    method cmd_disableoutput (line 1531) | def cmd_disableoutput(self, conn, output_id):
    method cmd_play (line 1542) | def cmd_play(self, conn, index=-1):
    method cmd_pause (line 1554) | def cmd_pause(self, conn, state=None):
    method cmd_stop (line 1561) | def cmd_stop(self, conn):
    method cmd_seek (line 1565) | def cmd_seek(self, conn, index, pos):
    method cmd_setvol (line 1574) | def cmd_setvol(self, conn, vol):
  class BPDPlugin (line 1583) | class BPDPlugin(BeetsPlugin):
    method __init__ (line 1588) | def __init__(self):
    method start_bpd (line 1601) | def start_bpd(self, lib, host, port, password, volume, ctrl_port):
    method commands (line 1607) | def commands(self):

FILE: beetsplug/bpd/gstplayer.py
  class QueryError (line 45) | class QueryError(Exception):
  class GstPlayer (line 49) | class GstPlayer:
    method __init__ (line 62) | def __init__(self, finished_callback=None):
    method _get_state (line 99) | def _get_state(self):
    method _handle_message (line 105) | def _handle_message(self, bus, message):
    method _set_volume (line 122) | def _set_volume(self, volume):
    method _get_volume (line 128) | def _get_volume(self):
    method play_file (line 134) | def play_file(self, path):
    method play (line 146) | def play(self):
    method pause (line 152) | def pause(self):
    method stop (line 156) | def stop(self):
    method run (line 162) | def run(self):
    method time (line 177) | def time(self):
    method seek (line 206) | def seek(self, position):
    method block (line 220) | def block(self):
    method get_decoders (line 225) | def get_decoders(self):
  function get_decoders (line 229) | def get_decoders():
  function play_simple (line 281) | def play_simple(paths):
  function play_complicated (line 292) | def play_complicated(paths):

FILE: beetsplug/bpm.py
  function bpm (line 23) | def bpm(max_strokes):
  class BPMPlugin (line 47) | class BPMPlugin(BeetsPlugin):
    method __init__ (line 48) | def __init__(self):
    method commands (line 57) | def commands(self):
    method command (line 65) | def command(self, lib, opts, args):
    method get_bpm (line 69) | def get_bpm(self, items, write=False):

FILE: beetsplug/bpsync.py
  class BPSyncPlugin (line 24) | class BPSyncPlugin(BeetsPlugin):
    method __init__ (line 25) | def __init__(self):
    method commands (line 31) | def commands(self):
    method func (line 65) | def func(self, lib, opts, args):
    method singletons (line 74) | def singletons(self, lib, query, move, pretend, write):
    method is_beatport_track (line 100) | def is_beatport_track(item):
    method get_album_tracks (line 106) | def get_album_tracks(self, album):
    method albums (line 129) | def albums(self, lib, query, move, pretend, write):

FILE: beetsplug/bucket.py
  class BucketError (line 27) | class BucketError(Exception):
  function pairwise (line 31) | def pairwise(iterable):
  function span_from_str (line 38) | def span_from_str(span_str):
  function complete_year_spans (line 73) | def complete_year_spans(spans):
  function extend_year_spans (line 83) | def extend_year_spans(spans, spanlen, start=1900, end=2014):
  function build_year_spans (line 104) | def build_year_spans(year_spans_str):
  function str2fmt (line 115) | def str2fmt(s):
  function format_span (line 133) | def format_span(fmt, yearfrom, yearto, fromnchars, tonchars):
  function extract_modes (line 142) | def extract_modes(spans):
  function build_alpha_spans (line 151) | def build_alpha_spans(alpha_spans_str, alpha_regexs):
  class BucketPlugin (line 179) | class BucketPlugin(plugins.BeetsPlugin):
    method __init__ (line 180) | def __init__(self):
    method setup (line 194) | def setup(self):
    method find_bucket_year (line 210) | def find_bucket_year(self, year):
    method find_bucket_alpha (line 228) | def find_bucket_alpha(self, s):
    method _tmpl_bucket (line 237) | def _tmpl_bucket(self, text, field=None):

FILE: beetsplug/chroma.py
  function prefix (line 60) | def prefix(it, count):
  function releases_key (line 68) | def releases_key(release, countries, original_year):
  function acoustid_match (line 91) | def acoustid_match(log, path):
  function _all_releases (line 163) | def _all_releases(items):
  class AcoustidPlugin (line 182) | class AcoustidPlugin(MetadataSourcePlugin):
    method __init__ (line 183) | def __init__(self):
    method mb (line 197) | def mb(self) -> MusicBrainzPlugin:
    method fingerprint_task (line 200) | def fingerprint_task(self, task, session):
    method track_distance (line 203) | def track_distance(self, item, info):
    method candidates (line 213) | def candidates(self, items, artist, album, va_likely):
    method item_candidates (line 223) | def item_candidates(self, item, artist, title) -> Iterable[TrackInfo]:
    method album_for_id (line 236) | def album_for_id(self, *args, **kwargs):
    method track_for_id (line 240) | def track_for_id(self, *args, **kwargs):
    method commands (line 244) | def commands(self):
  function fingerprint_task (line 274) | def fingerprint_task(log, task, session):
  function apply_acoustid_metadata (line 283) | def apply_acoustid_metadata(task, session):
  function submit_items (line 295) | def submit_items(log, userkey, items, chunksize=64):
  function fingerprint_item (line 343) | def fingerprint_item(log, item, write=False):

FILE: beetsplug/convert.py
  function replace_ext (line 48) | def replace_ext(path, ext):
  function get_format (line 57) | def get_format(fmt=None):
  function in_no_convert (line 88) | def in_no_convert(item: Item) -> bool:
  function should_transcode (line 98) | def should_transcode(item, fmt, force: bool = False):
  class ConvertPlugin (line 119) | class ConvertPlugin(BeetsPlugin):
    method __init__ (line 120) | def __init__(self):
    method commands (line 174) | def commands(self):
    method auto_convert (line 259) | def auto_convert(self, config, task):
    method auto_convert_keep (line 266) | def auto_convert_keep(self, config, task):
    method encode (line 301) | def encode(self, command, source, dest, pretend=False):
    method convert_item (line 363) | def convert_item(
    method copy_album_art (line 509) | def copy_album_art(
    method convert_func (line 593) | def convert_func(self, lib, opts, args):
    method convert_on_import (line 672) | def convert_on_import(self, lib, item):
    method _get_art_resize (line 711) | def _get_art_resize(self, artpath):
    method _cleanup (line 731) | def _cleanup(self, task, session):
    method _get_opts_and_config (line 738) | def _get_opts_and_config(self, opts):
    method _parallel_convert (line 785) | def _parallel_convert(

FILE: beetsplug/deezer.py
  class DeezerPlugin (line 39) | class DeezerPlugin(SearchApiMetadataSourcePlugin[IDResponse]):
    method __init__ (line 51) | def __init__(self) -> None:
    method commands (line 54) | def commands(self):
    method album_for_id (line 68) | def album_for_id(self, album_id: str) -> AlbumInfo | None:
    method track_for_id (line 151) | def track_for_id(self, track_id: str) -> None | TrackInfo:
    method _get_track (line 195) | def _get_track(self, track_data: JSONDict) -> TrackInfo:
    method get_search_query_with_filters (line 220) | def get_search_query_with_filters(
    method get_search_response (line 234) | def get_search_response(self, params: SearchParams) -> list[IDResponse]:
    method deezerupdate (line 249) | def deezerupdate(self, items: Sequence[Item], write: bool):
    method fetch_data (line 276) | def fetch_data(self, url: str):

FILE: beetsplug/discogs/__init__.py
  class DiscogsPlugin (line 93) | class DiscogsPlugin(SearchApiMetadataSourcePlugin[IDResponse]):
    method __init__ (line 94) | def __init__(self):
    method extra_discogs_field_by_tag (line 121) | def extra_discogs_field_by_tag(self) -> dict[str, str]:
    method setup (line 139) | def setup(self, session=None) -> None:
    method reset_auth (line 165) | def reset_auth(self) -> None:
    method _tokenfile (line 170) | def _tokenfile(self) -> str:
    method authenticate (line 174) | def authenticate(self, c_key: str, c_secret: str) -> tuple[str, str]:
    method get_track_from_album (line 203) | def get_track_from_album(
    method item_candidates (line 217) | def item_candidates(
    method album_for_id (line 228) | def album_for_id(self, album_id: str) -> AlbumInfo | None:
    method track_for_id (line 257) | def track_for_id(self, track_id: str) -> TrackInfo | None:
    method get_search_query_with_filters (line 264) | def get_search_query_with_filters(
    method get_search_response (line 308) | def get_search_response(self, params: SearchParams) -> Sequence[IDResp...
    method get_master_year (line 315) | def get_master_year(self, master_id: str) -> int | None:
    method get_media_and_albumtype (line 342) | def get_media_and_albumtype(
    method get_album_info (line 353) | def get_album_info(self, result: Release) -> AlbumInfo | None:
    method select_cover_art (line 476) | def select_cover_art(self, result: Release) -> str | None:
    method get_tracks (line 486) | def get_tracks(
    method _coalesce_tracks (line 568) | def _coalesce_tracks(self, raw_tracklist: list[Track]) -> list[Track]:
    method _add_merged_subtracks (line 613) | def _add_merged_subtracks(
    method strip_disambiguation (line 656) | def strip_disambiguation(self, text: str) -> str:
    method get_track_info (line 664) | def get_track_info(
    method get_track_index (line 704) | def get_track_index(
    method get_track_length (line 720) | def get_track_length(self, duration: str) -> int | None:

FILE: beetsplug/discogs/states.py
  class ArtistState (line 40) | class ArtistState:
    class ValidArtist (line 50) | class ValidArtist(NamedTuple):
      method get_artist (line 64) | def get_artist(self, property_name: str) -> str:
    method info (line 81) | def info(self) -> ArtistInfo:
    method strip_disambiguation (line 85) | def strip_disambiguation(self, text: str) -> str:
    method valid_artists (line 97) | def valid_artists(self) -> list[ValidArtist]:
    method artists_ids (line 128) | def artists_ids(self) -> list[str]:
    method artist_id (line 133) | def artist_id(self) -> str:
    method artists (line 138) | def artists(self) -> list[str]:
    method artists_credit (line 143) | def artists_credit(self) -> list[str]:
    method artist (line 148) | def artist(self) -> str:
    method artist_credit (line 153) | def artist_credit(self) -> str:
    method join_artists (line 157) | def join_artists(self, property_name: str) -> str:
    method from_config (line 178) | def from_config(
  class TracklistState (line 196) | class TracklistState:
    method info (line 206) | def info(self) -> TracklistInfo:
    method build (line 210) | def build(

FILE: beetsplug/discogs/types.py
  class ReleaseFormat (line 25) | class ReleaseFormat(TypedDict):
  class Artist (line 31) | class Artist(TypedDict):
  class Track (line 41) | class Track(TypedDict):
  class ArtistInfo (line 51) | class ArtistInfo(TypedDict):
  class TracklistInfo (line 60) | class TracklistInfo(TypedDict):

FILE: beetsplug/duplicates.py
  class DuplicatesPlugin (line 34) | class DuplicatesPlugin(BeetsPlugin):
    method __init__ (line 37) | def __init__(self):
    method commands (line 144) | def commands(self):
    method _process_item (line 215) | def _process_item(
    method _checksum (line 245) | def _checksum(self, item, prog):
    method _group_by (line 278) | def _group_by(self, objs, keys, strict):
    method _order (line 308) | def _order(self, objs, tiebreak=None):
    method _merge_items (line 345) | def _merge_items(self, objs):
    method _merge_albums (line 369) | def _merge_albums(self, objs):
    method _merge (line 392) | def _merge(self, objs):
    method _duplicates (line 403) | def _duplicates(self, objs, keys, full, strict, tiebreak, merge):

FILE: beetsplug/edit.py
  class ParseError (line 41) | class ParseError(Exception):
  function edit (line 47) | def edit(filename, log):
  function dump (line 58) | def dump(arg):
  function load (line 67) | def load(s):
  function _safe_value (line 90) | def _safe_value(obj, key, value):
  function flatten (line 101) | def flatten(obj, fields):
  function apply_ (line 127) | def apply_(obj, data):
  class EditPlugin (line 145) | class EditPlugin(plugins.BeetsPlugin):
    method __init__ (line 146) | def __init__(self):
    method commands (line 163) | def commands(self):
    method _edit_command (line 182) | def _edit_command(self, lib, opts, args):
    method _get_fields (line 198) | def _get_fields(self, album, extra):
    method edit (line 215) | def edit(self, album, objs, fields):
    method edit_objects (line 230) | def edit_objects(self, objs, fields):
    method apply_data (line 301) | def apply_data(self, objs, old_data, new_data):
    method save_changes (line 332) | def save_changes(self, objs):
    method before_choose_candidate_listener (line 342) | def before_choose_candidate_listener(self, session, task):
    method importer_edit (line 356) | def importer_edit(self, session, task):
    method importer_edit_candidate (line 385) | def importer_edit_candidate(self, session, task):

FILE: beetsplug/embedart.py
  function _confirm (line 31) | def _confirm(objs, album):
  class EmbedCoverArtPlugin (line 52) | class EmbedCoverArtPlugin(BeetsPlugin):
    method __init__ (line 55) | def __init__(self):
    method commands (line 89) | def commands(self):
    method process_album (line 261) | def process_album(self, album):
    method remove_artfile (line 275) | def remove_artfile(self, album):
    method import_task_files (line 286) | def import_task_files(self, session, task):

FILE: beetsplug/embyupdate.py
  function api_url (line 19) | def api_url(host, port, endpoint):
  function password_data (line 52) | def password_data(username, password):
  function create_headers (line 69) | def create_headers(user_id, token=None):
  function get_token (line 97) | def get_token(host, port, headers, auth_data):
  function get_user (line 122) | def get_user(host, port, username):
  class EmbyUpdate (line 141) | class EmbyUpdate(BeetsPlugin):
    method __init__ (line 142) | def __init__(self):
    method listen_for_db_change (line 163) | def listen_for_db_change(self, lib, model):
    method update (line 167) | def update(self, lib):

FILE: beetsplug/export.py
  class ExportEncoder (line 30) | class ExportEncoder(json.JSONEncoder):
    method default (line 33) | def default(self, o):
  class ExportPlugin (line 39) | class ExportPlugin(BeetsPlugin):
    method __init__ (line 40) | def __init__(self):
    method commands (line 81) | def commands(self):
    method run (line 123) | def run(self, lib, opts, args):
  class ExportFormat (line 169) | class ExportFormat:
    method __init__ (line 172) | def __init__(self, file_path, file_mode="w", encoding="utf-8"):
    method factory (line 184) | def factory(cls, file_type, **kwargs):
    method export (line 194) | def export(self, data, **kwargs):
  class JsonFormat (line 198) | class JsonFormat(ExportFormat):
    method __init__ (line 201) | def __init__(self, file_path, file_mode="w", encoding="utf-8"):
    method export (line 204) | def export(self, data, **kwargs):
  class CSVFormat (line 209) | class CSVFormat(ExportFormat):
    method __init__ (line 212) | def __init__(self, file_path, file_mode="w", encoding="utf-8"):
    method export (line 215) | def export(self, data, **kwargs):
  class XMLFormat (line 222) | class XMLFormat(ExportFormat):
    method __init__ (line 225) | def __init__(self, file_path, file_mode="w", encoding="utf-8"):
    method export (line 228) | def export(self, data, **kwargs):

FILE: beetsplug/fetchart.py
  class ImageAction (line 57) | class ImageAction(Enum):
  class MetadataMatch (line 68) | class MetadataMatch(Enum):
  class Candidate (line 78) | class Candidate:
    method __init__ (line 83) | def __init__(
    method _validate (line 100) | def _validate(
    method validate (line 236) | def validate(
    method resize (line 244) | def resize(self, plugin: FetchArtPlugin) -> None:
    method _resize (line 261) | def _resize(
  function _logged_get (line 298) | def _logged_get(log: Logger, *args, **kwargs) -> requests.Response:
  class RequestMixin (line 338) | class RequestMixin:
    method request (line 345) | def request(self, *args, **kwargs) -> requests.Response:
  class ArtSource (line 356) | class ArtSource(RequestMixin, ABC):
    method __init__ (line 367) | def __init__(
    method description (line 378) | def description(self) -> str:
    method add_default_config (line 382) | def add_default_config(config: confuse.ConfigView) -> None:
    method available (line 386) | def available(cls, log: Logger, config: confuse.ConfigView) -> bool:
    method get (line 393) | def get(
    method _candidate (line 401) | def _candidate(self, **kwargs) -> Candidate:
    method fetch_image (line 405) | def fetch_image(self, candidate: Candidate, plugin: FetchArtPlugin) ->...
    method cleanup (line 414) | def cleanup(self, candidate: Candidate) -> None:
  class LocalArtSource (line 418) | class LocalArtSource(ArtSource):
    method fetch_image (line 421) | def fetch_image(self, candidate: Candidate, plugin: FetchArtPlugin) ->...
  class RemoteArtSource (line 425) | class RemoteArtSource(ArtSource):
    method fetch_image (line 428) | def fetch_image(self, candidate: Candidate, plugin: FetchArtPlugin) ->...
    method cleanup (line 512) | def cleanup(self, candidate: Candidate) -> None:
  class CoverArtArchive (line 520) | class CoverArtArchive(RemoteArtSource):
    method get (line 529) | def get(
  class Amazon (line 595) | class Amazon(RemoteArtSource):
    method get (line 601) | def get(
  class AlbumArtOrg (line 616) | class AlbumArtOrg(RemoteArtSource):
    method get (line 622) | def get(
  class GoogleImages (line 648) | class GoogleImages(RemoteArtSource):
    method __init__ (line 653) | def __init__(self, *args, **kwargs):
    method add_default_config (line 659) | def add_default_config(config: confuse.ConfigView):
    method available (line 670) | def available(cls, log: Logger, config: confuse.ConfigView) -> bool:
    method get (line 676) | def get(
  class FanartTV (line 722) | class FanartTV(RemoteArtSource):
    method __init__ (line 731) | def __init__(self, *args, **kwargs):
    method add_default_config (line 736) | def add_default_config(config: confuse.ConfigView):
    method get (line 744) | def get(
  class ITunesStore (line 809) | class ITunesStore(RemoteArtSource):
    method get (line 814) | def get(
  class Wikipedia (line 893) | class Wikipedia(RemoteArtSource):
    method get (line 920) | def get(
  class FileSystem (line 1041) | class FileSystem(LocalArtSource):
    method filename_priority (line 1046) | def filename_priority(
    method get (line 1057) | def get(
  class LastFM (line 1128) | class LastFM(RemoteArtSource):
    method __init__ (line 1145) | def __init__(self, *args, **kwargs) -> None:
    method add_default_config (line 1150) | def add_default_config(config: confuse.ConfigView) -> None:
    method available (line 1159) | def available(cls, log: Logger, config: confuse.ConfigView) -> bool:
    method get (line 1165) | def get(
  class Spotify (line 1219) | class Spotify(RemoteArtSource):
    method available (line 1226) | def available(cls, log: Logger, config: confuse.ConfigView) -> bool:
    method get (line 1235) | def get(
  class CoverArtUrl (line 1274) | class CoverArtUrl(RemoteArtSource):
    method get (line 1283) | def get(
  class FetchArtPlugin (line 1326) | class FetchArtPlugin(plugins.BeetsPlugin, RequestMixin):
    method __init__ (line 1330) | def __init__(self) -> None:
    method _is_source_file_removal_enabled (line 1445) | def _is_source_file_removal_enabled() -> bool:
    method _is_candidate_fallback (line 1450) | def _is_candidate_fallback(self, candidate: Candidate) -> bool:
    method fetch_art (line 1461) | def fetch_art(self, session: ImportSession, task: ImportTask) -> None:
    method _set_art (line 1487) | def _set_art(
    method assign_art (line 1500) | def assign_art(self, session: ImportSession, task: ImportTask):
    method commands (line 1512) | def commands(self) -> list[ui.Subcommand]:
    method art_for_album (line 1539) | def art_for_album(
    method batch_fetch_art (line 1583) | def batch_fetch_art(

FILE: beetsplug/filefilter.py
  class FileFilterPlugin (line 25) | class FileFilterPlugin(BeetsPlugin):
    method __init__ (line 26) | def __init__(self):
    method import_task_created_event (line 47) | def import_task_created_event(self, session, task):
    method file_filter (line 67) | def file_filter(self, full_path):

FILE: beetsplug/fish.py
  class FishPlugin (line 69) | class FishPlugin(BeetsPlugin):
    method commands (line 70) | def commands(self):
    method run (line 98) | def run(self, lib, opts, args):
  function _escape (line 141) | def _escape(name):
  function get_cmds_list (line 148) | def get_cmds_list(cmds_names):
  function get_standard_fields (line 153) | def get_standard_fields(fields):
  function get_extravalues (line 159) | def get_extravalues(lib, extravalues):
  function get_set_of_values_for_field (line 170) | def get_set_of_values_for_field(lib, fields):
  function get_basic_beet_options (line 181) | def get_basic_beet_options():
  function get_subcommands (line 204) | def get_subcommands(cmd_name_and_help, nobasicfields, extravalues):
  function get_all_commands (line 236) | def get_all_commands(beetcmds):
  function clean_whitespace (line 287) | def clean_whitespace(word):
  function wrap (line 292) | def wrap(word):

FILE: beetsplug/freedesktop.py
  class FreedesktopPlugin (line 21) | class FreedesktopPlugin(BeetsPlugin):
    method commands (line 22) | def commands(self):
    method deprecation_message (line 30) | def deprecation_message(self, lib, opts, args):

FILE: beetsplug/fromfilename.py
  function equal (line 45) | def equal(seq):
  function equal_fields (line 50) | def equal_fields(matchdict, field):
  function all_matches (line 58) | def all_matches(names, pattern):
  function bad_title (line 77) | def bad_title(title):
  function apply_matches (line 87) | def apply_matches(d, log):
  class FromFilenamePlugin (line 137) | class FromFilenamePlugin(plugins.BeetsPlugin):
    method __init__ (line 138) | def __init__(self):
    method filename_task (line 142) | def filename_task(self, task, session):

FILE: beetsplug/ftintitle.py
  function split_on_feat (line 54) | def split_on_feat(
  function contains_feat (line 94) | def contains_feat(title: str, custom_words: list[str] | None = None) -> ...
  function find_feat_part (line 105) | def find_feat_part(
  function _album_artist_no_feat (line 144) | def _album_artist_no_feat(album: Album) -> str:
  class FtInTitlePlugin (line 149) | class FtInTitlePlugin(plugins.BeetsPlugin):
    method bracket_keywords (line 151) | def bracket_keywords(self) -> list[str]:
    method _bracket_position_pattern (line 156) | def _bracket_position_pattern(keywords: tuple[str, ...]) -> re.Pattern...
    method __init__ (line 184) | def __init__(self) -> None:
    method commands (line 219) | def commands(self) -> list[ui.Subcommand]:
    method imported (line 245) | def imported(self, session: ImportSession, task: ImportTask) -> None:
    method update_metadata (line 262) | def update_metadata(
    method ft_in_title (line 304) | def ft_in_title(
    method find_bracket_position (line 347) | def find_bracket_position(
    method insert_ft_into_title (line 358) | def insert_ft_into_title(

FILE: beetsplug/fuzzy.py
  class FuzzyQuery (line 24) | class FuzzyQuery(StringFieldQuery[str]):
    method __init__ (line 25) | def __init__(self, field_name: str, pattern: str, *_) -> None:
    method string_match (line 30) | def string_match(cls, pattern: str, val: str) -> bool:
  class FuzzyPlugin (line 51) | class FuzzyPlugin(BeetsPlugin):
    method __init__ (line 52) | def __init__(self) -> None:
    method queries (line 61) | def queries(self):

FILE: beetsplug/hook.py
  class BytesToStrFormatter (line 28) | class BytesToStrFormatter(string.Formatter):
    method convert_field (line 31) | def convert_field(self, value: Any, conversion: str | None) -> Any:
  class HookPlugin (line 44) | class HookPlugin(BeetsPlugin):
    method __init__ (line 47) | def __init__(self):
    method create_and_register_hook (line 62) | def create_and_register_hook(self, event, command):

FILE: beetsplug/ihate.py
  function summary (line 26) | def summary(task):
  class IHatePlugin (line 36) | class IHatePlugin(BeetsPlugin):
    method __init__ (line 37) | def __init__(self):
    method do_i_hate_this (line 50) | def do_i_hate_this(cls, task, action_patterns):
    method import_task_choice_event (line 64) | def import_task_choice_event(self, session, task):

FILE: beetsplug/importadded.py
  class ImportAddedPlugin (line 13) | class ImportAddedPlugin(BeetsPlugin):
    method __init__ (line 14) | def __init__(self):
    method check_config (line 43) | def check_config(self, task, session):
    method reimported_item (line 46) | def reimported_item(self, item):
    method reimported_album (line 49) | def reimported_album(self, album):
    method record_if_inplace (line 52) | def record_if_inplace(self, task, session):
    method record_reimported (line 71) | def record_reimported(self, task, session):
    method write_file_mtime (line 79) | def write_file_mtime(self, path, mtime):
    method write_item_mtime (line 84) | def write_item_mtime(self, item, mtime):
    method record_import_mtime (line 92) | def record_import_mtime(self, item, source, destination):
    method update_album_times (line 103) | def update_album_times(self, lib, album):
    method update_item_times (line 128) | def update_item_times(self, lib, item):
    method update_after_write_time (line 146) | def update_after_write_time(self, item, path):

FILE: beetsplug/importfeeds.py
  function _build_m3u_session_filename (line 32) | def _build_m3u_session_filename(basename):
  function _build_m3u_filename (line 45) | def _build_m3u_filename(basename):
  function _write_m3u (line 59) | def _write_m3u(m3u_path, items_paths):
  class ImportFeedsPlugin (line 67) | class ImportFeedsPlugin(BeetsPlugin):
    method __init__ (line 68) | def __init__(self):
    method get_feeds_dir (line 91) | def get_feeds_dir(self):
    method _record_items (line 97) | def _record_items(self, lib, basename, items):
    method album_imported (line 141) | def album_imported(self, lib, album):
    method item_imported (line 144) | def item_imported(self, lib, item):
    method import_begin (line 147) | def import_begin(self, session):

FILE: beetsplug/importsource.py
  class ImportSourcePlugin (line 17) | class ImportSourcePlugin(BeetsPlugin):
    method __init__ (line 20) | def __init__(self):
    method prevent_suggest_removal (line 41) | def prevent_suggest_removal(self, session, task):
    method import_stage (line 48) | def import_stage(self, _, task):
    method suggest_removal (line 61) | def suggest_removal(self, item):

FILE: beetsplug/info.py
  function tag_data (line 27) | def tag_data(lib, args, album=False):
  function tag_fields (line 41) | def tag_fields():
  function tag_data_emitter (line 47) | def tag_data_emitter(path):
  function library_data (line 72) | def library_data(lib, args, album=False):
  function library_data_emitter (line 77) | def library_data_emitter(item):
  function update_summary (line 86) | def update_summary(summary, tags):
  function print_data (line 95) | def print_data(data, item=None, fmt=None):
  function print_data_keys (line 131) | def print_data_keys(data, item=None):
  class InfoPlugin (line 148) | class InfoPlugin(BeetsPlugin):
    method commands (line 149) | def commands(self):
    method run (line 187) | def run(self, lib, opts, args):

FILE: beetsplug/inline.py
  class InlineError (line 26) | class InlineError(Exception):
    method __init__ (line 29) | def __init__(self, code, exc):
  function _compile_func (line 35) | def _compile_func(body):
  class InlinePlugin (line 47) | class InlinePlugin(BeetsPlugin):
    method __init__ (line 48) | def __init__(self):
    method compile_inline (line 75) | def compile_inline(self, python_code, album, field_name):

FILE: beetsplug/ipfs.py
  class IPFSPlugin (line 25) | class IPFSPlugin(BeetsPlugin):
    method __init__ (line 26) | def __init__(self):
    method commands (line 38) | def commands(self):
    method auto_add (line 104) | def auto_add(self, session, task):
    method ipfs_play (line 109) | def ipfs_play(self, lib, opts, args):
    method ipfs_add (line 118) | def ipfs_add(self, album):
    method ipfs_get (line 164) | def ipfs_get(self, lib, query):
    method ipfs_get_from_hash (line 176) | def ipfs_get_from_hash(self, lib, _hash):
    method ipfs_publish (line 197) | def ipfs_publish(self, lib):
    method ipfs_import (line 213) | def ipfs_import(self, lib, args):
    method already_added (line 252) | def already_added(self, check, jlib):
    method ipfs_list (line 258) | def ipfs_list(self, lib, args):
    method query (line 269) | def query(self, lib, args):
    method get_remote_lib (line 274) | def get_remote_lib(self, lib):
    method ipfs_added_albums (line 282) | def ipfs_added_albums(self, rlib, tmpname):
    method create_new_album (line 293) | def create_new_album(self, album, tmplib):

FILE: beetsplug/keyfinder.py
  class KeyFinderPlugin (line 24) | class KeyFinderPlugin(BeetsPlugin):
    method __init__ (line 25) | def __init__(self):
    method commands (line 38) | def commands(self):
    method command (line 45) | def command(self, lib, opts, args):
    method imported (line 48) | def imported(self, session, task):
    method find_key (line 51) | def find_key(self, items, write=False):

FILE: beetsplug/kodiupdate.py
  function update_kodi (line 31) | def update_kodi(host, port, user, password):
  class KodiUpdate (line 53) | class KodiUpdate(BeetsPlugin):
    method __init__ (line 54) | def __init__(self):
    method listen_for_db_change (line 66) | def listen_for_db_change(self, lib, model):
    method update (line 70) | def update(self, lib):

FILE: beetsplug/lastgenre/__init__.py
  function flatten_tree (line 58) | def flatten_tree(
  function find_parents (line 79) | def find_parents(candidate: str, branches: CanonTree) -> list[str]:
  function get_depth (line 92) | def get_depth(tag: str, branches: CanonTree) -> int | None:
  function sort_by_depth (line 100) | def sort_by_depth(tags: list[str], branches: CanonTree) -> list[str]:
  class LastGenrePlugin (line 114) | class LastGenrePlugin(plugins.BeetsPlugin):
    method __init__ (line 115) | def __init__(self) -> None:
    method setup (line 137) | def setup(self) -> None:
    method _load_whitelist (line 149) | def _load_whitelist(self) -> Whitelist:
    method _load_c14n_tree (line 167) | def _load_c14n_tree(self) -> tuple[CanonTree, bool]:
    method sources (line 191) | def sources(self) -> tuple[str, ...]:
    method _resolve_genres (line 205) | def _resolve_genres(self, tags: list[str]) -> list[str]:
    method _filter_valid (line 262) | def _filter_valid(self, genres: Iterable[str]) -> list[str]:
    method _format_genres (line 278) | def _format_genres(self, tags: list[str]) -> list[str]:
    method _get_existing_genres (line 285) | def _get_existing_genres(self, obj: LibModel) -> list[str]:
    method _combine_resolve_and_log (line 294) | def _combine_resolve_and_log(
    method _get_genre (line 303) | def _get_genre(self, obj: LibModel) -> tuple[list[str], str]:
    method _fetch_and_log_genre (line 458) | def _fetch_and_log_genre(self, obj: LibModel) -> None:
    method _process (line 467) | def _process(self, obj: LibModel, write: bool) -> None:
    method _process_track (line 472) | def _process_track(self, obj: Item, write: bool) -> None:
    method _process_album (line 479) | def _process_album(self, obj: Album, write: bool) -> None:
    method commands (line 491) | def commands(self) -> list[ui.Subcommand]:
    method imported (line 562) | def imported(self, _: ImportSession, task: ImportTask) -> None:

FILE: beetsplug/lastgenre/client.py
  class LastFmClient (line 48) | class LastFmClient:
    method __init__ (line 51) | def __init__(self, log: BeetsLogger, min_weight: int):
    method fetch_genre (line 60) | def fetch_genre(
    method _tags_for (line 68) | def _tags_for(
    method _last_lookup (line 108) | def _last_lookup(
    method fetch_album_genre (line 132) | def fetch_album_genre(self, albumartist: str, albumtitle: str) -> list...
    method fetch_artist_genre (line 138) | def fetch_artist_genre(self, artist: str) -> list[str]:
    method fetch_track_genre (line 142) | def fetch_track_genre(self, trackartist: str, tracktitle: str) -> list...

FILE: beetsplug/lastimport.py
  class LastImportPlugin (line 25) | class LastImportPlugin(plugins.BeetsPlugin):
    method __init__ (line 26) | def __init__(self):
    method commands (line 46) | def commands(self):
  class CustomUser (line 56) | class CustomUser(pylast.User):
    method __init__ (line 63) | def __init__(self, *args, **kwargs):
    method _get_things (line 66) | def _get_things(
    method get_top_tracks_by_page (line 91) | def get_top_tracks_by_page(
  function import_lastfm (line 116) | def import_lastfm(lib, log):
  function fetch_tracks (line 173) | def fetch_tracks(user, page, limit):
  function process_tracks (line 200) | def process_tracks(lib, tracks, log):

FILE: beetsplug/limit.py
  function lslimit (line 31) | def lslimit(lib, opts, args):
  class LimitPlugin (line 67) | class LimitPlugin(BeetsPlugin):
    method commands (line 70) | def commands(self):
    method queries (line 74) | def queries(self):

FILE: beetsplug/listenbrainz.py
  class ListenBrainzPlugin (line 14) | class ListenBrainzPlugin(MusicBrainzAPIMixin, BeetsPlugin):
    method __init__ (line 19) | def __init__(self):
    method commands (line 27) | def commands(self):
    method _lbupdate (line 39) | def _lbupdate(self, lib, log):
    method _make_request (line 54) | def _make_request(self, url, params=None):
    method get_listens (line 69) | def get_listens(self, min_ts=None, max_ts=None, count=None):
    method get_tracks_from_listens (line 106) | def get_tracks_from_listens(self, listens):
    method get_mb_recording_id (line 133) | def get_mb_recording_id(self, track) -> str | None:
    method get_playlists_createdfor (line 144) | def get_playlists_createdfor(self, username):
    method get_listenbrainz_playlists (line 149) | def get_listenbrainz_playlists(self):
    method get_playlist (line 184) | def get_playlist(self, identifier):
    method get_tracks_from_playlist (line 189) | def get_tracks_from_playlist(self, playlist):
    method get_track_info (line 206) | def get_track_info(self, tracks):
    method get_weekly_playlist (line 238) | def get_weekly_playlist(self, playlist_type, most_recent=True):
    method get_weekly_exploration (line 261) | def get_weekly_exploration(self):
    method get_weekly_jams (line 264) | def get_weekly_jams(self):
    method get_last_weekly_exploration (line 267) | def get_last_weekly_exploration(self):
    method get_last_weekly_jams (line 270) | def get_last_weekly_jams(self):

FILE: beetsplug/loadext.py
  class LoadExtPlugin (line 23) | class LoadExtPlugin(BeetsPlugin):
    method __init__ (line 24) | def __init__(self):
    method library_opened (line 36) | def library_opened(self, lib):

FILE: beetsplug/lyrics.py
  class CaptchaError (line 62) | class CaptchaError(requests.exceptions.HTTPError):
    method __init__ (line 63) | def __init__(self, *args, **kwargs) -> None:
  class GeniusHTTPError (line 67) | class GeniusHTTPError(requests.exceptions.HTTPError):
  function search_pairs (line 74) | def search_pairs(item):
  function slug (line 150) | def slug(text: str) -> str:
  class LyricsRequestHandler (line 164) | class LyricsRequestHandler(RequestHandler):
    method status_to_error (line 167) | def status_to_error(self, code: int) -> type[requests.HTTPError] | None:
    method debug (line 176) | def debug(self, message: str, *args) -> None:
    method info (line 180) | def info(self, message: str, *args) -> None:
    method warn (line 184) | def warn(self, message: str, *args) -> None:
    method format_url (line 189) | def format_url(url: str, params: JSONDict | None) -> str:
    method get_text (line 195) | def get_text(
    method get_json (line 209) | def get_json(self, url: str, params: JSONDict | None = None, **kwargs):
    method post_json (line 215) | def post_json(self, url: str, params: JSONDict | None = None, **kwargs):
    method handle_request (line 222) | def handle_request(self) -> Iterator[None]:
  class BackendClass (line 231) | class BackendClass(type):
    method name (line 233) | def name(cls) -> str:
  class Backend (line 238) | class Backend(LyricsRequestHandler, metaclass=BackendClass):
    method __init__ (line 241) | def __init__(self, config: confuse.Subview, log: Logger) -> None:
    method fetch (line 245) | def fetch(
  class LRCLyrics (line 254) | class LRCLyrics:
    method __le__ (line 267) | def __le__(self, other: LRCLyrics) -> bool:
    method verify_synced_lyrics (line 272) | def verify_synced_lyrics(
    method make (line 288) | def make(
    method duration_dist (line 305) | def duration_dist(self) -> float:
    method is_valid (line 310) | def is_valid(self) -> bool:
    method dist (line 321) | def dist(self) -> tuple[bool, float]:
    method get_text (line 333) | def get_text(self, want_synced: bool) -> str:
  class LRCLib (line 344) | class LRCLib(Backend):
    method fetch_candidates (line 351) | def fetch_candidates(
    method pick_best_match (line 375) | def pick_best_match(cls, lyrics: Iterable[LRCLyrics]) -> LRCLyrics | N...
    method fetch (line 379) | def fetch(
  class MusiXmatch (line 396) | class MusiXmatch(Backend):
    method encode (line 409) | def encode(cls, text: str) -> str:
    method build_url (line 416) | def build_url(cls, *args: str) -> str:
    method fetch (line 419) | def fetch(self, artist: str, title: str, *_) -> Lyrics | None:
  class Html (line 444) | class Html:
    method normalize_space (line 469) | def normalize_space(cls, text: str) -> str:
    method remove_ads (line 474) | def remove_ads(cls, text: str) -> str:
    method merge_paragraphs (line 478) | def merge_paragraphs(cls, text: str) -> str:
  class SoupMixin (line 482) | class SoupMixin:
    method pre_process_html (line 484) | def pre_process_html(cls, html: str) -> str:
    method get_soup (line 489) | def get_soup(cls, html: str) -> BeautifulSoup:
  class SearchResult (line 493) | class SearchResult(NamedTuple):
    method source (line 499) | def source(self) -> str:
  class SearchBackend (line 503) | class SearchBackend(SoupMixin, Backend):
    method dist_thresh (line 505) | def dist_thresh(self) -> float:
    method check_match (line 508) | def check_match(
    method search (line 534) | def search(self, artist: str, title: str) -> Iterable[SearchResult]:
    method get_results (line 538) | def get_results(self, artist: str, title: str) -> Iterable[SearchResult]:
    method fetch (line 544) | def fetch(self, artist: str, title: str, *_) -> Lyrics | None:
    method scrape (line 555) | def scrape(cls, html: str) -> str | None:
  class Genius (line 560) | class Genius(SearchBackend):
    method headers (line 573) | def headers(self) -> dict[str, str]:
    method get_json (line 576) | def get_json(self, *args, **kwargs) -> GeniusAPI.Search:
    method search (line 584) | def search(self, artist: str, title: str) -> Iterable[SearchResult]:
    method scrape (line 594) | def scrape(cls, html: str) -> str | None:
  class Tekstowo (line 602) | class Tekstowo(SearchBackend):
    method build_url (line 608) | def build_url(self, artist, title):
    method search (line 613) | def search(self, artist: str, title: str) -> Iterable[SearchResult]:
    method scrape (line 625) | def scrape(cls, html: str) -> str | None:
  class Google (line 634) | class Google(SearchBackend):
    method pre_process_html (line 678) | def pre_process_html(cls, html: str) -> str:
    method get_text (line 683) | def get_text(self, *args, **kwargs) -> str:
    method get_part_dist (line 694) | def get_part_dist(artist: str, title: str, part: str) -> float:
    method make_search_result (line 703) | def make_search_result(
    method search (line 734) | def search(self, artist: str, title: str) -> Iterable[SearchResult]:
    method get_results (line 750) | def get_results(self, *args) -> Iterable[SearchResult]:
    method scrape (line 760) | def scrape(cls, html: str) -> str | None:
  class Translator (line 769) | class Translator(LyricsRequestHandler):
    method from_config (line 781) | def from_config(
    method get_translations (line 796) | def get_translations(self, texts: Iterable[str]) -> list[str]:
    method translate (line 816) | def translate(self, lyrics: Lyrics, old_lyrics: Lyrics) -> Lyrics:
  class RestFiles (line 855) | class RestFiles:
    method artists_dir (line 890) | def artists_dir(self) -> Path:
    method write_indexes (line 895) | def write_indexes(self) -> None:
    method write_artist (line 908) | def write_artist(self, artist: str, items: Iterable[Item]) -> None:
    method write (line 927) | def write(self, items: list[Item]) -> None:
  class LyricsPlugin (line 950) | class LyricsPlugin(LyricsRequestHandler, plugins.BeetsPlugin):
    method backends (line 959) | def backends(self) -> list[Backend]:
    method translator (line 970) | def translator(self) -> Translator | None:
    method __init__ (line 976) | def __init__(self):
    method commands (line 1015) | def commands(self):
    method imported (line 1066) | def imported(self, _, task: ImportTask) -> None:
    method find_lyrics (line 1071) | def find_lyrics(self, item: Item) -> Lyrics | None:
    method add_item_lyrics (line 1082) | def add_item_lyrics(self, item: Item, write: bool) -> None:
    method get_lyrics (line 1125) | def get_lyrics(self, artist: str, title: str, *args) -> Lyrics | None:

FILE: beetsplug/mbcollection.py
  class MusicBrainzUserAPI (line 45) | class MusicBrainzUserAPI(MusicBrainzAPI):
    method __post_init__ (line 61) | def __post_init__(self) -> None:
    method request (line 69) | def request(self, *args, **kwargs) -> Response:
    method browse_collections (line 76) | def browse_collections(self) -> list[JSONDict]:
  class MBCollection (line 82) | class MBCollection:
    method id (line 97) | def id(self) -> str:
    method release_count (line 102) | def release_count(self) -> int:
    method releases_url (line 107) | def releases_url(self) -> str:
    method releases (line 112) | def releases(self) -> list[JSONDict]:
    method get_releases (line 121) | def get_releases(self, offset: int) -> list[JSONDict]:
    method get_id_chunks (line 129) | def get_id_chunks(cls, id_list: list[str]) -> Iterator[list[str]]:
    method add_releases (line 138) | def add_releases(self, releases: list[str]) -> None:
    method remove_releases (line 144) | def remove_releases(self, releases: list[str]) -> None:
  function submit_albums (line 151) | def submit_albums(collection: MBCollection, release_ids):
  class MusicBrainzCollectionPlugin (line 158) | class MusicBrainzCollectionPlugin(BeetsPlugin):
    method __init__ (line 159) | def __init__(self) -> None:
    method mb_api (line 172) | def mb_api(self) -> MusicBrainzUserAPI:
    method collection (line 176) | def collection(self) -> MBCollection:
    method commands (line 198) | def commands(self):
    method update_collection (line 211) | def update_collection(self, lib: Library, opts, args) -> None:
    method imported (line 216) | def imported(self, session: ImportSession, task: ImportTask) -> None:
    method update_album_list (line 223) | def update_album_list(

FILE: beetsplug/mbpseudo.py
  class MusicBrainzPseudoReleasePlugin (line 49) | class MusicBrainzPseudoReleasePlugin(MusicBrainzPlugin):
    method __init__ (line 50) | def __init__(self) -> None:
    method _on_plugins_loaded (line 100) | def _on_plugins_loaded(self):
    method candidates (line 111) | def candidates(
    method album_info (line 136) | def album_info(self, release: JSONDict) -> AlbumInfo:
    method _intercept_mb_release (line 164) | def _intercept_mb_release(self, data: JSONDict) -> list[str]:
    method _has_desired_script (line 176) | def _has_desired_script(self, release: JSONDict) -> bool:
    method _wanted_pseudo_release_id (line 184) | def _wanted_pseudo_release_id(
    method _replace_artist_with_alias (line 208) | def _replace_artist_with_alias(
    method _add_custom_tags (line 243) | def _add_custom_tags(
    method _adjust_final_album_match (line 260) | def _adjust_final_album_match(self, match: AlbumMatch):
    method _extract_id (line 275) | def _extract_id(self, url: str) -> str | None:
  class PseudoAlbumInfo (line 279) | class PseudoAlbumInfo(AlbumInfo):
    method __init__ (line 294) | def __init__(
    method get_official_release (line 307) | def get_official_release(self) -> AlbumInfo:
    method determine_best_ref (line 310) | def determine_best_ref(self, items: Sequence[Item]) -> str:
    method _compute_distance (line 324) | def _compute_distance(self, items: Sequence[Item]) -> Distance:
    method use_pseudo_as_ref (line 328) | def use_pseudo_as_ref(self):
    method use_official_as_ref (line 331) | def use_official_as_ref(self):
    method __getattr__ (line 334) | def __getattr__(self, attr: str) -> Any:
    method __deepcopy__ (line 341) | def __deepcopy__(self, memo):

FILE: beetsplug/mbsubmit.py
  class MBSubmitPlugin (line 33) | class MBSubmitPlugin(BeetsPlugin):
    method __init__ (line 34) | def __init__(self):
    method before_choose_candidate_event (line 59) | def before_choose_candidate_event(self, session, task):
    method picard (line 66) | def picard(self, session, task):
    method print_tracks (line 77) | def print_tracks(self, session, task):
    method commands (line 81) | def commands(self):
    method _mbsubmit (line 95) | def _mbsubmit(self, items):

FILE: beetsplug/mbsync.py
  class MBSyncPlugin (line 23) | class MBSyncPlugin(BeetsPlugin):
    method __init__ (line 24) | def __init__(self):
    method commands (line 27) | def commands(self):
    method func (line 61) | def func(self, lib, opts, args):
    method singletons (line 70) | def singletons(self, lib, query, move, pretend, write):
    method albums (line 96) | def albums(self, lib, query, move, pretend, write):

FILE: beetsplug/metasync/__init__.py
  class MetaSource (line 40) | class MetaSource(metaclass=ABCMeta):
    method __init__ (line 43) | def __init__(self, config, log):
    method sync_from_source (line 48) | def sync_from_source(self, item):
  function load_meta_sources (line 52) | def load_meta_sources():
  function load_item_types (line 68) | def load_item_types():
  class MetaSyncPlugin (line 76) | class MetaSyncPlugin(BeetsPlugin):
    method __init__ (line 79) | def __init__(self):
    method commands (line 82) | def commands(self):
    method func (line 104) | def func(self, lib, opts, args):

FILE: beetsplug/metasync/amarok.py
  function import_dbus (line 28) | def import_dbus():
  class Amarok (line 38) | class Amarok(MetaSource):
    method __init__ (line 55) | def __init__(self, config, log):
    method sync_from_source (line 65) | def sync_from_source(self, item):

FILE: beetsplug/metasync/itunes.py
  function create_temporary_copy (line 35) | def create_temporary_copy(path):
  function _norm_itunes_path (line 45) | def _norm_itunes_path(path):
  class Itunes (line 61) | class Itunes(MetaSource):
    method __init__ (line 71) | def __init__(self, config, log):
    method sync_from_source (line 104) | def sync_from_source(self, item):

FILE: beetsplug/missing.py
  function _missing_count (line 60) | def _missing_count(album):
  function _item (line 65) | def _item(track_info, album_info, album_id):
  class MissingPlugin (line 115) | class MissingPlugin(MusicBrainzAPIMixin, BeetsPlugin):
    method __init__ (line 122) | def __init__(self):
    method commands (line 172) | def commands(self):
    method _missing_tracks (line 183) | def _missing_tracks(self, lib, query):
    method _missing_albums (line 210) | def _missing_albums(self, lib: Library, query: list[str]) -> None:
    method _missing (line 263) | def _missing(self, album: Album) -> Iterator[Item]:

FILE: beetsplug/mpdstats.py
  function is_url (line 37) | def is_url(path):
  class MPDClientWrapper (line 44) | class MPDClientWrapper:
    method __init__ (line 45) | def __init__(self, log):
    method connect (line 60) | def connect(self):
    method disconnect (line 81) | def disconnect(self):
    method get (line 86) | def get(self, command, retries=RETRIES):
    method currentsong (line 109) | def currentsong(self):
    method status (line 130) | def status(self):
    method events (line 134) | def events(self):
  class MPDStats (line 141) | class MPDStats:
    method __init__ (line 142) | def __init__(self, lib, log):
    method rating (line 155) | def rating(self, play_count, skip_count, rating, skipped):
    method get_item (line 166) | def get_item(self, path):
    method update_item (line 175) | def update_item(self, item, attribute, value=None, increment=None):
    method update_rating (line 198) | def update_rating(self, item, skipped):
    method handle_song_change (line 215) | def handle_song_change(self, song):
    method handle_played (line 235) | def handle_played(self, song):
    method handle_skipped (line 240) | def handle_skipped(self, song):
    method on_stop (line 245) | def on_stop(self, status):
    method on_pause (line 255) | def on_pause(self, status):
    method on_play (line 259) | def on_play(self, status):
    method run (line 303) | def run(self):
  class MPDStatsPlugin (line 321) | class MPDStatsPlugin(plugins.BeetsPlugin):
    method __init__ (line 329) | def __init__(self):
    method commands (line 345) | def commands(self):

FILE: beetsplug/mpdupdate.py
  class BufferedSocket (line 34) | class BufferedSocket:
    method __init__ (line 37) | def __init__(self, host, port, sep=b"\n"):
    method readline (line 47) | def readline(self):
    method send (line 59) | def send(self, data):
    method close (line 62) | def close(self):
  class MPDUpdatePlugin (line 66) | class MPDUpdatePlugin(BeetsPlugin):
    method __init__ (line 67) | def __init__(self):
    method db_change (line 86) | def db_change(self, lib, model):
    method update (line 89) | def update(self, lib):
    method update_mpd (line 96) | def update_mpd(self, host="localhost", port=6600, password=None):

FILE: beetsplug/musicbrainz.py
  function _preferred_alias (line 74) | def _preferred_alias(
  function _key_with_preferred_alias (line 108) | def _key_with_preferred_alias(obj: JSONDict, key: str) -> str:
  function _multi_artist_credit (line 113) | def _multi_artist_credit(
  function track_url (line 156) | def track_url(trackid: str) -> str:
  function _flatten_artist_credit (line 160) | def _flatten_artist_credit(credit: list[JSONDict]) -> tuple[str, str, str]:
  function _artist_ids (line 175) | def _artist_ids(credit: list[JSONDict]) -> list[str]:
  function _get_related_artist_names (line 188) | def _get_related_artist_names(relations, relation_type):
  function album_url (line 201) | def album_url(albumid: str) -> str:
  function _preferred_release_event (line 205) | def _preferred_release_event(
  function _set_date_str (line 228) | def _set_date_str(
  function _merge_pseudo_and_actual_album (line 252) | def _merge_pseudo_and_actual_album(
  class MusicBrainzPlugin (line 292) | class MusicBrainzPlugin(
    method genres_field (line 296) | def genres_field(self) -> str:
    method __init__ (line 299) | def __init__(self):
    method track_info (line 329) | def track_info(
    method album_info (line 434) | def album_info(self, release: JSONDict) -> beets.autotag.hooks.AlbumInfo:
    method extra_mb_field_by_tag (line 694) | def extra_mb_field_by_tag(self) -> dict[str, str]:
    method get_album_criteria (line 710) | def get_album_criteria(
    method get_search_query_with_filters (line 732) | def get_search_query_with_filters(
    method get_search_response (line 751) | def get_search_response(self, params: SearchParams) -> Sequence[IDResp...
    method album_for_id (line 761) | def album_for_id(
    method track_for_id (line 804) | def track_for_id(

FILE: beetsplug/parentwork.py
  class ParentWorkPlugin (line 31) | class ParentWorkPlugin(MusicBrainzAPIMixin, BeetsPlugin):
    method __init__ (line 32) | def __init__(self):
    method commands (line 45) | def commands(self):
    method imported (line 74) | def imported(self, session, task):
    method get_info (line 82) | def get_info(self, item, work_info):
    method find_work (line 125) | def find_work(self, item, force, verbose):
    method find_parentwork_info (line 194) | def find_parentwork_info(

FILE: beetsplug/permissions.py
  function convert_perm (line 17) | def convert_perm(perm):
  function check_permissions (line 27) | def check_permissions(path, permission):
  function assert_permissions (line 34) | def assert_permissions(path, permission, log):
  function dirs_in_library (line 48) | def dirs_in_library(library, item):
  class Permissions (line 55) | class Permissions(BeetsPlugin):
    method __init__ (line 56) | def __init__(self):
    method fix (line 71) | def fix(self, lib, item=None, album=None):
    method fix_art (line 84) | def fix_art(self, album):
    method set_permissions (line 89) | def set_permissions(self, files=[], dirs=[]):

FILE: beetsplug/play.py
  function play (line 38) | def play(
  class PlayPlugin (line 66) | class PlayPlugin(BeetsPlugin):
    method __init__ (line 67) | def __init__(self):
    method commands (line 85) | def commands(self):
    method _play_command (line 111) | def _play_command(self, lib, opts, args):
    method _command_str (line 174) | def _command_str(self, args=None):
    method _playlist_or_paths (line 189) | def _playlist_or_paths(self, paths):
    method _exceeds_threshold (line 197) | def _exceeds_threshold(
    method _create_tmp_playlist (line 222) | def _create_tmp_playlist(self, paths_list):
    method before_choose_candidate_listener (line 235) | def before_choose_candidate_listener(self, session, task):
    method importer_play (line 239) | def importer_play(self, session, task):

FILE: beetsplug/playlist.py
  function is_m3u_file (line 30) | def is_m3u_file(path: str) -> bool:
  class PlaylistQuery (line 34) | class PlaylistQuery(InQuery[bytes]):
    method subvals (line 38) | def subvals(self) -> Sequence[BLOB_TYPE]:
    method __init__ (line 41) | def __init__(self, _, pattern: str, __):
  class PlaylistPlugin (line 89) | class PlaylistPlugin(beets.plugins.BeetsPlugin):
    method __init__ (line 94) | def __init__(self):
    method item_moved (line 124) | def item_moved(self, item, source, destination):
    method item_removed (line 127) | def item_removed(self, item):
    method cli_exit (line 131) | def cli_exit(self, lib):
    method find_playlists (line 145) | def find_playlists(self):
    method update_playlist (line 160) | def update_playlist(self, filename, base_dir):

FILE: beetsplug/plexupdate.py
  function get_music_section (line 20) | def get_music_section(
  function update_plex (line 41) | def update_plex(host, port, token, library_name, secure, ignore_cert_err...
  function append_token (line 66) | def append_token(url, token):
  function get_protocol (line 73) | def get_protocol(secure):
  class PlexUpdate (line 80) | class PlexUpdate(BeetsPlugin):
    method __init__ (line 81) | def __init__(self):
    method listen_for_db_change (line 99) | def listen_for_db_change(self, lib, model):
    method update (line 103) | def update(self, lib):

FILE: beetsplug/random.py
  function random_func (line 33) | def random_func(lib: Library, opts: optparse.Values, args: list[str]):
  class Random (line 82) | class Random(BeetsPlugin):
    method commands (line 83) | def commands(self):
  function _equal_chance_permutation (line 87) | def _equal_chance_permutation(
  function _take_time (line 112) | def _take_time(
  function random_objs (line 128) | def random_objs(

FILE: beetsplug/replace.py
  class ReplacePlugin (line 16) | class ReplacePlugin(BeetsPlugin):
    method commands (line 17) | def commands(self):
    method run (line 24) | def run(self, lib: Library, args: list[str]) -> None:
    method file_check (line 50) | def file_check(self, filepath: Path) -> None:
    method select_song (line 62) | def select_song(self, items: list[Item]):
    method confirm_replacement (line 87) | def confirm_replacement(self, new_file_path: Path, song: Item):
    method replace_file (line 105) | def replace_file(self, new_file_path: Path, song: Item) -> None:

FILE: beetsplug/replaygain.py
  class ReplayGainError (line 52) | class ReplayGainError(Exception):
  class FatalReplayGainError (line 58) | class FatalReplayGainError(Exception):
  class FatalGstreamerPluginReplayGainError (line 62) | class FatalGstreamerPluginReplayGainError(FatalReplayGainError):
  function call (line 67) | def call(args: list[str], log: Logger, **kwargs: Any):
  function db_to_lufs (line 78) | def db_to_lufs(db: float) -> float:
  function lufs_to_db (line 87) | def lufs_to_db(db: float) -> float:
  class Gain (line 100) | class Gain:
  class PeakMethod (line 107) | class PeakMethod(enum.Enum):
  class RgTask (line 112) | class RgTask:
    method __init__ (line 122) | def __init__(
    method _store_track_gain (line 140) | def _store_track_gain(self, item: Item, track_gain: Gain):
    method _store_album_gain (line 150) | def _store_album_gain(self, item: Item, album_gain: Gain):
    method _store_track (line 163) | def _store_track(self, write: bool):
    method _store_album (line 180) | def _store_album(self, write: bool):
    method store (line 201) | def store(self, write: bool):
  class R128Task (line 209) | class R128Task(RgTask):
    method __init__ (line 219) | def __init__(
    method _store_track_gain (line 230) | def _store_track_gain(self, item: Item, track_gain: Gain):
    method _store_album_gain (line 235) | def _store_album_gain(self, item: Item, album_gain: Gain):
  class Backend (line 248) | class Backend(ABC):
    method __init__ (line 254) | def __init__(self, config: ConfigView, log: Logger):
    method compute_track_gain (line 261) | def compute_track_gain(self, task: AnyRgTask) -> AnyRgTask:
    method compute_album_gain (line 268) | def compute_album_gain(self, task: AnyRgTask) -> AnyRgTask:
  class FfmpegBackend (line 276) | class FfmpegBackend(Backend):
    method __init__ (line 282) | def __init__(self, config: ConfigView, log: Logger):
    method compute_track_gain (line 310) | def compute_track_gain(self, task: AnyRgTask) -> AnyRgTask:
    method compute_album_gain (line 326) | def compute_album_gain(self, task: AnyRgTask) -> AnyRgTask:
    method _construct_cmd (line 391) | def _construct_cmd(
    method _analyse_item (line 410) | def _analyse_item(
    method _find_line (line 503) | def _find_line(
    method _parse_float (line 522) | def _parse_float(self, line: bytes) -> float:
  class CommandBackend (line 550) | class CommandBackend(Backend):
    method __init__ (line 561) | def __init__(self, config: ConfigView, log: Logger):
    method compute_track_gain (line 589) | def compute_track_gain(self, task: AnyRgTask) -> AnyRgTask:
    method compute_album_gain (line 598) | def compute_album_gain(self, task: AnyRgTask) -> AnyRgTask:
    method format_supported (line 617) | def format_supported(self, item: Item) -> bool:
    method compute_gain (line 621) | def compute_gain(
    method parse_tool_output (line 666) | def parse_tool_output(self, text: bytes, num_lines: int) -> list[Gain]:
  class GStreamerBackend (line 692) | class GStreamerBackend(Backend):
    method __init__ (line 695) | def __init__(self, config: ConfigView, log: Logger):
    method _import_gst (line 754) | def _import_gst(self):
    method compute (line 784) | def compute(self, items: Sequence[Item], target_level: float, album: b...
    method compute_track_gain (line 806) | def compute_track_gain(self, task: AnyRgTask) -> AnyRgTask:
    method compute_album_gain (line 826) | def compute_album_gain(self, task: AnyRgTask) -> AnyRgTask:
    method close (line 857) | def close(self):
    method _on_eos (line 860) | def _on_eos(self, bus, message):
    method _on_error (line 868) | def _on_error(self, bus, message):
    method _on_tag (line 878) | def _on_tag(self, bus, message):
    method _set_first_file (line 909) | def _set_first_file(self) -> bool:
    method _set_file (line 919) | def _set_file(self) -> bool:
    method _set_next_file (line 952) | def _set_next_file(self) -> bool:
    method _on_pad_added (line 973) | def _on_pad_added(self, decbin, pad):
    method _on_pad_removed (line 978) | def _on_pad_removed(self, decbin, pad):
  class AudioToolsBackend (line 985) | class AudioToolsBackend(Backend):
    method __init__ (line 993) | def __init__(self, config: ConfigView, log: Logger):
    method _import_audiotools (line 997) | def _import_audiotools(self):
    method open_audio_file (line 1013) | def open_audio_file(self, item: Item):
    method init_replaygain (line 1033) | def init_replaygain(self, audiofile, item: Item):
    method compute_track_gain (line 1050) | def compute_track_gain(self, task: AnyRgTask) -> AnyRgTask:
    method _with_target_level (line 1060) | def _with_target_level(self, gain: float, target_level: float):
    method _title_gain (line 1067) | def _title_gain(self, rg, audiofile, target_level: float):
    method _compute_track_gain (line 1085) | def _compute_track_gain(self, item: Item, target_level: float):
    method compute_album_gain (line 1107) | def compute_album_gain(self, task: AnyRgTask) -> AnyRgTask:
  class ExceptionWatcher (line 1150) | class ExceptionWatcher(Thread):
    method __init__ (line 1155) | def __init__(
    method run (line 1163) | def run(self):
    method join (line 1174) | def join(self, timeout: float | None = None):
  class ReplayGainPlugin (line 1190) | class ReplayGainPlugin(BeetsPlugin):
    method __init__ (line 1195) | def __init__(self) -> None:
    method should_use_r128 (line 1256) | def should_use_r128(self, item: Item) -> bool:
    method has_r128_track_data (line 1263) | def has_r128_track_data(item: Item) -> bool:
    method has_rg_track_data (line 1267) | def has_rg_track_data(item: Item) -> bool:
    method track_requires_gain (line 1270) | def track_requires_gain(self, item: Item) -> bool:
    method has_r128_album_data (line 1281) | def has_r128_album_data(item: Item) -> bool:
    method has_rg_album_data (line 1288) | def has_rg_album_data(item: Item) -> bool:
    method album_requires_gain (line 1291) | def album_requires_gain(self, album: Album) -> bool:
    method create_task (line 1306) | def create_task(
    method handle_album (line 1330) | def handle_album(self, album: Album, write: bool, force: bool = False):
    method handle_track (line 1379) | def handle_track(self, item: Item, write: bool, force: bool = False):
    method open_pool (line 1408) | def open_pool(self, threads: int):
    method _apply (line 1422) | def _apply(
    method terminate_pool (line 1444) | def terminate_pool(self):
    method _interrupt (line 1457) | def _interrupt(self, signal, frame):
    method close_pool (line 1466) | def close_pool(self):
    method import_begin (line 1474) | def import_begin(self, session: ImportSession):
    method import_end (line 1485) | def import_end(self, paths):
    method imported (line 1489) | def imported(self, session: ImportSession, task: ImportTask):
    method command_func (line 1499) | def command_func(
    method commands (line 1536) | def commands(self) -> list[ui.Subcommand]:

FILE: beetsplug/rewrite.py
  function rewriter (line 26) | def rewriter(field, rules):
  class RewritePlugin (line 44) | class RewritePlugin(BeetsPlugin):
    method __init__ (line 45) | def __init__(self):

FILE: beetsplug/scrub.py
  class ScrubPlugin (line 44) | class ScrubPlugin(BeetsPlugin):
    method __init__ (line 47) | def __init__(self):
    method commands (line 58) | def commands(self):
    method _mutagen_classes (line 79) | def _mutagen_classes():
    method _scrub (line 87) | def _scrub(self, path):
    method _scrub_item (line 114) | def _scrub_item(self, item, restore):
    method import_task_files (line 147) | def import_task_files(self, session, task):

FILE: beetsplug/smartplaylist.py
  class SmartPlaylistPlugin (line 51) | class SmartPlaylistPlugin(BeetsPlugin):
    method __init__ (line 52) | def __init__(self) -> None:
    method commands (line 78) | def commands(self) -> list[ui.Subcommand]:
    method update_cmd (line 148) | def update_cmd(self, lib: Library, opts: Any, args: list[str]) -> None:
    method __apply_opts_to_config (line 175) | def __apply_opts_to_config(self, opts: Any) -> None:
    method _parse_one_query (line 180) | def _parse_one_query(
    method build_queries (line 196) | def build_queries(self) -> None:
    method _matches_query (line 230) | def _matches_query(self, model: Item | Album, query: PlaylistQuery) ->...
    method matches (line 237) | def matches(
    method db_change (line 249) | def db_change(self, lib: Library, model: Item | Album) -> None:
    method update_playlists (line 262) | def update_playlists(self, lib: Library, pretend: bool = False) -> None:
  class PlaylistItem (line 394) | class PlaylistItem:
    method __init__ (line 395) | def __init__(self, item: Item, uri: bytes) -> None:

FILE: beetsplug/sonosupdate.py
  class SonosUpdate (line 24) | class SonosUpdate(BeetsPlugin):
    method __init__ (line 25) | def __init__(self):
    method listen_for_db_change (line 29) | def listen_for_db_change(self, lib, model):
    method update (line 33) | def update(self, lib):

FILE: beetsplug/spotify.py
  class SearchResponseAlbums (line 52) | class SearchResponseAlbums(IDResponse):
  class SearchResponseTracks (line 70) | class SearchResponseTracks(IDResponse):
  class APIError (line 79) | class APIError(Exception):
  class AudioFeaturesUnavailableError (line 83) | class AudioFeaturesUnavailableError(Exception):
  class SpotifyPlugin (line 89) | class SpotifyPlugin(
    method __init__ (line 133) | def __init__(self):
    method setup (line 158) | def setup(self):
    method _tokenfile (line 169) | def _tokenfile(self) -> str:
    method _authenticate (line 173) | def _authenticate(self) -> None:
    method _handle_response (line 203) | def _handle_response(
    method _multi_artist_credit (line 301) | def _multi_artist_credit(
    method album_for_id (line 315) | def album_for_id(self, album_id: str) -> AlbumInfo | None:
    method _get_track (line 397) | def _get_track(self, track_data: JSONDict) -> TrackInfo:
    method track_for_id (line 434) | def track_for_id(self, track_id: str) -> None | TrackInfo:
    method get_search_query_with_filters (line 470) | def get_search_query_with_filters(
    method get_search_response (line 484) | def get_search_response(
    method commands (line 520) | def commands(self) -> list[ui.Subcommand]:
    method _parse_opts (line 569) | def _parse_opts(self, opts):
    method _match_library_tracks (line 585) | def _match_library_tracks(self, library: Library, keywords: str):
    method _output_match_results (line 697) | def _output_match_results(self, results):
    method _fetch_info (line 725) | def _fetch_info(self, items, write, force):
    method track_info (line 768) | def track_info(self, track_id: str):
    method track_audio_features (line 785) | def track_audio_features(self, track_id: str):

FILE: beetsplug/subsonicplaylist.py
  function filter_to_be_removed (line 32) | def filter_to_be_removed(items, keys):
  class SubsonicPlaylistPlugin (line 59) | class SubsonicPlaylistPlugin(BeetsPlugin):
    method __init__ (line 60) | def __init__(self):
    method update_tags (line 73) | def update_tags(self, playlist_dict, lib):
    method get_playlist (line 93) | def get_playlist(self, playlist_id):
    method commands (line 108) | def commands(self):
    method generate_token (line 154) | def generate_token(self):
    method send (line 161) | def send(self, endpoint, params=None):
    method get_playlists (line 176) | def get_playlists(self, ids):

FILE: beetsplug/subsonicupdate.py
  class SubsonicUpdate (line 44) | class SubsonicUpdate(BeetsPlugin):
    method __init__ (line 45) | def __init__(self):
    method db_change (line 61) | def db_change(self, lib, model):
    method spl_update (line 64) | def spl_update(self):
    method __create_token (line 67) | def __create_token(self):
    method __format_url (line 83) | def __format_url(self, endpoint):
    method start_scan (line 106) | def start_scan(self):

FILE: beetsplug/substitute.py
  class Substitute (line 25) | class Substitute(BeetsPlugin):
    method tmpl_substitute (line 33) | def tmpl_substitute(self, text):
    method __init__ (line 42) | def __init__(self):

FILE: beetsplug/the.py
  class ThePlugin (line 30) | class ThePlugin(BeetsPlugin):
    method __init__ (line 33) | def __init__(self):
    method unthe (line 68) | def unthe(self, text, pattern):
    method the_template_func (line 91) | def the_template_func(self, text):

FILE: beetsplug/thumbnails.py
  class ThumbnailsPlugin (line 40) | class ThumbnailsPlugin(BeetsPlugin):
    method __init__ (line 41) | def __init__(self):
    method commands (line 54) | def commands(self):
    method process_query (line 78) | def process_query(self, lib, opts, args):
    method _check_local_ok (line 84) | def _check_local_ok(self):
    method process_album (line 117) | def process_album(self, album):
    method make_cover_thumbnail (line 144) | def make_cover_thumbnail(self, album, size, target_dir):
    method thumbnail_file_name (line 174) | def thumbnail_file_name(self, path):
    method add_tags (line 182) | def add_tags(self, album, image_path):
    method make_dolphin_cover_thumbnail (line 198) | def make_dolphin_cover_thumbnail(self, album):
  class URIGetter (line 210) | class URIGetter:
    method uri (line 214) | def uri(self, path):
  class PathlibURI (line 218) | class PathlibURI(URIGetter):
    method uri (line 222) | def uri(self, path):
  function copy_c_string (line 226) | def copy_c_string(c_string):
  class GioURI (line 236) | class GioURI(URIGetter):
    method __init__ (line 241) | def __init__(self):
    method get_library (line 255) | def get_library(self):
    method uri (line 264) | def uri(self, path):

FILE: beetsplug/titlecase.py
  class PreservedText (line 40) | class PreservedText(TypedDict):
  class TitlecasePlugin (line 45) | class TitlecasePlugin(BeetsPlugin):
    method __init__ (line 46) | def __init__(self) -> None:
    method force_lowercase (line 102) | def force_lowercase(self) -> bool:
    method replace (line 106) | def replace(self) -> list[tuple[str, str]]:
    method the_artist (line 110) | def the_artist(self) -> bool:
    method fields_to_process (line 114) | def fields_to_process(self) -> set[str]:
    method preserve (line 120) | def preserve(self) -> PreservedText:
    method separators (line 133) | def separators(self) -> re.Pattern[str] | None:
    method small_first_last (line 141) | def small_first_last(self) -> bool:
    method all_caps (line 145) | def all_caps(self) -> bool:
    method all_lowercase (line 149) | def all_lowercase(self) -> bool:
    method the_artist_regexp (line 153) | def the_artist_regexp(self) -> re.Pattern[str]:
    method titlecase_callback (line 156) | def titlecase_callback(self, word, **kwargs) -> str | None:
    method received_info_handler (line 162) | def received_info_handler(self, info: Info):
    method commands (line 171) | def commands(self) -> list[ui.Subcommand]:
    method titlecase_fields (line 184) | def titlecase_fields(self, item: Item | Info) -> None:
    method titlecase (line 214) | def titlecase(self, text: str, field: str = "") -> str:
    method imported (line 250) | def imported(self, session: ImportSession, task: ImportTask) -> None:

FILE: beetsplug/types.py
  class TypesPlugin (line 22) | class TypesPlugin(BeetsPlugin):
    method item_types (line 24) | def item_types(self):
    method album_types (line 28) | def album_types(self):
    method _types (line 31) | def _types(self):

FILE: beetsplug/unimported.py
  class Unimported (line 29) | class Unimported(BeetsPlugin):
    method __init__ (line 30) | def __init__(self):
    method commands (line 34) | def commands(self):

FILE: beetsplug/web/__init__.py
  class LibraryCtx (line 36) | class LibraryCtx(flask.ctx._AppCtxGlobals):
  function _rep (line 46) | def _rep(obj, expand=False):
  function json_generator (line 83) | def json_generator(items, root, expand=False):
  function is_expand (line 103) | def is_expand():
  function is_delete (line 109) | def is_delete():
  function get_method (line 117) | def get_method():
  function resource (line 122) | def resource(name, patchable=False):
  function resource_query (line 176) | def resource_query(name, patchable=False):
  function resource_list (line 223) | def resource_list(name):
  function _get_unique_table_field_values (line 241) | def _get_unique_table_field_values(model, field, sort_field):
  class IdListConverter (line 252) | class IdListConverter(BaseConverter):
    method to_python (line 255) | def to_python(self, value):
    method to_url (line 264) | def to_url(self, value):
  class QueryConverter (line 268) | class QueryConverter(PathConverter):
    method to_python (line 271) | def to_python(self, value):
    method to_url (line 279) | def to_url(self, value):
  class EverythingConverter (line 283) | class EverythingConverter(PathConverter):
  function before_request (line 297) | def before_request():
  function get_item (line 306) | def get_item(id):
  function all_items (line 313) | def all_items():
  function item_file (line 318) | def item_file(item_id):
  function item_query (line 340) | def item_query(queries):
  function item_at_path (line 345) | def item_at_path(path):
  function item_unique_field_values (line 355) | def item_unique_field_values(key):
  function get_album (line 371) | def get_album(id):
  function all_albums (line 378) | def all_albums():
  function album_query (line 384) | def album_query(queries):
  function album_art (line 389) | def album_art(album_id):
  function album_unique_field_values (line 398) | def album_unique_field_values(key):
  function all_artists (line 413) | def all_artists():
  function stats (line 424) | def stats():
  function home (line 440) | def home():
  class WebPlugin (line 447) | class WebPlugin(BeetsPlugin):
    method __init__ (line 448) | def __init__(self):
    method commands (line 462) | def commands(self):
  class ReverseProxied (line 520) | class ReverseProxied:
    method __init__ (line 540) | def __init__(self, app):
    method __call__ (line 543) | def __call__(self, environ, start_response):

FILE: beetsplug/web/static/jquery.js
  function jQuerySub (line 871) | function jQuerySub( selector, context ) {
  function doScrollCheck (line 937) | function doScrollCheck() {
  function createFlags (line 964) | function createFlags( flags ) {
  function resolveFunc (line 1296) | function resolveFunc( i ) {
  function progressFunc (line 1304) | function progressFunc( i ) {
  function dataAttr (line 1931) | function dataAttr( elem, key, data ) {
  function isEmptyDataObject (line 1962) | function isEmptyDataObject( obj ) {
  function handleQueueMarkDefer (line 1980) | function handleQueueMarkDefer( elem, type, src ) {
  function resolve (line 2133) | function resolve() {
  function returnFalse (line 3465) | function returnFalse() {
  function returnTrue (line 3468) | function returnTrue() {
  function dirNodeCheck (line 5168) | function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
  function dirCheck (line 5201) | function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
  function isDisconnected (line 5474) | function isDisconnected( node ) {
  function winnow (line 5591) | function winnow( elements, qualifier, keep ) {
  function createSafeFragment (line 5628) | function createSafeFragment( document ) {
  function root (line 5992) | function root( elem, cur ) {
  function cloneCopyEvent (line 5999) | function cloneCopyEvent( src, dest ) {
  function cloneFixAttributes (line 6027) | function cloneFixAttributes( src, dest ) {
  function getAll (line 6163) | function getAll( elem ) {
  function fixDefaultChecked (line 6176) | function fixDefaultChecked( elem ) {
  function findInputs (line 6182) | function findInputs( elem ) {
  function shimCloneNode (line 6193) | function shimCloneNode( elem ) {
  function evalScript (line 6425) | function evalScript( i, elem ) {
  function getWH (line 6767) | function getWH( elem, name, extra ) {
  function addToPrefiltersOrTransports (line 6895) | function addToPrefiltersOrTransports( structure ) {
  function inspectPrefiltersOrTransports (line 6931) | function inspectPrefiltersOrTransports( structure, options, originalOpti...
  function ajaxExtend (line 6973) | function ajaxExtend( target, src ) {
  function done (line 7315) | function done( status, nativeStatusText, responses, headers ) {
  function buildParams (line 7630) | function buildParams( prefix, obj, traditional, add ) {
  function ajaxHandleResponses (line 7680) | function ajaxHandleResponses( s, jqXHR, responses ) {
  function ajaxConvert (line 7745) | function ajaxConvert( s, response ) {
  function createStandardXHR (line 8011) | function createStandardXHR() {
  function createActiveXHR (line 8017) | function createActiveXHR() {
  function doAnimation (line 8349) | function doAnimation() {
  function stopQueue (line 8492) | function stopQueue( elem, data, index ) {
  function createFxNow (line 8534) | function createFxNow() {
  function clearFxNow (line 8539) | function clearFxNow() {
  function genFx (line 8544) | function genFx( type, num ) {
  function t (line 8659) | function t( gotoEnd ) {
  function defaultDisplay (line 8851) | function defaultDisplay( nodeName ) {
  function getWindow (line 9160) | function getWindow( elem ) {

FILE: beetsplug/web/static/underscore.js
  function eq (line 670) | function eq(a, b, stack) {

FILE: beetsplug/zero.py
  class ZeroPlugin (line 29) | class ZeroPlugin(BeetsPlugin):
    method __init__ (line 30) | def __init__(self):
    method commands (line 75) | def commands(self):
    method _set_pattern (line 89) | def _set_pattern(self, field):
    method import_task_choice_event (line 108) | def import_task_choice_event(self, session, task):
    method write_event (line 114) | def write_event(self, item, path, tags):
    method set_fields (line 118) | def set_fields(self, item, tags):
    method process_item (line 151) | def process_item(self, item):
  function _match_progs (line 160) | def _match_progs(value, progs):

FILE: docs/conf.py
  function skip_member (line 137) | def skip_member(app, what, name, obj, skip, options):
  function setup (line 143) | def setup(app):

FILE: docs/extensions/conf.py
  class Conf (line 27) | class Conf(ObjectDescription[str]):
    method handle_signature (line 34) | def handle_signature(self, sig: str, signode: desc_signature) -> str:
    method add_target_and_index (line 49) | def add_target_and_index(
  class ConfDomain (line 70) | class ConfDomain(Domain):
    method get_objects (line 80) | def get_objects(self) -> Iterable[tuple[str, str, str, str, str, int]]:
    method resolve_xref (line 87) | def resolve_xref(
  function conf_role (line 107) | def conf_role(
  function setup (line 130) | def setup(app: Sphinx) -> ExtensionMetadata:

FILE: extra/release.py
  class Ref (line 37) | class Ref(NamedTuple):
    method from_line (line 45) | def from_line(cls, line: str) -> Ref:
    method url (line 68) | def url(self) -> str:
    method name (line 73) | def name(self) -> str:
  function get_refs (line 78) | def get_refs() -> dict[str, Ref]:
  function create_rst_replacements (line 97) | def create_rst_replacements() -> list[Replacement]:
  function update_docs_config (line 151) | def update_docs_config(text: str, new: Version) -> str:
  function update_changelog (line 157) | def update_changelog(text: str, new: Version) -> str:
  function validate_new_version (line 206) | def validate_new_version(
  function bump_version (line 220) | def bump_version(new: Version) -> None:
  function rst2md (line 230) | def rst2md(text: str) -> str:
  function get_changelog_contents (line 242) | def get_changelog_contents() -> str | None:
  function changelog_as_markdown (line 249) | def changelog_as_markdown(rst: str) -> str:
  function cli (line 262) | def cli():
  function bump (line 268) | def bump(version: Version) -> None:
  function changelog (line 274) | def changelog():

FILE: test/autotag/test_autotag.py
  class ApplyTest (line 27) | class ApplyTest(BeetsTestCase):
    method _apply (line 28) | def _apply(self, per_disc_numbering=False, artist_credit=False):
    method setUp (line 35) | def setUp(self):
    method test_autotag_items (line 142) | def test_autotag_items(self):
    method test_per_disc_numbering (line 154) | def test_per_disc_numbering(self):
    method test_artist_credit_prefers_artist_over_albumartist_credit (line 162) | def test_artist_credit_prefers_artist_over_albumartist_credit(self):
    method test_artist_credit_falls_back_to_albumartist (line 169) | def test_artist_credit_falls_back_to_albumartist(self):
    method test_date_only_zeroes_month_and_day (line 176) | def test_date_only_zeroes_month_and_day(self):
    method test_missing_date_applies_nothing (line 186) | def test_missing_date_applies_nothing(self):
  function test_correct_list_fields (line 217) | def test_correct_list_fields(

FILE: test/autotag/test_distance.py
  class TestDistance (line 19) | class TestDistance:
    method setup_config (line 21) | def setup_config(self, config):
    method dist (line 27) | def dist(self):
    method test_add (line 30) | def test_add(self, dist):
    method test_add_methods (line 84) | def test_add_methods(self, dist, key, args_with_expected):
    method test_distance (line 90) | def test_distance(self, dist):
    method test_operators (line 102) | def test_operators(self, dist):
    method test_penalties_sort (line 116) | def test_penalties_sort(self, dist):
    method test_update (line 127) | def test_update(self, dist):
  class TestTrackDistance (line 145) | class TestTrackDistance:
    method info (line 147) | def info(self):
    method test_track_distance (line 159) | def test_track_distance(self, info, title, artist, expected_penalty):
  class TestAlbumDistance (line 166) | class TestAlbumDistance:
    method items (line 168) | def items(self):
    method get_dist (line 181) | def get_dist(self, items):
    method info (line 188) | def info(self, items):
    method test_identical_albums (line 204) | def test_identical_albums(self, get_dist, info):
    method test_incomplete_album (line 207) | def test_incomplete_album(self, get_dist, info):
    method test_overly_complete_album (line 212) | def test_overly_complete_album(self, get_dist, info):
    method test_albumartist (line 220) | def test_albumartist(self, get_dist, info, va):
    method test_comp_no_track_artists (line 226) | def test_comp_no_track_artists(self, get_dist, info):
    method test_comp_track_artists_do_not_match (line 235) | def test_comp_track_artists_do_not_match(self, get_dist, info):
    method test_tracks_out_of_order (line 241) | def test_tracks_out_of_order(self, get_dist, info):
    method test_two_medium_release (line 247) | def test_two_medium_release(self, get_dist, info):
  class TestStringDistance (line 255) | class TestStringDistance:
    method test_matching_distance (line 272) | def test_matching_distance(self, string1, string2):
    method test_different_distance (line 275) | def test_different_distance(self):
    method test_relative_weights (line 287) | def test_relative_weights(self, string1, string2, reference):
    method test_solo_pattern (line 290) | def test_solo_pattern(self):
  class TestDataSourceDistance (line 297) | class TestDataSourceDistance:
    method setup (line 302) | def setup(self, monkeypatch, penalty, weight, multiple_data_sources):
    method test_distance (line 351) | def test_distance(self, item, info, expected_distance):

FILE: test/autotag/test_hooks.py
  function test_genre_deprecation (line 13) | def test_genre_deprecation(genre, expected_genres):

FILE: test/autotag/test_match.py
  class TestAssignment (line 10) | class TestAssignment:
    method config (line 16) | def config(self, config):
    method test_assign_tracks (line 37) | def test_assign_tracks(self, item_titles, track_titles, expected):
    method test_order_works_when_track_names_are_entirely_wrong (line 53) | def test_order_works_when_track_names_are_entirely_wrong(self):
  class TestTagMultipleDataSources (line 100) | class TestTagMultipleDataSources:
    method shared_track_id (line 102) | def shared_track_id(self):
    method shared_album_id (line 106) | def shared_album_id(self):
    method _setup_plugins (line 110) | def _setup_plugins(self, monkeypatch, shared_album_id, shared_track_id):
    method check_proposal (line 158) | def check_proposal(self, proposal):
    method test_search_album_ids (line 165) | def test_search_album_ids(self, shared_album_id):
    method test_search_album_current_id (line 170) | def test_search_album_current_id(self, shared_album_id):
    method test_search_track_ids (line 175) | def test_search_track_ids(self, shared_track_id):
    method test_search_track_current_id (line 180) | def test_search_track_current_id(self, shared_track_id):

FILE: test/conftest.py
  function _is_importable (line 16) | def _is_importable(modname: str) -> bool:
  function skip_marked_items (line 20) | def skip_marked_items(items: list[pytest.Item], marker_name: str, reason...
  function pytest_collection_modifyitems (line 26) | def pytest_collection_modifyitems(
  function pytest_configure (line 61) | def pytest_configure(config: pytest.Config) -> None:
  function pytest_make_parametrize_id (line 79) | def pytest_make_parametrize_id(config, val, argname):
  function pytest_assertrepr_compare (line 96) | def pytest_assertrepr_compare(op, left, right):
  function clear_cached_classproperty (line 102) | def clear_cached_classproperty():
  function config (line 107) | def config():
  function io (line 113) | def io(
  function is_importable (line 134) | def is_importable():

FILE: test/library/test_migrations.py
  class TestMultiGenreFieldMigration (line 11) | class TestMultiGenreFieldMigration:
    method helper (line 13) | def helper(self, monkeypatch):
    method test_migrate (line 41) | def test_migrate(self, helper: TestHelper):
  class TestLyricsMetadataInFlexFieldsMigration (line 77) | class TestLyricsMetadataInFlexFieldsMigration:
    method helper (line 79) | def helper(self, monkeypatch):
    method test_migrate (line 95) | def test_migrate(self, helper: TestHelper, is_importable):

FILE: test/plugins/conftest.py
  function requests_mock (line 13) | def requests_mock(requests_mock, monkeypatch) -> Mocker:

FILE: test/plugins/lyrics_pages.py
  function xfail_on_ci (line 11) | def xfail_on_ci(msg: str) -> pytest.MarkDecorator:
  class LyricsPage (line 19) | class LyricsPage(NamedTuple):
    method __str__ (line 30) | def __str__(self) -> str:
    method make (line 35) | def make(cls, url, lyrics, *args, **kwargs):
    method root_url (line 39) | def root_url(self) -> str:
    method source (line 43) | def source(self) -> str:
    method backend (line 47) | def backend(self) -> str:

FILE: test/plugins/test_acousticbrainz.py
  class MapDataToSchemeTest (line 25) | class MapDataToSchemeTest(unittest.TestCase):
    method test_basic (line 26) | def test_basic(self):
    method test_recurse (line 36) | def test_recurse(self):
    method test_composite (line 59) | def test_composite(self):
    method test_realistic (line 66) | def test_realistic(self):

FILE: test/plugins/test_advancedrewrite.py
  class AdvancedRewritePluginTest (line 25) | class AdvancedRewritePluginTest(PluginTestCase):
    method test_simple_rewrite_example (line 29) | def test_simple_rewrite_example(self):
    method test_advanced_rewrite_example (line 40) | def test_advanced_rewrite_example(self):
    method test_advanced_rewrite_example_with_multi_valued_field (line 73) | def test_advanced_rewrite_example_with_multi_valued_field(self):
    method test_fail_when_replacements_empty (line 89) | def test_fail_when_replacements_empty(self):
    method test_fail_when_rewriting_single_valued_field_with_list (line 99) | def test_fail_when_rewriting_single_valued_field_with_list(self):
    method test_combined_rewrite_example (line 116) | def test_combined_rewrite_example(self):

FILE: test/plugins/test_albumtypes.py
  class AlbumTypesPluginTest (line 29) | class AlbumTypesPluginTest(PluginTestCase):
    method test_renames_types (line 34) | def test_renames_types(self):
    method test_returns_only_specified_types (line 45) | def test_returns_only_specified_types(self):
    method test_respects_type_order (line 55) | def test_respects_type_order(self):
    method test_ignores_va (line 66) | def test_ignores_va(self):
    method test_respects_defaults (line 80) | def test_respects_defaults(self):
    method _set_config (line 97) | def _set_config(
    method _create_album (line 107) | def _create_album(self, album_types: Sequence[str], artist_id: str = "...

FILE: test/plugins/test_art.py
  class Settings (line 51) | class Settings:
    method __init__ (line 56) | def __init__(self, **kwargs):
  class DummyRemoteArtSource (line 61) | class DummyRemoteArtSource(fetchart.RemoteArtSource):
    method get (line 65) | def get(
  class UseThePlugin (line 74) | class UseThePlugin(CleanupModulesMixin, BeetsTestCase):
    method setUp (line 77) | def setUp(self):
  class FetchImageTestCase (line 82) | class FetchImageTestCase(FetchImageHelper, UseThePlugin):
  class CAAHelper (line 86) | class CAAHelper:
    method mock_caa_response (line 216) | def mock_caa_response(self, url, json):
  class FetchImageTest (line 222) | class FetchImageTest(FetchImageTestCase):
    method setUp (line 225) | def setUp(self):
    method test_invalid_type_returns_none (line 234) | def test_invalid_type_returns_none(self):
    method test_jpeg_type_returns_path (line 239) | def test_jpeg_type_returns_path(self):
    method test_extension_set_by_content_type (line 244) | def test_extension_set_by_content_type(self):
    method test_does_not_rely_on_server_content_type (line 250) | def test_does_not_rely_on_server_content_type(self):
  class FSArtTest (line 257) | class FSArtTest(UseThePlugin):
    method setUp (line 258) | def setUp(self):
    method test_finds_jpg_in_directory (line 268) | def test_finds_jpg_in_directory(self):
    method test_appropriately_named_file_takes_precedence (line 273) | def test_appropriately_named_file_takes_precedence(self):
    method test_non_image_file_not_identified (line 279) | def test_non_image_file_not_identified(self):
    method test_cautious_skips_fallback (line 284) | def test_cautious_skips_fallback(self):
    method test_configured_fallback_is_used (line 290) | def test_configured_fallback_is_used(self):
    method test_empty_dir (line 297) | def test_empty_dir(self):
    method test_precedence_amongst_correct_files (line 301) | def test_precedence_amongst_correct_files(self):
    method test_is_candidate_fallback_os_error (line 314) | def test_is_candidate_fallback_os_error(self, mock_samefile):
  class CombinedTest (line 324) | class CombinedTest(FetchImageTestCase, CAAHelper):
    method setUp (line 330) | def setUp(self):
    method test_main_interface_returns_amazon_art (line 335) | def test_main_interface_returns_amazon_art(self):
    method test_main_interface_returns_none_for_missing_asin_and_path (line 341) | def test_main_interface_returns_none_for_missing_asin_and_path(self):
    method test_main_interface_gives_precedence_to_fs_art (line 346) | def test_main_interface_gives_precedence_to_fs_art(self):
    method test_main_interface_falls_back_to_amazon (line 354) | def test_main_interface_falls_back_to_amazon(self):
    method test_main_interface_tries_amazon_before_aao (line 361) | def test_main_interface_tries_amazon_before_aao(self):
    method test_main_interface_falls_back_to_aao (line 368) | def test_main_interface_falls_back_to_aao(self):
    method test_main_interface_uses_caa_when_mbid_available (line 374) | def test_main_interface_uses_caa_when_mbid_available(self):
    method test_local_only_does_not_access_network (line 395) | def test_local_only_does_not_access_network(self):
    method test_local_only_gets_fs_image (line 400) | def test_local_only_gets_fs_image(self):
  class AAOTest (line 411) | class AAOTest(UseThePlugin):
    method setUp (line 415) | def setUp(self):
    method run (line 421) | def run(self, *args, **kwargs):
    method mock_response (line 424) | def mock_response(self, url, body):
    method test_aao_scraper_finds_image (line 427) | def test_aao_scraper_finds_image(self):
    method test_aao_scraper_returns_no_result_when_no_image_present (line 440) | def test_aao_scraper_returns_no_result_when_no_image_present(self):
  class ITunesStoreTest (line 447) | class ITunesStoreTest(UseThePlugin):
    method setUp (line 448) | def setUp(self):
    method run (line 455) | def run(self, *args, **kwargs):
    method mock_response (line 458) | def mock_response(self, url, json):
    method test_itunesstore_finds_image (line 463) | def test_itunesstore_finds_image(self):
    method test_itunesstore_no_result (line 479) | def test_itunesstore_no_result(self):
    method test_itunesstore_requestexception (line 489) | def test_itunesstore_requestexception(self):
    method test_itunesstore_fallback_match (line 503) | def test_itunesstore_fallback_match(self):
    method test_itunesstore_returns_result_without_artwork (line 518) | def test_itunesstore_returns_result_without_artwork(self):
    method test_itunesstore_returns_no_result_when_error_received (line 536) | def test_itunesstore_returns_no_result_when_error_received(self):
    method test_itunesstore_returns_no_result_with_malformed_response (line 546) | def test_itunesstore_returns_no_result_with_malformed_response(self):
  class GoogleImageTest (line 557) | class GoogleImageTest(UseThePlugin):
    method setUp (line 558) | def setUp(self):
    method run (line 564) | def run(self, *args, **kwargs):
    method mock_response (line 567) | def mock_response(self, url, json):
    method test_google_art_finds_image (line 572) | def test_google_art_finds_image(self):
    method test_google_art_returns_no_result_when_error_received (line 579) | def test_google_art_returns_no_result_when_error_received(self):
    method test_google_art_returns_no_result_with_malformed_response (line 586) | def test_google_art_returns_no_result_with_malformed_response(self):
  class CoverArtArchiveTest (line 594) | class CoverArtArchiveTest(UseThePlugin, CAAHelper):
    method setUp (line 595) | def setUp(self):
    method run (line 601) | def run(self, *args, **kwargs):
    method test_caa_finds_image (line 604) | def test_caa_finds_image(self):
    method test_fetchart_uses_caa_pre_sized_maxwidth_thumbs (line 615) | def test_fetchart_uses_caa_pre_sized_maxwidth_thumbs(self):
    method test_caa_finds_image_if_maxwidth_is_set_and_thumbnails_is_empty (line 631) | def test_caa_finds_image_if_maxwidth_is_set_and_thumbnails_is_empty(se...
  class FanartTVTest (line 653) | class FanartTVTest(UseThePlugin):
    method setUp (line 711) | def setUp(self):
    method run (line 717) | def run(self, *args, **kwargs):
    method mock_response (line 720) | def mock_response(self, url, json):
    method test_fanarttv_finds_image (line 725) | def test_fanarttv_finds_image(self):
    method test_fanarttv_returns_no_result_when_error_received (line 734) | def test_fanarttv_returns_no_result_when_error_received(self):
    method test_fanarttv_returns_no_result_with_malformed_response (line 743) | def test_fanarttv_returns_no_result_with_malformed_response(self):
    method test_fanarttv_only_other_images (line 752) | def test_fanarttv_only_other_images(self):
  class ArtImporterTest (line 764) | class ArtImporterTest(UseThePlugin):
    method setUp (line 765) | def setUp(self):
    method tearDown (line 811) | def tearDown(self):
    method _fetch_art (line 815) | def _fetch_art(self, should_exist):
    method test_fetch_art (line 833) | def test_fetch_art(self):
    method test_art_not_found (line 837) | def test_art_not_found(self):
    method test_no_art_for_singleton (line 841) | def test_no_art_for_singleton(self):
    method test_leave_original_file_in_place (line 845) | def test_leave_original_file_in_place(self):
    method test_delete_original_file (line 849) | def test_delete_original_file(self):
    method test_do_not_delete_original_if_already_in_place (line 858) | def test_do_not_delete_original_if_already_in_place(self):
    method test_fetch_art_if_imported_file_deleted (line 868) | def test_fetch_art_if_imported_file_deleted(self):
  class AlbumArtOperationTestCase (line 883) | class AlbumArtOperationTestCase(UseThePlugin):
    method setUpClass (line 897) | def setUpClass(cls):
    method get_album_art (line 909) | def get_album_art(self):
  class AlbumArtOperationConfigurationTest (line 913) | class AlbumArtOperationConfigurationTest(AlbumArtOperationTestCase):
    method test_minwidth (line 920) | def test_minwidth(self):
    method test_enforce_ratio (line 927) | def test_enforce_ratio(self):
    method test_enforce_ratio_with_px_margin (line 934) | def test_enforce_ratio_with_px_margin(self):
    method test_enforce_ratio_with_percent_margin (line 943) | def test_enforce_ratio_with_percent_margin(self):
  class AlbumArtPerformOperationTest (line 954) | class AlbumArtPerformOperationTest(AlbumArtOperationTestCase):
    method setUp (line 957) | def setUp(self):
    method test_resize (line 966) | def test_resize(self):
    method test_file_resized (line 971) | def test_file_resized(self):
    method test_file_not_resized (line 976) | def test_file_not_resized(self):
    method test_file_resized_but_not_scaled (line 981) | def test_file_resized_but_not_scaled(self):
    method test_file_resized_and_scaled (line 987) | def test_file_resized_and_scaled(self):
    method test_deinterlaced (line 993) | def test_deinterlaced(self):
    method test_not_deinterlaced (line 998) | def test_not_deinterlaced(self):
    method test_deinterlaced_and_resized (line 1003) | def test_deinterlaced_and_resized(self):
  class DeprecatedConfigTest (line 1011) | class DeprecatedConfigTest(unittest.TestCase):
    method setUp (line 1020) | def setUp(self):
    method test_moves_filesystem_to_end (line 1025) | def test_moves_filesystem_to_end(self):
  class EnforceRatioConfigTest (line 1029) | class EnforceRatioConfigTest(unittest.TestCase):
    method _load_with_config (line 1032) | def _load_with_config(self, values, should_raise):
    method test_px (line 1043) | def test_px(self):
    method test_percent (line 1047) | def test_percent(self):

FILE: test/plugins/test_aura.py
  function helper (line 17) | def helper():
  function app (line 25) | def app(helper):
  function item (line 34) | def item(helper):
  function album (line 44) | def album(helper, item):
  function _other_album_and_item (line 49) | def _other_album_and_item(helper):
  class TestAuraResponse (line 60) | class TestAuraResponse:
    method get_response_data (line 62) | def get_response_data(self, client: Client, item):
    method track_document (line 86) | def track_document(self, item, album):
    method artist_document (line 105) | def artist_document(self, item):
    method album_document (line 116) | def album_document(self, album):
    method test_tracks (line 126) | def test_tracks(
    method test_artists (line 141) | def test_artists(
    method test_albums (line 150) | def test_albums(

FILE: test/plugins/test_autobpm.py
  class TestAutoBPMPlugin (line 8) | class TestAutoBPMPlugin(PluginMixin, ImportHelper):
    method fixture_lib (line 12) | def fixture_lib(self):
    method item (line 20) | def item(self):
    method importer (line 24) | def importer(self, lib):
    method test_command (line 32) | def test_command(self, lib, item):
    method test_import (line 38) | def test_import(self, lib, importer):

FILE: test/plugins/test_bareasc.py
  class BareascPluginTest (line 10) | class BareascPluginTest(IOMixin, PluginTestCase):
    method setUp (line 15) | def setUp(self):
    method test_bareasc_search (line 29) | def test_bareasc_search(self):
    method test_bareasc_list_output (line 66) | def test_bareasc_list_output(self):
    method test_bareasc_format_output (line 72) | def test_bareasc_format_output(self):

FILE: test/plugins/test_beatport.py
  class BeatportTest (line 25) | class BeatportTest(BeetsTestCase):
    method _make_release_response (line 26) | def _make_release_response(self):
    method _make_tracks_response (line 66) | def _make_tracks_response(self):
    method setUp (line 450) | def setUp(self):
    method mk_test_album (line 467) | def mk_test_album(self):
    method test_album_name_applied (line 532) | def test_album_name_applied(self):
    method test_catalog_number_applied (line 535) | def test_catalog_number_applied(self):
    method test_label_applied (line 538) | def test_label_applied(self):
    method test_category_applied (line 541) | def test_category_applied(self):
    method test_album_url_applied (line 544) | def test_album_url_applied(self):
    method test_title_applied (line 548) | def test_title_applied(self):
    method test_mix_name_applied (line 552) | def test_mix_name_applied(self):
    method test_length_applied (line 556) | def test_length_applied(self):
    method test_track_url_applied (line 560) | def test_track_url_applied(self):
    method test_bpm_applied (line 576) | def test_bpm_applied(self):
    method test_initial_key_applied (line 580) | def test_initial_key_applied(self):
    method test_genre_applied (line 584) | def test_genre_applied(self):
  class BeatportResponseEmptyTest (line 589) | class BeatportResponseEmptyTest(unittest.TestCase):
    method _make_tracks_response (line 590) | def _make_tracks_response(self):
    method setUp (line 615) | def setUp(self):
    method test_response_tracks_empty (line 625) | def test_response_tracks_empty(self):
    method test_sub_genre_empty_fallback (line 630) | def test_sub_genre_empty_fallback(self):
    method test_genre_empty (line 639) | def test_genre_empty(self):

FILE: test/plugins/test_bpd.py
  class CommandParseTest (line 38) | class CommandParseTest(unittest.TestCase):
    method test_no_args (line 39) | def test_no_args(self):
    method test_one_unquoted_arg (line 45) | def test_one_unquoted_arg(self):
    method test_two_unquoted_args (line 51) | def test_two_unquoted_args(self):
    method test_one_quoted_arg (line 57) | def test_one_quoted_arg(self):
    method test_heterogenous_args (line 63) | def test_heterogenous_args(self):
    method test_quote_in_arg (line 69) | def test_quote_in_arg(self):
    method test_backslash_in_arg (line 74) | def test_backslash_in_arg(self):
  class MPCResponse (line 80) | class MPCResponse:
    method __init__ (line 81) | def __init__(self, raw_response):
    method _parse_status (line 87) | def _parse_status(self, status):
    method _parse_body (line 99) | def _parse_body(self, body):
  class MPCClient (line 123) | class MPCClient:
    method __init__ (line 124) | def __init__(self, sock, do_hello=True):
    method get_response (line 132) | def get_response(self, force_multi=None):
    method serialise_command (line 158) | def serialise_command(self, command, *args):
    method send_command (line 167) | def send_command(self, command, *args):
    method send_commands (line 172) | def send_commands(self, *commands):
    method readline (line 189) | def readline(self, terminator=b"\n", bufsize=1024):
  function implements (line 207) | def implements(commands, fail=False):
  function start_server (line 222) | def start_server(args, assigned_port, listener_patch):
  class BPDTestHelper (line 242) | class BPDTestHelper(PluginTestCase):
    method setUp (line 246) | def setUp(self):
    method run_bpd (line 263) | def run_bpd(
    method _assert_ok (line 340) | def _assert_ok(self, *responses):
    method _assert_failed (line 345) | def _assert_failed(self, response, code, pos=None):
    method _bpd_add (line 359) | def _bpd_add(self, client, *items, **kwargs):
  class BPDTest (line 380) | class BPDTest(BPDTestHelper):
    method test_server_hello (line 381) | def test_server_hello(self):
    method test_unknown_cmd (line 385) | def test_unknown_cmd(self):
    method test_unexpected_argument (line 390) | def test_unexpected_argument(self):
    method test_missing_argument (line 395) | def test_missing_argument(self):
    method test_system_error (line 400) | def test_system_error(self):
    method test_empty_request (line 405) | def test_empty_request(self):
  class BPDQueryTest (line 411) | class BPDQueryTest(BPDTestHelper):
    method test_cmd_currentsong (line 418) | def test_cmd_currentsong(self):
    method test_cmd_currentsong_tagtypes (line 428) | def test_cmd_currentsong_tagtypes(self):
    method test_cmd_status (line 437) | def test_cmd_status(self):
    method test_cmd_stats (line 469) | def test_cmd_stats(self):
    method test_cmd_idle (line 484) | def test_cmd_idle(self):
    method test_cmd_idle_with_pending (line 504) | def test_cmd_idle_with_pending(self):
    method test_cmd_noidle (line 511) | def test_cmd_noidle(self):
    method test_cmd_noidle_when_not_idle (line 520) | def test_cmd_noidle_when_not_idle(self):
  class BPDPlaybackTest (line 529) | class BPDPlaybackTest(BPDTestHelper):
    method test_cmd_consume (line 536) | def test_cmd_consume(self):
    method test_cmd_consume_in_reverse (line 558) | def test_cmd_consume_in_reverse(self):
    method test_cmd_single (line 574) | def test_cmd_single(self):
    method test_cmd_repeat (line 591) | def test_cmd_repeat(self):
    method test_cmd_repeat_with_single (line 608) | def test_cmd_repeat_with_single(self):
    method test_cmd_repeat_in_reverse (line 625) | def test_cmd_repeat_in_reverse(self):
    method test_cmd_repeat_with_single_in_reverse (line 639) | def test_cmd_repeat_with_single_in_reverse(self):
    method test_cmd_crossfade (line 656) | def test_cmd_crossfade(self):
    method test_cmd_mixrampdb (line 670) | def test_cmd_mixrampdb(self):
    method test_cmd_mixrampdelay (line 676) | def test_cmd_mixrampdelay(self):
    method test_cmd_setvol (line 689) | def test_cmd_setvol(self):
    method test_cmd_volume (line 702) | def test_cmd_volume(self):
    method test_cmd_replay_gain (line 710) | def test_cmd_replay_gain(self):
  class BPDControlTest (line 721) | class BPDControlTest(BPDTestHelper):
    method test_cmd_play (line 731) | def test_cmd_play(self):
    method test_cmd_playid (line 746) | def test_cmd_playid(self):
    method test_cmd_pause (line 760) | def test_cmd_pause(self):
    method test_cmd_stop (line 770) | def test_cmd_stop(self):
    method test_cmd_next (line 780) | def test_cmd_next(self):
    method test_cmd_previous (line 796) | def test_cmd_previous(self):
  class BPDQueueTest (line 815) | class BPDQueueTest(BPDTestHelper):
    method test_cmd_add (line 843) | def test_cmd_add(self):
    method test_cmd_playlistinfo (line 847) | def test_cmd_playlistinfo(self):
    method test_cmd_playlistinfo_tagtypes (line 860) | def test_cmd_playlistinfo_tagtypes(self):
    method test_cmd_playlistid (line 869) | def test_cmd_playlistid(self):
  class BPDPlaylistsTest (line 880) | class BPDPlaylistsTest(BPDTestHelper):
    method test_cmd_listplaylist (line 883) | def test_cmd_listplaylist(self):
    method test_cmd_listplaylistinfo (line 888) | def test_cmd_listplaylistinfo(self):
    method test_cmd_listplaylists (line 893) | def test_cmd_listplaylists(self):
    method test_cmd_load (line 898) | def test_cmd_load(self):
    method test_cmd_playlistadd (line 904) | def test_cmd_playlistadd(self):
    method test_cmd_playlistclear (line 908) | def test_cmd_playlistclear(self):
    method test_cmd_playlistdelete (line 913) | def test_cmd_playlistdelete(self):
    method test_cmd_playlistmove (line 918) | def test_cmd_playlistmove(self):
    method test_cmd_rename (line 923) | def test_cmd_rename(self):
    method test_cmd_rm (line 928) | def test_cmd_rm(self):
    method test_cmd_save (line 933) | def test_cmd_save(self):
  class BPDDatabaseTest (line 940) | class BPDDatabaseTest(BPDTestHelper):
    method test_cmd_search (line 958) | def test_cmd_search(self):
    method test_cmd_list (line 964) | def test_cmd_list(self):
    method test_cmd_list_three_arg_form (line 975) | def test_cmd_list_three_arg_form(self):
    method test_cmd_lsinfo (line 985) | def test_cmd_lsinfo(self):
    method test_cmd_count (line 999) | def test_cmd_count(self):
  class BPDMountsTest (line 1007) | class BPDMountsTest(BPDTestHelper):
  class BPDStickerTest (line 1019) | class BPDStickerTest(BPDTestHelper):
  class BPDConnectionTest (line 1028) | class BPDConnectionTest(BPDTestHelper):
    method test_cmd_password (line 1069) | def test_cmd_password(self):
    method test_cmd_ping (line 1082) | def test_cmd_ping(self):
    method test_cmd_tagtypes (line 1087) | def test_cmd_tagtypes(self):
    method test_tagtypes_mask (line 1094) | def test_tagtypes_mask(self):
  class BPDPartitionTest (line 1100) | class BPDPartitionTest(BPDTestHelper):
  class BPDDeviceTest (line 1111) | class BPDDeviceTest(BPDTestHelper):
  class BPDReflectionTest (line 1123) | class BPDReflectionTest(BPDTestHelper):
    method test_cmd_decoders (line 1138) | def test_cmd_decoders(self):
  class BPDPeersTest (line 1147) | class BPDPeersTest(BPDTestHelper):

FILE: test/plugins/test_bucket.py
  class BucketPluginTest (line 26) | class BucketPluginTest(BeetsTestCase):
    method setUp (line 27) | def setUp(self):
    method _setup_config (line 31) | def _setup_config(
    method test_year_single_year (line 44) | def test_year_single_year(self):
    method test_year_single_year_last_folder (line 51) | def test_year_single_year_last_folder(self):
    method test_year_two_years (line 59) | def test_year_two_years(self):
    method test_year_multiple_years (line 65) | def test_year_multiple_years(self):
    method test_year_out_of_range (line 71) | def test_year_out_of_range(self):
    method test_year_out_of_range_extrapolate (line 78) | def test_year_out_of_range_extrapolate(self):
    method test_alpha_all_chars (line 100) | def test_alpha_all_chars(self):
    method test_alpha_first_last_chars (line 105) | def test_alpha_first_last_chars(self):
    method test_alpha_out_of_range (line 111) | def test_alpha_out_of_range(self):
    method test_alpha_regex (line 118) | def test_alpha_regex(self):
    method test_alpha_regex_mix (line 129) | def test_alpha_regex_mix(self):
    method test_bad_alpha_range_def (line 141) | def test_bad_alpha_range_def(self):
    method test_bad_year_range_def_no4digits (line 146) | def test_bad_year_range_def_no4digits(self):
    method test_bad_year_range_def_nodigits (line 153) | def test_bad_year_range_def_nodigits(self):
    method check_span_from_str (line 160) | def check_span_from_str(self, sstr, dfrom, dto):
    method test_span_from_str (line 165) | def test_span_from_str(self):

FILE: test/plugins/test_convert.py
  function shell_quote (line 42) | def shell_quote(text):
  class ConvertMixin (line 48) | class ConvertMixin:
    method tagged_copy_cmd (line 49) | def tagged_copy_cmd(self, tag):
    method file_endswith (line 62) | def file_endswith(self, path: Path, tag: str):
  class ConvertTestCase (line 69) | class ConvertTestCase(IOMixin, ConvertMixin, PluginTestCase):
  class ImportConvertTest (line 75) | class ImportConvertTest(AsIsImporterMixin, ImportHelper, ConvertTestCase):
    method setUp (line 76) | def setUp(self):
    method test_import_converted (line 87) | def test_import_converted(self):
    method test_import_original_on_convert_error (line 94) | def test_import_original_on_convert_error(self):
    method test_delete_originals (line 103) | def test_delete_originals(self):
    method get_count_of_import_files (line 112) | def get_count_of_import_files(self):
  class ConvertCommand (line 122) | class ConvertCommand:
    method run_convert_path (line 127) | def run_convert_path(self, item, *args):
    method run_convert (line 131) | def run_convert(self, *args):
  class ConvertCliTest (line 137) | class ConvertCliTest(ConvertTestCase, ConvertCommand):
    method setUp (line 138) | def setUp(self):
    method test_convert (line 159) | def test_convert(self):
    method test_convert_with_auto_confirmation (line 164) | def test_convert_with_auto_confirmation(self):
    method test_reject_confirmation (line 168) | def test_reject_confirmation(self):
    method test_convert_keep_new (line 173) | def test_convert_keep_new(self):
    method test_format_option (line 182) | def test_format_option(self):
    method test_embed_album_art (line 187) | def test_embed_album_art(self):
    method test_skip_existing (line 200) | def test_skip_existing(self):
    method test_pretend (line 207) | def test_pretend(self):
    method test_empty_query (line 211) | def test_empty_query(self):
    method test_no_transcode_when_maxbr_set_high_and_different_formats (line 216) | def test_no_transcode_when_maxbr_set_high_and_different_formats(self):
    method test_transcode_when_maxbr_set_low_and_different_formats (line 222) | def test_transcode_when_maxbr_set_low_and_different_formats(self):
    method test_transcode_when_maxbr_set_to_none_and_different_formats (line 228) | def test_transcode_when_maxbr_set_to_none_and_different_formats(self):
    method test_no_transcode_when_maxbr_set_high_and_same_formats (line 233) | def test_no_transcode_when_maxbr_set_high_and_same_formats(self):
    method test_force_overrides_max_bitrate_and_same_formats (line 242) | def test_force_overrides_max_bitrate_and_same_formats(self):
    method test_transcode_when_maxbr_set_low_and_same_formats (line 252) | def test_transcode_when_maxbr_set_low_and_same_formats(self):
    method test_transcode_when_maxbr_set_to_none_and_same_formats (line 259) | def test_transcode_when_maxbr_set_to_none_and_same_formats(self):
    method test_playlist (line 267) | def test_playlist(self):
    method test_playlist_pretend (line 272) | def test_playlist_pretend(self):
    method test_force_overrides_no_convert (line 276) | def test_force_overrides_no_convert(self):
    method assert_playlist_entry (line 291) | def assert_playlist_entry(self, expected_entry, *args):
    method test_playlist_entry_uses_config_format (line 298) | def test_playlist_entry_uses_config_format(self):
    method test_playlist_entry_uses_cli_format (line 301) | def test_playlist_entry_uses_cli_format(self):
    method test_playlist_entry_keeps_original_extension_when_not_transcoded (line 304) | def test_playlist_entry_keeps_original_extension_when_not_transcoded(s...
    method test_playlist_entry_keep_new_points_to_destination_file (line 308) | def test_playlist_entry_keep_new_points_to_destination_file(self):
  class NeverConvertLossyFilesTest (line 313) | class NeverConvertLossyFilesTest(ConvertTestCase, ConvertCommand):
    method setUp (line 316) | def setUp(self):
    method test_transcode_from_lossless (line 330) | def test_transcode_from_lossless(self):
    method test_transcode_from_lossy (line 337) | def test_transcode_from_lossy(self):
    method test_transcode_from_lossy_prevented (line 345) | def test_transcode_from_lossy_prevented(self):
    method test_force_overrides_never_convert_lossy_files (line 352) | def test_force_overrides_never_convert_lossy_files(self):
  class TestNoConvert (line 366) | class TestNoConvert:
    method test_no_convert_skip (line 378) | def test_no_convert_skip(self, config_value, should_skip):

FILE: test/plugins/test_discogs.py
  function _artist (line 28) | def _artist(name: str, **kwargs):
  class DGAlbumInfoTest (line 41) | class DGAlbumInfoTest(BeetsTestCase):
    method _make_release (line 42) | def _make_release(self, tracks=None):
    method _make_track (line 82) | def _make_track(self, title, position="", duration="", type_=None):
    method _make_release_from_positions (line 92) | def _make_release_from_positions(self, positions):
    method test_parse_media_for_tracks (line 101) | def test_parse_media_for_tracks(self):
    method test_parse_medium_numbers_single_medium (line 114) | def test_parse_medium_numbers_single_medium(self):
    method test_parse_medium_numbers_two_mediums (line 125) | def test_parse_medium_numbers_two_mediums(self):
    method test_parse_medium_numbers_two_mediums_two_sided (line 136) | def test_parse_medium_numbers_two_mediums_two_sided(self):
    method test_parse_track_indices (line 152) | def test_parse_track_indices(self):
    method test_parse_track_indices_several_media (line 164) | def test_parse_track_indices_several_media(self):
    method test_parse_tracklist_without_sides (line 185) | def test_parse_tracklist_without_sides(self):
    method test_parse_tracklist_with_sides (line 193) | def test_parse_tracklist_with_sides(self):
    method test_parse_tracklist_multiple_lp (line 201) | def test_parse_tracklist_multiple_lp(self):
    method test_parse_tracklist_multiple_cd (line 209) | def test_parse_tracklist_multiple_cd(self):
    method test_parse_tracklist_non_standard (line 219) | def test_parse_tracklist_non_standard(self):
    method test_parse_tracklist_subtracks_dot (line 227) | def test_parse_tracklist_subtracks_dot(self):
    method test_parse_tracklist_subtracks_letter (line 243) | def test_parse_tracklist_subtracks_letter(self):
    method test_parse_tracklist_subtracks_extra_material (line 259) | def test_parse_tracklist_subtracks_extra_material(self):
    method test_parse_tracklist_subtracks_indices (line 267) | def test_parse_tracklist_subtracks_indices(self):
    method test_parse_tracklist_subtracks_nested_logical (line 281) | def test_parse_tracklist_subtracks_nested_logical(self):
    method test_parse_tracklist_subtracks_nested_physical (line 298) | def test_parse_tracklist_subtracks_nested_physical(self):
    method test_parse_tracklist_disctitles (line 316) | def test_parse_tracklist_disctitles(self):
    method test_parse_minimal_release (line 333) | def test_parse_minimal_release(self):
    method test_parse_release_without_required_fields (line 352) | def test_parse_release_without_required_fields(self):
    method test_default_genre_style_settings (line 361) | def test_default_genre_style_settings(self):
    method test_append_style_to_genre (line 369) | def test_append_style_to_genre(self):
    method test_append_style_to_genre_no_style (line 378) | def test_append_style_to_genre_no_style(self):
    method test_strip_disambiguation (line 388) | def test_strip_disambiguation(self):
    method test_strip_disambiguation_false (line 429) | def test_strip_disambiguation_false(self):
  class DGSearchQueryTest (line 471) | class DGSearchQueryTest(BeetsTestCase):
    method test_default_search_filters_without_extra_tags (line 472) | def test_default_search_filters_without_extra_tags(self):
    method test_extra_tags_populate_discogs_filters (line 484) | def test_extra_tags_populate_discogs_filters(self):
  function test_anv (line 543) | def test_anv(
  function test_anv_no_variation (line 607) | def test_anv_no_variation(artist_anv, albumartist_anv, artistcredit_anv):
  function test_anv_album_artist (line 644) | def test_anv_album_artist():
  function test_parse_featured_artists (line 710) | def test_parse_featured_artists(track, expected_artist, expected_artists):
  function test_get_media_and_albumtype (line 737) | def test_get_media_and_albumtype(formats, expected_media, expected_album...
  function test_va_buildartistinfo (line 761) | def test_va_buildartistinfo(given_artists, expected_info, config_va_name):
  function test_get_track_index (line 784) | def test_get_track_index(position, medium, index, subindex):

FILE: test/plugins/test_edit.py
  class ModifyFileMocker (line 33) | class ModifyFileMocker:
    method __init__ (line 38) | def __init__(self, contents=None, replacements=None):
    method overwrite_contents (line 57) | def overwrite_contents(self, filename, log):
    method replace_contents (line 65) | def replace_contents(self, filename, log):
  class EditMixin (line 77) | class EditMixin(PluginMixin):
    method assertItemFieldsModified (line 82) | def assertItemFieldsModified(
    method run_mocked_interpreter (line 101) | def run_mocked_interpreter(self, modify_file_args={}, stdin=[]):
    method run_mocked_command (line 111) | def run_mocked_command(self, modify_file_args={}, stdin=[], args=[]):
  class EditCommandTest (line 123) | class EditCommandTest(IOMixin, EditMixin, BeetsTestCase):
    method setUp (line 132) | def setUp(self):
    method test_title_edit_discard (line 141) | def test_title_edit_discard(self, mock_write):
    method test_title_edit_apply (line 153) | def test_title_edit_apply(self, mock_write):
    method test_single_title_edit_apply (line 167) | def test_single_title_edit_apply(self, mock_write):
    method test_title_edit_keep_editing_then_apply (line 183) | def test_title_edit_keep_editing_then_apply(self, mock_write):
    method test_title_edit_keep_editing_then_cancel (line 198) | def test_title_edit_keep_editing_then_cancel(self, mock_write):
    method test_noedit (line 213) | def test_noedit(self, mock_write):
    method test_album_edit_apply (line 225) | def test_album_edit_apply(self, mock_write):
    method test_single_edit_add_field (line 244) | def test_single_edit_add_field(self, mock_write):
    method test_a_album_edit_apply (line 261) | def test_a_album_edit_apply(self, mock_write):
    method test_a_albumartist_edit_apply (line 277) | def test_a_albumartist_edit_apply(self, mock_write):
    method test_malformed_yaml (line 293) | def test_malformed_yaml(self, mock_write):
    method test_invalid_yaml (line 305) | def test_invalid_yaml(self, mock_write):
  class EditDuringImporterTestCase (line 319) | class EditDuringImporterTestCase(
    method setUp (line 328) | def setUp(self):
  class EditDuringImporterNonSingletonTest (line 336) | class EditDuringImporterNonSingletonTest(EditDuringImporterTestCase):
    method setUp (line 337) | def setUp(self):
    method test_edit_apply_asis (line 341) | def test_edit_apply_asis(self):
    method test_edit_discard_asis (line 369) | def test_edit_discard_asis(self):
    method test_edit_apply_candidate (line 392) | def test_edit_apply_candidate(self):
    method test_edit_retag_apply (line 411) | def test_edit_retag_apply(self):
    method test_edit_discard_candidate (line 439) | def test_edit_discard_candidate(self):
    method test_edit_apply_candidate_singleton (line 458) | def test_edit_apply_candidate_singleton(self):
  class EditDuringImporterSingletonTest (line 476) | class EditDuringImporterSingletonTest(EditDuringImporterTestCase):
    method setUp (line 477) | def setUp(self):
    method test_edit_apply_asis_singleton (line 481) | def test_edit_apply_asis_singleton(self):

FILE: test/plugins/test_embedart.py
  function require_artresizer_compare (line 41) | def require_artresizer_compare(test):
  class EmbedartCliTest (line 79) | class EmbedartCliTest(
    method _setup_data (line 88) | def _setup_data(self, artpath=None):
    method test_embed_art_from_file_with_yes_input (line 94) | def test_embed_art_from_file_with_yes_input(self):
    method test_embed_art_from_file_with_no_input (line 103) | def test_embed_art_from_file_with_no_input(self):
    method test_embed_art_from_file (line 113) | def test_embed_art_from_file(self):
    method test_embed_art_from_album (line 121) | def test_embed_art_from_album(self):
    method test_embed_art_remove_art_file (line 131) | def test_embed_art_remove_art_file(self):
    method test_art_file_missing (line 154) | def test_art_file_missing(self):
    method test_embed_non_image_file (line 160) | def test_embed_non_image_file(self):
    method test_reject_different_art (line 178) | def test_reject_different_art(self):
    method test_accept_similar_art (line 192) | def test_accept_similar_art(self):
    method test_non_ascii_album_path (line 205) | def test_non_ascii_album_path(self):
    method test_extracted_extension (line 215) | def test_extracted_extension(self):
    method test_clear_art_with_yes_input (line 225) | def test_clear_art_with_yes_input(self):
    method test_clear_art_with_no_input (line 246) | def test_clear_art_with_no_input(self):
    method test_embed_art_from_url_with_yes_input (line 257) | def test_embed_art_from_url_with_yes_input(self):
    method test_embed_art_from_url_png (line 269) | def test_embed_art_from_url_png(self):
    method test_embed_art_from_url_not_image (line 280) | def test_embed_art_from_url_not_image(self):
    method test_clearart_on_import_disabled (line 289) | def test_clearart_on_import_disabled(self):
    method test_clearart_on_import_enabled (line 301) | def test_clearart_on_import_enabled(self):
  class DummyArtResizer (line 316) | class DummyArtResizer(ArtResizer):
    method __init__ (line 321) | def __init__(self):
  class ArtSimilarityTest (line 327) | class ArtSimilarityTest(unittest.TestCase):
    method setUp (line 328) | def setUp(self):
    method _similarity (line 333) | def _similarity(self, threshold):
    method _popen (line 342) | def _popen(self, status=0, stdout="", stderr=""):
    method _mock_popens (line 348) | def _mock_popens(
    method test_compare_success_similar (line 365) | def test_compare_success_similar(self, mock_extract, mock_subprocess):
    method test_compare_success_different (line 369) | def test_compare_success_different(self, mock_extract, mock_subprocess):
    method test_compare_status1_similar (line 373) | def test_compare_status1_similar(self, mock_extract, mock_subprocess):
    method test_compare_status1_different (line 377) | def test_compare_status1_different(self, mock_extract, mock_subprocess):
    method test_compare_failed (line 381) | def test_compare_failed(self, mock_extract, mock_subprocess):
    method test_compare_parsing_error (line 385) | def test_compare_parsing_error(self, mock_extract, mock_subprocess):
    method test_compare_parsing_error_and_failure (line 389) | def test_compare_parsing_error_and_failure(
    method test_convert_failure (line 395) | def test_convert_failure(self, mock_extract, mock_subprocess):

FILE: test/plugins/test_embyupdate.py
  class EmbyUpdateTest (line 7) | class EmbyUpdateTest(PluginTestCase):
    method setUp (line 10) | def setUp(self):
    method test_api_url_only_name (line 20) | def test_api_url_only_name(self):
    method test_api_url_http (line 30) | def test_api_url_http(self):
    method test_api_url_https (line 40) | def test_api_url_https(self):
    method test_password_data (line 50) | def test_password_data(self):
    method test_create_header_no_token (line 60) | def test_create_header_no_token(self):
    method test_create_header_with_token (line 74) | def test_create_header_with_token(self):
    method test_get_token (line 90) | def test_get_token(self):
    method test_get_user (line 175) | def test_get_user(self):

FILE: test/plugins/test_export.py
  class ExportPluginTest (line 25) | class ExportPluginTest(IOMixin, PluginTestCase):
    method setUp (line 28) | def setUp(self):
    method execute_command (line 32) | def execute_command(self, format_type, artist):
    method create_item (line 39) | def create_item(self):
    method test_json_output (line 48) | def test_json_output(self):
    method test_jsonlines_output (line 56) | def test_jsonlines_output(self):
    method test_csv_output (line 64) | def test_csv_output(self):
    method test_xml_output (line 74) | def test_xml_output(self):

FILE: test/plugins/test_fetchart.py
  class FetchartCliTest (line 24) | class FetchartCliTest(IOMixin, PluginTestCase):
    method setUp (line 27) | def setUp(self):
    method check_cover_is_stored (line 34) | def check_cover_is_stored(self):
    method hide_file_windows (line 39) | def hide_file_windows(self):
    method test_set_art_from_folder (line 47) | def test_set_art_from_folder(self):
    method test_filesystem_does_not_pick_up_folder (line 55) | def test_filesystem_does_not_pick_up_folder(self):
    method test_filesystem_does_not_pick_up_ignored_file (line 61) | def test_filesystem_does_not_pick_up_ignored_file(self):
    method test_filesystem_picks_up_non_ignored_file (line 68) | def test_filesystem_picks_up_non_ignored_file(self):
    method test_filesystem_does_not_pick_up_hidden_file (line 75) | def test_filesystem_does_not_pick_up_hidden_file(self):
    method test_filesystem_picks_up_non_hidden_file (line 85) | def test_filesystem_picks_up_non_hidden_file(self):
    method test_filesystem_picks_up_hidden_file (line 92) | def test_filesystem_picks_up_hidden_file(self):
    method test_colorization (line 102) | def test_colorization(self):

FILE: test/plugins/test_filefilter.py
  class FileFilterPluginMixin (line 21) | class FileFilterPluginMixin(PluginMixin, ImportTestCase):
    method setUp (line 25) | def setUp(self):
    method prepare_tracks_for_import (line 29) | def prepare_tracks_for_import(self):
    method _run (line 44) | def _run(self, config, expected_album_count, expected_paths):
  class FileFilterPluginNonSingletonTest (line 52) | class FileFilterPluginNonSingletonTest(FileFilterPluginMixin):
    method setUp (line 53) | def setUp(self):
    method test_import_default (line 57) | def test_import_default(self):
    method test_import_nothing (line 61) | def test_import_nothing(self):
    method test_global_config (line 64) | def test_global_config(self):
    method test_album_config (line 71) | def test_album_config(self):
    method test_singleton_config (line 78) | def test_singleton_config(self):
  class FileFilterPluginSingletonTest (line 83) | class FileFilterPluginSingletonTest(FileFilterPluginMixin):
    method setUp (line 84) | def setUp(self):
    method test_global_config (line 88) | def test_global_config(self):
    method test_album_config (line 93) | def test_album_config(self):
    method test_singleton_config (line 97) | def test_singleton_config(self):

FILE: test/plugins/test_fromfilename.py
  class Session (line 21) | class Session:
  class Item (line 25) | class Item:
    method __init__ (line 26) | def __init__(self, path):
  class Task (line 33) | class Task:
    method __init__ (line 34) | def __init__(self, items):
  function test_fromfilename (line 75) | def test_fromfilename(song1, song2):

FILE: test/plugins/test_ftintitle.py
  class FtInTitlePluginFunctional (line 35) | class FtInTitlePluginFunctional(PluginTestCase):
  function env (line 40) | def env() -> Generator[FtInTitlePluginFunctional, None, None]:
  function set_config (line 49) | def set_config(
  function add_item (line 64) | def add_item(
  function test_ftintitle_functional (line 275) | def test_ftintitle_functional(
  function test_find_feat_part (line 311) | def test_find_feat_part(
  function test_split_on_feat (line 341) | def test_split_on_feat(
  function test_insert_ft_into_title (line 395) | def test_insert_ft_into_title(
  function test_contains_feat (line 426) | def test_contains_feat(given: str, expected: bool) -> None:
  function test_custom_words (line 454) | def test_custom_words(
  function test_album_template_value (line 462) | def test_album_template_value(config):

FILE: test/plugins/test_fuzzy.py
  function helper (line 22) | def helper(request):
  class TestFuzzyPlugin (line 35) | class TestFuzzyPlugin(PluginMixin):
    method test_fuzzy_queries (line 47) | def test_fuzzy_queries(self, query, expected_titles):

FILE: test/plugins/test_hook.py
  class HookTestCase (line 31) | class HookTestCase(PluginTestCase):
    method _get_hook (line 35) | def _get_hook(self, event: str, command: str) -> dict[str, str]:
  class HookLogsTest (line 39) | class HookLogsTest(HookTestCase):
    method _configure_logs (line 43) | def _configure_logs(self, command: str) -> Iterator[list[str]]:
    method test_hook_empty_command (line 50) | def test_hook_empty_command(self):
    method test_hook_non_zero_exit (line 56) | def test_hook_non_zero_exit(self):
    method test_hook_non_existent_command (line 60) | def test_hook_non_existent_command(self):
  class HookCommandTest (line 72) | class HookCommandTest(HookTestCase):
    method setUp (line 75) | def setUp(self):
    method _test_command (line 79) | def _test_command(
    method test_hook_no_arguments (line 111) | def test_hook_no_arguments(self):
    method test_hook_event_substitution (line 115) | def test_hook_event_substitution(self):
    method test_hook_argument_substitution (line 119) | def test_hook_argument_substitution(self):
    method test_hook_bytes_interpolation (line 123) | def test_hook_bytes_interpolation(self):

FILE: test/plugins/test_ihate.py
  class IHatePluginTest (line 10) | class IHatePluginTest(unittest.TestCase):
    method test_hate (line 11) | def test_hate(self):

FILE: test/plugins/test_importadded.py
  function preserve_plugin_listeners (line 30) | def preserve_plugin_listeners():
  function modify_mtimes (line 38) | def modify_mtimes(paths, offset=-60000):
  class ImportAddedTest (line 44) | class ImportAddedTest(PluginMixin, AutotagImportTestCase):
    method setUp (line 49) | def setUp(self):
    method find_media_file (line 62) | def find_media_file(self, item):
    method test_import_album_with_added_dates (line 71) | def test_import_album_with_added_dates(self):
    method test_import_album_inplace_with_added_dates (line 79) | def test_import_album_inplace_with_added_dates(self):
    method test_import_album_with_preserved_mtimes (line 89) | def test_import_album_with_preserved_mtimes(self):
    method test_reimported_album_skipped (line 102) | def test_reimported_album_skipped(self):
    method test_import_singletons_with_added_dates (line 122) | def test_import_singletons_with_added_dates(self):
    method test_import_singletons_with_preserved_mtimes (line 131) | def test_import_singletons_with_preserved_mtimes(self):
    method test_reimported_singletons_skipped (line 143) | def test_reimported_singletons_skipped(self):

FILE: test/plugins/test_importfeeds.py
  class ImportFeedsTest (line 9) | class ImportFeedsTest(PluginTestCase):
    method setUp (line 12) | def setUp(self):
    method test_multi_format_album_playlist (line 18) | def test_multi_format_album_playlist(self):
    method test_playlist_in_subdir (line 32) | def test_playlist_in_subdir(self):
    method test_playlist_per_session (line 49) | def test_playlist_per_session(self):

FILE: test/plugins/test_importsource.py
  function preserve_plugin_listeners (line 29) | def preserve_plugin_listeners():
  class ImportSourceTest (line 37) | class ImportSourceTest(IOMixin, PluginMixin, AutotagImportTestCase):
    method setUp (line 41) | def setUp(self):
    method interact (line 53) | def interact(self, stdin: list[str]):
    method test_do_nothing (line 58) | def test_do_nothing(self):
    method test_remove_single (line 63) | def test_remove_single(self):
    method test_remove_all_from_single (line 68) | def test_remove_all_from_single(self):
    method test_stop_suggesting (line 74) | def test_stop_suggesting(self):
    method test_source_path_attribute_written (line 80) | def test_source_path_attribute_written(self):
    method test_source_files_not_modified_during_import (line 89) | def test_source_files_not_modified_during_import(self):
    method test_prevent_suggest_removal_on_reimport (line 115) | def test_prevent_suggest_removal_on_reimport(self):
    method test_prevent_suggest_removal_handles_skipped_task (line 133) | def test_prevent_suggest_removal_handles_skipped_task(self):

FILE: test/plugins/test_info.py
  class InfoTest (line 22) | class InfoTest(IOMixin, PluginTestCase):
    method test_path (line 25) | def test_path(self):
    method test_item_query (line 42) | def test_item_query(self):
    method test_item_library_query (line 55) | def test_item_library_query(self):
    method test_collect_item_and_path (line 64) | def test_collect_item_and_path(self):
    method test_collect_item_and_path_with_multi_values (line 83) | def test_collect_item_and_path_with_multi_values(self):
    method test_custom_format (line 110) | def test_custom_format(self):

FILE: test/plugins/test_inline.py
  class TestInlineRecursion (line 20) | class TestInlineRecursion(PluginTestCase):
    method test_no_recursion_when_inline_shadows_fixed_field (line 21) | def test_no_recursion_when_inline_shadows_fixed_field(self):
    method test_inline_function_body_item_field (line 46) | def test_inline_function_body_item_field(self):
    method test_inline_album_expression_uses_items (line 55) | def test_inline_album_expression_uses_items(self):

FILE: test/plugins/test_ipfs.py
  class IPFSPluginTest (line 25) | class IPFSPluginTest(PluginTestCase):
    method test_stored_hashes (line 28) | def test_stored_hashes(self):
    method mk_test_album (line 53) | def mk_test_album(self):

FILE: test/plugins/test_keyfinder.py
  class KeyFinderTest (line 24) | class KeyFinderTest(AsIsImporterMixin, PluginMixin, ImportTestCase):
    method test_add_key (line 27) | def test_add_key(self, command_output):
    method test_add_key_on_import (line 40) | def test_add_key_on_import(self, command_output):
    method test_force_overwrite (line 47) | def test_force_overwrite(self, command_output):
    method test_do_not_overwrite (line 59) | def test_do_not_overwrite(self, command_output):
    method test_no_key (line 69) | def test_no_key(self, command_output):

FILE: test/plugins/test_lastgenre.py
  class LastGenrePluginTest (line 26) | class LastGenrePluginTest(IOMixin, PluginTestCase):
    method setUp (line 29) | def setUp(self):
    method _setup_config (line 33) | def _setup_config(
    method test_default (line 47) | def test_default(self):
    method test_c14n_only (line 52) | def test_c14n_only(self):
    method test_whitelist_only (line 60) | def test_whitelist_only(self):
    method test_whitelist_c14n (line 65) | def test_whitelist_c14n(self):
    method test_whitelist_custom (line 75) | def test_whitelist_custom(self):
    method test_format_genres (line 83) | def test_format_genres(self):
    method test_count_c14n (line 93) | def test_count_c14n(self):
    method test_c14n_whitelist (line 104) | def test_c14n_whitelist(self):
    method test_empty_string_enables_canonical (line 109) | def test_empty_string_enables_canonical(self):
    method test_empty_string_enables_whitelist (line 116) | def test_empty_string_enables_whitelist(self):
    method test_prefer_specific_loads_tree (line 123) | def test_prefer_specific_loads_tree(self):
    method test_prefer_specific_without_canonical (line 130) | def test_prefer_specific_without_canonical(self):
    method test_pretend_option_skips_library_updates (line 143) | def test_pretend_option_skips_library_updates(self):
    method test_no_duplicate (line 165) | def test_no_duplicate(self):
    method test_tags_for (line 170) | def test_tags_for(self):
    method test_sort_by_depth (line 194) | def test_sort_by_depth(self):
  function config (line 207) | def config(config):
  function test_get_genre (line 585) | def test_get_genre(

FILE: test/plugins/test_limit.py
  class LimitPluginTest (line 19) | class LimitPluginTest(IOMixin, PluginTestCase):
    method setUp (line 27) | def setUp(self):
    method test_no_limit (line 48) | def test_no_limit(self):
    method test_lslimit_head (line 53) | def test_lslimit_head(self):
    method test_lslimit_tail (line 58) | def test_lslimit_tail(self):
    method test_lslimit_head_invariant (line 63) | def test_lslimit_head_invariant(self):
    method test_lslimit_tail_invariant (line 70) | def test_lslimit_tail_invariant(self):
    method test_prefix (line 77) | def test_prefix(self):
    method test_prefix_when_correctly_ordered (line 82) | def test_prefix_when_correctly_ordered(self):
    method test_prefix_when_incorrectly_ordred (line 89) | def test_prefix_when_incorrectly_ordred(self):

FILE: test/plugins/test_listenbrainz.py
  class TestListenBrainzPlugin (line 7) | class TestListenBrainzPlugin(ConfigMixin):
    method plugin (line 9) | def plugin(self) -> ListenBrainzPlugin:
    method test_get_mb_recording_id (line 19) | def test_get_mb_recording_id(
    method test_get_track_info (line 29) | def test_get_track_info(self, plugin, requests_mock):

FILE: test/plugins/test_lyrics.py
  function helper (line 48) | def helper():
  class TestLyricsUtils (line 55) | class TestLyricsUtils:
    method test_search_empty (line 67) | def test_search_empty(self, artist, title):
    method test_search_pairs_artists (line 91) | def test_search_pairs_artists(
    method test_search_pairs_titles (line 115) | def test_search_pairs_titles(self, title, expected_extra_titles):
    method test_slug (line 139) | def test_slug(self, text, expected):
  class TestHtml (line 143) | class TestHtml:
    method test_scrape_strip_cruft (line 144) | def test_scrape_strip_cruft(self):
    method test_scrape_merge_paragraphs (line 155) | def test_scrape_merge_paragraphs(self):
  class TestSearchBackend (line 162) | class TestSearchBackend:
    method backend (line 164) | def backend(self, dist_thresh):
    method test_check_match (line 192) | def test_check_match(self, backend, target_artist, artist, should_match):
  function lyrics_root_dir (line 199) | def lyrics_root_dir(pytestconfig: pytest.Config):
  class LyricsPluginMixin (line 203) | class LyricsPluginMixin(PluginMixin):
    method plugin_config (line 207) | def plugin_config(self):
    method lyrics_plugin (line 212) | def lyrics_plugin(self, backend_name, plugin_config):
  class TestLyricsPlugin (line 220) | class TestLyricsPlugin(LyricsPluginMixin):
    method backend_name (line 222) | def backend_name(self):
    method test_error_handling (line 236) | def test_error_handling(
    method test_overwrite_config (line 321) | def test_overwrite_config(
    method test_set_additional_lyrics_info (line 341) | def test_set_additional_lyrics_info(
  class LyricsBackendTest (line 370) | class LyricsBackendTest(LyricsPluginMixin):
    method backend (line 372) | def backend(self, lyrics_plugin):
    method lyrics_html (line 377) | def lyrics_html(self, lyrics_root_dir, file_name):
  class TestLyricsSources (line 384) | class TestLyricsSources(LyricsBackendTest):
    method plugin_config (line 386) | def plugin_config(self):
    method lyrics_page (line 393) | def lyrics_page(self, request):
    method backend_name (line 397) | def backend_name(self, lyrics_page):
    method _patch_google_search (line 401) | def _patch_google_search(self, requests_mock, lyrics_page):
    method test_backend_source (line 416) | def test_backend_source(
  class TestGoogleLyrics (line 440) | class TestGoogleLyrics(LyricsBackendTest):
    method backend_name (line 444) | def backend_name(self):
    method plugin_config (line 448) | def plugin_config(self):
    method file_name (line 452) | def file_name(self):
    method search_item (line 456) | def search_item(self, url_title, url):
    method test_disabled_without_api_key (line 460) | def test_disabled_without_api_key(self, lyrics_plugin):
    method test_mocked_source_ok (line 463) | def test_mocked_source_ok(self, backend, lyrics_html):
    method test_make_search_result (line 501) | def test_make_search_result(
  class TestGeniusLyrics (line 510) | class TestGeniusLyrics(LyricsBackendTest):
    method backend_name (line 512) | def backend_name(self):
    method test_scrape (line 523) | def test_scrape(self, backend, lyrics_html, expected_line_count):
  class TestTekstowoLyrics (line 529) | class TestTekstowoLyrics(LyricsBackendTest):
    method backend_name (line 531) | def backend_name(self):
    method test_scrape (line 544) | def test_scrape(self, backend, lyrics_html, expecting_lyrics):
  function lyrics_match (line 551) | def lyrics_match(**overrides):
  class TestLRCLibLyrics (line 562) | class TestLRCLibLyrics(LyricsBackendTest):
    method backend_name (line 567) | def backend_name(self):
    method fetch_lyrics (line 571) | def fetch_lyrics(self, backend, requests_mock, response_data):
    method test_synced_config_option (line 585) | def test_synced_config_option(
    method test_fetch_lyrics (line 662) | def test_fetch_lyrics(self, fetch_lyrics, expected_lyrics):
  class TestTranslation (line 672) | class TestTranslation:
    method _patch_bing (line 674) | def _patch_bing(self, requests_mock):
    method test_translate (line 760) | def test_translate(self, new_lyrics, old_lyrics, expected):
  class TestRestFiles (line 769) | class TestRestFiles:
    method rest_dir (line 771) | def rest_dir(self, tmp_path):
    method rest_files (line 775) | def rest_files(self, rest_dir):
    method test_write (line 778) | def test_write(self, rest_dir: Path, rest_files):

FILE: test/plugins/test_mbcollection.py
  class TestMbCollectionPlugin (line 13) | class TestMbCollectionPlugin(PluginMixin, TestHelper):
    method setup_config (line 21) | def setup_config(self):
    method helper (line 27) | def helper(self):
    method test_get_collection_validation (line 58) | def test_get_collection_validation(
    method test_mbupdate (line 68) | def test_mbupdate(self, helper, requests_mock, monkeypatch):

FILE: test/plugins/test_mbpseudo.py
  function rsrc_dir (line 27) | def rsrc_dir(pytestconfig: pytest.Config):
  function official_release (line 32) | def official_release(rsrc_dir: pathlib.Path) -> JSONDict:
  function pseudo_release (line 38) | def pseudo_release(rsrc_dir: pathlib.Path) -> JSONDict:
  function official_release_info (line 44) | def official_release_info() -> AlbumInfo:
  function pseudo_release_info (line 53) | def pseudo_release_info() -> AlbumInfo:
  class TestPseudoAlbumInfo (line 62) | class TestPseudoAlbumInfo:
    method test_album_id_always_from_pseudo (line 63) | def test_album_id_always_from_pseudo(
    method test_get_attr_from_pseudo (line 70) | def test_get_attr_from_pseudo(
    method test_get_attr_from_official (line 76) | def test_get_attr_from_official(
    method test_determine_best_ref (line 83) | def test_determine_best_ref(
  class TestMBPseudoMixin (line 97) | class TestMBPseudoMixin(PluginMixin):
    method patch_get_release (line 101) | def patch_get_release(self, monkeypatch, pseudo_release: JSONDict):
    method plugin_config (line 110) | def plugin_config(self):
    method mbpseudo_plugin (line 114) | def mbpseudo_plugin(self, plugin_config) -> MusicBrainzPseudoReleasePl...
  class TestMBPseudoPlugin (line 119) | class TestMBPseudoPlugin(TestMBPseudoMixin):
    method test_scripts_init (line 120) | def test_scripts_init(
    method test_extract_id_uses_music_brainz_pattern (line 132) | def test_extract_id_uses_music_brainz_pattern(
    method test_album_info_for_pseudo_release (line 142) | def test_album_info_for_pseudo_release(
    method test_interception_skip_when_rel_values_dont_match (line 160) | def test_interception_skip_when_rel_values_dont_match(
    method test_interception_skip_when_script_doesnt_match (line 172) | def test_interception_skip_when_script_doesnt_match(
    method test_interception (line 185) | def test_interception(
    method test_final_adjustment_skip (line 194) | def test_final_adjustment_skip(
    method test_final_adjustment (line 209) | def test_final_adjustment(
  class TestMBPseudoPluginCustomTagsOnly (line 240) | class TestMBPseudoPluginCustomTagsOnly(TestMBPseudoMixin):
    method plugin_config (line 242) | def plugin_config(self):
    method test_custom_tags (line 245) | def test_custom_tags(
    method test_custom_tags_with_import_languages (line 260) | def test_custom_tags_with_import_languages(

FILE: test/plugins/test_mbsubmit.py
  class MBSubmitPluginTest (line 23) | class MBSubmitPluginTest(
    method setUp (line 28) | def setUp(self):
    method test_print_tracks_output (line 33) | def test_print_tracks_output(self):
    method test_print_tracks_output_as_tracks (line 48) | def test_print_tracks_output_as_tracks(self):

FILE: test/plugins/test_mbsync.py
  class MbsyncCliTest (line 22) | class MbsyncCliTest(PluginTestCase):
    method test_update_library (line 43) | def test_update_library(self):
    method test_custom_format (line 69) | def test_custom_format(self):

FILE: test/plugins/test_missing.py
  function helper (line 15) | def helper(request):
  class TestMissingAlbums (line 27) | class TestMissingAlbums(IOMixin, PluginMixin):
    method test_missing_artist_albums (line 47) | def test_missing_artist_albums(
    method test_release_types_filters_results (line 70) | def test_release_types_filters_results(self, requests_mock):
    method test_release_types_comma_separated (line 98) | def test_release_types_comma_separated(self, requests_mock):
    method test_empty_release_types_config_sends_empty_type (line 131) | def test_empty_release_types_config_sends_empty_type(self, requests_mo...
    method test_missing_albums_total (line 153) | def test_missing_albums_total(self, requests_mock):
  class TestMissingTracks (line 184) | class TestMissingTracks(IOMixin, PluginMixin):
    method test_missing_tracks (line 197) | def test_missing_tracks(self, album_for_id, total, count, expected):

FILE: test/plugins/test_mpdstats.py
  class MPDStatsTest (line 25) | class MPDStatsTest(PluginTestCase):
    method test_update_rating (line 28) | def test_update_rating(self):
    method test_get_item (line 38) | def test_get_item(self):
    method test_run_mpdstats (line 70) | def test_run_mpdstats(self, mpd_mock):

FILE: test/plugins/test_musicbrainz.py
  function make_alias (line 31) | def make_alias(suffix: str, locale: str, primary: bool = False):
  class MusicBrainzTestCase (line 42) | class MusicBrainzTestCase(BeetsTestCase):
    method setUp (line 43) | def setUp(self):
  class MBAlbumInfoTest (line 49) | class MBAlbumInfoTest(MusicBrainzTestCase):
    method _make_release (line 50) | def _make_release(
    method _make_track (line 179) | def _make_track(
    method test_parse_release_title (line 242) | def test_parse_release_title(self):
    method test_parse_release_with_year (line 258) | def test_parse_release_with_year(self):
    method test_parse_release_type (line 269) | def test_parse_release_type(self):
    method test_parse_release_full_date (line 274) | def test_parse_release_full_date(self):
    method test_parse_tracks (line 281) | def test_parse_tracks(self):
    method test_parse_track_indices (line 325) | def test_parse_track_indices(self):
    method test_parse_medium_numbers_single_medium (line 339) | def test_parse_medium_numbers_single_medium(self):
    method test_parse_medium_numbers_two_mediums (line 352) | def test_parse_medium_numbers_two_mediums(self):
    method test_parse_release_year_month_only (line 383) | def test_parse_release_year_month_only(self):
    method test_no_durations (line 389) | def test_no_durations(self):
    method test_track_length_overrides_recording_length (line 395) | def test_track_length_overrides_recording_length(self):
    method test_no_release_date (line 401) | def test_no_release_date(self):
    method test_various_artists_defaults_false (line 408) | def test_various_artists_defaults_false(self):
    method test_detect_various_artists (line 413) | def test_detect_various_artists(self):
    method test_parse_artist_sort_name (line 421) | def test_parse_artist_sort_name(self):
    method test_parse_releasegroupid (line 426) | def test_parse_releasegroupid(self):
    method test_parse_release_group_title (line 431) | def test_parse_release_group_title(self):
    method test_parse_asin (line 447) | def test_parse_asin(self):
    method test_parse_catalognum (line 452) | def test_parse_catalognum(self):
    method test_parse_textrepr (line 457) | def test_parse_textrepr(self):
    method test_parse_country (line 463) | def test_parse_country(self):
    method test_parse_status (line 468) | def test_parse_status(self):
    method test_parse_barcode (line 473) | def test_parse_barcode(self):
    method test_parse_media (line 478) | def test_parse_media(self):
    method test_parse_disambig (line 487) | def test_parse_disambig(self):
    method test_parse_disctitle (line 493) | def test_parse_disctitle(self):
    method test_missing_language (line 504) | def test_missing_language(self):
    method test_parse_recording_artist (line 510) | def test_parse_recording_artist(self):
    method test_parse_recording_artist_multi (line 519) | def test_parse_recording_artist_multi(self):
    method test_track_artist_overrides_recording_artist (line 551) | def test_track_artist_overrides_recording_artist(self):
    method test_track_artist_overrides_recording_artist_multi (line 560) | def test_track_artist_overrides_recording_artist_multi(self):
    method test_parse_recording_remixer (line 587) | def test_parse_recording_remixer(self):
    method test_data_source (line 593) | def test_data_source(self):
    method test_genres (line 598) | def test_genres(self):
    method test_tags (line 605) | def test_tags(self):
    method test_no_genres (line 612) | def test_no_genres(self):
    method test_ignored_media (line 618) | def test_ignored_media(self):
    method test_no_ignored_media (line 628) | def test_no_ignored_media(self):
    method test_skip_data_track (line 638) | def test_skip_data_track(self):
    method test_skip_audio_data_tracks_by_default (line 650) | def test_skip_audio_data_tracks_by_default(self):
    method test_no_skip_audio_data_tracks_if_configured (line 666) | def test_no_skip_audio_data_tracks_if_configured(self):
    method test_skip_video_tracks_by_default (line 684) | def test_skip_video_tracks_by_default(self):
    method test_skip_video_data_tracks_by_default (line 698) | def test_skip_video_data_tracks_by_default(self):
    method test_no_skip_video_tracks_if_configured (line 714) | def test_no_skip_video_tracks_if_configured(self):
    method test_no_skip_video_data_tracks_if_configured (line 731) | def test_no_skip_video_data_tracks_if_configured(self):
    method test_track_disambiguation (line 750) | def test_track_disambiguation(self):
    method test_missing_tracks (line 768) | def test_missing_tracks(self):
  class ArtistFlatteningTest (line 786) | class ArtistFlatteningTest(unittest.TestCase):
    method _credit_dict (line 787) | def _credit_dict(self, suffix=""):
    method test_single_artist (line 796) | def test_single_artist(self):
    method test_two_artists (line 810) | def test_two_artists(self):
    method test_alias (line 827) | def test_alias(self):
  class MBLibraryTest (line 867) | class MBLibraryTest(MusicBrainzTestCase):
    method test_follow_pseudo_releases (line 868) | def test_follow_pseudo_releases(self):
    method test_pseudo_releases_with_empty_links (line 955) | def test_pseudo_releases_with_empty_links(self):
    method test_pseudo_releases_without_links (line 999) | def test_pseudo_releases_without_links(self):
    method test_pseudo_releases_with_unsupported_links (line 1043) | def test_pseudo_releases_with_unsupported_links(self):
  class TestMusicBrainzPlugin (line 1097) | class TestMusicBrainzPlugin(PluginMixin):
    method plugin_config (line 1108) | def plugin_config(self):
    method mb (line 1112) | def mb(self, plugin_config):
    method test_get_album_criteria (line 1129) | def test_get_album_criteria(
    method test_item_candidates (line 1143) | def test_item_candidates(self, monkeypatch, mb):
    method test_candidates (line 1158) | def test_candidates(self, monkeypatch, mb):
    method test_import_handles_404_gracefully (line 1194) | def test_import_handles_404_gracefully(self, mb, requests_mock):
    method test_import_propagates_non_404_errors (line 1205) | def test_import_propagates_non_404_errors(self, mb):

FILE: test/plugins/test_parentwork.py
  class ParentWorkIntegrationTest (line 24) | class ParentWorkIntegrationTest(PluginTestCase):
    method test_normal_case_real (line 28) | def test_normal_case_real(self):
    method test_force_real (line 41) | def test_force_real(self):
    method test_no_force_real (line 57) | def test_no_force_real(self):
  class ParentWorkTest (line 74) | class ParentWorkTest(PluginTestCase):
    method patch_works (line 78) | def patch_works(self, requests_mock):
    method test_normal_case (line 124) | def test_normal_case(self):
    method test_force (line 133) | def test_force(self):
    method test_no_force (line 149) | def test_no_force(self):

FILE: test/plugins/test_permissions.py
  class PermissionsPluginTest (line 16) | class PermissionsPluginTest(AsIsImporterMixin, PluginMixin, ImportTestCa...
    method setUp (line 19) | def setUp(self):
    method test_permissions_on_album_imported (line 24) | def test_permissions_on_album_imported(self):
    method test_permissions_on_item_imported (line 27) | def test_permissions_on_item_imported(self):
    method import_and_check_permissions (line 31) | def import_and_check_permissions(self):
    method test_convert_perm_from_string (line 45) | def test_convert_perm_from_string(self):
    method test_convert_perm_from_int (line 48) | def test_convert_perm_from_int(self):
    method test_permissions_on_set_art (line 51) | def test_permissions_on_set_art(self):
    method test_failing_permissions_on_set_art (line 55) | def test_failing_permissions_on_set_art(self):
    method do_set_art (line 58) | def do_set_art(self, expect_success):

FILE: test/plugins/test_play.py
  class PlayPluginTest (line 31) | class PlayPluginTest(IOMixin, CleanupModulesMixin, PluginTestCase):
    method setUp (line 35) | def setUp(self):
    method run_and_assert (line 41) | def run_and_assert(
    method test_basic (line 56) | def test_basic(self, open_mock):
    method test_album_option (line 59) | def test_album_option(self, open_mock):
    method test_args_option (line 62) | def test_args_option(self, open_mock):
    method test_args_option_in_middle (line 67) | def test_args_option_in_middle(self, open_mock):
    method test_unset_args_option_in_middle (line 74) | def test_unset_args_option_in_middle(self, open_mock):
    method test_relative_to (line 81) | def test_relative_to(self, open_mock):
    method test_use_folders (line 91) | def test_use_folders(self, open_mock):
    method test_raw (line 101) | def test_raw(self, open_mock):
    method test_pls_marker (line 108) | def test_pls_marker(self, open_mock):
    method test_not_found (line 121) | def test_not_found(self, open_mock):
    method test_warning_threshold (line 126) | def test_warning_threshold(self, open_mock):
    method test_skip_warning_threshold_bypass (line 135) | def test_skip_warning_threshold_bypass(self, open_mock):
    method _playlist_lines (line 148) | def _playlist_lines(self, open_mock):
    method _add_many_ordered_items (line 155) | def _add_many_ordered_items(self, *, count, album):
    method test_randomize (line 168) | def test_randomize(self, open_mock):
    method test_command_failed (line 180) | def test_command_failed(self, open_mock):

FILE: test/plugins/test_playlist.py
  class PlaylistTestCase (line 24) | class PlaylistTestCase(PluginTestCase):
    method setUp (line 28) | def setUp(self):
    method setup_test (line 83) | def setup_test(self):
  class PlaylistQueryTest (line 87) | class PlaylistQueryTest:
    method test_name_query_with_absolute_paths_in_playlist (line 88) | def test_name_query_with_absolute_paths_in_playlist(self):
    method test_path_query_with_absolute_paths_in_playlist (line 93) | def test_path_query_with_absolute_paths_in_playlist(self):
    method test_name_query_with_relative_paths_in_playlist (line 98) | def test_name_query_with_relative_paths_in_playlist(self):
    method test_path_query_with_relative_paths_in_playlist (line 103) | def test_path_query_with_relative_paths_in_playlist(self):
    method test_name_query_with_nonexisting_playlist (line 108) | def test_name_query_with_nonexisting_playlist(self):
    method test_path_query_with_nonexisting_playlist (line 113) | def test_path_query_with_nonexisting_playlist(self):
  class PlaylistTestRelativeToLib (line 119) | class PlaylistTestRelativeToLib(PlaylistQueryTest, PlaylistTestCase):
    method setup_test (line 120) | def setup_test(self):
  class PlaylistTestRelativeToDir (line 142) | class PlaylistTestRelativeToDir(PlaylistQueryTest, PlaylistTestCase):
    method setup_test (line 143) | def setup_test(self):
  class PlaylistTestRelativeToPls (line 165) | class PlaylistTestRelativeToPls(PlaylistQueryTest, PlaylistTestCase):
    method setup_test (line 166) | def setup_test(self):
  class PlaylistUpdateTest (line 201) | class PlaylistUpdateTest:
    method setup_test (line 202) | def setup_test(self):
  class PlaylistTestItemMoved (line 225) | class PlaylistTestItemMoved(PlaylistUpdateTest, PlaylistTestCase):
    method test_item_moved (line 226) | def test_item_moved(self):
  class PlaylistTestItemRemoved (line 281) | class PlaylistTestItemRemoved(PlaylistUpdateTest, PlaylistTestCase):
    method test_item_removed (line 282) | def test_item_removed(self):

FILE: test/plugins/test_plexupdate.py
  class PlexUpdateTest (line 7) | class PlexUpdateTest(PluginTestCase):
    method add_response_get_music_section (line 10) | def add_response_get_music_section(self, section_name="Music"):
    method add_response_update_plex (line 61) | def add_response_update_plex(self):
    method setUp (line 75) | def setUp(self):
    method test_get_music_section (line 81) | def test_get_music_section(self):
    method test_get_named_music_section (line 99) | def test_get_named_music_section(self):
    method test_update_plex (line 116) | def test_update_plex(self):

FILE: test/plugins/test_plugin_mediafield.py
  class ExtendedFieldTestMixin (line 44) | class ExtendedFieldTestMixin(BeetsTestCase):
    method _mediafile_fixture (line 45) | def _mediafile_fixture(self, name, extension="mp3"):
    method test_extended_field_write (line 52) | def test_extended_field_write(self):
    method test_extended_list_field_write (line 68) | def test_extended_list_field_write(self):
    method test_write_extended_tag_from_item (line 84) | def test_write_extended_tag_from_item(self):
    method test_read_flexible_attribute_from_file (line 101) | def test_read_flexible_attribute_from_file(self):
    method test_invalid_descriptor (line 117) | def test_invalid_descriptor(self):
    method test_overwrite_property (line 123) | def test_overwrite_property(self):

FILE: test/plugins/test_random.py
  function helper (line 27) | def helper():
  function seed_random (line 37) | def seed_random():
  class TestEqualChancePermutation (line 41) | class TestEqualChancePermutation:
    method setup (line 45) | def setup(self, helper):
    method _stats (line 56) | def _stats(self, data):
    method test_equal_permutation (line 66) | def test_equal_permutation(self):
    method test_equal_permutation_items (line 110) | def test_equal_permutation_items(
  class TestRandomObjs (line 126) | class TestRandomObjs:
    method setup (line 130) | def setup(self, helper):
    method test_random_selection_by_count (line 141) | def test_random_selection_by_count(self):
    method test_random_selection_by_time (line 147) | def test_random_selection_by_time(self):
    method test_equal_chance_permutation (line 157) | def test_equal_chance_permutation(self, helper):
    method test_empty_input_list (line 175) | def test_empty_input_list(self):
    method test_no_constraints_returns_all (line 180) | def test_no_constraints_returns_all(self):

FILE: test/plugins/test_replace.py
  class TestReplace (line 14) | class TestReplace:
    method _fake_dir (line 16) | def _fake_dir(self, tmp_path):
    method _fake_file (line 20) | def _fake_file(self, tmp_path):
    method test_path_is_dir (line 23) | def test_path_is_dir(self):
    method test_path_is_unsupported_file (line 29) | def test_path_is_unsupported_file(self):
    method test_path_is_supported_file (line 35) | def test_path_is_supported_file(self):
    method test_select_song_valid_choice (line 49) | def test_select_song_valid_choice(self, monkeypatch, capfd):
    method test_select_song_cancel (line 62) | def test_select_song_cancel(self, monkeypatch):
    method test_select_song_invalid_then_valid (line 70) | def test_select_song_invalid_then_valid(self, monkeypatch, capfd):
    method test_confirm_replacement_file_not_exist (line 86) | def test_confirm_replacement_file_not_exist(self):
    method test_confirm_replacement_yes (line 95) | def test_confirm_replacement_yes(self, monkeypatch):
    method test_confirm_replacement_no (line 106) | def test_confirm_replacement_no(self, monkeypatch):

FILE: test/plugins/test_replaygain.py
  function reset_replaygain (line 54) | def reset_replaygain(item):
  class ReplayGainTestCase (line 65) | class ReplayGainTestCase(PluginMixin, ImportTestCase):
    method backend (line 73) | def backend(self):
    method setUp (line 76) | def setUp(self):
  class ThreadedImportMixin (line 86) | class ThreadedImportMixin:
    method setUp (line 87) | def setUp(self):
  class BackendMixin (line 92) | class BackendMixin:
    method test_backend (line 96) | def test_backend(self):
  class GstBackendMixin (line 100) | class GstBackendMixin(BackendMixin):
    method test_backend (line 104) | def test_backend(self):
  class CmdBackendMixin (line 116) | class CmdBackendMixin(BackendMixin):
  class FfmpegBackendMixin (line 124) | class FfmpegBackendMixin(BackendMixin):
  class ReplayGainCliTest (line 129) | class ReplayGainCliTest:
    method _add_album (line 132) | def _add_album(self, *args, **kwargs):
    method test_cli_saves_track_gain (line 140) | def test_cli_saves_track_gain(self):
    method test_cli_skips_calculated_tracks (line 171) | def test_cli_skips_calculated_tracks(self):
    method test_cli_does_not_skip_wrong_tag_type (line 212) | def test_cli_does_not_skip_wrong_tag_type(self):
    method test_cli_saves_album_gain_to_file (line 248) | def test_cli_saves_album_gain_to_file(self):
    method test_cli_writes_only_r128_tags (line 272) | def test_cli_writes_only_r128_tags(self):
    method test_targetlevel_has_effect (line 291) | def test_targetlevel_has_effect(self):
    method test_r128_targetlevel_has_effect (line 306) | def test_r128_targetlevel_has_effect(self):
    method test_per_disc (line 326) | def test_per_disc(self):
  class ReplayGainGstCliTest (line 340) | class ReplayGainGstCliTest(
  class ReplayGainCmdCliTest (line 347) | class ReplayGainCmdCliTest(
  class ReplayGainFfmpegCliTest (line 354) | class ReplayGainFfmpegCliTest(
  class ReplayGainFfmpegNoiseCliTest (line 361) | class ReplayGainFfmpegNoiseCliTest(
  class ImportTest (line 367) | class ImportTest(AsIsImporterMixin):
    method test_import_converted (line 368) | def test_import_converted(self):
  class ReplayGainGstImportTest (line 379) | class ReplayGainGstImportTest(ImportTest, ReplayGainTestCase, GstBackend...
  class ReplayGainCmdImportTest (line 384) | class ReplayGainCmdImportTest(ImportTest, ReplayGainTestCase, CmdBackend...
  class ReplayGainFfmpegImportTest (line 389) | class ReplayGainFfmpegImportTest(
  class ReplayGainFfmpegThreadedImportTest (line 396) | class ReplayGainFfmpegThreadedImportTest(

FILE: test/plugins/test_scrub.py
  class ScrubbedImportTest (line 8) | class ScrubbedImportTest(AsIsImporterMixin, PluginMixin, ImportTestCase):
    method test_tags_not_scrubbed (line 12) | def test_tags_not_scrubbed(self):
    method test_tags_restored (line 21) | def test_tags_restored(self):
    method test_tags_not_restored (line 30) | def test_tags_not_restored(self):

FILE: test/plugins/test_smartplaylist.py
  class SmartPlaylistTest (line 34) | class SmartPlaylistTest(BeetsTestCase):
    method test_build_queries (line 35) | def test_build_queries(self):
    method test_build_queries_with_sorts (line 70) | def test_build_queries_with_sorts(self):
    method test_matches (line 113) | def test_matches(self):
    method test_db_changes (line 144) | def test_db_changes(self):
    method test_playlist_update (line 170) | def test_playlist_update(self):
    method test_playlist_update_output_extm3u (line 207) | def test_playlist_update_output_extm3u(self):
    method test_playlist_update_output_extm3u_fields (line 255) | def test_playlist_update_output_extm3u_fields(self):
    method test_playlist_update_uri_format (line 305) | def test_playlist_update_uri_format(self):
    method test_playlist_update_multiple_queries_preserve_order (line 349) | def test_playlist_update_multiple_queries_preserve_order(self):
    method test_playlist_update_multiple_queries_no_duplicates (line 409) | def test_playlist_update_multiple_queries_no_duplicates(self):
    method test_playlist_update_dest_regen (line 461) | def test_playlist_update_dest_regen(self):
  class SmartPlaylistCLITest (line 544) | class SmartPlaylistCLITest(IOMixin, PluginTestCase):
    method setUp (line 547) | def setUp(self):
    method test_splupdate (line 559) | def test_splupdate(self):

FILE: test/plugins/test_spotify.py
  class ArgumentsMock (line 14) | class ArgumentsMock:
    method __init__ (line 15) | def __init__(self, mode, show_failures):
  function _params (line 21) | def _params(url):
  class SpotifyPluginTest (line 26) | class SpotifyPluginTest(PluginTestCase):
    method setUp (line 30) | def setUp(self):
    method test_args (line 48) | def test_args(self):
    method test_empty_query (line 54) | def test_empty_query(self):
    method test_missing_request (line 58) | def test_missing_request(self):
    method test_track_request (line 90) | def test_track_request(self):
    method test_track_for_id (line 125) | def test_track_for_id(self):
    method test_japanese_track (line 183) | def test_japanese_track(self):
    method test_multiartist_album_and_track (line 254) | def test_multiartist_album_and_track(self):

FILE: test/plugins/test_subsonicupdate.py
  class ArgumentsMock (line 12) | class ArgumentsMock:
    method __init__ (line 15) | def __init__(self, mode, show_failures):
  function _params (line 22) | def _params(url):
  class SubsonicPluginTest (line 27) | class SubsonicPluginTest(unittest.TestCase):
    method setUp (line 31) | def setUp(self):
    method test_start_scan (line 91) | def test_start_scan(self):
    method test_start_scan_failed_bad_credentials (line 103) | def test_start_scan_failed_bad_credentials(self):
    method test_start_scan_failed_not_found (line 115) | def test_start_scan_failed_not_found(self):
    method test_start_scan_failed_unreachable (line 126) | def test_start_scan_failed_unreachable(self):
    method test_url_with_context_path (line 131) | def test_url_with_context_path(self):
    method test_url_with_trailing_forward_slash_url (line 145) | def test_url_with_trailing_forward_slash_url(self):
    method test_url_with_missing_port (line 159) | def test_url_with_missing_port(self):
    method test_url_with_missing_schema (line 173) | def test_url_with_missing_schema(self):

FILE: test/plugins/test_substitute.py
  class SubstitutePluginTest (line 21) | class SubstitutePluginTest(PluginTestCase):
    method run_substitute (line 25) | def run_substitute(self, config, cases):
    method test_simple_substitute (line 30) | def test_simple_substitute(self):
    method test_case_insensitivity (line 40) | def test_case_insensitivity(self):
    method test_unmatched_input_preserved (line 43) | def test_unmatched_input_preserved(self):
    method test_regex_to_static (line 46) | def test_regex_to_static(self):
    method test_regex_capture_group (line 52) | def test_regex_capture_group(self):
    method test_partial_substitution (line 68) | def test_partial_substitution(self):
    method test_rules_applied_in_definition_order (line 71) | def test_rules_applied_in_definition_order(self):
    method test_rules_applied_in_sequence (line 84) | def test_rules_applied_in_sequence(self):

FILE: test/plugins/test_the.py
  class ThePluginTest (line 9) | class ThePluginTest(unittest.TestCase):
    method test_unthe_with_default_patterns (line 10) | def test_unthe_with_default_patterns(self):
    method test_unthe_with_strip (line 32) | def test_unthe_with_strip(self):
    method test_template_function_with_defaults (line 37) | def test_template_function_with_defaults(self):
    method test_custom_pattern (line 42) | def test_custom_pattern(self):
    method test_custom_format (line 47) | def test_custom_format(self):

FILE: test/plugins/test_thumbnails.py
  class ThumbnailsTest (line 34) | class ThumbnailsTest(BeetsTestCase):
    method test_add_tags (line 38) | def test_add_tags(self, mock_stat, mock_artresizer):
    method test_check_local_ok (line 58) | def test_check_local_ok(self, mock_giouri, mock_artresizer, mock_os):
    method test_make_cover_thumbnail (line 106) | def test_make_cover_thumbnail(self, mock_shutils, mock_os, mock_artres...
    method test_make_dolphin_cover_thumbnail (line 167) | def test_make_dolphin_cover_thumbnail(self):
    method test_process_album (line 191) | def test_process_album(self, mock_artresizer):
    method test_invokations (line 235) | def test_invokations(self):
    method test_thumbnail_file_name (line 250) | def test_thumbnail_file_name(self, mock_basedir):
    method test_uri (line 258) | def test_uri(self):
  class TestPathlibURI (line 275) | class TestPathlibURI:
    method test_uri (line 278) | def test_uri(self):

FILE: test/plugins/test_titlecase.py
  class TestTitlecasePlugin (line 58) | class TestTitlecasePlugin(PluginTestCase):
    method test_auto (line 62) | def test_auto(self):
    method test_basic_titlecase (line 71) | def test_basic_titlecase(self):
    method test_small_first_last (line 85) | def test_small_first_last(self):
    method test_preserve (line 97) | def test_preserve(self):
    method test_separators (line 115) | def test_separators(self):
    method test_all_caps (line 136) | def test_all_caps(self):
    method test_all_lowercase (line 150) | def test_all_lowercase(self):
    method test_received_info_handler (line 162) | def test_received_info_handler(self):
    method test_titlecase_fields (line 210) | def test_titlecase_fields(self):
    method test_cli_write (line 362) | def test_cli_write(self):
    method test_cli_no_write (line 382) | def test_cli_no_write(self):
    method test_imported (line 402) | def test_imported(self):

FILE: test/plugins/test_types_plugin.py
  class TypesPluginTest (line 25) | class TypesPluginTest(IOMixin, PluginTestCase):
    method test_integer_modify_and_query (line 28) | def test_integer_modify_and_query(self):
    method test_album_integer_modify_and_query (line 44) | def test_album_integer_modify_and_query(self):
    method test_float_modify_and_query (line 60) | def test_float_modify_and_query(self):
    method test_bool_modify_and_query (line 76) | def test_bool_modify_and_query(self):
    method test_date_modify_and_query (line 107) | def test_date_modify_and_query(self):
    method test_unknown_type_error (line 134) | def test_unknown_type_error(self):
    method test_template_if_def (line 139) | def test_template_if_def(self):
    method modify (line 173) | def modify(self, *args):
    method list (line 178) | def list(self, query, fmt="$artist - $album - $title"):
    method list_album (line 181) | def list_album(self, query, fmt="$albumartist - $album - $title"):
  function mktime (line 185) | def mktime(*args):

FILE: test/plugins/test_web.py
  class WebPluginTest (line 16) | class WebPluginTest(ItemInDBTestCase):
    method setUp (line 17) | def setUp(self):
    method test_config_include_paths_true (line 70) | def test_config_include_paths_true(self):
    method test_config_include_artpaths_true (line 83) | def test_config_include_artpaths_true(self):
    method test_config_include_paths_false (line 98) | def test_config_include_paths_false(self):
    method test_config_include_artpaths_false (line 106) | def test_config_include_artpaths_false(self):
    method test_get_all_items (line 114) | def test_get_all_items(self):
    method test_get_unique_item_artist (line 121) | def test_get_unique_item_artist(self):
    method test_get_single_item_by_id (line 128) | def test_get_single_item_by_id(self):
    method test_get_multiple_items_by_id (line 136) | def test_get_multiple_items_by_id(self):
    method test_get_single_item_not_found (line 145) | def test_get_single_item_not_found(self):
    method test_get_single_item_by_path (line 149) | def test_get_single_item_by_path(self):
    method test_get_single_item_by_path_not_found_if_not_in_library (line 158) | def test_get_single_item_by_path_not_found_if_not_in_library(self):
    method test_get_item_empty_query (line 166) | def test_get_item_empty_query(self):
    method test_get_simple_item_query (line 173) | def test_get_simple_item_query(self):
    method test_query_item_string (line 181) | def test_query_item_string(self):
    method test_query_item_regex (line 189) | def test_query_item_regex(self):
    method test_query_item_regex_backslash (line 199) | def test_query_item_regex_backslash(self):
    method test_query_item_path (line 209) | def test_query_item_path(self):
    method test_get_all_albums (line 223) | def test_get_all_albums(self):
    method test_get_single_album_by_id (line 231) | def test_get_single_album_by_id(self):
    method test_get_multiple_albums_by_id (line 239) | def test_get_multiple_albums_by_id(self):
    method test_get_album_empty_query (line 247) | def test_get_album_empty_query(self):
    method test_get_simple_album_query (line 254) | def test_get_simple_album_query(self):
    method test_get_album_details (line 263) | def test_get_album_details(self):
    method test_query_album_string (line 274) | def test_query_album_string(self):
    method test_query_album_artpath_regex (line 284) | def test_query_album_artpath_regex(self):
    method test_query_album_regex_backslash (line 294) | def test_query_album_regex_backslash(self):
    method test_get_stats (line 304) | def test_get_stats(self):
    method test_delete_item_id (line 312) | def test_delete_item_id(self):
    method test_delete_item_without_file (line 337) | def test_delete_item_without_file(self):
    method test_delete_item_with_file (line 365) | def test_delete_item_with_file(self):
    method test_delete_item_query (line 392) | def test_delete_item_query(self):
    method test_delete_item_all_fails (line 417) | def test_delete_item_all_fails(self):
    method test_delete_item_id_readonly (line 429) | def test_delete_item_id_readonly(self):
    method test_delete_item_query_readonly (line 456) | def test_delete_item_query_readonly(self):
    method test_delete_album_id (line 483) | def test_delete_album_id(self):
    method test_delete_album_query (line 508) | def test_delete_album_query(self):
    method test_delete_album_all_fails (line 533) | def test_delete_album_all_fails(self):
    method test_delete_album_id_readonly (line 545) | def test_delete_album_id_readonly(self):
    method test_delete_album_query_readonly (line 572) | def test_delete_album_query_readonly(self):
    method test_patch_item_id (line 601) | def test_patch_item_id(self):
    method test_patch_item_id_readonly (line 643) | def test_patch_item_id_readonly(self):
    method test_get_item_file (line 675) | def test_get_item_file(self):

FILE: test/plugins/test_zero.py
  class ZeroPluginTest (line 11) | class ZeroPluginTest(IOMixin, PluginTestCase):
    method test_no_patterns (line 15) | def test_no_patterns(self):
    method test_pattern_match (line 33) | def test_pattern_match(self):
    method test_pattern_nomatch (line 45) | def test_pattern_nomatch(self):
    method test_do_not_change_database (line 57) | def test_do_not_change_database(self):
    method test_change_database (line 66) | def test_change_database(self):
    method test_album_art (line 77) | def test_album_art(self):
    method test_auto_false (line 87) | def test_auto_false(self):
    method test_subcommand_update_database_true (line 98) | def test_subcommand_update_database_true(self):
    method test_subcommand_update_database_false (line 119) | def test_subcommand_update_database_false(self):
    method test_subcommand_query_include (line 144) | def test_subcommand_query_include(self):
    method test_subcommand_query_exclude (line 161) | def test_subcommand_query_exclude(self):
    method test_no_fields (line 178) | def test_no_fields(self):
    method test_whitelist_and_blacklist (line 195) | def test_whitelist_and_blacklist(self):
    method test_keep_fields (line 214) | def test_keep_fields(self):
    method test_keep_fields_removes_preserved_tags (line 230) | def test_keep_fields_removes_preserved_tags(self):
    method test_fields_removes_preserved_tags (line 239) | def test_fields_removes_preserved_tags(self):
    method test_omit_single_disc_with_tags_single (line 247) | def test_omit_single_disc_with_tags_single(self):
    method test_omit_single_disc_with_tags_multi (line 262) | def test_omit_single_disc_with_tags_multi(self):
    method test_omit_single_disc_only_change_single (line 277) | def test_omit_single_disc_only_change_single(self):
    method test_omit_single_disc_only_change_multi (line 288) | def test_omit_single_disc_only_change_multi(self):
    method test_empty_query_n_response_no_changes (line 299) | def test_empty_query_n_response_no_changes(self):

FILE: test/plugins/utils/test_musicbrainz.py
  function test_group_relations (line 6) | def test_group_relations():
  function test_format_search_term (line 95) | def test_format_search_term(field, term, expected):

FILE: test/plugins/utils/test_vfs.py
  class VFSTest (line 22) | class VFSTest(BeetsTestCase):
    method setUp (line 23) | def setUp(self):
    method test_singleton_item (line 33) | def test_singleton_item(self):
    method test_album_item (line 38) | def test_album_item(self):

FILE: test/rsrc/beetsplug/test.py
  class TestPlugin (line 5) | class TestPlugin(BeetsPlugin):
    method __init__ (line 6) | def __init__(self):
    method commands (line 10) | def commands(self):

FILE: test/rsrc/convert_stub.py
  function convert (line 10) | def convert(in_file, out_file, tag):

FILE: test/test_art_resize.py
  class DummyIMBackend (line 28) | class DummyIMBackend(IMBackend):
    method __init__ (line 34) | def __init__(self):
  class DummyPILBackend (line 43) | class DummyPILBackend(PILBackend):
    method __init__ (line 46) | def __init__(self):
  class ArtResizerFileSizeTest (line 51) | class ArtResizerFileSizeTest(CleanupModulesMixin, BeetsTestCase):
    method _test_img_resize (line 59) | def _test_img_resize(self, backend):
    method test_pil_file_resize (line 108) | def test_pil_file_resize(self):
    method test_im_file_resize (line 113) | def test_im_file_resize(self):
    method test_pil_file_deinterlace (line 118) | def test_pil_file_deinterlace(self):
    method test_im_file_deinterlace (line 131) | def test_im_file_deinterlace(self):
    method test_write_metadata_im (line 149) | def test_write_metadata_im(self, mock_util):

FILE: test/test_datequery.py
  class TestDateInterval (line 32) | class TestDateInterval:
    method test_intervals (line 90) | def test_intervals(self, pattern, datestr, include):
  function _parsetime (line 96) | def _parsetime(s):
  class DateQueryTest (line 100) | class DateQueryTest(ItemInDBTestCase):
    method setUp (line 101) | def setUp(self):
    method test_single_month_match_fast (line 106) | def test_single_month_match_fast(self):
    method test_single_month_nonmatch_fast (line 111) | def test_single_month_nonmatch_fast(self):
    method test_single_month_match_slow (line 116) | def test_single_month_match_slow(self):
    method test_single_month_nonmatch_slow (line 120) | def test_single_month_nonmatch_slow(self):
    method test_single_day_match_fast (line 124) | def test_single_day_match_fast(self):
    method test_single_day_nonmatch_fast (line 129) | def test_single_day_nonmatch_fast(self):
  class DateQueryTestRelative (line 135) | class DateQueryTestRelative(ItemInDBTestCase):
    method setUp (line 136) | def setUp(self):
    method test_single_month_match_fast (line 146) | def test_single_month_match_fast(self):
    method test_single_month_nonmatch_fast (line 151) | def test_single_month_nonmatch_fast(self):
    method test_single_month_match_slow (line 158) | def test_single_month_match_slow(self):
    method test_single_month_nonmatch_slow (line 162) | def test_single_month_nonmatch_slow(self):
    method test_single_day_match_fast (line 168) | def test_single_day_match_fast(self):
    method test_single_day_nonmatch_fast (line 173) | def test_single_day_nonmatch_fast(self):
  class DateQueryTestRelativeMore (line 181) | class DateQueryTestRelativeMore(ItemInDBTestCase):
    method setUp (line 182) | def setUp(self):
    method test_relative (line 187) | def test_relative(self):
    method test_relative_fail (line 193) | def test_relative_fail(self):
    method test_start_relative (line 199) | def test_start_relative(self):
    method test_start_relative_fail (line 205) | def test_start_relative_fail(self):
    method test_end_relative (line 211) | def test_end_relative(self):
    method test_end_relative_fail (line 217) | def test_end_relative_fail(self):
  class DateQueryConstructTest (line 224) | class DateQueryConstructTest(unittest.TestCase):
    method test_long_numbers (line 225) | def test_long_numbers(self):
    method test_too_many_components (line 229) | def test_too_many_components(self):
    method test_invalid_date_query (line 233) | def test_invalid_date_query(self):
    method test_datetime_uppercase_t_separator (line 248) | def test_datetime_uppercase_t_separator(self):
    method test_datetime_lowercase_t_separator (line 253) | def test_datetime_lowercase_t_separator(self):
    method test_datetime_space_separator (line 258) | def test_datetime_space_separator(self):
    method test_datetime_invalid_separator (line 263) | def test_datetime_invalid_separator(self):

FILE: test/test_dbcore.py
  function db (line 37) | def db(model):
  class SortFixture (line 43) | class SortFixture(dbcore.query.FieldSort):
  class QueryFixture (line 47) | class QueryFixture(dbcore.query.FieldQuery):
    method __init__ (line 48) | def __init__(self, pattern):
    method clause (line 51) | def clause(self):
    method match (line 54) | def match(self):
  class ModelFixture1 (line 58) | class ModelFixture1(LibModel):
    method _types (line 73) | def _types(cls):
    method _queries (line 79) | def _queries(cls):
    method _getters (line 85) | def _getters(cls):
    method _template_funcs (line 88) | def _template_funcs(self):
  class DatabaseFixture1 (line 92) | class DatabaseFixture1(dbcore.Database):
  class ModelFixture2 (line 96) | class ModelFixture2(ModelFixture1):
  class DatabaseFixture2 (line 104) | class DatabaseFixture2(dbcore.Database):
  class ModelFixture3 (line 108) | class ModelFixture3(ModelFixture1):
  class DatabaseFixture3 (line 117) | class DatabaseFixture3(dbcore.Database):
  class ModelFixture4 (line 121) | class ModelFixture4(ModelFixture1):
  class DatabaseFixture4 (line 131) | class DatabaseFixture4(dbcore.Database):
  class AnotherModelFixture (line 135) | class AnotherModelFixture(ModelFixture1):
  class ModelFixture5 (line 145) | class ModelFixture5(ModelFixture1):
  class DatabaseFixture5 (line 153) | class DatabaseFixture5(dbcore.Database):
  class DatabaseFixtureTwoModels (line 157) | class DatabaseFixtureTwoModels(dbcore.Database):
  class ModelFixtureWithGetters (line 161) | class ModelFixtureWithGetters(dbcore.Model):
    method _getters (line 163) | def _getters(cls):
    method _template_funcs (line 166) | def _template_funcs(self):
  class MigrationTest (line 171) | class MigrationTest(unittest.TestCase):
    method setUpClass (line 177) | def setUpClass(cls):
    method tearDownClass (line 192) | def tearDownClass(cls):
    method setUp (line 195) | def setUp(self):
    method tearDown (line 200) | def tearDown(self):
    method test_open_with_same_fields_leaves_untouched (line 203) | def test_open_with_same_fields_leaves_untouched(self):
    method test_open_with_new_field_adds_column (line 211) | def test_open_with_new_field_adds_column(self):
    method test_open_with_fewer_fields_leaves_untouched (line 219) | def test_open_with_fewer_fields_leaves_untouched(self):
    method test_open_with_multiple_new_fields (line 227) | def test_open_with_multiple_new_fields(self):
    method test_extra_model_adds_table (line 235) | def test_extra_model_adds_table(self):
    method test_index_creation (line 244) | def test_index_creation(self):
  class TransactionTest (line 253) | class TransactionTest(unittest.TestCase):
    method setUp (line 254) | def setUp(self):
    method tearDown (line 257) | def tearDown(self):
    method test_mutate_increase_revision (line 260) | def test_mutate_increase_revision(self):
    method test_query_no_increase_revision (line 269) | def test_query_no_increase_revision(self):
  class ModelTest (line 276) | class ModelTest(unittest.TestCase):
    method setUp (line 277) | def setUp(self):
    method tearDown (line 280) | def tearDown(self):
    method test_add_model (line 283) | def test_add_model(self):
    method test_store_fixed_field (line 289) | def test_store_fixed_field(self):
    method test_revision (line 297) | def test_revision(self):
    method test_retrieve_by_id (line 321) | def test_retrieve_by_id(self):
    method test_store_and_retrieve_flexattr (line 327) | def test_store_and_retrieve_flexattr(self):
    method test_delete_flexattr (line 336) | def test_delete_flexattr(self):
    method test_delete_flexattr_via_dot (line 343) | def test_delete_flexattr_via_dot(self):
    method test_delete_flexattr_persists (line 350) | def test_delete_flexattr_persists(self):
    method test_delete_non_existent_attribute (line 363) | def test_delete_non_existent_attribute(self):
    method test_delete_fixed_attribute (line 368) | def test_delete_fixed_attribute(self):
    method test_null_value_normalization_by_type (line 381) | def test_null_value_normalization_by_type(self):
    method test_null_value_stays_none_for_untyped_field (line 386) | def test_null_value_stays_none_for_untyped_field(self):
    method test_normalization_for_typed_flex_fields (line 391) | def test_normalization_for_typed_flex_fields(self):
    method test_load_deleted_flex_field (line 396) | def test_load_deleted_flex_field(self):
    method test_check_db_fails (line 410) | def test_check_db_fails(self):
    method test_missing_field (line 418) | def test_missing_field(self):
    method test_computed_field (line 422) | def test_computed_field(self):
    method test_items (line 428) | def test_items(self):
    method test_delete_internal_field (line 435) | def test_delete_internal_field(self):
    method test_parse_nonstring (line 441) | def test_parse_nonstring(self):
    method test_pickle_dump (line 445) | def test_pickle_dump(self):
  class FormatTest (line 460) | class FormatTest(unittest.TestCase):
    method test_format_fixed_field_integer (line 461) | def test_format_fixed_field_integer(self):
    method test_format_fixed_field_integer_normalized (line 467) | def test_format_fixed_field_integer_normalized(self):
    method test_format_fixed_field_string (line 478) | def test_format_fixed_field_string(self):
    method test_format_flex_field (line 484) | def test_format_flex_field(self):
    method test_format_flex_field_bytes (line 490) | def test_format_flex_field_bytes(self):
    method test_format_unset_field (line 497) | def test_format_unset_field(self):
    method test_format_typed_flex_field (line 502) | def test_format_typed_flex_field(self):
  class FormattedMappingTest (line 509) | class FormattedMappingTest(unittest.TestCase):
    method test_keys_equal_model_keys (line 510) | def test_keys_equal_model_keys(self):
    method test_get_unset_field (line 515) | def test_get_unset_field(self):
    method test_get_method_with_default (line 521) | def test_get_method_with_default(self):
    method test_get_method_with_specified_default (line 526) | def test_get_method_with_specified_default(self):
  class ParseTest (line 532) | class ParseTest(unittest.TestCase):
    method test_parse_fixed_field (line 533) | def test_parse_fixed_field(self):
    method test_parse_flex_field (line 538) | def test_parse_flex_field(self):
    method test_parse_untyped_field (line 543) | def test_parse_untyped_field(self):
  class QueryParseTest (line 548) | class QueryParseTest(unittest.TestCase):
    method pqp (line 549) | def pqp(self, part):
    method test_one_basic_term (line 556) | def test_one_basic_term(self):
    method test_one_keyed_term (line 561) | def test_one_keyed_term(self):
    method test_colon_at_end (line 566) | def test_colon_at_end(self):
    method test_one_basic_regexp (line 571) | def test_one_basic_regexp(self):
    method test_keyed_regexp (line 576) | def test_keyed_regexp(self):
    method test_escaped_colon (line 581) | def test_escaped_colon(self):
    method test_escaped_colon_in_regexp (line 586) | def test_escaped_colon_in_regexp(self):
    method test_single_year (line 591) | def test_single_year(self):
    method test_multiple_years (line 596) | def test_multiple_years(self):
    method test_empty_query_part (line 601) | def test_empty_query_part(self):
  class QueryFromStringsTest (line 607) | class QueryFromStringsTest(unittest.TestCase):
    method qfs (line 608) | def qfs(self, strings):
    method test_zero_parts (line 616) | def test_zero_parts(self):
    method test_two_parts (line 622) | def test_two_parts(self):
    method test_parse_fixed_type_query (line 629) | def test_parse_fixed_type_query(self):
    method test_parse_flex_type_query (line 633) | def test_parse_flex_type_query(self):
    method test_empty_query_part (line 637) | def test_empty_query_part(self):
  class SortFromStringsTest (line 642) | class SortFromStringsTest(unittest.TestCase):
    method sfs (line 643) | def sfs(self, strings):
    method test_zero_parts (line 649) | def test_zero_parts(self):
    method test_one_parts (line 654) | def test_one_parts(self):
    method test_two_parts (line 658) | def test_two_parts(self):
    method test_fixed_field_sort (line 663) | def test_fixed_field_sort(self):
    method test_flex_field_sort (line 668) | def test_flex_field_sort(self):
    method test_special_sort (line 673) | def test_special_sort(self):
  class ParseSortedQueryTest (line 678) | class ParseSortedQueryTest(unittest.TestCase):
    method psq (line 679) | def psq(self, parts):
    method test_and_query (line 685) | def test_and_query(self):
    method test_or_query (line 691) | def test_or_query(self):
    method test_no_space_before_comma_or_query (line 697) | def test_no_space_before_comma_or_query(self):
    method test_no_spaces_or_query (line 703) | def test_no_spaces_or_query(self):
    method test_trailing_comma_or_query (line 709) | def test_trailing_comma_or_query(self):
    method test_leading_comma_or_query (line 715) | def test_leading_comma_or_query(self):
    method test_only_direction (line 721) | def test_only_direction(self):
  class ResultsIteratorTest (line 728) | class ResultsIteratorTest(unittest.TestCase):
    method setUp (line 729) | def setUp(self):
    method tearDown (line 738) | def tearDown(self):
    method test_iterate_once (line 741) | def test_iterate_once(self):
    method test_iterate_twice (line 745) | def test_iterate_twice(self):
    method test_concurrent_iterators (line 750) | def test_concurrent_iterators(self):
    method test_slow_query (line 758) | def test_slow_query(self):
    method test_slow_query_negative (line 763) | def test_slow_query_negative(self):
    method test_iterate_slow_sort (line 768) | def test_iterate_slow_sort(self):
    method test_unsorted_subscript (line 775) | def test_unsorted_subscript(self):
    method test_slow_sort_subscript (line 780) | def test_slow_sort_subscript(self):
    method test_length (line 786) | def test_length(self):
    method test_out_of_range (line 790) | def test_out_of_range(self):
    method test_no_results (line 795) | def test_no_results(self):
  class TestException (line 802) | class TestException:
    method test_custom_function_error (line 810) | def test_custom_function_error(self, db: DatabaseFixture1):

FILE: test/test_files.py
  class MoveTest (line 34) | class MoveTest(BeetsTestCase):
    method setUp (line 35) | def setUp(self):
    method test_move_arrives (line 58) | def test_move_arrives(self):
    method test_move_to_custom_dir (line 62) | def test_move_to_custom_dir(self):
    method test_move_departs (line 66) | def test_move_departs(self):
    method test_move_in_lib_prunes_empty_dir (line 70) | def test_move_in_lib_prunes_empty_dir(self):
    method test_copy_arrives (line 80) | def test_copy_arrives(self):
    method test_copy_does_not_depart (line 84) | def test_copy_does_not_depart(self):
    method test_reflink_arrives (line 88) | def test_reflink_arrives(self):
    method test_reflink_does_not_depart (line 92) | def test_reflink_does_not_depart(self):
    method test_force_reflink_arrives (line 97) | def test_force_reflink_arrives(self):
    method test_force_reflink_does_not_depart (line 102) | def test_force_reflink_does_not_depart(self):
    method test_move_changes_path (line 106) | def test_move_changes_path(self):
    method test_copy_already_at_destination (line 110) | def test_copy_already_at_destination(self):
    method test_move_already_at_destination (line 116) | def test_move_already_at_destination(self):
    method test_move_file_with_colon (line 122) | def test_move_file_with_colon(self):
    method test_move_file_with_multiple_colons (line 127) | def test_move_file_with_multiple_colons(self):
    method test_move_file_with_colon_alt_separator (line 133) | def test_move_file_with_colon_alt_separator(self):
    method test_read_only_file_copied_writable (line 141) | def test_read_only_file_copied_writable(self):
    method test_move_avoids_collision_with_existing_file (line 153) | def test_move_avoids_collision_with_existing_file(self):
    method test_link_arrives (line 164) | def test_link_arrives(self):
    method test_link_does_not_depart (line 171) | def test_link_does_not_depart(self):
    method test_link_changes_path (line 176) | def test_link_changes_path(self):
    method test_hardlink_arrives (line 181) | def test_hardlink_arrives(self):
    method test_hardlink_does_not_depart (line 192) | def test_hardlink_does_not_depart(self):
    method test_hardlink_changes_path (line 197) | def test_hardlink_changes_path(self):
    method test_hardlink_from_symlink (line 202) | def test_hardlink_from_symlink(self):
  class HelperTest (line 217) | class HelperTest(unittest.TestCase):
    method test_ancestry_works_on_file (line 218) | def test_ancestry_works_on_file(self):
    method test_ancestry_works_on_dir (line 223) | def test_ancestry_works_on_dir(self):
    method test_ancestry_works_on_relative (line 228) | def test_ancestry_works_on_relative(self):
    method test_components_works_on_file (line 233) | def test_components_works_on_file(self):
    method test_components_works_on_dir (line 238) | def test_components_works_on_dir(self):
    method test_components_works_on_relative (line 243) | def test_components_works_on_relative(self):
    method test_forward_slash (line 248) | def test_forward_slash(self):
  class AlbumFileTest (line 254) | class AlbumFileTest(BeetsTestCase):
    method setUp (line 255) | def setUp(self):
    method test_albuminfo_move_changes_paths (line 272) | def test_albuminfo_move_changes_paths(self):
    method test_albuminfo_move_moves_file (line 280) | def test_albuminfo_move_moves_file(self):
    method test_albuminfo_move_copies_file (line 290) | def test_albuminfo_move_copies_file(self):
    method test_albuminfo_move_reflinks_file (line 301) | def test_albuminfo_move_reflinks_file(self):
    method test_albuminfo_move_to_custom_dir (line 311) | def test_albuminfo_move_to_custom_dir(self):
  class ArtFileTest (line 318) | class ArtFileTest(BeetsTestCase):
    method setUp (line 319) | def setUp(self):
    method test_art_deleted_when_items_deleted (line 339) | def test_art_deleted_when_items_deleted(self):
    method test_art_moves_with_album (line 344) | def test_art_moves_with_album(self):
    method test_art_moves_with_album_to_custom_dir (line 356) | def test_art_moves_with_album_to_custom_dir(self):
    method test_setart_copies_image (line 368) | def test_setart_copies_image(self):
    method test_setart_to_existing_art_works (line 383) | def test_setart_to_existing_art_works(self):
    method test_setart_to_existing_but_unset_art_works (line 400) | def test_setart_to_existing_but_unset_art_works(self):
    method test_setart_to_conflicting_file_gets_new_path (line 417) | def test_setart_to_conflicting_file_gets_new_path(self):
    method test_setart_sets_permissions (line 435) | def test_setart_sets_permissions(self):
    method test_move_last_file_moves_albumart (line 459) | def test_move_last_file_moves_albumart(self):
    method test_move_not_last_file_does_not_move_albumart (line 472) | def test_move_not_last_file_does_not_move_albumart(self):
  class RemoveTest (line 490) | class RemoveTest(BeetsTestCase):
    method setUp (line 491) | def setUp(self):
    method test_removing_last_item_prunes_empty_dir (line 503) | def test_removing_last_item_prunes_empty_dir(self):
    method test_removing_last_item_preserves_nonempty_dir (line 508) | def test_removing_last_item_preserves_nonempty_dir(self):
    method test_removing_last_item_prunes_dir_with_blacklisted_file (line 513) | def test_removing_last_item_prunes_dir_with_blacklisted_file(self):
    method test_removing_without_delete_leaves_file (line 518) | def test_removing_without_delete_leaves_file(self):
    method test_removing_last_item_preserves_library_dir (line 522) | def test_removing_last_item_preserves_library_dir(self):
    method test_removing_item_outside_of_library_deletes_nothing (line 526) | def test_removing_item_outside_of_library_deletes_nothing(self):
    method test_removing_last_item_in_album_with_albumart_prunes_dir (line 531) | def test_removing_last_item_in_album_with_albumart_prunes_dir(self):
  class FilePathTestCase (line 541) | class FilePathTestCase(BeetsTestCase):
    method setUp (line 542) | def setUp(self):
  class SoftRemoveTest (line 550) | class SoftRemoveTest(FilePathTestCase):
    method test_soft_remove_deletes_file (line 551) | def test_soft_remove_deletes_file(self):
    method test_soft_remove_silent_on_no_file (line 555) | def test_soft_remove_silent_on_no_file(self):
  class SafeMoveCopyTest (line 562) | class SafeMoveCopyTest(FilePathTestCase):
    method setUp (line 563) | def setUp(self):
    method test_successful_move (line 570) | def test_successful_move(self):
    method test_successful_copy (line 575) | def test_successful_copy(self):
    method test_successful_reflink (line 581) | def test_successful_reflink(self):
    method test_unsuccessful_move (line 586) | def test_unsuccessful_move(self):
    method test_unsuccessful_copy (line 590) | def test_unsuccessful_copy(self):
    method test_unsuccessful_reflink (line 594) | def test_unsuccessful_reflink(self):
    method test_self_move (line 598) | def test_self_move(self):
    method test_self_copy (line 602) | def test_self_copy(self):
  class PruneTest (line 607) | class PruneTest(BeetsTestCase):
    method setUp (line 608) | def setUp(self):
    method test_prune_existent_directory (line 616) | def test_prune_existent_directory(self):
    method test_prune_nonexistent_directory (line 621) | def test_prune_nonexistent_directory(self):
  class WalkTest (line 627) | class WalkTest(BeetsTestCase):
    method setUp (line 628) | def setUp(self):
    method test_sorted_files (line 638) | def test_sorted_files(self):
    method test_ignore_file (line 644) | def test_ignore_file(self):
    method test_ignore_directory (line 650) | def test_ignore_directory(self):
    method test_ignore_everything (line 655) | def test_ignore_everything(self):
  class UniquePathTest (line 661) | class UniquePathTest(BeetsTestCase):
    method setUp (line 662) | def setUp(self):
    method test_new_file_unchanged (line 672) | def test_new_file_unchanged(self):
    method test_conflicting_file_appends_1 (line 676) | def test_conflicting_file_appends_1(self):
    method test_conflicting_file_appends_higher_number (line 680) | def test_conflicting_file_appends_higher_number(self):
    method test_conflicting_file_with_number_increases_number (line 684) | def test_conflicting_file_with_number_increases_number(self):
  class MkDirAllTest (line 689) | class MkDirAllTest(BeetsTestCase):
    method test_mkdirall (line 690) | def test_mkdirall(self):

FILE: test/test_hidden.py
  class HiddenFileTest (line 28) | class HiddenFileTest(unittest.TestCase):
    method setUp (line 29) | def setUp(self):
    method test_osx_hidden (line 32) | def test_osx_hidden(self):
    method test_windows_hidden (line 49) | def test_windows_hidden(self):
    method test_other_hidden (line 68) | def test_other_hidden(self):

FILE: test/test_importer.py
  class PathsMixin (line 57) | class PathsMixin:
    method track_import_path (line 61) | def track_import_path(self) -> Path:
    method album_path (line 65) | def album_path(self) -> Path:
    method track_lib_path (line 69) | def track_lib_path(self):
  class NonAutotaggedImportTest (line 74) | class NonAutotaggedImportTest(PathsMixin, AsIsImporterMixin, ImportTestC...
    method test_album_created_with_track_artist (line 77) | def test_album_created_with_track_artist(self):
    method test_import_copy_arrives (line 84) | def test_import_copy_arrives(self):
    method test_threaded_import_copy_arrives (line 89) | def test_threaded_import_copy_arrives(self):
    method test_import_with_move_deletes_import_files (line 95) | def test_import_with_move_deletes_import_files(self):
    method test_threaded_import_move_arrives (line 106) | def test_threaded_import_move_arrives(self):
    method test_import_without_delete_retains_files (line 112) | def test_import_without_delete_retains_files(self):
    method test_import_with_delete_removes_files (line 117) | def test_import_with_delete_removes_files(self):
    method test_album_mb_albumartistids (line 123) | def test_album_mb_albumartistids(self):
    method test_import_link_arrives (line 129) | def test_import_link_arrives(self):
    method test_import_hardlink_arrives (line 137) | def test_import_hardlink_arrives(self):
    method test_import_reflink_arrives (line 147) | def test_import_reflink_arrives(self):
    method test_import_reflink_auto_arrives (line 154) | def test_import_reflink_auto_arrives(self):
  function create_archive (line 161) | def create_archive(session):
  class RmTempTest (line 172) | class RmTempTest(BeetsTestCase):
    method setUp (line 177) | def setUp(self):
    method test_rm (line 183) | def test_rm(self):
  class ImportZipTest (line 193) | class ImportZipTest(AsIsImporterMixin, ImportTestCase):
    method test_import_zip (line 194) | def test_import_zip(self):
  class ImportTarTest (line 204) | class ImportTarTest(ImportZipTest):
    method create_archive (line 205) | def create_archive(self):
  class ImportRarTest (line 218) | class ImportRarTest(ImportZipTest):
    method create_archive (line 219) | def create_archive(self):
  class Import7zTest (line 223) | class Import7zTest(ImportZipTest):
    method create_archive (line 224) | def create_archive(self):
  class ImportPasswordRarTest (line 229) | class ImportPasswordRarTest(ImportZipTest):
    method create_archive (line 230) | def create_archive(self):
  class ImportSingletonTest (line 234) | class ImportSingletonTest(AutotagImportTestCase):
    method setUp (line 239) | def setUp(self):
    method test_apply_asis_adds_only_singleton_track (line 244) | def test_apply_asis_adds_only_singleton_track(self):
    method test_apply_candidate_adds_track (line 253) | def test_apply_candidate_adds_track(self):
    method test_apply_from_scratch_removes_other_metadata (line 261) | def test_apply_from_scratch_removes_other_metadata(self):
    method test_skip_does_not_add_track (line 272) | def test_skip_does_not_add_track(self):
    method test_skip_first_add_second_asis (line 278) | def test_skip_first_add_second_asis(self):
    method test_import_single_files (line 287) | def test_import_single_files(self):
    method test_set_fields (line 306) | def test_set_fields(self):
  class ImportTest (line 346) | class ImportTest(PathsMixin, AutotagImportTestCase):
    method setUp (line 349) | def setUp(self):
    method test_asis_moves_album_and_track (line 354) | def test_asis_moves_album_and_track(self):
    method test_apply_moves_album_and_track (line 363) | def test_apply_moves_album_and_track(self):
    method test_apply_from_scratch_removes_other_metadata (line 372) | def test_apply_from_scratch_removes_other_metadata(self):
    method test_apply_from_scratch_keeps_format (line 383) | def test_apply_from_scratch_keeps_format(self):
    method test_apply_from_scratch_keeps_bitrate (line 390) | def test_apply_from_scratch_keeps_bitrate(self):
    method test_apply_with_move_deletes_import (line 398) | def test_apply_with_move_deletes_import(self):
    method test_apply_with_delete_deletes_import (line 407) | def test_apply_with_delete_deletes_import(self):
    method test_skip_does_not_add_track (line 416) | def test_skip_does_not_add_track(self):
    method test_skip_non_album_dirs (line 422) | def test_skip_non_album_dirs(self):
    method test_unmatched_tracks_not_added (line 430) | def test_unmatched_tracks_not_added(self):
    method test_empty_directory_warning (line 437) | def test_empty_directory_warning(self):
    method test_empty_directory_singleton_warning (line 447) | def test_empty_directory_singleton_warning(self):
    method test_asis_no_data_source (line 457) | def test_asis_no_data_source(self):
    method test_set_fields (line 466) | def test_set_fields(self):
  class ImportTracksTest (line 520) | class ImportTracksTest(AutotagImportTestCase):
    method setUp (line 523) | def setUp(self):
    method test_apply_tracks_adds_singleton_track (line 528) | def test_apply_tracks_adds_singleton_track(self):
    method test_apply_tracks_adds_singleton_path (line 537) | def test_apply_tracks_adds_singleton_path(self):
  class ImportCompilationTest (line 546) | class ImportCompilationTest(AutotagImportTestCase):
    method setUp (line 549) | def setUp(self):
    method test_asis_homogenous_sets_albumartist (line 554) | def test_asis_homogenous_sets_albumartist(self):
    method test_asis_heterogenous_sets_various_albumartist (line 561) | def test_asis_heterogenous_sets_various_albumartist(self):
    method test_asis_heterogenous_sets_compilation (line 573) | def test_asis_heterogenous_sets_compilation(self):
    method test_asis_sets_majority_albumartist (line 584) | def test_asis_sets_majority_albumartist(self):
    method test_asis_albumartist_tag_sets_albumartist (line 596) | def test_asis_albumartist_tag_sets_albumartist(self):
    method test_asis_albumartists_tag_sets_multi_albumartists (line 612) | def test_asis_albumartists_tag_sets_multi_albumartists(self):
  class ImportExistingTest (line 651) | class ImportExistingTest(PathsMixin, AutotagImportTestCase):
    method setUp (line 654) | def setUp(self):
    method tearDown (line 661) | def tearDown(self):
    method applied_track_path (line 666) | def applied_track_path(self) -> Path:
    method test_does_not_duplicate_item_nor_album (line 669) | def test_does_not_duplicate_item_nor_album(self):
    method test_does_not_duplicate_singleton_track (line 680) | def test_does_not_duplicate_singleton_track(self):
    method test_asis_updates_metadata_and_moves_file (line 691) | def test_asis_updates_metadata_and_moves_file(self):
    method test_asis_updated_without_copy_does_not_move_file (line 705) | def test_asis_updated_without_copy_does_not_move_file(self):
    method test_outside_file_is_copied (line 718) | def test_outside_file_is_copied(self):
  class GroupAlbumsImportTest (line 731) | class GroupAlbumsImportTest(AutotagImportTestCase):
    method setUp (line 734) | def setUp(self):
    method test_add_album_for_different_artist_and_different_album (line 744) | def test_add_album_for_different_artist_and_different_album(self):
    method test_add_album_for_different_artist_and_same_albumartist (line 753) | def test_add_album_for_different_artist_and_same_albumartist(self):
    method test_add_album_for_same_artist_and_different_album (line 765) | def test_add_album_for_same_artist_and_different_album(self):
    method test_add_album_for_same_album_and_different_artist (line 773) | def test_add_album_for_same_album_and_different_artist(self):
    method test_incremental (line 781) | def test_incremental(self):
  class GlobalGroupAlbumsImportTest (line 791) | class GlobalGroupAlbumsImportTest(GroupAlbumsImportTest):
    method setUp (line 792) | def setUp(self):
  class ChooseCandidateTest (line 799) | class ChooseCandidateTest(AutotagImportTestCase):
    method setUp (line 802) | def setUp(self):
    method test_choose_first_candidate (line 807) | def test_choose_first_candidate(self):
    method test_choose_second_candidate (line 812) | def test_choose_second_candidate(self):
  class InferAlbumDataTest (line 818) | class InferAlbumDataTest(unittest.TestCase):
    method setUp (line 819) | def setUp(self):
    method test_asis_homogenous_single_artist (line 837) | def test_asis_homogenous_single_artist(self):
    method test_asis_heterogenous_va (line 843) | def test_asis_heterogenous_va(self):
    method test_asis_comp_applied_to_all_items (line 853) | def test_asis_comp_applied_to_all_items(self):
    method test_asis_majority_artist_single_artist (line 864) | def test_asis_majority_artist_single_artist(self):
    method test_asis_track_albumartist_override (line 873) | def test_asis_track_albumartist_override(self):
    method test_apply_gets_artist_and_id (line 886) | def test_apply_gets_artist_and_id(self):
    method test_apply_lets_album_values_override (line 894) | def test_apply_lets_album_values_override(self):
    method test_small_single_artist_album (line 905) | def test_small_single_artist_album(self):
  function album_candidates_mock (line 913) | def album_candidates_mock(*args, **kwargs):
  class ImportDuplicateAlbumTest (line 928) | class ImportDuplicateAlbumTest(PluginMixin, ImportTestCase):
    method setUp (line 931) | def setUp(self):
    method test_remove_duplicate_album (line 943) | def test_remove_duplicate_album(self):
    method test_no_autotag_removes_duplicate_album (line 957) | def test_no_autotag_removes_duplicate_album(self):
    method test_keep_duplicate_album (line 986) | def test_keep_duplicate_album(self):
    method test_skip_duplicate_album (line 993) | def test_skip_duplicate_album(self):
    method test_merge_duplicate_album (line 1005) | def test_merge_duplicate_album(self):
    method test_twice_in_import_dir (line 1011) | def test_twice_in_import_dir(self):
    method test_keep_when_extra_key_is_different (line 1014) | def test_keep_when_extra_key_is_different(self):
    method add_album_fixture (line 1033) | def add_album_fixture(self, **kwargs):
  function item_candidates_mock (line 1041) | def item_candidates_mock(*args, **kwargs):
  class ImportDuplicateSingletonTest (line 1054) | class ImportDuplicateSingletonTest(ImportTestCase):
    method setUp (line 1055) | def setUp(self):
    method test_remove_duplicate (line 1069) | def test_remove_duplicate(self):
    method test_keep_duplicate (line 1082) | def test_keep_duplicate(self):
    method test_skip_duplicate (line 1090) | def test_skip_duplicate(self):
    method test_keep_when_extra_key_is_different (line 1101) | def test_keep_when_extra_key_is_different(self):
    method test_no_autotag_removes_duplicate_singleton (line 1113) | def test_no_autotag_removes_duplicate_singleton(self):
    method test_twice_in_import_dir (line 1139) | def test_twice_in_import_dir(self):
    method add_item_fixture (line 1142) | def add_item_fixture(self, **kwargs):
  class TagLogTest (line 1150) | class TagLogTest(unittest.TestCase):
    method test_tag_log_line (line 1151) | def test_tag_log_line(self):
    method test_tag_log_unicode (line 1158) | def test_tag_log_unicode(self):
  class ResumeImportTest (line 1166) | class ResumeImportTest(ImportTestCase):
    method test_resume_album (line 1168) | def test_resume_album(self, plugins_send):
    method test_resume_singleton (line 1189) | def test_resume_singleton(self, plugins_send):
  class IncrementalImportTest (line 1212) | class IncrementalImportTest(AsIsImporterMixin, ImportTestCase):
    method test_incremental_album (line 1213) | def test_incremental_album(self):
    method test_incremental_item (line 1225) | def test_incremental_item(self):
    method test_invalid_state_file (line 1237) | def test_invalid_state_file(self):
  function _mkmp3 (line 1244) | def _mkmp3(path):
  class AlbumsInDirTest (line 1251) | class AlbumsInDirTest(BeetsTestCase):
    method setUp (line 1252) | def setUp(self):
    method test_finds_all_albums (line 1271) | def test_finds_all_albums(self):
    method test_separates_contents (line 1275) | def test_separates_contents(self):
    method test_finds_multiple_songs (line 1284) | def test_finds_multiple_songs(self):
  class MultiDiscAlbumsInDirTest (line 1293) | class MultiDiscAlbumsInDirTest(BeetsTestCase):
    method create_music (line 1294) | def create_music(self, files=True, ascii=True):
    method _normalize_path (line 1354) | def _normalize_path(self, path):
    method test_coalesce_nested_album_multiple_subdirs (line 1363) | def test_coalesce_nested_album_multiple_subdirs(self):
    method test_coalesce_nested_album_single_subdir (line 1371) | def test_coalesce_nested_album_single_subdir(self):
    method test_coalesce_flattened_album_case_typo (line 1378) | def test_coalesce_flattened_album_case_typo(self):
    method test_single_disc_album (line 1385) | def test_single_disc_album(self):
    method test_do_not_yield_empty_album (line 1392) | def test_do_not_yield_empty_album(self):
    method test_single_disc_unicode (line 1397) | def test_single_disc_unicode(self):
    method test_coalesce_multiple_unicode (line 1404) | def test_coalesce_multiple_unicode(self):
  class ReimportTest (line 1413) | class ReimportTest(AutotagImportTestCase):
    method setUp (line 1424) | def setUp(self):
    method _setup_session (line 1438) | def _setup_session(self, singletons=False):
    method _album (line 1442) | def _album(self):
    method _item (line 1445) | def _item(self):
    method test_reimported_album_gets_new_metadata (line 1448) | def test_reimported_album_gets_new_metadata(self):
    method test_reimported_album_preserves_flexattr (line 1454) | def test_reimported_album_preserves_flexattr(self):
    method test_reimported_album_preserves_added (line 1459) | def test_reimported_album_preserves_added(self):
    method test_reimported_album_preserves_item_flexattr (line 1464) | def test_reimported_album_preserves_item_flexattr(self):
    method test_reimported_album_preserves_item_added (line 1469) | def test_reimported_album_preserves_item_added(self):
    method test_reimported_item_gets_new_metadata (line 1474) | def test_reimported_item_gets_new_metadata(self):
    method test_reimported_item_preserves_flexattr (line 1480) | def test_reimported_item_preserves_flexattr(self):
    method test_reimported_item_preserves_added (line 1485) | def test_reimported_item_preserves_added(self):
    method test_reimported_item_preserves_art (line 1490) | def test_reimported_item_preserves_art(self):
    method test_reimported_album_has_new_flexattr (line 1505) | def test_reimported_album_has_new_flexattr(self):
    method test_reimported_album_not_preserves_flexattr (line 1511) | def test_reimported_album_not_preserves_flexattr(self):
  class ImportPretendTest (line 1518) | class ImportPretendTest(IOMixin, AutotagImportTestCase):
    method setUp (line 1521) | def setUp(self):
    method __run (line 1527) | def __run(self, importer):
    method test_import_singletons_pretend (line 1537) | def test_import_singletons_pretend(self):
    method test_import_album_pretend (line 1543) | def test_import_album_pretend(self):
    method test_import_pretend_empty (line 1551) | def test_import_pretend_empty(self):
  function mocked_get_albums_by_ids (line 1560) | def mocked_get_albums_by_ids(ids):
  function mocked_get_tracks_by_ids (line 1595) | def mocked_get_tracks_by_ids(ids):
  class ImportIdTest (line 1627) | class ImportIdTest(ImportTestCase):
    method setUp (line 1633) | def setUp(self):
    method test_one_mbid_one_album (line 1637) | def test_one_mbid_one_album(self):
    method test_several_mbid_one_album (line 1644) | def test_several_mbid_one_album(self):
    method test_one_mbid_one_singleton (line 1652) | def test_one_mbid_one_singleton(self):
    method test_several_mbid_one_singleton (line 1659) | def test_several_mbid_one_singleton(self):
    method test_candidates_album (line 1669) | def test_candidates_album(self):
    method test_candidates_singleton (line 1681) | def test_candidates_singleton(self):

FILE: test/test_library.py
  class LoadTest (line 43) | class LoadTest(ItemInDBTestCase):
    method test_load_restores_data_from_db (line 44) | def test_load_restores_data_from_db(self):
    method test_load_clears_dirty_flags (line 50) | def test_load_clears_dirty_flags(self):
  class StoreTest (line 57) | class StoreTest(ItemInDBTestCase):
    method test_store_changes_database_value (line 58) | def test_store_changes_database_value(self):
    method test_store_only_writes_dirty_fields (line 65) | def test_store_only_writes_dirty_fields(self):
    method test_store_clears_dirty_flags (line 72) | def test_store_clears_dirty_flags(self):
    method test_store_album_cascades_flex_deletes (line 77) | def test_store_album_cascades_flex_deletes(self):
  class AddTest (line 90) | class AddTest(BeetsTestCase):
    method setUp (line 91) | def setUp(self):
    method test_item_add_inserts_row (line 95) | def test_item_add_inserts_row(self):
    method test_library_add_path_inserts_row (line 107) | def test_library_add_path_inserts_row(self):
    method test_library_add_one_database_change_event (line 122) | def test_library_add_one_database_change_event(self):
  class RemoveTest (line 142) | class RemoveTest(ItemInDBTestCase):
    method test_remove_deletes_from_db (line 143) | def test_remove_deletes_from_db(self):
  class GetSetTest (line 149) | class GetSetTest(BeetsTestCase):
    method setUp (line 150) | def setUp(self):
    method test_set_changes_value (line 154) | def test_set_changes_value(self):
    method test_set_sets_dirty_flag (line 158) | def test_set_sets_dirty_flag(self):
    method test_set_does_not_dirty_if_value_unchanged (line 162) | def test_set_does_not_dirty_if_value_unchanged(self):
    method test_invalid_field_raises_attributeerror (line 166) | def test_invalid_field_raises_attributeerror(self):
    method test_album_fallback (line 170) | def test_album_fallback(self):
  class DestinationTest (line 185) | class DestinationTest(BeetsTestCase):
    method create_temp_dir (line 188) | def create_temp_dir(self, **kwargs):
    method setUp (line 192) | def setUp(self):
    method test_directory_works_with_trailing_slash (line 196) | def test_directory_works_with_trailing_slash(self):
    method test_directory_works_without_trailing_slash (line 201) | def test_directory_works_without_trailing_slash(self):
    method test_destination_substitutes_metadata_values (line 206) | def test_destination_substitutes_metadata_values(self):
    method test_destination_preserves_extension (line 214) | def test_destination_preserves_extension(self):
    method test_lower_case_extension (line 220) | def test_lower_case_extension(self):
    method test_destination_pads_some_indices (line 226) | def test_destination_pads_some_indices(self):
    method test_destination_pads_date_values (line 238) | def test_destination_pads_date_values(self):
    method test_destination_escapes_slashes (line 246) | def test_destination_escapes_slashes(self):
    method test_destination_escapes_leading_dot (line 253) | def test_destination_escapes_leading_dot(self):
    method test_destination_preserves_legitimate_slashes (line 259) | def test_destination_preserves_legitimate_slashes(self):
    method test_destination_long_names_truncated (line 265) | def test_destination_long_names_truncated(self):
    method test_destination_long_names_keep_extension (line 271) | def test_destination_long_names_keep_extension(self):
    method test_distination_windows_removes_both_separators (line 277) | def test_distination_windows_removes_both_separators(self):
    method test_path_with_format (line 286) | def test_path_with_format(self):
    method test_heterogeneous_album_gets_single_directory (line 291) | def test_heterogeneous_album_gets_single_directory(self):
    method test_default_path_for_non_compilations (line 299) | def test_default_path_for_non_compilations(self):
    method test_singleton_path (line 306) | def test_singleton_path(self):
    method test_comp_before_singleton_path (line 316) | def test_comp_before_singleton_path(self):
    method test_comp_path (line 327) | def test_comp_path(self):
    method test_albumtype_query_path (line 334) | def test_albumtype_query_path(self):
    method test_albumtype_path_fallback_to_comp (line 346) | def test_albumtype_path_fallback_to_comp(self):
    method test_get_formatted_does_not_replace_separators (line 358) | def test_get_formatted_does_not_replace_separators(self):
    method test_get_formatted_pads_with_zero (line 365) | def test_get_formatted_pads_with_zero(self):
    method test_get_formatted_uses_kbps_bitrate (line 371) | def test_get_formatted_uses_kbps_bitrate(self):
    method test_get_formatted_uses_khz_samplerate (line 377) | def test_get_formatted_uses_khz_samplerate(self):
    method test_get_formatted_datetime (line 383) | def test_get_formatted_datetime(self):
    method test_get_formatted_none (line 389) | def test_get_formatted_none(self):
    method test_artist_falls_back_to_albumartist (line 395) | def test_artist_falls_back_to_albumartist(self):
    method test_albumartist_falls_back_to_artist (line 402) | def test_albumartist_falls_back_to_artist(self):
    method test_artist_overrides_albumartist (line 409) | def test_artist_overrides_albumartist(self):
    method test_albumartist_overrides_artist (line 416) | def test_albumartist_overrides_artist(self):
    method test_unicode_normalized_nfd_on_mac (line 423) | def test_unicode_normalized_nfd_on_mac(self):
    method test_unicode_normalized_nfc_on_linux (line 430) | def test_unicode_normalized_nfc_on_linux(self):
    method test_unicode_extension_in_fragment (line 437) | def test_unicode_extension_in_fragment(self):
    method test_asciify_and_replace (line 444) | def test_asciify_and_replace(self):
    method test_asciify_character_expanding_to_slash (line 452) | def test_asciify_character_expanding_to_slash(self):
    method test_destination_with_replacements (line 459) | def test_destination_with_replacements(self):
    method test_destination_with_empty_component (line 468) | def test_destination_with_empty_component(self):
    method test_destination_with_empty_final_component (line 479) | def test_destination_with_empty_final_component(self):
    method test_album_field_query (line 488) | def test_album_field_query(self):
    method test_album_field_in_template (line 497) | def test_album_field_in_template(self):
  class ItemFormattedMappingTest (line 506) | class ItemFormattedMappingTest(ItemInDBTestCase):
    method test_formatted_item_value (line 507) | def test_formatted_item_value(self):
    method test_get_unset_field (line 511) | def test_get_unset_field(self):
    method test_get_method_with_default (line 516) | def test_get_method_with_default(self):
    method test_get_method_with_specified_default (line 520) | def test_get_method_with_specified_default(self):
    method test_item_precedence (line 524) | def test_item_precedence(self):
    method test_album_flex_field (line 530) | def test_album_flex_field(self):
    method test_album_field_overrides_item_field_for_path (line 536) | def test_album_field_overrides_item_field_for_path(self):
    method test_artist_falls_back_to_albumartist (line 548) | def test_artist_falls_back_to_albumartist(self):
    method test_albumartist_falls_back_to_artist (line 553) | def test_albumartist_falls_back_to_artist(self):
    method test_both_artist_and_albumartist_empty (line 558) | def test_both_artist_and_albumartist_empty(self):
  class PathFormattingMixin (line 565) | class PathFormattingMixin:
    method _setf (line 571) | def _setf(self, fmt):
    method _assert_dest (line 574) | def _assert_dest(self, dest, i=None):
  class DestinationFunctionTest (line 590) | class DestinationFunctionTest(BeetsTestCase, PathFormattingMixin):
    method setUp (line 591) | def setUp(self):
    method test_upper_case_literal (line 597) | def test_upper_case_literal(self):
    method test_upper_case_variable (line 601) | def test_upper_case_variable(self):
    method test_capitalize_variable (line 605) | def test_capitalize_variable(self):
    method test_title_case_variable (line 609) | def test_title_case_variable(self):
    method test_title_case_variable_aphostrophe (line 613) | def test_title_case_variable_aphostrophe(self):
    method test_asciify_variable (line 617) | def test_asciify_variable(self):
    method test_left_variable (line 621) | def test_left_variable(self):
    method test_right_variable (line 625) | def test_right_variable(self):
    method test_if_false (line 629) | def test_if_false(self):
    method test_if_false_value (line 633) | def test_if_false_value(self):
    method test_if_true (line 637) | def test_if_true(self):
    method test_if_else_false (line 641) | def test_if_else_false(self):
    method test_if_else_false_value (line 645) | def test_if_else_false_value(self):
    method test_if_int_value (line 649) | def test_if_int_value(self):
    method test_nonexistent_function (line 653) | def test_nonexistent_function(self):
    method test_if_def_field_return_self (line 657) | def test_if_def_field_return_self(self):
    method test_if_def_field_not_defined (line 662) | def test_if_def_field_not_defined(self):
    method test_if_def_field_not_defined_2 (line 666) | def test_if_def_field_not_defined_2(self):
    method test_if_def_true (line 670) | def test_if_def_true(self):
    method test_if_def_true_complete (line 674) | def test_if_def_true_complete(self):
    method test_if_def_false_complete (line 679) | def test_if_def_false_complete(self):
    method test_first (line 683) | def test_first(self):
    method test_first_skip (line 688) | def test_first_skip(self):
    method test_first_different_sep (line 693) | def test_first_different_sep(self):
  class DisambiguationTest (line 698) | class DisambiguationTest(BeetsTestCase, PathFormattingMixin):
    method setUp (line 699) | def setUp(self):
    method test_unique_expands_to_disambiguating_year (line 714) | def test_unique_expands_to_disambiguating_year(self):
    method test_unique_with_default_arguments_uses_albumtype (line 717) | def test_unique_with_default_arguments_uses_albumtype(self):
    method test_unique_expands_to_nothing_for_distinct_albums (line 724) | def test_unique_expands_to_nothing_for_distinct_albums(self):
    method test_use_fallback_numbers_when_identical (line 731) | def test_use_fallback_numbers_when_identical(self):
    method test_unique_falls_back_to_second_distinguishing_field (line 739) | def test_unique_falls_back_to_second_distinguishing_field(self):
    method test_unique_sanitized (line 743) | def test_unique_sanitized(self):
    method test_drop_empty_disambig_string (line 753) | def test_drop_empty_disambig_string(self):
    method test_change_brackets (line 763) | def test_change_brackets(self):
    method test_remove_brackets (line 767) | def test_remove_brackets(self):
    method test_key_flexible_attribute (line 771) | def test_key_flexible_attribute(self):
  class SingletonDisambiguationTest (line 782) | class SingletonDisambiguationTest(BeetsTestCase, PathFormattingMixin):
    method setUp (line 783) | def setUp(self):
    method test_sunique_expands_to_disambiguating_year (line 798) | def test_sunique_expands_to_disambiguating_year(self):
    method test_sunique_with_default_arguments_uses_trackdisambig (line 801) | def test_sunique_with_default_arguments_uses_trackdisambig(self):
    method test_sunique_expands_to_nothing_for_distinct_singletons (line 808) | def test_sunique_expands_to_nothing_for_distinct_singletons(self):
    method test_sunique_does_not_match_album (line 814) | def test_sunique_does_not_match_album(self):
    method test_sunique_use_fallback_numbers_when_identical (line 818) | def test_sunique_use_fallback_numbers_when_identical(self):
    method test_sunique_falls_back_to_second_distinguishing_field (line 825) | def test_sunique_falls_back_to_second_distinguishing_field(self):
    method test_sunique_sanitized (line 829) | def test_sunique_sanitized(self):
    method test_drop_empty_disambig_string (line 837) | def test_drop_empty_disambig_string(self):
    method test_change_brackets (line 845) | def test_change_brackets(self):
    method test_remove_brackets (line 849) | def test_remove_brackets(self):
    method test_key_flexible_attribute (line 853) | def test_key_flexible_attribute(self):
  class PluginDestinationTest (line 862) | class PluginDestinationTest(BeetsTestCase):
    method setUp (line 863) | def setUp(self):
    method tearDown (line 882) | def tearDown(self):
    method _assert_dest (line 886) | def _assert_dest(self, dest):
    method test_undefined_value_not_substituted (line 891) | def test_undefined_value_not_substituted(self):
    method test_plugin_value_not_substituted (line 894) | def test_plugin_value_not_substituted(self):
    method test_plugin_value_overrides_attribute (line 900) | def test_plugin_value_overrides_attribute(self):
    method test_plugin_value_sanitized (line 906) | def test_plugin_value_sanitized(self):
  class AlbumInfoTest (line 913) | class AlbumInfoTest(BeetsTestCase):
    method setUp (line 914) | def setUp(self):
    method test_albuminfo_reflects_metadata (line 919) | def test_albuminfo_reflects_metadata(self):
    method test_albuminfo_stores_art (line 926) | def test_albuminfo_stores_art(self):
    method test_albuminfo_for_two_items_doesnt_duplicate_row (line 933) | def test_albuminfo_for_two_items_doesnt_duplicate_row(self):
    method test_individual_tracks_have_no_albuminfo (line 944) | def test_individual_tracks_have_no_albuminfo(self):
    method test_get_album_by_id (line 951) | def test_get_album_by_id(self):
    method test_album_items_consistent (line 956) | def test_album_items_consistent(self):
    method test_albuminfo_changes_affect_items (line 964) | def test_albuminfo_changes_affect_items(self):
    method test_albuminfo_change_albumartist_changes_items (line 971) | def test_albuminfo_change_albumartist_changes_items(self):
    method test_albuminfo_change_artist_does_change_items (line 979) | def test_albuminfo_change_artist_does_change_items(self):
    method test_albuminfo_change_artist_does_not_change_items (line 986) | def test_albuminfo_change_artist_does_not_change_items(self):
    method test_albuminfo_remove_removes_items (line 993) | def test_albuminfo_remove_removes_items(self):
    method test_removing_last_item_removes_album (line 1001) | def test_removing_last_item_removes_album(self):
    method test_noop_albuminfo_changes_affect_items (line 1006) | def test_noop_albuminfo_changes_affect_items(self):
  class ArtDestinationTest (line 1017) | class ArtDestinationTest(BeetsTestCase):
    method setUp (line 1018) | def setUp(self):
    method test_art_filename_respects_setting (line 1027) | def test_art_filename_respects_setting(self):
    method test_art_path_in_item_dir (line 1032) | def test_art_path_in_item_dir(self):
    method test_art_path_sanitized (line 1037) | def test_art_path_sanitized(self):
  class PathStringTest (line 1043) | class PathStringTest(BeetsTestCase):
    method setUp (line 1044) | def setUp(self):
    method test_item_path_is_bytestring (line 1048) | def test_item_path_is_bytestring(self):
    method test_fetched_item_path_is_bytestring (line 1051) | def test_fetched_item_path_is_bytestring(self):
    method test_unicode_path_becomes_bytestring (line 1055) | def test_unicode_path_becomes_bytestring(self):
    method test_unicode_in_database_becomes_bytestring (line 1059) | def test_unicode_in_database_becomes_bytestring(self):
    method test_special_chars_preserved_in_database (line 1069) | def test_special_chars_preserved_in_database(self):
    method test_special_char_path_added_to_database (line 1076) | def test_special_char_path_added_to_database(self):
    method test_destination_returns_bytestring (line 1085) | def test_destination_returns_bytestring(self):
    method test_art_destination_returns_bytestring (line 1090) | def test_art_destination_returns_bytestring(self):
    method test_artpath_stores_special_chars (line 1096) | def test_artpath_stores_special_chars(self):
    method test_sanitize_path_with_special_chars (line 1104) | def test_sanitize_path_with_special_chars(self):
    method test_sanitize_path_returns_unicode (line 1109) | def test_sanitize_path_returns_unicode(self):
    method test_unicode_artpath_becomes_bytestring (line 1114) | def test_unicode_artpath_becomes_bytestring(self):
    method test_unicode_artpath_in_database_decoded (line 1119) | def test_unicode_artpath_in_database_decoded(self):
  class MtimeTest (line 1128) | class MtimeTest(BeetsTestCase):
    method setUp (line 1129) | def setUp(self):
    method tearDown (line 1139) | def tearDown(self):
    method _mtime (line 1144) | def _mtime(self):
    method test_mtime_initially_up_to_date (line 1147) | def test_mtime_initially_up_to_date(self):
    method test_mtime_reset_on_db_modify (line 1150) | def test_mtime_reset_on_db_modify(self):
    method test_mtime_up_to_date_after_write (line 1154) | def test_mtime_up_to_date_after_write(self):
    method test_mtime_up_to_date_after_read (line 1159) | def test_mtime_up_to_date_after_read(self):
  class ImportTimeTest (line 1165) | class ImportTimeTest(BeetsTestCase):
    method added (line 1166) | def added(self):
    method test_atime_for_singleton (line 1172) | def test_atime_for_singleton(self):
  class TemplateTest (line 1177) | class TemplateTest(ItemInDBTestCase):
    method test_year_formatted_in_template (line 1178) | def test_year_formatted_in_template(self):
    method test_album_flexattr_appears_in_item_template (line 1183) | def test_album_flexattr_appears_in_item_template(self):
    method test_album_and_item_format (line 1189) | def test_album_and_item_format(self):
  class UnicodePathTest (line 1207) | class UnicodePathTest(ItemInDBTestCase):
    method test_unicode_path (line 1208) | def test_unicode_path(self):
  class WriteTest (line 1216) | class WriteTest(BeetsTestCase):
    method test_write_nonexistant (line 1217) | def test_write_nonexistant(self):
    method test_no_write_permission (line 1223) | def test_no_write_permission(self):
    method test_write_with_custom_path (line 1236) | def test_write_with_custom_path(self):
    method test_write_custom_tags (line 1249) | def test_write_custom_tags(self):
    method test_write_multi_tags (line 1255) | def test_write_multi_tags(self):
    method test_write_multi_tags_id3v23 (line 1264) | def test_write_multi_tags_id3v23(self):
    method test_write_date_field (line 1274) | def test_write_date_field(self):
  class ItemReadTest (line 1283) | class ItemReadTest(unittest.TestCase):
    method test_unreadable_raise_read_error (line 1284) | def test_unreadable_raise_read_error(self):
    method test_nonexistent_raise_read_error (line 1291) | def test_nonexistent_raise_read_error(self):
  class FilesizeTest (line 1297) | class FilesizeTest(BeetsTestCase):
    method test_filesize (line 1298) | def test_filesize(self):
    method test_nonexistent_file (line 1302) | def test_nonexistent_file(self):
  class ParseQueryTest (line 1307) | class ParseQueryTest(unittest.TestCase):
    method test_parse_invalid_query_string (line 1308) | def test_parse_invalid_query_string(self):
    method test_parse_bytes (line 1312) | def test_parse_bytes(self):

FILE: test/test_logging.py
  class TestStrFormatLogger (line 17) | class TestStrFormatLogger:
    method test_logger_creation (line 20) | def test_logger_creation(self):
    method test_str_format_logging (line 57) | def test_str_format_logging(
  class TestLogSanitization (line 70) | class TestLogSanitization:
    method test_sanitization (line 110) | def test_sanitization(self, msg, args, kwargs, expected, caplog):
  class DummyModule (line 122) | class DummyModule(ModuleType):
    class DummyPlugin (line 123) | class DummyPlugin(plugins.BeetsPlugin):
      method __init__ (line 124) | def __init__(self):
      method log_all (line 129) | def log_all(self, name):
      method commands (line 134) | def commands(self):
      method import_stage (line 139) | def import_stage(self, session, task):
      method listener (line 142) | def listener(self):
    method __init__ (line 145) | def __init__(self, *_, **__):
  class LoggingLevelTest (line 152) | class LoggingLevelTest(AsIsImporterMixin, PluginMixin, ImportTestCase):
    method setUpClass (line 156) | def setUpClass(cls):
    method test_command_level0 (line 163) | def test_command_level0(self):
    method test_command_level1 (line 171) | def test_command_level1(self):
    method test_command_level2 (line 179) | def test_command_level2(self):
    method test_listener_level0 (line 187) | def test_listener_level0(self):
    method test_listener_level1 (line 195) | def test_listener_level1(self):
    method test_listener_level2 (line 203) | def test_listener_level2(self):
    method test_import_stage_level0 (line 211) | def test_import_stage_level0(self):
    method test_import_stage_level1 (line 219) | def test_import_stage_level1(self):
    method test_import_stage_level2 (line 227) | def test_import_stage_level2(self):
  class ConcurrentEventsTest (line 237) | class ConcurrentEventsTest(AsIsImporterMixin, ImportTestCase):
    class DummyPlugin (line 245) | class DummyPlugin(plugins.BeetsPlugin):
      method __init__ (line 246) | def __init__(self, test_case):
      method log_all (line 256) | def log_all(self, name):
      method listener1 (line 261) | def listener1(self):
      method listener2 (line 271) | def listener2(self):
    method test_concurrent_events (line 281) | def test_concurrent_events(self):
    method test_root_logger_levels (line 334) | def test_root_logger_levels(self):

FILE: test/test_m3ufile.py
  class M3UFileTest (line 29) | class M3UFileTest(unittest.TestCase):
    method test_playlist_write_empty (line 32) | def test_playlist_write_empty(self):
    method test_playlist_write (line 41) | def test_playlist_write(self):
    method test_playlist_write_unicode (line 56) | def test_playlist_write_unicode(self):
    method test_playlist_write_and_read_unicode_windows (line 72) | def test_playlist_write_and_read_unicode_windows(self):
    method test_playlist_load_ascii (line 100) | def test_playlist_load_ascii(self):
    method test_playlist_load_unicode (line 110) | def test_playlist_load_unicode(self):
    method test_playlist_load_unicode_windows (line 120) | def test_playlist_load_unicode_windows(self):
    method test_playlist_load_extm3u (line 130) | def test_playlist_load_extm3u(self):
    method test_playlist_load_non_extm3u (line 137) | def test_playlist_load_non_extm3u(self):

FILE: test/test_metadata_plugins.py
  class ErrorMetadataMockPlugin (line 9) | class ErrorMetadataMockPlugin(metadata_plugins.MetadataSourcePlugin):
    method candidates (line 12) | def candidates(self, *args, **kwargs):
    method item_candidates (line 15) | def item_candidates(self, *args, **kwargs):
    method album_for_id (line 20) | def album_for_id(self, *args, **kwargs):
    method track_for_id (line 23) | def track_for_id(self, *args, **kwargs):
  class TestMetadataPluginsException (line 27) | class TestMetadataPluginsException(PluginMixin):
    method setup (line 33) | def setup(self):
    method call_method (line 41) | def call_method(self, method_name, args):
    method test_logging (line 59) | def test_logging(self, caplog, call_method, method_name):
    method test_raising (line 80) | def test_raising(self, call_method):
  class TestSearchApiMetadataSourcePlugin (line 87) | class TestSearchApiMetadataSourcePlugin(PluginMixin):
    class RaisingSearchApiMetadataMockPlugin (line 91) | class RaisingSearchApiMetadataMockPlugin(
      method get_search_query_with_filters (line 96) | def get_search_query_with_filters(self, _):
      method get_search_response (line 99) | def get_search_response(self, _):
      method album_for_id (line 102) | def album_for_id(self, _):
      method track_for_id (line 105) | def track_for_id(self, _):
    method search_plugin (line 109) | def search_plugin(self):
    method test_search_api_returns_empty_when_raise_on_error_disabled (line 112) | def test_search_api_returns_empty_when_raise_on_error_disabled(
    method test_search_api_raises_when_raise_on_error_enabled (line 120) | def test_search_api_raises_when_raise_on_error_enabled(

FILE: test/test_metasync.py
  function _parsetime (line 26) | def _parsetime(s):
  function _is_windows (line 30) | def _is_windows():
  class MetaSyncTest (line 34) | class MetaSyncTest(IOMixin, PluginTestCase):
    method setUp (line 41) | def setUp(self):
    method _set_up_data (line 57) | def _set_up_data(self):
    method test_load_item_types (line 85) | def test_load_item_types(self):
    method test_pretend_sync_from_itunes (line 90) | def test_pretend_sync_from_itunes(self):
    method test_sync_from_itunes (line 102) | def test_sync_from_itunes(self):

FILE: test/test_pipeline.py
  function _produce (line 25) | def _produce(num=5):
  function _work (line 29) | def _work():
  function _consume (line 36) | def _consume(result):
  class PipelineError (line 43) | class PipelineError(Exception):
  function _exc_produce (line 47) | def _exc_produce(num=5):
  function _exc_work (line 52) | def _exc_work(num=3):
  function _exc_consume (line 61) | def _exc_consume(result, num=4):
  function _bub_work (line 70) | def _bub_work(num=3):
  function _multi_work (line 81) | def _multi_work():
  class SimplePipelineTest (line 88) | class SimplePipelineTest(unittest.TestCase):
    method setUp (line 89) | def setUp(self):
    method test_run_sequential (line 95) | def test_run_sequential(self):
    method test_run_parallel (line 99) | def test_run_parallel(self):
    method test_pull (line 103) | def test_pull(self):
    method test_pull_chain (line 107) | def test_pull_chain(self):
  class ParallelStageTest (line 113) | class ParallelStageTest(unittest.TestCase):
    method setUp (line 114) | def setUp(self):
    method test_run_sequential (line 120) | def test_run_sequential(self):
    method test_run_parallel (line 124) | def test_run_parallel(self):
    method test_pull (line 129) | def test_pull(self):
  class ExceptionTest (line 134) | class ExceptionTest(unittest.TestCase):
    method setUp (line 135) | def setUp(self):
    method run_sequential (line 138) | def run_sequential(self, *stages):
    method run_parallel (line 143) | def run_parallel(self, *stages):
    method test_run_sequential (line 148) | def test_run_sequential(self):
    method test_run_parallel (line 156) | def test_run_parallel(self):
    method test_pull (line 164) | def test_pull(self):
  class ParallelExceptionTest (line 173) | class ParallelExceptionTest(unittest.TestCase):
    method setUp (line 174) | def setUp(self):
    method test_run_parallel (line 180) | def test_run_parallel(self):
  class ConstrainedThreadedPipelineTest (line 185) | class ConstrainedThreadedPipelineTest(unittest.TestCase):
    method setUp (line 186) | def setUp(self):
    method test_constrained (line 189) | def test_constrained(self):
    method test_constrained_exception (line 198) | def test_constrained_exception(self):
    method test_constrained_parallel (line 206) | def test_constrained_parallel(self):
  class BubbleTest (line 214) | class BubbleTest(unittest.TestCase):
    method setUp (line 215) | def setUp(self):
    method test_run_sequential (line 221) | def test_run_sequential(self):
    method test_run_parallel (line 225) | def test_run_parallel(self):
    method test_pull (line 229) | def test_pull(self):
  class MultiMessageTest (line 234) | class MultiMessageTest(unittest.TestCase):
    method setUp (line 235) | def setUp(self):
    method test_run_sequential (line 241) | def test_run_sequential(self):
    method test_run_parallel (line 245) | def test_run_parallel(self):
    method test_pull (line 249) | def test_pull(self):
  class StageDecoratorTest (line 254) | class StageDecoratorTest(unittest.TestCase):
    method test_stage_decorator (line 255) | def test_stage_decorator(self):
    method test_mutator_stage_decorator (line 263) | def test_mutator_stage_decorator(self):

FILE: test/test_plugins.py
  class TestPluginRegistration (line 49) | class TestPluginRegistration(IOMixin, PluginTestCase):
    class RatingPlugin (line 50) | class RatingPlugin(plugins.BeetsPlugin):
      method __init__ (line 56) | def __init__(self):
      method on_write (line 61) | def on_write(item=None, path=None, tags=None):
    method setUp (line 65) | def setUp(self):
    method test_field_type_registered (line 70) | def test_field_type_registered(self):
    method test_duplicate_type (line 73) | def test_duplicate_type(self):
    method test_listener_registered (line 85) | def test_listener_registered(self):
    method test_multi_value_flex_field_type (line 93) | def test_multi_value_flex_field_type(self):
  class PluginImportTestCase (line 102) | class PluginImportTestCase(ImportHelper, PluginTestCase):
    method setUp (line 103) | def setUp(self):
  class EventsTest (line 108) | class EventsTest(PluginImportTestCase):
    method test_import_task_created (line 109) | def test_import_task_created(self):
    method test_import_task_created_with_plugin (line 126) | def test_import_task_created_with_plugin(self):
  class ListenersTest (line 168) | class ListenersTest(PluginTestCase):
    method test_register (line 169) | def test_register(self):
    method test_events_called (line 188) | def test_events_called(self):
    method test_listener_params (line 207) | def test_listener_params(self):
  class PromptChoicesTest (line 270) | class PromptChoicesTest(TerminalImportMixin, PluginImportTestCase):
    method setUp (line 271) | def setUp(self):
    method tearDown (line 282) | def tearDown(self):
    method test_plugin_choices_in_ui_input_options_album (line 286) | def test_plugin_choices_in_ui_input_options_album(self):
    method test_plugin_choices_in_ui_input_options_singleton (line 324) | def test_plugin_choices_in_ui_input_options_singleton(self):
    method test_choices_conflicts (line 361) | def test_choices_conflicts(self):
    method test_plugin_callback (line 399) | def test_plugin_callback(self):
    method test_plugin_callback_return (line 443) | def test_plugin_callback_return(self):
  function get_available_plugins (line 484) | def get_available_plugins():
  class TestImportPlugin (line 495) | class TestImportPlugin(PluginMixin):
    method plugin_name (line 497) | def plugin_name(self, request):
    method unload_plugins (line 508) | def unload_plugins(self):
    method cleanup (line 516) | def cleanup(self):
    method test_import_plugin (line 529) | def test_import_plugin(self, caplog, plugin_name):
  class TestDeprecationCopy (line 539) | class TestDeprecationCopy:
    method test_legacy_metadata_plugin_deprecation (line 541) | def test_legacy_metadata_plugin_deprecation(self):
  class TestMusicBrainzPluginLoading (line 559) | class TestMusicBrainzPluginLoading:
    method config (line 561) | def config(self):
    method test_default (line 567) | def test_default(self):
    method test_other_plugin_enabled (line 570) | def test_other_plugin_enabled(self, config):
    method test_deprecated_enabled (line 575) | def test_deprecated_enabled(self, config, caplog):
    method test_deprecated_disabled (line 585) | def test_deprecated_disabled(self, config, caplog):

FILE: test/test_query.py
  function helper (line 54) | def helper():
  class TestGet (line 63) | class TestGet:
    method lib (line 65) | def lib(self, helper):
    method test_get_query (line 147) | def test_get_query(self, lib, q, expected_titles):
    method test_query_logic (line 176) | def test_query_logic(self, lib, q, expected_titles):
    method test_negation_prefix (line 215) | def test_negation_prefix(self, lib, q, expected_titles):
    method test_fast_vs_slow (line 231) | def test_fast_vs_slow(self, lib, make_q):
  class TestMatch (line 243) | class TestMatch:
    method item (line 245) | def item(self):
    method test_match (line 267) | def test_match(self, item, q, should_match):
  class TestPathQuery (line 272) | class TestPathQuery:
    method lib (line 281) | def lib(self, helper):
    method test_explicit (line 307) | def test_explicit(self, monkeypatch, lib, q, expected_titles):
    method test_implicit (line 323) | def test_implicit(self, monkeypatch, lib, q, expected_titles):
    method test_case_sensitivity (line 338) | def test_case_sensitivity(
    method test_path_sep_detection (line 364) | def test_path_sep_detection(self, monkeypatch, tmp_path, q, is_path_qu...
  class TestQuery (line 375) | class TestQuery:
    method lib (line 380) | def lib(self, helper):
    method test_equality (line 402) | def test_equality(self, query_class):
    method test_invalid_query (line 412) | def test_invalid_query(self, make_q, expected_msg):
    method test_value_type (line 438) | def test_value_type(self, lib, q, expected_titles):
  class TestDefaultSearchFields (line 442) | class TestDefaultSearchFields:
    method lib (line 444) | def lib(self, helper):
    method test_search (line 465) | def test_search(self, lib, entity, q, should_match):
  class TestRelatedQueries (line 469) | class TestRelatedQueries:
    method lib (line 473) | def lib(self, helper):
    method test_related_query (line 518) | def test_related_query(self, lib, q, expected_titles, expected_albums):

FILE: test/test_release.py
  function rst_changelog (line 22) | def rst_changelog():
  function md_changelog (line 88) | def md_changelog():
  function test_convert_rst_to_md (line 127) | def test_convert_rst_to_md(rst_changelog, md_changelog):

FILE: test/test_sort.py
  class DummyDataTestCase (line 29) | class DummyDataTestCase(BeetsTestCase):
    method setUp (line 30) | def setUp(self):
  class SortFixedFieldTest (line 111) | class SortFixedFieldTest(DummyDataTestCase):
    method test_sort_asc (line 112) | def test_sort_asc(self):
    method test_sort_desc (line 124) | def test_sort_desc(self):
    method test_sort_two_field_asc (line 136) | def test_sort_two_field_asc(self):
    method test_sort_path_field (line 155) | def test_sort_path_field(self):
  class SortFlexFieldTest (line 165) | class SortFlexFieldTest(DummyDataTestCase):
    method test_sort_asc (line 166) | def test_sort_asc(self):
    method test_sort_desc (line 178) | def test_sort_desc(self):
    method test_sort_two_field (line 192) | def test_sort_two_field(self):
  class SortAlbumFixedFieldTest (line 212) | class SortAlbumFixedFieldTest(DummyDataTestCase):
    method test_sort_asc (line 213) | def test_sort_asc(self):
    method test_sort_desc (line 225) | def test_sort_desc(self):
    method test_sort_two_field_asc (line 237) | def test_sort_two_field_asc(self):
  class SortAlbumFlexFieldTest (line 257) | class SortAlbumFlexFieldTest(DummyDataTestCase):
    method test_sort_asc (line 258) | def test_sort_asc(self):
    method test_sort_desc (line 270) | def test_sort_desc(self):
    method test_sort_two_field_asc (line 282) | def test_sort_two_field_asc(self):
  class SortAlbumComputedFieldTest (line 302) | class SortAlbumComputedFieldTest(DummyDataTestCase):
    method test_sort_asc (line 303) | def test_sort_asc(self):
    method test_sort_desc (line 315) | def test_sort_desc(self):
  class SortCombinedFieldTest (line 328) | class SortCombinedFieldTest(DummyDataTestCase):
    method test_computed_first (line 329) | def test_computed_first(self):
    method test_computed_second (line 344) | def test_computed_second(self):
  class ConfigSortTest (line 361) | class ConfigSortTest(DummyDataTestCase):
    method test_default_sort_item (line 362) | def test_default_sort_item(self):
    method test_config_opposite_sort_item (line 366) | def test_config_opposite_sort_item(self):
    method test_default_sort_album (line 371) | def test_default_sort_album(self):
    method test_config_opposite_sort_album (line 375) | def test_config_opposite_sort_album(self):
  class CaseSensitivityTest (line 381) | class CaseSensitivityTest(DummyDataTestCase):
    method setUp (line 386) | def setUp(self):
    method tearDown (line 415) | def tearDown(self):
    method test_smart_artist_case_insensitive (line 420) | def test_smart_artist_case_insensitive(self):
    method test_smart_artist_case_sensitive (line 427) | def test_smart_artist_case_sensitive(self):
    method test_fixed_field_case_insensitive (line 434) | def test_fixed_field_case_insensitive(self):
    method test_fixed_field_case_sensitive (line 441) | def test_fixed_field_case_sensitive(self):
    method test_flex_field_case_insensitive (line 448) | def test_flex_field_case_insensitive(self):
    method test_flex_field_case_sensitive (line 455) | def test_flex_field_case_sensitive(self):
    method test_case_sensitive_only_affects_text (line 462) | def test_case_sensitive_only_affects_text(self):
  class NonExistingFieldTest (line 474) | class NonExistingFieldTest(DummyDataTestCase):
    method test_non_existing_fields_not_fail (line 477) | def test_non_existing_fields_not_fail(self):
    method test_combined_non_existing_field_asc (line 487) | def test_combined_non_existing_field_asc(self):
    method test_combined_non_existing_field_desc (line 495) | def test_combined_non_existing_field_desc(self):
    method test_field_present_in_some_items (line 503) | def test_field_present_in_some_items(self):
    method test_int_field_present_in_some_items (line 530) | def test_int_field_present_in_some_items(self):
    method test_negation_interaction (line 556) | def test_negation_interaction(self):

FILE: test/test_template.py
  function _normexpr (line 22) | def _normexpr(expr):
  function _normparse (line 44) | def _normparse(text):
  class ParseTest (line 49) | class ParseTest(unittest.TestCase):
    method test_empty_string (line 50) | def test_empty_string(self):
    method _assert_symbol (line 53) | def _assert_symbol(self, obj, ident):
    method _assert_call (line 58) | def _assert_call(self, obj, ident, numargs):
    method test_plain_text (line 68) | def test_plain_text(self):
    method test_escaped_character_only (line 71) | def test_escaped_character_only(self):
    method test_escaped_character_in_text (line 74) | def test_escaped_character_in_text(self):
    method test_escaped_character_at_start (line 77) | def test_escaped_character_at_start(self):
    method test_escaped_character_at_end (line 80) | def test_escaped_character_at_end(self):
    method test_escaped_function_delim (line 83) | def test_escaped_function_delim(self):
    method test_escaped_sep (line 86) | def test_escaped_sep(self):
    method test_escaped_close_brace (line 89) | def test_escaped_close_brace(self):
    method test_bare_value_delim_kept_intact (line 92) | def test_bare_value_delim_kept_intact(self):
    method test_bare_function_delim_kept_intact (line 95) | def test_bare_function_delim_kept_intact(self):
    method test_bare_opener_kept_intact (line 98) | def test_bare_opener_kept_intact(self):
    method test_bare_closer_kept_intact (line 101) | def test_bare_closer_kept_intact(self):
    method test_bare_sep_kept_intact (line 104) | def test_bare_sep_kept_intact(self):
    method test_symbol_alone (line 107) | def test_symbol_alone(self):
    method test_symbol_in_text (line 112) | def test_symbol_in_text(self):
    method test_symbol_with_braces (line 119) | def test_symbol_with_braces(self):
    method test_unclosed_braces_symbol (line 126) | def test_unclosed_braces_symbol(self):
    method test_empty_braces_symbol (line 129) | def test_empty_braces_symbol(self):
    method test_call_without_args_at_end (line 132) | def test_call_without_args_at_end(self):
    method test_call_without_args (line 135) | def test_call_without_args(self):
    method test_call_with_unclosed_args (line 138) | def test_call_with_unclosed_args(self):
    method test_call_with_unclosed_multiple_args (line 141) | def test_call_with_unclosed_multiple_args(self):
    method test_call_empty_arg (line 146) | def test_call_empty_arg(self):
    method test_call_single_arg (line 152) | def test_call_single_arg(self):
    method test_call_two_args (line 158) | def test_call_two_args(self):
    method test_call_with_escaped_sep (line 165) | def test_call_with_escaped_sep(self):
    method test_call_with_escaped_close (line 171) | def test_call_with_escaped_close(self):
    method test_call_with_symbol_argument (line 177) | def test_call_with_symbol_argument(self):
    method test_call_with_nested_call_argument (line 186) | def test_call_with_nested_call_argument(self):
    method test_nested_call_with_argument (line 195) | def test_nested_call_with_argument(self):
    method test_sep_before_call_two_args (line 204) | def test_sep_before_call_two_args(self):
    method test_sep_with_symbols (line 212) | def test_sep_with_symbols(self):
    method test_newline_at_end (line 220) | def test_newline_at_end(self):
  class EvalTest (line 226) | class EvalTest(unittest.TestCase):
    method _eval (line 227) | def _eval(self, template):
    method test_plain_text (line 238) | def test_plain_text(self):
    method test_subtitute_value (line 241) | def test_subtitute_value(self):
    method test_subtitute_value_in_text (line 244) | def test_subtitute_value_in_text(self):
    method test_not_subtitute_undefined_value (line 247) | def test_not_subtitute_undefined_value(self):
    method test_function_call (line 250) | def test_function_call(self):
    method test_function_call_with_text (line 253) | def test_function_call_with_text(self):
    method test_nested_function_call (line 256) | def test_nested_function_call(self):
    method test_symbol_in_argument (line 259) | def test_symbol_in_argument(self):
    method test_function_call_exception (line 262) | def test_function_call_exception(self):
    method test_function_returning_integer (line 266) | def test_function_returning_integer(self):
    method test_not_subtitute_undefined_func (line 269) | def test_not_subtitute_undefined_func(self):
    method test_not_subtitute_func_with_no_args (line 272) | def test_not_subtitute_func_with_no_args(self):
    method test_function_call_with_empty_arg (line 275) | def test_function_call_with_empty_arg(self):

FILE: test/test_types.py
  function test_datetype (line 8) | def test_datetype():
  function test_pathtype (line 22) | def test_pathtype():
  function test_musicalkey (line 33) | def test_musicalkey():
  function test_durationtype (line 42) | def test_durationtype():

FILE: test/test_util.py
  class UtilTest (line 31) | class UtilTest(unittest.TestCase):
    method test_open_anything (line 32) | def test_open_anything(self):
    method test_interactive_open (line 44) | def test_interactive_open(self, mock_open, mock_execlp):
    method test_sanitize_unix_replaces_leading_dot (line 53) | def test_sanitize_unix_replaces_leading_dot(self):
    method test_sanitize_windows_replaces_trailing_dot (line 58) | def test_sanitize_windows_replaces_trailing_dot(self):
    method test_sanitize_windows_replaces_illegal_chars (line 63) | def test_sanitize_windows_replaces_illegal_chars(self):
    method test_sanitize_windows_replaces_trailing_space (line 74) | def test_sanitize_windows_replaces_trailing_space(self):
    method test_sanitize_path_works_on_empty_string (line 79) | def test_sanitize_path_works_on_empty_string(self):
    method test_sanitize_with_custom_replace_overrides_built_in_sub (line 84) | def test_sanitize_with_custom_replace_overrides_built_in_sub(self):
    method test_sanitize_with_custom_replace_adds_replacements (line 89) | def test_sanitize_with_custom_replace_adds_replacements(self):
    method test_sanitize_empty_component (line 95) | def test_sanitize_empty_component(self):
    method test_command_output (line 101) | def test_command_output(self, mock_popen):
    method test_case_sensitive_default (line 113) | def test_case_sensitive_default(self):
    method test_case_sensitive_detects_sensitive (line 123) | def test_case_sensitive_detects_sensitive(self):
    method test_case_sensitive_detects_insensitive (line 129) | def test_case_sensitive_detects_insensitive(self):
  class PathConversionTest (line 135) | class PathConversionTest(unittest.TestCase):
    method test_syspath_windows_format (line 136) | def test_syspath_windows_format(self):
    method test_syspath_windows_format_unc_path (line 143) | def test_syspath_windows_format_unc_path(self):
    method test_syspath_posix_unchanged (line 152) | def test_syspath_posix_unchanged(self):
    method _windows_bytestring_path (line 158) | def _windows_bytestring_path(self, path):
    method test_bytestring_path_windows_encodes_utf8 (line 162) | def test_bytestring_path_windows_encodes_utf8(self):
    method test_bytesting_path_windows_removes_magic_prefix (line 167) | def test_bytesting_path_windows_removes_magic_prefix(self):
  class TestPathLegalization (line 173) | class TestPathLegalization:
    method _patch_max_filename_length (line 177) | def _patch_max_filename_length(self, monkeypatch):
    method test_truncate (line 193) | def test_truncate(self, path, expected):
    method test_replacements (line 212) | def test_replacements(
  class TestPlurality (line 223) | class TestPlurality:
    method test_plurality (line 232) | def test_plurality(self, objs, expected_obj, expected_freq):
    method test_empty_sequence_raises_error (line 235) | def test_empty_sequence_raises_error(self):
    method test_get_most_common_tags (line 239) | def test_get_most_common_tags(self):

FILE: test/ui/commands/test_completion.py
  class CompletionTest (line 20) | class CompletionTest(IOMixin, TestPluginTestCase):
    method test_completion (line 21) | def test_completion(self):

FILE: test/ui/commands/test_config.py
  class ConfigCommandTest (line 11) | class ConfigCommandTest(IOMixin, BeetsTestCase):
    method setUp (line 12) | def setUp(self):
    method _run_with_yaml_output (line 34) | def _run_with_yaml_output(self, *args):
    method test_show_user_config (line 38) | def test_show_user_config(self):
    method test_show_user_config_with_defaults (line 44) | def test_show_user_config_with_defaults(self):
    method test_show_user_config_with_cli (line 52) | def test_show_user_config_with_cli(self):
    method test_show_redacted_user_config (line 60) | def test_show_redacted_user_config(self):
    method test_show_redacted_user_config_with_defaults (line 66) | def test_show_redacted_user_config_with_defaults(self):
    method test_config_paths (line 73) | def test_config_paths(self):
    method test_config_paths_with_cli (line 80) | def test_config_paths_with_cli(self):
    method test_edit_config_with_visual_or_editor_env (line 88) | def test_edit_config_with_visual_or_editor_env(self):
    method test_edit_config_with_automatic_open (line 104) | def test_edit_config_with_automatic_open(self):
    method test_config_editor_not_found (line 113) | def test_config_editor_not_found(self):
    method test_edit_invalid_config_file (line 121) | def test_edit_invalid_config_file(self):
    method test_edit_config_with_custom_config_path (line 132) | def test_edit_config_with_custom_config_path(self):

FILE: test/ui/commands/test_fields.py
  class FieldsTest (line 6) | class FieldsTest(IOMixin, ItemInDBTestCase):
    method remove_keys (line 7) | def remove_keys(self, keys, text):
    method test_fields_func (line 14) | def test_fields_func(self):

FILE: test/ui/commands/test_import.py
  class ImportTest (line 16) | class ImportTest(BeetsTestCase):
    method test_quiet_timid_disallowed (line 17) | def test_quiet_timid_disallowed(self):
    method test_parse_paths_from_logfile (line 23) | def test_parse_paths_from_logfile(self):
  class ShowChangeTestCase (line 59) | class ShowChangeTestCase(IOMixin, BeetsTestCase):
    method _show_change (line 60) | def _show_change(self):
    method test_newline_layout (line 95) | def test_newline_layout(self):
    method test_column_layout (line 119) | def test_column_layout(self):
  class SummarizeItemsTest (line 151) | class SummarizeItemsTest(unittest.TestCase):
    method setUp (line 152) | def setUp(self):
    method test_summarize_item (line 160) | def test_summarize_item(self):
    method test_summarize_items (line 167) | def test_summarize_items(self):

FILE: test/ui/commands/test_list.py
  class ListTest (line 6) | class ListTest(IOMixin, BeetsTestCase):
    method setUp (line 7) | def setUp(self):
    method _run_list (line 14) | def _run_list(self, query="", album=False, path=False, fmt=""):
    method test_list_outputs_item (line 18) | def test_list_outputs_item(self):
    method test_list_unicode_query (line 22) | def test_list_unicode_query(self):
    method test_list_item_path (line 31) | def test_list_item_path(self):
    method test_list_album_outputs_something (line 35) | def test_list_album_outputs_something(self):
    method test_list_album_path (line 39) | def test_list_album_path(self):
    method test_list_album_omits_title (line 43) | def test_list_album_omits_title(self):
    method test_list_uses_track_artist (line 47) | def test_list_uses_track_artist(self):
    method test_list_album_uses_album_artist (line 52) | def test_list_album_uses_album_artist(self):
    method test_list_item_format_artist (line 57) | def test_list_item_format_artist(self):
    method test_list_item_format_multiple (line 61) | def test_list_item_format_multiple(self):
    method test_list_album_format (line 65) | def test_list_album_format(self):

FILE: test/ui/commands/test_modify.py
  class ModifyTest (line 10) | class ModifyTest(IOMixin, BeetsTestCase):
    method setUp (line 11) | def setUp(self):
    method modify_inp (line 16) | def modify_inp(self, inp: list[str], *args):
    method modify (line 21) | def modify(self, *args):
    method test_modify_item (line 26) | def test_modify_item(self):
    method test_modify_item_abort (line 31) | def test_modify_item_abort(self):
    method test_modify_item_no_change (line 38) | def test_modify_item_no_change(self):
    method test_modify_write_tags (line 45) | def test_modify_write_tags(self):
    method test_modify_dont_write_tags (line 51) | def test_modify_dont_write_tags(self):
    method test_move (line 57) | def test_move(self):
    method test_not_move (line 62) | def test_not_move(self):
    method test_no_write_no_move (line 67) | def test_no_write_no_move(self):
    method test_update_mtime (line 74) | def test_update_mtime(self):
    method test_reset_mtime_with_no_write (line 83) | def test_reset_mtime_with_no_write(self):
    method test_selective_modify (line 90) | def test_selective_modify(self):
    method test_modify_formatted (line 109) | def test_modify_formatted(self):
    method test_modify_album (line 123) | def test_modify_album(self):
    method test_modify_album_write_tags (line 128) | def test_modify_album_write_tags(self):
    method test_modify_album_dont_write_tags (line 134) | def test_modify_album_dont_write_tags(self):
    method test_album_move (line 140) | def test_album_move(self):
    method test_album_not_move (line 146) | def test_album_not_move(self):
    method test_modify_album_formatted (line 152) | def test_modify_album_formatted(self):
    method test_write_initial_key_tag (line 161) | def test_write_initial_key_tag(self):
    method test_set_flexattr (line 167) | def test_set_flexattr(self):
    method test_remove_flexattr (line 172) | def test_remove_flexattr(self):
    method test_delete_initial_key_tag (line 182) | def test_delete_initial_key_tag(self):
    method test_arg_parsing_colon_query (line 195) | def test_arg_parsing_colon_query(self):
    method test_arg_parsing_delete (line 200) | def test_arg_parsing_delete(self):
    method test_arg_parsing_query_with_exclaimation (line 205) | def test_arg_parsing_query_with_exclaimation(self):
    method test_arg_parsing_equals_in_value (line 212) | def test_arg_parsing_equals_in_value(self):

FILE: test/ui/commands/test_move.py
  class MoveTest (line 8) | class MoveTest(BeetsTestCase):
    method setUp (line 9) | def setUp(self):
    method _move (line 23) | def _move(
    method test_move_item (line 34) | def test_move_item(self):
    method test_copy_item (line 41) | def test_copy_item(self):
    method test_move_album (line 48) | def test_move_album(self):
    method test_copy_album (line 55) | def test_copy_album(self):
    method test_move_item_custom_dir (line 62) | def test_move_item_custom_dir(self):
    method test_move_album_custom_dir (line 69) | def test_move_album_custom_dir(self):
    method test_pretend_move_item (line 76) | def test_pretend_move_item(self):
    method test_pretend_move_album (line 81) | def test_pretend_move_album(self):
    method test_export_item_custom_dir (line 86) | def test_export_item_custom_dir(self):
    method test_export_album_custom_dir (line 92) | def test_export_album_custom_dir(self):
    method test_pretend_export_item (line 98) | def test_pretend_export_item(self):

FILE: test/ui/commands/test_remove.py
  class RemoveTest (line 9) | class RemoveTest(IOMixin, BeetsTestCase):
    method setUp (line 10) | def setUp(self):
    method test_remove_items_no_delete (line 18) | def test_remove_items_no_delete(self):
    method test_remove_items_with_delete (line 25) | def test_remove_items_with_delete(self):
    method test_remove_items_with_force_no_delete (line 32) | def test_remove_items_with_force_no_delete(self):
    method test_remove_items_with_force_delete (line 38) | def test_remove_items_with_force_delete(self):
    method test_remove_items_select_with_delete (line 44) | def test_remove_items_select_with_delete(self):
    method test_remove_albums_select_with_delete (line 63) | def test_remove_albums_select_with_delete(self):

FILE: test/ui/commands/test_update.py
  class UpdateTest (line 12) | class UpdateTest(IOMixin, BeetsTestCase):
    method setUp (line 13) | def setUp(self):
    method _update (line 34) | def _update(
    method test_delete_removes_item (line 57) | def test_delete_removes_item(self):
    method test_delete_removes_album (line 64) | def test_delete_removes_album(self):
    method test_delete_removes_album_art (line 71) | def test_delete_removes_album_art(self):
    method test_modified_metadata_detected (line 79) | def test_modified_metadata_detected(self):
    method test_modified_metadata_moved (line 87) | def test_modified_metadata_moved(self):
    method test_modified_metadata_not_moved (line 95) | def test_modified_metadata_not_moved(self):
    method test_selective_modified_metadata_moved (line 103) | def test_selective_modified_metadata_moved(self):
    method test_selective_modified_metadata_not_moved (line 113) | def test_selective_modified_metadata_not_moved(self):
    method test_modified_album_metadata_moved (line 123) | def test_modified_album_metadata_moved(self):
    method test_modified_album_metadata_art_moved (line 131) | def test_modified_album_metadata_art_moved(self):
    method test_selective_modified_album_metadata_moved (line 141) | def test_selective_modified_album_metadata_moved(self):
    method test_selective_modified_album_metadata_not_moved (line 151) | def test_selective_modified_album_metadata_not_moved(self):
    method test_mtime_match_skips_update (line 161) | def test_mtime_match_skips_update(self):
    method test_multivalued_albumtype_roundtrip (line 174) | def test_multivalued_albumtype_roundtrip(self):
    method test_modified_metadata_excluded (line 199) | def test_modified_metadata_excluded(self):

FILE: test/ui/commands/test_utils.py
  class QueryTest (line 13) | class QueryTest(BeetsTestCase):
    method add_item (line 14) | def add_item(self, filename=b"srcfile", templatefile=b"full.mp3"):
    method add_album (line 24) | def add_album(self, items):
    method check_do_query (line 28) | def check_do_query(
    method test_query_empty (line 35) | def test_query_empty(self):
    method test_query_empty_album (line 39) | def test_query_empty_album(self):
    method test_query_item (line 43) | def test_query_item(self):
    method test_query_album (line 49) | def test_query_album(self):

FILE: test/ui/commands/test_write.py
  class WriteTest (line 4) | class WriteTest(IOMixin, BeetsTestCase):
    method write_cmd (line 5) | def write_cmd(self, *args):
    method test_update_mtime (line 8) | def test_update_mtime(self):
    method test_non_metadata_field_unchanged (line 20) | def test_non_metadata_field_unchanged(self):
    method test_write_metadata_field (line 36) | def test_write_metadata_field(self):

FILE: test/ui/test_ui.py
  class PrintTest (line 34) | class PrintTest(IOMixin, unittest.TestCase):
    method test_print_without_locale (line 35) | def test_print_without_locale(self):
    method test_print_with_invalid_locale (line 48) | def test_print_with_invalid_locale(self):
  class ShowModelChangesTest (line 69) | class ShowModelChangesTest(IOMixin, BeetsTestCase):
    method test_uses_database_state_when_old_not_provided (line 70) | def test_uses_database_state_when_old_not_provided(self):
  class TestPluginTestCase (line 84) | class TestPluginTestCase(PluginTestCase):
    method setUp (line 87) | def setUp(self):
  class ConfigTest (line 92) | class ConfigTest(IOMixin, TestPluginTestCase):
    method setUp (line 93) | def setUp(self):
    method tearDown (line 129) | def tearDown(self):
    method _make_test_cmd (line 135) | def _make_test_cmd(self):
    method _reset_config (line 146) | def _reset_config(self):
    method write_config_file (line 151) | def write_config_file(self):
    method test_paths_section_respected (line 154) | def test_paths_section_respected(self):
    method test_default_paths_preserved (line 163) | def test_default_paths_preserved(self):
    method test_nonexistant_db (line 175) | def test_nonexistant_db(self):
    method test_user_config_file (line 183) | def test_user_config_file(self):
    method test_replacements_parsed (line 190) | def test_replacements_parsed(self):
    method test_multiple_replacements_parsed (line 199) | def test_multiple_replacements_parsed(self):
    method test_cli_config_option (line 207) | def test_cli_config_option(self):
    method test_cli_config_file_overwrites_user_defaults (line 213) | def test_cli_config_file_overwrites_user_defaults(self):
    method test_cli_config_file_overwrites_beetsdir_defaults (line 222) | def test_cli_config_file_overwrites_beetsdir_defaults(self):
    method test_cli_config_paths_resolve_relative_to_user_dir (line 265) | def test_cli_config_paths_resolve_relative_to_user_dir(self):
    method test_cli_config_paths_resolve_relative_to_beetsdir (line 274) | def test_cli_config_paths_resolve_relative_to_beetsdir(self):
    method test_command_line_option_relative_to_working_dir (line 285) | def test_command_line_option_relative_to_working_dir(self):
    method test_cli_config_file_loads_plugin_commands (line 291) | def test_cli_config_file_loads_plugin_commands(self):
    method test_beetsdir_config (line 302) | def test_beetsdir_config(self):
    method test_beetsdir_points_to_file_error (line 311) | def test_beetsdir_points_to_file_error(self):
    method test_beetsdir_config_does_not_load_default_user_config (line 318) | def test_beetsdir_config_does_not_load_default_user_config(self):
    method test_default_config_paths_resolve_relative_to_beetsdir (line 327) | def test_default_config_paths_resolve_relative_to_beetsdir(self):
    method test_beetsdir_config_paths_resolve_relative_to_beetsdir (line 334) | def test_beetsdir_config_paths_resolve_relative_to_beetsdir(self):
  class PathFormatTest (line 346) | class PathFormatTest(unittest.TestCase):
    method test_custom_paths_prepend (line 347) | def test_custom_paths_prepend(self):
  class PluginTest (line 359) | class PluginTest(TestPluginTestCase):
    method test_plugin_command_from_pluginpath (line 360) | def test_plugin_command_from_pluginpath(self):
  class CommonOptionsParserCliTest (line 364) | class CommonOptionsParserCliTest(IOMixin, BeetsTestCase):
    method setUp (line 369) | def setUp(self):
    method test_base (line 376) | def test_base(self):
    method test_path_option (line 383) | def test_path_option(self):
    method test_format_option (line 390) | def test_format_option(self):
    method test_format_option_unicode (line 397) | def test_format_option_unicode(self):
    method test_root_format_option (line 401) | def test_root_format_option(self):
    method test_help (line 412) | def test_help(self):
    method test_stats (line 422) | def test_stats(self):
    method test_version (line 430) | def test_version(self):
  class CommonOptionsParserTest (line 440) | class CommonOptionsParserTest(unittest.TestCase):
    method test_album_option (line 441) | def test_album_option(self):
    method test_path_option (line 451) | def test_path_option(self):
    method test_format_option (line 472) | def test_format_option(self):
    method test_format_option_with_target (line 490) | def test_format_option_with_target(self):
    method test_format_option_with_album (line 505) | def test_format_option_with_album(self):
    method test_add_all_common_options (line 524) | def test_add_all_common_options(self):
  class EncodingTest (line 533) | class EncodingTest(unittest.TestCase):
    method out_encoding_overridden (line 538) | def out_encoding_overridden(self):
    method in_encoding_overridden (line 542) | def in_encoding_overridden(self):
    method out_encoding_default_utf8 (line 546) | def out_encoding_default_utf8(self):
    method in_encoding_default_utf8 (line 551) | def in_encoding_default_utf8(self):

FILE: test/ui/test_ui_importer.py
  class NonAutotaggedImportTest (line 25) | class NonAutotaggedImportTest(
  class ImportTest (line 31) | class ImportTest(TerminalImportMixin, test_importer.ImportTest):
  class ImportSingletonTest (line 35) | class ImportSingletonTest(
  class ImportTracksTest (line 41) | class ImportTracksTest(TerminalImportMixin, test_importer.ImportTracksTe...
  class ImportCompilationTest (line 45) | class ImportCompilationTest(
  class ImportExistingTest (line 51) | class ImportExistingTest(TerminalImportMixin, test_importer.ImportExisti...
  class ChooseCandidateTest (line 55) | class ChooseCandidateTest(
  class GroupAlbumsImportTest (line 61) | class GroupAlbumsImportTest(
  class GlobalGroupAlbumsImportTest (line 67) | class GlobalGroupAlbumsImportTest(

FILE: test/ui/test_ui_init.py
  class InputMethodsTest (line 28) | class InputMethodsTest(IOMixin, unittest.TestCase):
    method _print_helper (line 29) | def _print_helper(self, s):
    method _print_helper2 (line 32) | def _print_helper2(self, s, prefix):
    method test_input_select_objects (line 35) | def test_input_select_objects(self):
  class ParentalDirCreation (line 88) | class ParentalDirCreation(IOMixin, BeetsTestCase):
    method test_create_yes (line 89) | def test_create_yes(self):
    method test_create_no (line 101) | def test_create_no(self):

FILE: test/util/test_color.py
  class ColorTestCase (line 6) | class ColorTestCase(TestCase):
    method test_uncolorize (line 7) | def test_uncolorize(self):
    method test_color_split (line 18) | def test_color_split(self):

FILE: test/util/test_config.py
  function test_sanitize_choices (line 14) | def test_sanitize_choices(input_choices, valid_choices, expected):
  function test_sanitize_pairs (line 18) | def test_sanitize_pairs():

FILE: test/util/test_diff.py
  class TestFieldDiff (line 11) | class TestFieldDiff:
    method configure_color (line 13) | def configure_color(self, config, color):
    method patch_colorize (line 17) | def patch_colorize(self, monkeypatch):
    method diff_fmt (line 25) | def diff_fmt(old, new):
    method test_field_diff_colors (line 59) | def test_field_diff_colors(self, old_data, new_data, field, expected_d...
    method test_field_diff_no_color (line 68) | def test_field_diff_no_color(self):

FILE: test/util/test_id_extractors.py
  function test_extract_release_id (line 35) | def test_extract_release_id(source, id_string, expected):
  class SourceWithURL (line 39) | class SourceWithURL(NamedTuple):
  function test_match_source_url (line 55) | def test_match_source_url(source, source_with_url):

FILE: test/util/test_layout.py
  class LayoutTestCase (line 6) | class LayoutTestCase(TestCase):
    method test_split_into_lines (line 7) | def test_split_into_lines(self):

FILE: test/util/test_lyrics.py
  class TestLyrics (line 6) | class TestLyrics:
    method test_instrumental_lyrics (line 7) | def test_instrumental_lyrics(self):
    method test_from_legacy_text (line 18) | def test_from_legacy_text(self, is_importable):

FILE: test/util/test_units.py
  function test_human_bytes (line 23) | def test_human_bytes(input_bytes, expected):
  function test_human_seconds (line 42) | def test_human_seconds(input_seconds, expected):