import re from pathlib import Path from typing import Any, Callable, Dict, Generator, List, Optional from ..utils.config import main_settings from ..utils.exception import MKComposeException from ..utils.string_processing import unify class Option: """ This could represent a data object, a string or a page. """ def __init__( self, value: Any, text: Optional[str] = None, keys: List[Any] = None, hidden: bool = False, parse_key: Callable[[Any], Any] = lambda x: x, ): self._parse_key: Callable[[Any], Any] = parse_key self.value = value self.text = text or str(value) self.hidden = hidden self._raw_keys = set(keys or []) self._raw_keys.add(self.text) self.keys = set(self.parse_key(key) for key in self._raw_keys) def register_key(self, key: Any): self._raw_keys.add(key) self.keys.add(self._parse_key(key)) @property def parse_key(self) -> Callable[[Any], Any]: return self._parse_key @parse_key.setter def parse_key(self, value: Callable[[Any], Any]): self._parse_key = value self.keys = set(self._parse_key(key) for key in self._raw_keys) def __str__(self): return self.text class Select: def __init__( self, options: Generator[Option, None, None] = None, option_factory: Callable[[Any], Option] = None, raw_options: List[Any] = None, parse_option_key: Callable[[Any], Any] = lambda x: x, ask_for_creating_option: Callable[[Option], bool] = lambda x: True, sort: bool = False, **kwargs ): self._parse_option_key: Callable[[Any], Any] = parse_option_key self._ask_for_creating_option: Callable[[Option], bool] = ask_for_creating_option self._key_to_option: Dict[Any, Option] = dict() self._options: List[Option] = [] options = options or [] self.option_factory: Optional[Callable[[Any], Option]] = option_factory if self.can_create_options: _raw_options = raw_options or [] if sort: _raw_options = sorted(_raw_options) for raw_option in _raw_options: self.append(self.option_factory(raw_option)) elif raw_options is not None: raise MKComposeException("Cannot create options without a factory.") self.extend(options) @property def can_create_options(self) -> bool: return self.option_factory is not None def append(self, option: Option): option.parse_key = self._parse_option_key self._options.append(option) for key in option.keys: self._key_to_option[key] = option def extend(self, options: List[Option]): for option in options: self.append(option) def __iter__(self) -> Generator[Option, None, None]: for option in self._options: if option.hidden: continue yield option def __contains__(self, key: Any) -> bool: return key in self._key_to_option def __getitem__(self, key: Any) -> Option: return self._key_to_option[key] def create_option(self, key: Any, **kwargs) -> Option: if not self.can_create_options: raise MKComposeException("Cannot create options without a factory.") option = self.option_factory(key, **kwargs) self.append(option) return option def choose(self, key: Any) -> Optional[Option]: if key not in self: if self.can_create_options and self._ask_for_creating_option(key): return self.create_option(key) return None return self[key] class StringSelect(Select): def __init__(self, **kwargs): self._current_index = 0 kwargs["option_factory"] = self.next_option kwargs["parse_option_key"] = lambda x: unify(str(x)) super().__init__(**kwargs) def next_option(self, value: Any) -> Optional[Option]: o = Option(value=value, keys=[self._current_index], text=f"{self._current_index:0>2}: {value}") self._current_index += 1 return o class GenreSelect(StringSelect): @staticmethod def is_valid_genre(genre: Path) -> bool: """ gets the name of all subdirectories of shared.MUSIC_DIR, but filters out all directories, where the name matches with any Patern from shared.NOT_A_GENRE_REGEX. """ if not genre.is_dir(): return False if any(re.match(regex_pattern, genre.name) for regex_pattern in main_settings["not_a_genre_regex"]): return False return True def __init__(self): super().__init__(sort=True, raw_options=(genre.name for genre in filter(self.is_valid_genre, main_settings["music_directory"].iterdir())))