#!/usr/bin/env python3 import time import os import sys import termios import tty import signal import shutil import libcache import argparse from datetime import datetime from typing import List, Dict, Set, Tuple, Optional from dataclasses import dataclass, field from pathlib import Path # Configuration FILES_DIR = Path("/home/user/mixes/") PLAYLISTS_DIR = Path("/home/user/playlists/") POLISH_INDICATORS = ("Polskie", "Dzem") @dataclass class InterfaceState: last_header: Optional[str] = None last_files_display: Optional[Tuple] = None last_selected_idx: int = -1 last_current_day_idx: int = -1 last_scroll_offset: int = -1 last_message: Optional[str] = None last_search: str = "" @dataclass class Config: custom_playlist_file: Optional[str] = None @property def is_custom_mode(self) -> bool: return self.custom_playlist_file is not None @dataclass class FileItem: """Represents either a single file or a folder containing files.""" name: str path: Path is_folder: bool _all_files_cache: Optional[Set[str]] = field(default=None, init=False, repr=False) @property def display_name(self) -> str: if self.is_folder: return f"📁 {self.name}/" return self.name @property def all_files(self) -> Set[str]: """Return set of relative paths for all files in this item.""" if self._all_files_cache is not None: return self._all_files_cache if self.is_folder: # For folders, get all files inside folder_path = self.path.parent files = set() if folder_path.exists(): for file in sorted(folder_path.glob("*")): if file.is_file(): rel_path = str(file.relative_to(FILES_DIR)) files.add(rel_path) self._all_files_cache = files return files else: # For single files rel_path = str(self.path.relative_to(FILES_DIR)) self._all_files_cache = {rel_path} return self._all_files_cache class FileManager: @staticmethod def get_file_items(directory: Path) -> List[FileItem]: """Get all audio files and folders containing audio files as FileItem objects.""" items = [] try: for entry in sorted(directory.glob("*")): if entry.is_dir(): # Create folder item item = FileItem(name=entry.name, path=entry / "*", is_folder=True) items.append(item) elif entry.is_file(): # Create file item item = FileItem(name=entry.name, path=entry, is_folder=False) items.append(item) return items except FileNotFoundError: print(f"Error: Directory '{directory}' not found.") return [] except PermissionError: print(f"Error: Permission denied for directory '{directory}'.") return [] class SearchManager: @staticmethod def filter_file_items(items: List[FileItem], search_term: str) -> List[FileItem]: if not search_term: return items search_lower = search_term.lower() # Group items by match type starts_with = [] contains = [] has_chars = [] for item in items: item_name_lower = item.name.lower() if item_name_lower.startswith(search_lower): starts_with.append(item) elif search_lower in item_name_lower: contains.append(item) elif SearchManager._has_matching_chars(item_name_lower, search_lower): has_chars.append(item) return starts_with + contains + has_chars @staticmethod def filter_files(files: List[str], search_term: str) -> List[str]: if not search_term: return files search_lower = search_term.lower() starts_with = [] contains = [] has_chars = [] for file in files: file_lower = file.lower() if file_lower.startswith(search_lower): starts_with.append(file) elif search_lower in file_lower: contains.append(file) elif SearchManager._has_matching_chars(file_lower, search_lower): has_chars.append(file) return starts_with + contains + has_chars @staticmethod def _has_matching_chars(text: str, search: str) -> bool: """Check if text contains all characters from search (in any order).""" search_chars = set(search) text_chars = set(text) return search_chars.issubset(text_chars) class PlaylistManager: def __init__(self, config: Config): self.periods = ['late_night', 'morning', 'day', 'night'] self.config = config self.custom_playlist_files = set() def ensure_playlist_dir(self, day: str) -> Path: """Ensure playlist directory exists for the given day.""" playlist_dir = PLAYLISTS_DIR / day playlist_dir.mkdir(parents=True, exist_ok=True) return playlist_dir def load_playlists(self, days: List[str]) -> Dict[str, Dict[str, Set[str]]]: """Load all playlists from disk.""" if self.config.is_custom_mode and self.config.custom_playlist_file: # In custom mode, we only need one "day" entry playlists = {"custom": {period: set() for period in self.periods}} # Load existing custom playlist if it exists custom_path = Path(self.config.custom_playlist_file) if custom_path.exists(): with open(custom_path, 'r') as f: for line in f: line = line.strip() if line: # Convert to relative path abs_path = Path(line) try: rel_path = str(abs_path.relative_to(FILES_DIR)) except ValueError: # If it's already relative, use as is rel_path = line self.custom_playlist_files.add(rel_path) playlists["custom"]["day"].add(rel_path) return playlists else: # Original functionality for weekly playlists playlists = {} for day in days: playlists[day] = {period: set() for period in self.periods} playlist_dir = PLAYLISTS_DIR / day if playlist_dir.exists(): for period in self.periods: playlist_file = playlist_dir / period if playlist_file.exists(): with open(playlist_file, 'r') as f: for line in f: line = line.strip() if line: # Convert to relative path abs_path = Path(line) try: rel_path = str(abs_path.relative_to(FILES_DIR)) except ValueError: # If it's already relative, use as is rel_path = line playlists[day][period].add(rel_path) return playlists def update_playlist_file(self, day: str, period: str, file_item: FileItem, add: bool): """Update a playlist file by adding or removing files from a FileItem.""" if self.config.is_custom_mode: self._update_custom_playlist(file_item, add) else: self._update_weekly_playlist(day, period, file_item, add) def _update_custom_playlist(self, file_item: FileItem, add: bool): """Update the custom playlist file.""" if not self.config.custom_playlist_file: raise Exception("No custom playlist file specified") custom_path = Path(self.config.custom_playlist_file) custom_path.parent.mkdir(parents=True, exist_ok=True) # Read existing content lines = [] if custom_path.exists(): with open(custom_path, 'r') as f: lines = f.read().splitlines() # Get all files in this item as absolute paths files_to_process = set() for rel_path in file_item.all_files: abs_path = str(FILES_DIR / rel_path) files_to_process.add(abs_path) if add: # Add new files that aren't already in the list for filepath in files_to_process: if filepath not in lines: lines.append(filepath) # Also update the tracking set with relative path try: rel_path = str(Path(filepath).relative_to(FILES_DIR)) self.custom_playlist_files.add(rel_path) except ValueError: pass else: # Remove files for filepath in files_to_process: while filepath in lines: lines.remove(filepath) # Also update the tracking set try: rel_path = str(Path(filepath).relative_to(FILES_DIR)) self.custom_playlist_files.discard(rel_path) except ValueError: pass with open(custom_path, 'w') as f: f.write('\n'.join(lines) + ('\n' if lines else '')) def _update_weekly_playlist(self, day: str, period: str, file_item: FileItem, add: bool): """Update a weekly playlist file (original functionality).""" playlist_dir = self.ensure_playlist_dir(day) playlist_file = playlist_dir / period if not playlist_file.exists(): playlist_file.touch() with open(playlist_file, 'r') as f: lines = f.read().splitlines() # Get all files in this item as absolute paths files_to_process = set() for rel_path in file_item.all_files: abs_path = str(FILES_DIR / rel_path) files_to_process.add(abs_path) if add: # Add new files that aren't already in the list for filepath in files_to_process: if filepath not in lines: lines.append(filepath) else: # Remove files for filepath in files_to_process: while filepath in lines: lines.remove(filepath) with open(playlist_file, 'w', encoding='utf-8', errors='strict') as f: for line in lines: try: f.write(line + '\n') except UnicodeEncodeError as e: print("⚠️ Encoding error in line:", repr(line)) time.sleep(5) exit() def is_file_item_in_playlist(self, file_item: FileItem, day: str, period: str, playlists: Dict) -> bool: """Check if ALL files in the item are in the playlist.""" playlist_set = playlists.get(day, {}).get(period, set()) return all(rel_path in playlist_set for rel_path in file_item.all_files) def copy_day_to_all(self, playlists: Dict, source_day: str, days: List[str]) -> Dict: """Copy all playlists from source day to all other days.""" if self.config.is_custom_mode: return playlists for target_day in days: if target_day == source_day: continue for period in self.periods: target_dir = self.ensure_playlist_dir(target_day) target_file = target_dir / period # Convert relative paths to absolute paths filepaths = [str(FILES_DIR / rel_path) for rel_path in playlists[source_day][period]] with open(target_file, 'w') as f: f.write('\n'.join(filepaths) + ('\n' if filepaths else '')) playlists[target_day][period] = set(playlists[source_day][period]) return playlists def copy_current_item_to_all(self, playlists: Dict, source_day: str, days: List[str], current_item: FileItem) -> Tuple[Dict, bool]: """Copy current item's playlist assignments to all other days.""" if self.config.is_custom_mode: # No-op in custom mode return playlists, False # Check which periods the item's files are in source_periods = {} for period in self.periods: source_periods[period] = self.is_file_item_in_playlist(current_item, source_day, period, playlists) for target_day in days: if target_day == source_day: continue for period, is_present in source_periods.items(): target_set = playlists[target_day][period] # Get all relative paths for this item item_rel_paths = current_item.all_files if is_present: # Add all files from the item target_set.update(item_rel_paths) else: # Remove all files from the item for rel_path in item_rel_paths: target_set.discard(rel_path) # Update the playlist file playlist_dir = self.ensure_playlist_dir(target_day) playlist_file = playlist_dir / period if playlist_file.exists(): with open(playlist_file, 'r') as f: lines = [line.strip() for line in f.readlines()] else: lines = [] # Convert relative paths to absolute for file storage abs_paths = [str(FILES_DIR / rel_path) for rel_path in item_rel_paths] if is_present: for abs_path in abs_paths: if abs_path not in lines: lines.append(abs_path) else: for abs_path in abs_paths: while abs_path in lines: lines.remove(abs_path) with open(playlist_file, 'w') as f: f.write('\n'.join(lines) + ('\n' if lines else '')) return playlists, True class TerminalUtils: @staticmethod def get_char() -> str: """Get a single character from stdin.""" fd = sys.stdin.fileno() old_settings = termios.tcgetattr(fd) try: tty.setraw(sys.stdin.fileno()) ch = sys.stdin.read(1) finally: termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) return ch @staticmethod def clear_screen(): print("\033[2J\033[H", end="", flush=True) @staticmethod def move_cursor(row: int, col: int = 1): print(f"\033[{row};{col}H", end="", flush=True) @staticmethod def clear_line(): print("\033[2K", end="", flush=True) @staticmethod def hide_cursor(): print("\033[?25l", end="", flush=True) @staticmethod def show_cursor(): print("\033[?25h", end="", flush=True) @staticmethod def get_terminal_size() -> os.terminal_size: return shutil.get_terminal_size() class DateUtils: @staticmethod def get_days_of_week() -> List[str]: """Get days of the week starting from today.""" days = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"] today = datetime.now().weekday() return days[today:] + days[:today] class DisplayManager: def __init__(self, terminal_utils: TerminalUtils, config: Config): self.terminal = terminal_utils self.config = config def draw_header(self, current_day_idx: int, days: List[str], term_width: int, force_redraw: bool = False, state: InterfaceState | None = None): """Draw the header, only if content has changed.""" if not state: raise Exception("State required") if self.config.is_custom_mode: # Custom mode header header_content = f"Custom Playlist: {self.config.custom_playlist_file}" else: header_content = " ".join([f"\033[1;44m[{day}]\033[0m" if i == current_day_idx else f"[{day}]" for i, day in enumerate(days)]) # Optimization: Only redraw if content has changed or if forced if force_redraw or state.last_header != header_content: self.terminal.move_cursor(1) self.terminal.clear_line() print(header_content.center(term_width), end="", flush=True) state.last_header = header_content def draw_search_bar(self, search_term: str, force_redraw: bool = False, state: InterfaceState | None = None): """Draw the search bar, only if the search term has changed.""" if not state: raise Exception("State required") # Optimization: Only redraw if search term changes if force_redraw or state.last_search != search_term: self.terminal.move_cursor(4) self.terminal.clear_line() search_display = f"Search: {search_term}" print(f"\033[1;33m{search_display}\033[0m") state.last_search = search_term def draw_files_section(self, file_items: List[FileItem], playlists: Dict, selected_idx: int, current_day: str, scroll_offset: int, term_width: int, term_height: int, force_redraw: bool = False, state: InterfaceState | None = None): """Draw the files list, optimized to only redraw when necessary.""" if not state: raise Exception("State required") available_lines = term_height - 6 start_idx = scroll_offset end_idx = min(start_idx + available_lines, len(file_items)) # Create a snapshot of the current state to compare against the last one files_display_state = ( start_idx, end_idx, selected_idx, current_day, # We also need to know if the playlist data for the visible items has changed tuple(self._get_item_playlist_status(item, playlists, current_day) for item in file_items[start_idx:end_idx]) ) if force_redraw or state.last_files_display != files_display_state: # Position info line self.terminal.move_cursor(6) self.terminal.clear_line() if start_idx > 0: print("↑", end="") else: print(" ", end="") if self.config.is_custom_mode: position_info = f" Custom | Item {selected_idx + 1}/{len(file_items)} " else: position_info = f" {current_day.capitalize()} | Item {selected_idx + 1}/{len(file_items)} " padding = term_width - len(position_info) - 2 print(position_info.center(padding), end="") if end_idx < len(file_items): print("↓", end="", flush=True) else: print(" ", end="", flush=True) # File list for display_row, idx in enumerate(range(start_idx, end_idx)): item = file_items[idx] line_row = 7 + display_row self.terminal.move_cursor(line_row) self.terminal.clear_line() if self.config.is_custom_mode: # In custom mode, only show 'C' for custom playlist in_custom = all(rel_path in playlists.get("custom", {}).get("day", set()) for rel_path in item.all_files) c_color = "\033[1;32m" if in_custom else "\033[1;30m" row_highlight = "\033[1;44m" if idx == selected_idx else "" max_filename_length = term_width - 6 display_name = item.display_name if len(display_name) > max_filename_length: display_name = display_name[:max_filename_length-3] + "..." print(f"{row_highlight}[{c_color}C\033[0m{row_highlight}] {display_name}\033[0m", end="", flush=True) else: # Original weekly mode display in_late_night = all(rel_path in playlists[current_day]['late_night'] for rel_path in item.all_files) in_morning = all(rel_path in playlists[current_day]['morning'] for rel_path in item.all_files) in_day = all(rel_path in playlists[current_day]['day'] for rel_path in item.all_files) in_night = all(rel_path in playlists[current_day]['night'] for rel_path in item.all_files) l_color = "\033[1;32m" if in_late_night else "\033[1;30m" m_color = "\033[1;32m" if in_morning else "\033[1;30m" d_color = "\033[1;32m" if in_day else "\033[1;30m" n_color = "\033[1;32m" if in_night else "\033[1;30m" row_highlight = "\033[1;44m" if idx == selected_idx else "" max_filename_length = term_width - 15 display_name = item.display_name if len(display_name) > max_filename_length: display_name = display_name[:max_filename_length-3] + "..." print(f"{row_highlight}[{l_color}L\033[0m{row_highlight}] [{m_color}M\033[0m{row_highlight}] [{d_color}D\033[0m{row_highlight}] [{n_color}N\033[0m{row_highlight}] {display_name}\033[0m", end="", flush=True) # Clear remaining lines last_end_idx = state.last_files_display[1] if state.last_files_display else 0 if end_idx < last_end_idx: for i in range(end_idx, last_end_idx): self.terminal.move_cursor(7 + (i - start_idx)) self.terminal.clear_line() state.last_files_display = files_display_state def _get_item_playlist_status(self, item: FileItem, playlists: Dict, current_day: str) -> Tuple: """Get playlist status for an item to use in display state comparison.""" if self.config.is_custom_mode: return (all(rel_path in playlists.get("custom", {}).get("day", set()) for rel_path in item.all_files),) else: return ( all(rel_path in playlists[current_day]['late_night'] for rel_path in item.all_files), all(rel_path in playlists[current_day]['morning'] for rel_path in item.all_files), all(rel_path in playlists[current_day]['day'] for rel_path in item.all_files), all(rel_path in playlists[current_day]['night'] for rel_path in item.all_files) ) class Application: def __init__(self, config: Config): self.config = config self.file_manager = FileManager() self.search_manager = SearchManager() self.playlist_manager = PlaylistManager(config) self.terminal = TerminalUtils() self.display = DisplayManager(self.terminal, config) self.terminal_cache = libcache.Cache() self.state = InterfaceState() # Application state self.selected_idx = 0 self.current_day_idx = 0 self.scroll_offset = 0 self.flash_message = None self.message_timer = 0 self.search_term = "" self.in_search_mode = False # Data self.all_file_items = [] self.filtered_file_items = [] self.playlists = {} self.days_of_week = [] self.redraw = False def setup_signal_handler(self): """Setup signal handler for graceful exit.""" def signal_handler(sig, frame): self.terminal.show_cursor() self.terminal.clear_screen() sys.exit(0) signal.signal(signal.SIGINT, signal_handler) def initialize_data(self): """Initialize application data.""" self.all_file_items = self.file_manager.get_file_items(FILES_DIR) if not self.all_file_items: print("No audio files or folders found. Exiting.") return False self.filtered_file_items = self.all_file_items.copy() if self.config.is_custom_mode: self.days_of_week = ["custom"] # Single "day" for custom mode else: self.days_of_week = DateUtils.get_days_of_week() self.playlists = self.playlist_manager.load_playlists(self.days_of_week) return True def update_search(self, new_search: str): """Update search term and filter file items.""" self.search_term = new_search self.filtered_file_items = self.search_manager.filter_file_items(self.all_file_items, self.search_term) # Reset selection if current selection is not in filtered results if self.selected_idx >= len(self.filtered_file_items): self.selected_idx = max(0, len(self.filtered_file_items) - 1) elif self.filtered_file_items and self.selected_idx < len(self.filtered_file_items): # Keep current item selected if it's still in results current_item = self.all_file_items[self.selected_idx] if self.selected_idx < len(self.all_file_items) else None if current_item and current_item in self.filtered_file_items: self.selected_idx = self.filtered_file_items.index(current_item) else: self.selected_idx = 0 def draw_interface(self, force_redraw: bool = False): """Draw the complete interface.""" term_width, term_height = self.terminal_cache.getElement("width", False), self.terminal_cache.getElement("height", False) if term_width is None or term_height is None: term_width, term_height = self.terminal.get_terminal_size() self.terminal_cache.saveElement("width", term_width, 5, False, True) self.terminal_cache.saveElement("height", term_height, 5, False, True) force_redraw = True current_day = self.days_of_week[self.current_day_idx] if force_redraw: self.terminal.clear_screen() self.terminal.hide_cursor() # Draw static elements self.terminal.move_cursor(2) if self.config.is_custom_mode: print("UP/DOWN: Navigate | C: Toggle | /: Search | Q: Quit", end="", flush=True) else: print("UP/DOWN: Navigate | D/N/L/M: Toggle | C: Copy day | F: Copy item | /: Search | Q: Quit", end="", flush=True) self.terminal.move_cursor(3) print("ESC: Exit search | ENTER: Apply search", end="", flush=True) # Draw header self.display.draw_header(self.current_day_idx, self.days_of_week, term_width, force_redraw, self.state) # Draw search bar self.display.draw_search_bar(self.search_term, force_redraw, self.state) # Draw files section self.display.draw_files_section(self.filtered_file_items, self.playlists, self.selected_idx, current_day, self.scroll_offset, term_width, term_height, force_redraw, self.state) # Handle message display if self.flash_message != self.state.last_message: self.terminal.move_cursor(6) self.terminal.clear_line() if self.flash_message: print(f"\033[1;32m{self.flash_message}\033[0m", end="", flush=True) self.state.last_message = self.flash_message def handle_navigation_key(self, key: str): """Handle navigation keys.""" term_width, term_height = self.terminal_cache.getElement("width", False), self.terminal_cache.getElement("height", False) if term_width is None or term_height is None: term_width, term_height = self.terminal.get_terminal_size() visible_lines = term_height - 6 if key == 'A': # Up arrow self.selected_idx = max(0, self.selected_idx - 1) elif key == 'B': # Down arrow self.selected_idx = min(len(self.filtered_file_items) - 1, self.selected_idx + 1) elif key == 'C' and not self.config.is_custom_mode: # Right arrow (disabled in custom mode) self.current_day_idx = (self.current_day_idx + 1) % len(self.days_of_week) elif key == 'D' and not self.config.is_custom_mode: # Left arrow (disabled in custom mode) self.current_day_idx = (self.current_day_idx - 1) % len(self.days_of_week) elif key == '5': # Page Up self.selected_idx = max(0, self.selected_idx - visible_lines) elif key == '6': # Page Down self.selected_idx = min(len(self.filtered_file_items) - 1, self.selected_idx + visible_lines) elif key == '1': # Home self.selected_idx = 0 elif key == '4': # End self.selected_idx = len(self.filtered_file_items) - 1 def toggle_playlist(self, period: str): """Toggle current file item in specified playlist period.""" if not self.filtered_file_items: return current_day = self.days_of_week[self.current_day_idx] file_item = self.filtered_file_items[self.selected_idx] if self.config.is_custom_mode: # In custom mode, all operations work with the "day" period is_in_playlist = self.playlist_manager.is_file_item_in_playlist(file_item, "custom", "day", self.playlists) if is_in_playlist: # Remove all files from the item for rel_path in file_item.all_files: self.playlists["custom"]["day"].discard(rel_path) else: # Add all files from the item self.playlists["custom"]["day"].update(file_item.all_files) self.playlist_manager.update_playlist_file("custom", "day", file_item, not is_in_playlist) else: # Original weekly mode is_in_playlist = self.playlist_manager.is_file_item_in_playlist(file_item, current_day, period, self.playlists) if is_in_playlist: # Remove all files from the item for rel_path in file_item.all_files: self.playlists[current_day][period].discard(rel_path) else: # Add all files from the item self.playlists[current_day][period].update(file_item.all_files) self.playlist_manager.update_playlist_file(current_day, period, file_item, not is_in_playlist) self.redraw = True def handle_search_input(self, key: str): """Handle search input.""" if key == '\x7f' or key == '\x08': # Backspace if self.search_term: self.search_term = self.search_term[:-1] self.update_search(self.search_term) elif key == '\r' or key == '\n': # Enter self.in_search_mode = False elif key == '\x1b': # Escape self.search_term = "" self.update_search(self.search_term) self.in_search_mode = False elif key.isprintable() and len(self.search_term) < 50: self.search_term += key self.update_search(self.search_term) def run(self): """Main application loop.""" if not self.initialize_data(): return 1 self.setup_signal_handler() # Initial draw self.draw_interface(force_redraw=True) try: while True: # Update scroll offset term_width, term_height = self.terminal_cache.getElement("width", False), self.terminal_cache.getElement("height", False) if term_width is None or term_height is None: term_width, term_height = self.terminal.get_terminal_size() visible_lines = term_height - 6 if self.selected_idx < self.scroll_offset: self.scroll_offset = self.selected_idx elif self.selected_idx >= self.scroll_offset + visible_lines: self.scroll_offset = self.selected_idx - visible_lines + 1 # Check if redraw is needed needs_redraw = ( self.state.last_selected_idx != self.selected_idx or self.state.last_current_day_idx != self.current_day_idx or self.state.last_scroll_offset != self.scroll_offset or self.flash_message != self.state.last_message or self.state.last_search != self.search_term or self.redraw ) if needs_redraw: self.draw_interface() self.state.last_selected_idx = self.selected_idx self.state.last_current_day_idx = self.current_day_idx self.state.last_scroll_offset = self.scroll_offset if self.redraw: self.redraw = False # Handle flash message timer if self.flash_message: self.message_timer += 1 if self.message_timer > 1: self.flash_message = None self.message_timer = 0 # Get input key = self.terminal.get_char() # Handle search mode if self.in_search_mode: self.handle_search_input(key) continue # Handle regular input if key == 'q': break elif key == '/': self.in_search_mode = True elif key == '\x1b': # Escape sequences next_key = self.terminal.get_char() if next_key == '[': arrow_key = self.terminal.get_char() self.handle_navigation_key(arrow_key) if arrow_key in ['5', '6', '1', '4']: try: self.terminal.get_char() # Consume the ~ character except: pass elif key == ' ': self.selected_idx = min(len(self.filtered_file_items) - 1, self.selected_idx + (term_height - 6)) elif key.lower() == 'c': if self.config.is_custom_mode: # In custom mode, 'c' toggles the custom playlist self.toggle_playlist('day') else: # In weekly mode, 'c' copies day to all current_day = self.days_of_week[self.current_day_idx] self.playlists = self.playlist_manager.copy_day_to_all(self.playlists, current_day, self.days_of_week) self.flash_message = f"Playlists from {current_day} copied to all other days!" self.message_timer = 0 elif key.lower() == 'm' and not self.config.is_custom_mode: self.toggle_playlist('morning') elif key.lower() == 'd' and not self.config.is_custom_mode: self.toggle_playlist('day') elif key.lower() == 'n' and not self.config.is_custom_mode: self.toggle_playlist('night') elif key.lower() == 'l' and not self.config.is_custom_mode: self.toggle_playlist('late_night') elif key.lower() == 'f' and not self.config.is_custom_mode: if self.filtered_file_items: current_day = self.days_of_week[self.current_day_idx] current_item = self.filtered_file_items[self.selected_idx] self.playlists, success = self.playlist_manager.copy_current_item_to_all(self.playlists, current_day, self.days_of_week, current_item) if success: item_name = current_item.display_name self.flash_message = f"Item '{item_name}' copied to all days!" else: self.flash_message = f"Item not in any playlist! Add it first." self.message_timer = 0 elif key.isupper() and len(key) == 1 and key.isalpha(): # Jump to item starting with letter target_letter = key.lower() found_idx = -1 for i in range(self.selected_idx + 1, len(self.filtered_file_items)): if self.filtered_file_items[i].name.lower().startswith(target_letter): found_idx = i break if found_idx == -1: for i in range(0, self.selected_idx): if self.filtered_file_items[i].name.lower().startswith(target_letter): found_idx = i break if found_idx != -1: self.selected_idx = found_idx finally: self.terminal.show_cursor() self.terminal.clear_screen() return 0 def parse_arguments(): """Parse command line arguments.""" parser = argparse.ArgumentParser( description="Audio Playlist Manager", prog="radioPlaylist" ) parser.add_argument( "-p", "--playlist", type=str, help="Custom playlist output file (e.g., /tmp/list.txt)" ) return parser.parse_args() def main(): """Main entry point.""" args = parse_arguments() fd = sys.stdin.fileno() original_settings = termios.tcgetattr(fd) new_settings = termios.tcgetattr(fd) new_settings[3] = new_settings[3] & ~termios.ECHOCTL termios.tcsetattr(fd, termios.TCSADRAIN, new_settings) config = Config(custom_playlist_file=args.playlist) app = Application(config) code = app.run() termios.tcsetattr(fd, termios.TCSADRAIN, original_settings) exit(code) if __name__ == "__main__": main()