diff --git a/.gitignore b/.gitignore
index 08263483..eadc9849 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,4 +19,5 @@ tags
 env/
 .idea/
 venv/
-test.py
\ No newline at end of file
+test.py
+uv.lock
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..a96d1883
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,47 @@
+# Repository Guidelines
+
+## Project structure & module organization
+This repository is a Python CLI application packaged as `yewtube`.
+Core code lives in `mps_youtube/`, with command handlers in
+`mps_youtube/commands/`, player backends in `mps_youtube/players/`, and
+list rendering helpers in `mps_youtube/listview/`. Project configuration is in
+`pyproject.toml`, dependency locking is in `uv.lock`, and packaging metadata is
+in `yewtube.egg-info/`.
+
+## Build, test, and development commands
+Use `uv` for local workflows.
+
+- `uv sync` installs runtime and dev dependencies from `pyproject.toml` and
+  `uv.lock`.
+- `uv run yt` runs the CLI entry point (`yt = mps_youtube.main:main`).
+- `uv run ruff check .` runs lint checks.
+- `uv run ruff check . --fix` auto-fixes safe lint issues.
+- `uv run python -m mps_youtube.main` runs the app directly during debugging.
+
+## Coding style & naming conventions
+Follow the existing Python style in `mps_youtube/`.
+
+- Use 4-space indentation and keep lines readable around the configured
+  80-character target.
+- Keep module and function names `snake_case`, classes `PascalCase`, and
+  constants `UPPER_SNAKE_CASE`.
+- Prefer small, focused command modules under `mps_youtube/commands/`.
+- Run `ruff` before committing; lint rules are configured in
+  `pyproject.toml`.
+
+## Testing guidelines
+There is currently no dedicated automated test suite in this repository.
+
+- Add new tests under a top-level `tests/` directory using `test_*.py` naming.
+- For behavior changes, include at least one automated test or document manual
+  verification steps in your pull request.
+- Minimum manual check: run `uv run yt` and verify the changed command path.
+
+## Commit & pull request guidelines
+The current Git history uses short, imperative commit messages
+(for example, `Capture current state for review`, `initial commit`).
+
+- Write concise, imperative commits focused on one logical change.
+- In pull requests, include: what changed, why, and how you validated it.
+- Link related issues when available and include terminal output or screenshots
+  for user-visible CLI behavior changes.
diff --git a/GEMINI.md b/GEMINI.md
new file mode 100644
index 00000000..f861a5e1
--- /dev/null
+++ b/GEMINI.md
@@ -0,0 +1,46 @@
+# yewtube (yt) - Terminal YouTube Player
+
+This directory is a specialized workspace for **yewtube** (a fork of `mps-youtube`), a terminal-based YouTube player and downloader that does not require a YouTube API key.
+
+## Project Overview
+
+- **Purpose**: Search, stream, and download YouTube content directly from the command line.
+- **Core Technologies**: Python 3.x, `yt-dlp`, `requests`, `pafy`, and `youtube-search-python`.
+- **Playback Engines**: Supports `mpv`, `mplayer`, and `VLC`.
+- **Architecture**: A terminal-based interactive CLI that interfaces with YouTube's web interface (via `pafy` and `yt-dlp`) to bypass API requirements.
+
+## Environment & Tools
+
+The project is managed via a `uv` virtual environment located in `.venv/`.
+
+### Key Executables
+- `yt`: The main interactive terminal interface.
+- `yt-dlp`: The underlying engine used for downloading and extracting media information.
+
+## Usage Guide
+
+To start the interface, run:
+```bash
+./.venv/bin/yt
+```
+
+### Common Commands (Internal to `yt`)
+- `/ <search terms>`: Search for videos.
+- `// <search terms>`: Search for playlists.
+- `1-5`: Play videos 1 through 5.
+- `d 1`: Download video 1.
+- `set <option> <value>`: Configure settings (e.g., `set player mpv`).
+- `h`: Show help.
+
+## Development Context
+
+- **Fork Status**: This is a fork of the original `mps-youtube` project, maintained to ensure continued functionality without official API keys.
+- **Configuration**: User configuration and local playlists are typically stored in `~/.config/mps-youtube` or `~/.config/yewtube`.
+- **Dependencies**: Relies heavily on `yt-dlp` for extracting streams. If playback fails, updating `yt-dlp` is often the first step:
+  ```bash
+  ./.venv/bin/python -m pip install -U yt-dlp
+  ```
+
+## Troubleshooting
+
+If you encounter `ModuleNotFoundError: No module named 'pip'` when running `yt`, it may be due to the specific `uv` environment configuration. Ensure all dependencies are correctly linked in `site-packages`.
diff --git a/IMPROVEMENTS.md b/IMPROVEMENTS.md
new file mode 100644
index 00000000..1c8a84ac
--- /dev/null
+++ b/IMPROVEMENTS.md
@@ -0,0 +1,119 @@
+# Improvements and Modernization of yewtube
+
+This document tracks the significant refactoring and modernizations applied to the yewtube (mps-youtube fork) terminal application.
+
+## 1. Dependency Modernization (Completed)
+- **Metadata Management**: Replaced legacy `pkg_resources` (via `pip._vendor`) with `importlib.metadata`, ensuring compatibility with Python 3.12+ and environments without `pip` internals.
+- **Environment Cleanup**: Removed unused or redundant pip modules including `gnureadline` (replaced by `prompt_toolkit`), `requests`, `charset-normalizer`, and `urllib3`, reducing the application footprint.
+
+## 2. CLI & Interactive Shell (Completed)
+- **Framework Migration**: Migrated from manual argument parsing to `click`, providing robust help generation and standard CLI patterns.
+- **Shell Upgrade**: Replaced standard `readline` with `prompt_toolkit` for all interactive input.
+- **Intelligent Completion**: Implemented a `CommandCompleter` with context-aware logic:
+    *   Suggests `true`/`false` only for boolean configuration items.
+    *   Provides playlist name completions for `open`, `view`, etc.
+    *   Provides command-specific sub-argument completions (e.g., for `sort`).
+- **Enhanced Exit Flow**: Improved the Ctrl-C exit confirmation prompt to support command history and tab completion.
+
+## 3. Playback Engine & mpv Integration (Completed)
+- **Robust IPC Communication**: Rewrote the `mpv` integration to use IPC sockets with improved connection retry logic and secure temporary directory management.
+- **Asynchronous Error Capture**: Implemented a background thread to capture `mpv` stderr, allowing the application to detect and report fatal initialization errors (e.g., driver failures) to the UI.
+- **Persistent Error Reporting**: Modified the playback loop to display captured errors for 3 seconds before refreshing, ensuring users can diagnose failures.
+- **Output Management**:
+    *   Muted standard diagnostic output (stdout) to keep the terminal clean.
+    *   Unified video suppression logic (fixed crashes when passing both `--no-video` and `--vid=no`).
+    *   Removed redundant double-quoting in subprocess arguments.
+- **Extensibility**: Added the `aux_mpv_cli_config` setting to allow users to pass arbitrary additional command-line arguments to `mpv`.
+- **Keyboard Interactivity**: Restored standard input flow to `mpv` while maintaining clean terminal output, ensuring Space (pause) and Arrow keys (seek) work during playback.
+
+## 4. Metadata & Sorting (Completed)
+- **Search Metadata**: Patched `youtubesearchpython` to correctly extract `publishedTime` from YouTube's varying renderer formats.
+- **Chronological Sorting**: Implemented a weight-based heuristic to convert relative upload strings (e.g., "2 weeks ago", "5 months ago") into sortable numeric values, fixing alphabetical sorting bugs.
+- **Matching Accuracy**: Improved the `best_song_match` algorithm in `album_search` and `spotify_playlist` by fixing duration variance scoring and preventing negative score components.
+
+## 5. Security & Reliability Fixs (Completed)
+- **Resource Management**: Implemented context managers for file downloads to prevent file handle leaks during network interruptions.
+- **Insecure Temp Files**: Replaced `tempfile.mktemp` with secure `tempfile.mkdtemp` in both `mpv` and `mplayer` backends to prevent race conditions.
+- **Safe Process Control**: Refactored the `VLC` backend to use granular process termination (`terminate()`) instead of aggressive system-wide `pkill`.
+- **API Modernization**: Replaced all remaining legacy `pafy.call_gdata` calls with modern search and metadata retrieval methods across `generate_playlist`, `spotify_playlist`, and `description_parser`.
+- **Input Robustness**: Fixed potential `IndexError` in the duration parser and `ZeroDivisionError` in metadata matching logic.
+- **Shadowing Fixes**: Resolved variable shadowing (e.g., `c` loop variable vs `c` color module) to prevent subtle logic errors.
+
+## 6. Code Quality (Completed)
+- **Linting & Formatting**: Adopted `ruff` for fast linting and formatting.
+- **Consistency**: Standardized on an 80-character line limit and project-wide formatting.
+- **Type Safety**: Converted bare `except` blocks to explicit `except Exception:` to prevent catching system signals or masking fatal errors.
+
+## 7. User Interface & Playback Control (Completed)
+- **Clean Playback UI**: Streamlined the status bar by replacing the scrolling track size and YouTube ID with a static track title (truncated to 20 characters), providing a cleaner and more readable playback experience.
+- **Sequential Autoplay**: Overhauled the `AUTOPLAY` logic to implement a predictable sequential flow through the current song list. This removed redundant random-related-video recursion in favor of stable list traversal.
+- **Advanced Navigation**:
+    - **Skip to Next**: Re-mapped the `q` key to skip to the next track when `AUTOPLAY` is enabled, rather than stopping playback.
+    - **Previous Track ('p')**: Added the `p` key for previous track navigation in both `mpv` and `mplayer` backends.
+    - **Help Legend**: Updated the in-player help text to dynamically show `[p] prev [q] next` when autoplay is active.
+- **Context-Aware Playback**: Refactored the playback command to provide the player with full list context and a `start_index`. This ensures that navigation keys (`p`/`q`) can correctly traverse the entire original list even when a single track is selected for play.
+- **MPlayer Modernization**: Restored standard terminal interactivity (`stdin`) to the `mplayer` backend, ensuring parity with `mpv` for keyboard controls like pause and seek.
+- **Diagnostic Transparency**: Improved exception handling in metadata retrieval to surface original error messages, aiding in the diagnosis of private or geo-restricted content.
+
+## 8. Extractor Modernization (yt-dlp Transition)
+- **Unified Extraction Layer**: Replaced the legacy `pafy` module with a modern `extractor.py` abstraction. This layer directly interfaces with `yt-dlp` and `youtubesearchpython`, providing a stable and high-performance foundation for all media operations.
+- **VideoInfo Abstraction**: Implemented a standardized `VideoInfo` class that ensures consistent metadata access across the entire application, eliminating brittle dictionary-key dependencies.
+- **Enhanced Stream Selection**:
+    - Leveraged `yt-dlp`'s detailed format metadata for more accurate stream identification (audio vs mixed vs video-only).
+    - Improved resolution-based filtering and bitrate-aware sorting for higher quality playback.
+    - Added resilient expiry parsing for stream URLs to optimize playback start times.
+- **Global terminology migration**: Conducted a project-wide cleanup to remove all legacy `pafy` naming from imports, variables, and global caches (e.g., `g.pafs` -> `g.metadata_cache`).
+- **Improved Metadata Retrieval**: Unified search and playlist metadata processing to use modern scraping techniques, significantly reducing "no results" or "extraction failed" errors.
+- **Search Fallback Mechanism**: Implemented a robust fallback to `yt-dlp` for video searches when `youtubesearchpython` crashes or fails (common with high-profile artists like 'Lana Del Rey' due to complex shelf renderers).
+
+## 9. Full yt-dlp Migration (Completed)
+- **Eliminated Scraping Dependencies**: Successfully migrated the entire application from `youtube-search-python` to an internal `yt-dlp` and direct API-based implementation. This removes fragile HTML scraping dependencies that frequently broke on YouTube UI updates.
+- **Unified Search Engine**: All search types (video, playlist, and channel) now use the robust `yt-dlp` search backend with optimized filters (e.g., `sp=EgIQAw%3D%3D` for playlists).
+- **High-Performance Discovery**: 
+    - **Playlist Loading**: Re-implemented `get_playlist` using `yt-dlp`'s `extract_flat` mode, providing significantly faster loading of large playlists.
+    - **Channel Content**: Refactored channel video and playlist retrieval to use `yt-dlp`, ensuring stable metadata across the discovery workflow.
+- **Lightweight Suggestions**: Replaced the legacy `Suggestions` class with a direct, asynchronous-ready API call to the Google Suggest service, reducing overhead and improving response times.
+- **Advanced Metadata**: 
+    - **Comment Extraction**: Re-integrated video comment viewing using `yt-dlp`'s `getcomments` capability.
+    - **Dislike Restoration**: Maintained integration with the `Return YouTube Dislike` API alongside `yt-dlp` metadata.
+
+## 10. Search Performance Optimization (Completed)
+- **Extractor Filtering**: Optimized `yt-dlp` initialization by restricting allowed extractors to `youtube:search` and `youtube`, cutting search startup time by reducing unnecessary extractor checks.
+- **Lazy Extraction**: Enabled `lazy_extract` for all search types, allowing the application to fetch result lists without waiting for detailed metadata for every individual entry.
+- **Disk I/O Reduction**: Disabled the `yt-dlp` cache directory for search operations to eliminate unnecessary disk writes during ephemeral queries.
+
+## 11. Architectural Refinements (Completed)
+- **Robust Metadata Mapping**: Implemented a `MockPlaylist` compatibility layer to bridge `yt-dlp` raw output with the existing UI, preventing attribute errors during display.
+- **Safe Network Handling**: Added timeouts and comprehensive error handling to all network-bound operations (e.g., content-length retrieval and search suggestions).
+- **Resolution Resilience**: Hardened the stream selection logic to handle non-standard or malformed resolution strings (e.g., "720p" vs "1280x720") common in `yt-dlp` results.
+- **Initialization Integrity**: Improved the main entry point to ensure the application stops immediately on initialization failures, preventing cascaded state errors.
+- **Pydantic Configuration**: Migrated the legacy custom configuration system to Pydantic `BaseSettings`. This provides robust type validation, environment variable support, and modern JSON serialization while maintaining full backward compatibility with the existing interactive CLI through a bridge layer.
+
+## 12. Recent Stabilization Updates (Completed)
+- **Argparse Unification**: Standardized CLI parsing on `argparse` end-to-end, removing the mixed parser state that previously caused runtime namespace mismatches.
+- **CLI Cookie Support**: Added first-class authentication switches:
+    - `--cookies <path>` for Netscape-format cookie files.
+    - `--cookies-from-browser <browser[:profile]>` for direct browser cookie loading.
+- **Cookie Source Hardening**: Removed cookie loading from environment variables and switched to explicit CLI-driven configuration (with `~/.config/mps-youtube/cookies.txt` fallback support retained in extractor logic).
+- **Browser-like Request Headers**: Added a shared browser User-Agent/header profile and applied it consistently to `yt-dlp` and direct HTTP requests to reduce anti-bot false positives.
+- **Search Error Noise Reduction**: Suppressed the specific YouTube bot-check warning when search results are still successfully returned, while preserving errors for empty/failed searches.
+- **Runtime Regression Fixes**:
+    - Restored `g.text` binding to fix `module 'mps_youtube.g' has no attribute 'text'`.
+    - Hardened CLI argument access in initialization to avoid missing-attribute crashes.
+    - Replaced stray runtime `print()` calls with debug logging in playback/config paths.
+- **Lint & Consistency Pass**: Ran a project-wide `ruff --fix` cleanup and resolved remaining manual lint issues.
+
+## 13. Hybrid Discovery Engine (Completed)
+- **Migrated to `youtube-search-next`**: Switched discovery (search, playlists, channels) to the `youtube-search-next` library for high-speed, maintained access to the YouTube internal API.
+- **Unified Extractor**: Updated `extractor.py` to prioritize library-based discovery while retaining `yt-dlp` as a robust fallback for complex metadata and restricted content.
+- **Redundant Code Removal**: Deleted the manual `mps_youtube/innertube.py` implementation as its functionality is now superiorly handled by the external library.
+
+## 14. Playback & UI Reliability Updates (Completed)
+- **MPRIS Navigation Enhancement**: Added dedicated exit codes (44, 45) for Next and Previous commands. This allows the playback loop to distinguish manual MPRIS skips from natural player exits, ensuring reliable queue progression.
+- **Fixed Track Date Display**: 
+    - Improved metadata parsing to extract upload ages (e.g., "5 months ago") from `accessibility` labels when standard fields are missing.
+    - Increased default column sizes for "Date" and "Time" from 8 to 14 characters to prevent truncation of relative date strings.
+- **Stream Extraction Stability**: 
+    - Refactored `StreamURLFetcher` to use the `yt-dlp` backend for URL resolution, eliminating 403 Forbidden errors encountered with the library-based fetcher.
+    - Fixed a critical playback bug by ensuring `vcodec` and `acodec` are always normalized to lowercase strings (e.g., `'none'`), preventing empty stream lists.
+- **Full Channel Metadata**: Implemented a direct Innertube `browse` call for the `user <name>` command to retrieve complete video metadata (age, view counts) which is often stripped in flat playlist listings.
diff --git a/mps_youtube/.gitignore b/mps_youtube/.gitignore
new file mode 100644
index 00000000..033df5fb
--- /dev/null
+++ b/mps_youtube/.gitignore
@@ -0,0 +1,2 @@
+.venv
+__pycache__
diff --git a/mps_youtube/__init__.py b/mps_youtube/__init__.py
index dcf16e21..32b0be7a 100644
--- a/mps_youtube/__init__.py
+++ b/mps_youtube/__init__.py
@@ -1,7 +1,10 @@
-from pip._vendor import pkg_resources
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("yewtube")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "unable to determine"
 
-__version__ = next((p.version for p in pkg_resources.working_set if p.project_name.lower() == 'yewtube'), "unable to determine")
 __author__ = "iamtalhaasghar"
 __license__ = "GPLv3"
 __url__ = "https://github.com/mps-youtube/yewtube"
-
diff --git a/mps_youtube/c.py b/mps_youtube/c.py
index 0021f4e7..1a83e9d7 100644
--- a/mps_youtube/c.py
+++ b/mps_youtube/c.py
@@ -1,4 +1,4 @@
-""" Module for holding colour code values. """
+"""Module for holding colour code values."""
 
 import os
 import re
@@ -8,23 +8,25 @@
     white = "\x1b[%sm" % 0
     ul = "\x1b[%sm" * 2 % (2, 4)
 
-    if not os.getenv('NO_COLOR'):
+    if not os.getenv("NO_COLOR"):
         ul += "\x1b[%33m"
 
     cols = ["\x1b[%sm" % n for n in range(91, 96)]
-    red, green, yellow, blue, pink = [""]*5 if os.getenv('NO_COLOR') else cols
+    red, green, yellow, blue, pink = [""] * 5 if os.getenv("NO_COLOR") else cols
 else:
     ul = red = green = yellow = blue = pink = white = ""
 
 r, g, y, b, p, w = red, green, yellow, blue, pink, white
 
-ansirx = re.compile(r'\x1b\[\d*m', re.UNICODE)
+ansirx = re.compile(r"\x1b\[\d*m", re.UNICODE)
+
 
 def c(colour, text):
-    """ Return coloured text. """
-    colours = {'r': r, 'g': g, 'y': y, 'b':b, 'p':p}
+    """Return coloured text."""
+    colours = {"r": r, "g": g, "y": y, "b": b, "p": p}
     return colours[colour] + text + w
 
+
 def charcount(s):
-    """ Return number of characters in string, with ANSI color codes excluded. """
-    return len(ansirx.sub('', s))
+    """Return number of characters in string, with ANSI color codes excluded."""
+    return len(ansirx.sub("", s))
diff --git a/mps_youtube/cache.py b/mps_youtube/cache.py
index 6d11f920..c8f8c915 100644
--- a/mps_youtube/cache.py
+++ b/mps_youtube/cache.py
@@ -10,28 +10,27 @@
 # So old cache can be dropped
 CACHE_VERSION = 1
 
+
 def load():
-    """ Import cache file. """
+    """Import cache file."""
     if os.path.isfile(g.CACHEFILE):
-
         try:
-
             with open(g.CACHEFILE, "rb") as cf:
                 cached = pickle.load(cf)
 
             # Note: will be none for yewtube 0.2.5 or earlier
-            version = cached.get('version')
+            version = cached.get("version")
 
-            if 'streams' in cached:
+            if "streams" in cached:
                 if version and version >= 1:
-                    g.streams = cached['streams']
-                    g.username_query_cache = cached['userdata']
+                    g.streams = cached["streams"]
+                    g.username_query_cache = cached["userdata"]
             else:
                 g.streams = cached
 
-            if 'pafy' in cached:
+            if "extractor" in cached:
                 pass
-                #pafy.load_cache(cached['pafy'])
+                # extractor.load_cache(cached['extractor'])
 
             dbg(c.g + "%s cached streams imported%s", str(len(g.streams)), c.w)
 
@@ -42,12 +41,12 @@ def load():
 
 
 def save():
-    """ Save stream cache. """
+    """Save stream cache."""
     caches = dict(
         version=CACHE_VERSION,
         streams=g.streams,
-        userdata=g.username_query_cache
-        #,pafy=pafy.dump_cache()
+        userdata=g.username_query_cache,
+        # ,extractor=extractor.dump_cache()
     )
 
     with open(g.CACHEFILE, "wb") as cf:
diff --git a/mps_youtube/commands/__init__.py b/mps_youtube/commands/__init__.py
index 4d8ab0b0..f025289f 100644
--- a/mps_youtube/commands/__init__.py
+++ b/mps_youtube/commands/__init__.py
@@ -2,14 +2,15 @@
 import re
 
 from .. import g
-from ..main import completer
+from ..util import completer
 
-Command = collections.namedtuple('Command', 'regex category usage function')
+Command = collections.namedtuple("Command", "regex category usage function")
 
 # input types
-WORD = r'[^\W\d][-\w\s]{,100}'
-RS = r'(?:(?:repeat|shuffle|-[avfw])\s*)'
-PL = r'\S*?((?:RD|PL|LL|UU|FL|OL)[-_0-9a-zA-Z]+)\s*'
+WORD = r"[^\W\d][-\w\s]{,100}"
+RS = r"(?:(?:repeat|shuffle|-[avfw])\s*)"
+PL = r"\S*?((?:RD|PL|LL|UU|FL|OL)[-_0-9a-zA-Z]+)\s*"
+
 
 ## @command decorator
 ##
@@ -23,16 +24,26 @@
 ## arguments, append the completion string on EACH function, not only
 ## the first time you register it.
 def command(regex, *commands):
-    """ Decorator to register an mps-youtube command. """
+    """Decorator to register an mps-youtube command."""
     for command in commands:
         completer.add_cmd(command)
+
     def decorator(function):
         cmd = Command(re.compile(regex), None, None, function)
         g.commands.append(cmd)
         return function
+
     return decorator
 
 
 # Placed at bottom to deal with cyclic imports
-from . import download, search, album_search, spotify_playlist, misc, config, local_playlist
+from . import (
+    download,
+    search,
+    album_search,
+    spotify_playlist,
+    misc,
+    config,
+    local_playlist,
+)
 from . import play, songlist, generate_playlist, lastfm
diff --git a/mps_youtube/commands/album_search.py b/mps_youtube/commands/album_search.py
index e0e7dd03..11f88f48 100644
--- a/mps_youtube/commands/album_search.py
+++ b/mps_youtube/commands/album_search.py
@@ -7,7 +7,7 @@
 from xml.etree import ElementTree as ET
 
 
-from .. import c, g, screen, __version__, __url__, config, util, pafy
+from .. import c, g, screen, __version__, __url__, config, util, extractor
 from .. import content as content_py
 from . import command
 from .songlist import paginatesongs
@@ -15,7 +15,7 @@
 
 
 def show_message(message, col=c.r, update=False):
-    """ Show message using col, update screen if required. """
+    """Show message using col, update screen if required."""
     g.content = content_py.generate_songlist_display()
     g.message = col + message + c.w
 
@@ -23,8 +23,8 @@ def show_message(message, col=c.r, update=False):
         screen.update()
 
 
-def _do_query(url, query, err='query failed', report=False):
-    """ Perform http request using yewtube user agent header.
+def _do_query(url, query, err="query failed", report=False):
+    """Perform http request using yewtube user agent header.
 
     if report is True, return whether response is from memo
 
@@ -32,7 +32,7 @@ def _do_query(url, query, err='query failed', report=False):
     # create url opener
     ua = "mps-youtube/%s ( %s )" % (__version__, __url__)
     mpsyt_opener = build_opener()
-    mpsyt_opener.addheaders = [('User-agent', ua)]
+    mpsyt_opener.addheaders = [("User-agent", ua)]
 
     # convert query to sorted list of tuples (needed for consistent url_memo)
     query = [(k, query[k]) for k in sorted(query.keys())]
@@ -50,7 +50,7 @@ def _do_query(url, query, err='query failed', report=False):
 
 
 def _best_song_match(songs, title, duration, titleweight, durationweight):
-    """ Select best matching song based on title, length.
+    """Select best matching song based on title, length.
 
     Score from 0 to 1 where 1 is best. titleweight and durationweight
     parameters added to enable function usage when duration can't be guessed
@@ -60,8 +60,8 @@ def _best_song_match(songs, title, duration, titleweight, durationweight):
     seqmatch = difflib.SequenceMatcher
 
     def variance(a, b):
-        """ Return difference ratio. """
-        return float(abs(a - b)) / max(a, b)
+        """Return difference ratio."""
+        return float(abs(a - b)) / max(a, b) if max(a, b) > 0 else 0
 
     candidates = []
 
@@ -89,8 +89,9 @@ def variance(a, b):
 
         title_score = seqmatch(None, title.lower(), tit.lower()).ratio()
         duration_score = 1 - variance(duration, dur)
-        util.dbg("Title score: %s, Duration score: %s", title_score,
-                 duration_score)
+        util.dbg(
+            "Title score: %s, Duration score: %s", title_score, duration_score
+        )
 
         # apply weightings
         score = duration_score * durationweight + title_score * titleweight
@@ -102,7 +103,7 @@ def variance(a, b):
 
 
 def _match_tracks(artist, title, mb_tracks):
-    """ Match list of tracks in mb_tracks by performing multiple searches. """
+    """Match list of tracks in mb_tracks by performing multiple searches."""
     # pylint: disable=R0914
     util.dbg("artists is %s", artist)
     util.dbg("title is %s", title)
@@ -110,22 +111,26 @@ def _match_tracks(artist, title, mb_tracks):
     util.xprint("\nSearching for %s by %s\n\n" % title_artist_str)
 
     def dtime(x):
-        """ Format time to M:S. """
-        return time.strftime('%M:%S', time.gmtime(int(x)))
+        """Format time to M:S."""
+        return time.strftime("%M:%S", time.gmtime(int(x)))
 
     # do matching
     for track in mb_tracks:
-        ttitle = track['title']
-        length = track['length']
-        util.xprint("Search :  %s%s - %s%s - %s" % (c.y, artist, ttitle, c.w,
-                                                    dtime(length)))
+        ttitle = track["title"]
+        length = track["length"]
+        util.xprint(
+            "Search :  %s%s - %s%s - %s"
+            % (c.y, artist, ttitle, c.w, dtime(length))
+        )
         q = "%s %s" % (artist, ttitle)
         w = q = ttitle if artist == "Various Artists" else q
-        query = w#generate_search_qs(w, 0)
+        query = w  # generate_search_qs(w, 0)
         util.dbg(query)
 
         # perform fetch
-        wdata = pafy.search_videos(q, int(config.PAGES.get))  # pafy.call_gdata('search', query)
+        wdata = extractor.search_videos(
+            q, int(config.PAGES.get)
+        )  # extractor.call_gdata('search', query)
         results = get_tracks_from_json(wdata)
 
         if not results:
@@ -133,34 +138,37 @@ def dtime(x):
             continue
 
         s, score = _best_song_match(
-            results, artist + " " + ttitle, length, .5, .5)
+            results, artist + " " + ttitle, length, 0.5, 0.5
+        )
         cc = c.g if score > 85 else c.y
         cc = c.r if score < 75 else cc
-        util.xprint("Matched:  %s%s%s - %s \n[%sMatch confidence: "
-                    "%s%s]\n" % (c.y, s.title, c.w, util.fmt_time(s.length),
-                                 cc, score, c.w))
+        util.xprint(
+            "Matched:  %s%s%s - %s \n[%sMatch confidence: "
+            "%s%s]\n"
+            % (c.y, s.title, c.w, util.fmt_time(s.length), cc, score, c.w)
+        )
         yield s
 
 
 def _get_mb_tracks(albumid):
-    """ Get track listing from MusicBraiz by album id. """
-    ns = {'mb': 'http://musicbrainz.org/ns/mmd-2.0#'}
+    """Get track listing from MusicBraiz by album id."""
+    ns = {"mb": "http://musicbrainz.org/ns/mmd-2.0#"}
     url = "http://musicbrainz.org/ws/2/release/" + albumid
     query = {"inc": "recordings"}
-    wdata = _do_query(url, query, err='album search error')
+    wdata = _do_query(url, query, err="album search error")
 
     if not wdata:
         return None
 
     root = ET.fromstring(wdata)
-    tlist = root.find("./mb:release/mb:medium-list/mb:medium/mb:track-list",
-                      namespaces=ns)
+    tlist = root.find(
+        "./mb:release/mb:medium-list/mb:medium/mb:track-list", namespaces=ns
+    )
     mb_songs = tlist.findall("mb:track", namespaces=ns)
     tracks = []
     path = "./mb:recording/mb:"
 
     for track in mb_songs:
-
         try:
             title, length, rawlength = "unknown", 0, 0
             title = track.find(path + "title", namespaces=ns).text
@@ -176,12 +184,13 @@ def _get_mb_tracks(albumid):
 
 
 def _get_mb_album(albumname, **kwa):
-    """ Return artist, album title and track count from MusicBrainz. """
+    """Return artist, album title and track count from MusicBrainz."""
     url = "http://musicbrainz.org/ws/2/release/"
     qargs = dict(
         release='"%s"' % albumname,
         primarytype=kwa.get("primarytype", "album"),
-        status=kwa.get("status", "official"))
+        status=kwa.get("status", "official"),
+    )
     qargs.update({k: '"%s"' % v for k, v in kwa.items()})
     qargs = ["%s:%s" % item for item in qargs.items()]
     qargs = {"query": " AND ".join(qargs)}
@@ -191,24 +200,27 @@ def _get_mb_album(albumname, **kwa):
     if not wdata:
         return None
 
-    ns = {'mb': 'http://musicbrainz.org/ns/mmd-2.0#'}
+    ns = {"mb": "http://musicbrainz.org/ns/mmd-2.0#"}
     root = ET.fromstring(wdata)
     rlist = root.find("mb:release-list", namespaces=ns)
 
-    if int(rlist.get('count')) == 0:
+    if int(rlist.get("count")) == 0:
         return None
 
     album = rlist.find("mb:release", namespaces=ns)
-    artist = album.find("./mb:artist-credit/mb:name-credit/mb:artist",
-                        namespaces=ns).find("mb:name", namespaces=ns).text
+    artist = (
+        album.find("./mb:artist-credit/mb:name-credit/mb:artist", namespaces=ns)
+        .find("mb:name", namespaces=ns)
+        .text
+    )
     title = album.find("mb:title", namespaces=ns).text
-    aid = album.get('id')
+    aid = album.get("id")
     return dict(artist=artist, title=title, aid=aid)
 
 
-@command(r'album\s*(.{0,500})', 'album')
+@command(r"album\s*(.{0,500})", "album")
 def search_album(term):
-    """Search for albums. """
+    """Search for albums."""
     # pylint: disable=R0914,R0912
     if not term:
         show_message("Enter album name:", c.g, update=True)
@@ -225,12 +237,11 @@ def search_album(term):
         show_message("Album '%s' not found!" % term)
         return
 
-    prompt = "Artist? [%s] > " % album['artist']
+    prompt = "Artist? [%s] > " % album["artist"]
     util.xprint(prompt, end="")
     artistentry = input().strip()
 
     if artistentry:
-
         if artistentry == "q":
             show_message("Album search abandoned!")
             return
@@ -241,8 +252,8 @@ def search_album(term):
             show_message("Album '%s' by '%s' not found!" % (term, artistentry))
             return
 
-    title, artist = album['title'], album['artist']
-    mb_tracks = _get_mb_tracks(album['aid'])
+    title, artist = album["title"], album["artist"]
+    mb_tracks = _get_mb_tracks(album["aid"])
 
     if not mb_tracks:
         show_message("Album '%s' by '%s' has 0 tracks!" % (title, artist))
@@ -253,7 +264,7 @@ def search_album(term):
     g.message = msg
     g.content = "Tracks:\n"
     for n, track in enumerate(mb_tracks, 1):
-        g.content += "%02s  %s" % (n, track['title'])
+        g.content += "%02s  %s" % (n, track["title"])
         g.content += "\n"
 
     screen.update()
@@ -291,10 +302,18 @@ def search_album(term):
             g.album = title
             g.scrobble = True
             # Fill up queue with all the track names
-            g.scrobble_queue = [t['title'] for t in mb_tracks]
+            g.scrobble_queue = [t["title"] for t in mb_tracks]
 
     msg = "Contents of album %s%s - %s%s %s(%d/%d)%s:" % (
-        c.y, artist, title, c.w, c.b, len(songs), len(mb_tracks), c.w)
+        c.y,
+        artist,
+        title,
+        c.w,
+        c.b,
+        len(songs),
+        len(mb_tracks),
+        c.w,
+    )
     failmsg = "Found no album tracks for %s%s%s" % (c.y, title, c.w)
 
     paginatesongs(songs, msg=msg, failmsg=failmsg)
diff --git a/mps_youtube/commands/config.py b/mps_youtube/commands/config.py
index a9a390af..828858cf 100644
--- a/mps_youtube/commands/config.py
+++ b/mps_youtube/commands/config.py
@@ -2,9 +2,9 @@
 from . import command
 
 
-@command(r'set|showconfig', 'set', 'showconfig')
+@command(r"set|showconfig", "set", "showconfig")
 def showconfig():
-    """ Dump config data. """
+    """Dump config data."""
     width = util.getxy().width
     longest_key = 17
     longest_val = 0
@@ -16,21 +16,35 @@ def showconfig():
         has_temps = has_temps or val.temp_value is not None
 
     width -= 27
-    s = "  %s%-{0}s%s : %-{1}s".format(longest_key, longest_val+1)
+    s = "  %s%-{0}s%s : %-{1}s".format(longest_key, longest_val + 1)
 
     if has_temps:
         width -= longest_val + 5
         out = "  %s%-{}s   %-{}s %s%s%s\n".format(longest_key, longest_val) % (
-            c.ul, "Key", "Value", "Temporary", " " * width, c.w)
+            c.ul,
+            "Key",
+            "Value",
+            "Temporary",
+            " " * width,
+            c.w,
+        )
     else:
-        out = "  %s%-{}s   %s%s%s\n".format(longest_key) % (c.ul, "Key", "Value", " " * width, c.w)
+        out = "  %s%-{}s   %s%s%s\n".format(longest_key) % (
+            c.ul,
+            "Key",
+            "Value",
+            " " * width,
+            c.w,
+        )
 
     for setting in config:
         val = config[setting]
 
         # don't show player specific settings if unknown player
-        if not util.is_known_player(config.PLAYER.get) and \
-                val.require_known_player:
+        if (
+            not util.is_known_player(config.PLAYER.get)
+            and val.require_known_player
+        ):
             continue
 
         # don't show max_results if auto determined
@@ -52,24 +66,23 @@ def showconfig():
     g.message += "Enter %sset all default%s to reset all" % (c.g, c.w)
 
 
-@command(r'set\s+-t\s*([-\w]+)\s*(.*)')
+@command(r"set\s+-t\s*([-\w]+)\s*(.*)")
 def setconfigtemp(key, val):
     setconfig(key, val, is_temp=True)
 
 
-@command(r'set\s+([-\w]+)\s*(.*)')
+@command(r"set\s+([-\w]+)\s*(.*)")
 def setconfig(key, val, is_temp=False):
-    """ Set configuration variable. """
+    """Set configuration variable."""
     key = key.replace("-", "_")
     if key.upper() == "ALL" and val.upper() == "DEFAULT":
-
         for ci in config:
             config[ci].value = config[ci].default
 
         config.save()
         message = "Default configuration reinstated"
 
-    elif not key.upper() in config:
+    elif key.upper() not in config:
         message = "Unknown config item: %s%s%s" % (c.r, key, c.w)
 
     elif val.upper() == "DEFAULT":
@@ -89,14 +102,14 @@ def setconfig(key, val, is_temp=False):
     g.message = message
 
 
-@command(r'encoders?', 'encoder')
+@command(r"encoders?", "encoder")
 def show_encs():
-    """ Display available encoding presets. """
+    """Display available encoding presets."""
     out = "%sEncoding profiles:%s\n\n" % (c.ul, c.w)
 
     for x, e in enumerate(g.encoders):
         sel = " (%sselected%s)" % (c.y, c.w) if config.ENCODER.get == x else ""
-        out += "%2d. %s%s\n" % (x, e['name'], sel)
+        out += "%2d. %s%s\n" % (x, e["name"], sel)
 
     g.content = out
     message = "Enter %sset encoder <num>%s to select an encoder"
diff --git a/mps_youtube/commands/download.py b/mps_youtube/commands/download.py
index 596b0ee8..f746a051 100644
--- a/mps_youtube/commands/download.py
+++ b/mps_youtube/commands/download.py
@@ -5,18 +5,20 @@
 import shlex
 import random
 import subprocess
-from urllib.request import urlopen
+from urllib.request import Request, urlopen
 from urllib.error import HTTPError
 
-from .. import g, c, screen, streams, content, config, util, pafy
+from .. import g, c, screen, streams, content, config, util, extractor
 from . import command, PL
 from .search import yt_url, user_pls
 from .songlist import dump, plist
 
 
-@command(r'(dv|da|d|dl|download)\s*(\d{1,4})', 'da', 'dv', 'd', 'dl', 'download')
+@command(
+    r"(dv|da|d|dl|download)\s*(\d{1,4})", "da", "dv", "d", "dl", "download"
+)
 def download(dltype, num):
-    """ Download a track or playlist by menu item number. """
+    """Download a track or playlist by menu item number."""
     # This function needs refactoring!
     # pylint: disable=R0912
     # pylint: disable=R0914
@@ -38,7 +40,7 @@ def download(dltype, num):
         return
 
     screen.writestatus("Fetching video info...")
-    song = (g.model[int(num) - 1])
+    song = g.model[int(num) - 1]
 
     # best = dltype.startswith("dv") or dltype.startswith("da")
     #
@@ -88,9 +90,15 @@ def download(dltype, num):
         # perform download(s)
         # dl_filenames = [args[1]]
         # f = _download(*args, **kwargs)
-        success = pafy.download_video(song.ytid, config.DDIR.get, True if dltype.startswith("da") else False)
+        success = extractor.download_video(
+            song.ytid,
+            config.DDIR.get,
+            True if dltype.startswith("da") else False,
+        )
         if success:
-            g.message = "Saved \'" + song.title + "\' to " + c.g + config.DDIR.get + c.w
+            g.message = (
+                "Saved '" + song.title + "' to " + c.g + config.DDIR.get + c.w
+            )
 
         # if url_au:
         #     dl_filenames += [args_au[1]]
@@ -126,9 +134,9 @@ def download(dltype, num):
     g.content = content.generate_songlist_display()
 
 
-@command(r'(da|dv)\s+((?:\d+\s\d+|-\d+|\d+-|\d+,)(?:[\d\s,-]*))', 'da', 'dv')
+@command(r"(da|dv)\s+((?:\d+\s\d+|-\d+|\d+-|\d+,)(?:[\d\s,-]*))", "da", "dv")
 def down_many(dltype, choice, subdir=None):
-    """ Download multiple items. """
+    """Download multiple items."""
     choice = util.parse_multi(choice)
     choice = list(set(choice))
     downsongs = [g.model[int(x) - 1] for x in choice]
@@ -139,7 +147,7 @@ def down_many(dltype, choice, subdir=None):
     msg = ""
 
     def handle_error(message):
-        """ Handle error in download. """
+        """Handle error in download."""
         g.message = message
         g.content = disp
         screen.update()
@@ -190,33 +198,33 @@ def handle_error(message):
         g.content = content.generate_songlist_display()
 
 
-@command(r'(da|dv)pl\s+%s' % PL, 'dapl', 'dvpl')
+@command(r"(da|dv)pl\s+%s" % PL, "dapl", "dvpl")
 def down_plist(dltype, parturl):
-    """ Download YouTube playlist. """
+    """Download YouTube playlist."""
 
     plist(parturl)
     dump(False)
-    title = g.pafy_pls[parturl][0].title
+    title = g.playlist_cache[parturl][0].title
     # Remove double quotes for convenience
-    subdir = util.sanitize_filename(title.replace('"', ''))
+    subdir = util.sanitize_filename(title.replace('"', ""))
     down_many(dltype, "1-", subdir=subdir)
     msg = g.message
     plist(parturl)
     g.message = msg
 
 
-@command(r'(da|dv)upl\s+(.*)', 'daupl', 'dvupl')
+@command(r"(da|dv)upl\s+(.*)", "daupl", "dvupl")
 def down_user_pls(dltype, user):
-    """ Download all user playlists. """
+    """Download all user playlists."""
     user_pls(user)
     for i in g.ytpls:
-        down_plist(dltype, i.get('link'))
+        down_plist(dltype, i.get("link"))
 
     return
 
 
 def _make_fname(song, ext=None, av=None, subdir=None):
-    """" Create download directory, generate filename. """
+    """ " Create download directory, generate filename."""
     # pylint: disable=E1103
     # Instance of 'bool' has no 'extension' member (some types not inferable)
     ddir = os.path.join(config.DDIR.get, subdir) if subdir else config.DDIR.get
@@ -224,28 +232,28 @@ def _make_fname(song, ext=None, av=None, subdir=None):
         os.makedirs(ddir)
 
     if not ext:
-        stream = streams.select(streams.get(song),
-                audio=av == "audio", m4a_ok=True)
-        ext = stream['ext']
+        stream = streams.select(
+            streams.get(song), audio=av == "audio", m4a_ok=True
+        )
+        ext = stream["ext"]
 
     # filename = song.title[:59] + "." + ext
     filename = song.title + "." + ext
     # Remove double quotes for convenience
-    filename = filename.replace('"', '')
+    filename = filename.replace('"', "")
     filename = os.path.join(ddir, util.sanitize_filename(filename))
     return filename
 
 
 def extract_metadata(name):
-    """ Try to determine metadata from video title. """
+    """Try to determine metadata from video title."""
     seps = name.count(" - ")
     artist = title = None
 
     if seps == 1:
-
         pos = name.find(" - ")
         artist = name[:pos].strip()
-        title = name[pos + 3:].strip()
+        title = name[pos + 3 :].strip()
 
     else:
         title = name.strip()
@@ -254,7 +262,7 @@ def extract_metadata(name):
 
 
 def remux_audio(filename, title):
-    """ Remux audio file. Insert limited metadata tags. """
+    """Remux audio file. Insert limited metadata tags."""
     util.dbg("starting remux")
     temp_file = filename + "." + str(random.randint(10000, 99999))
     os.rename(filename, temp_file)
@@ -262,8 +270,11 @@ def remux_audio(filename, title):
     metadata = ["title=%s" % meta["title"]]
 
     if meta["artist"]:
-        metadata = ["title=%s" % meta["title"], "-metadata",
-                    "artist=%s" % meta["artist"]]
+        metadata = [
+            "title=%s" % meta["title"],
+            "-metadata",
+            "artist=%s" % meta["artist"],
+        ]
 
     cmd = [g.muxapp, "-y", "-i", temp_file, "-acodec", "copy", "-metadata"]
     cmd += metadata + ["-vn", filename]
@@ -283,7 +294,7 @@ def remux_audio(filename, title):
 
 
 def transcode(filename, enc_data):
-    """ Re encode a download. """
+    """Re encode a download."""
     base = os.path.splitext(filename)[0]
     exe = g.muxapp if g.transcoder_path == "auto" else g.transcoder_path
 
@@ -293,11 +304,10 @@ def transcode(filename, enc_data):
         time.sleep(2)
         return filename
 
-    command = shlex.split(enc_data['command'])
+    command = shlex.split(enc_data["command"])
     newcom, outfn = command[::], ""
 
     for n, d in enumerate(command):
-
         if d == "ENCODER_PATH":
             newcom[n] = exe
 
@@ -308,7 +318,7 @@ def transcode(filename, enc_data):
             newcom[n] = outfn = base
 
         elif d == "OUT.EXT":
-            newcom[n] = outfn = base + "." + enc_data['ext']
+            newcom[n] = outfn = base + "." + enc_data["ext"]
 
     returncode = subprocess.call(newcom)
 
@@ -319,13 +329,13 @@ def transcode(filename, enc_data):
 
 
 def external_download(song, filename, url):
-    """ Perform download using external application. """
+    """Perform download using external application."""
     cmd = config.DOWNLOAD_COMMAND.get
     ddir, basename = config.DDIR.get, os.path.basename(filename)
     cmd_list = shlex.split(cmd)
 
     def list_string_sub(orig, repl, lst):
-        """ Replace substrings for items in a list. """
+        """Replace substrings for items in a list."""
         return [x if orig not in x else x.replace(orig, repl) for x in lst]
 
     cmd_list = list_string_sub("%F", filename, cmd_list)
@@ -338,7 +348,7 @@ def list_string_sub(orig, repl, lst):
 
 
 def _download(song, filename, url=None, audio=False, allow_transcode=True):
-    """ Download file, show status.
+    """Download file, show status.
 
     Return filename or None in case of user specified download command.
 
@@ -349,7 +359,7 @@ def _download(song, filename, url=None, audio=False, allow_transcode=True):
 
     if not url:
         stream = streams.select(streams.get(song), audio=audio, m4a_ok=True)
-        url = stream['url']
+        url = stream["url"]
 
     # if an external download command is set, use it
     if config.DOWNLOAD_COMMAND.get:
@@ -360,45 +370,47 @@ def _download(song, filename, url=None, audio=False, allow_transcode=True):
 
     if not config.OVERWRITE.get:
         if os.path.exists(filename):
-            util.xprint("File exists. Skipping %s%s%s ..\n" %
-                    (c.r, filename, c.w))
+            util.xprint(
+                "File exists. Skipping %s%s%s ..\n" % (c.r, filename, c.w)
+            )
             time.sleep(0.2)
             return filename
 
     util.xprint("Downloading to %s%s%s .." % (c.r, filename, c.w))
-    status_string = ('  {0}{1:,}{2} Bytes [{0}{3:.2%}{2}] received. Rate: '
-                     '[{0}{4:4.0f} kbps{2}].  ETA: [{0}{5:.0f} secs{2}]')
-
-    resp = urlopen(url)
-    total = int(resp.info()['Content-Length'].strip())
+    status_string = (
+        "  {0}{1:,}{2} Bytes [{0}{3:.2%}{2}] received. Rate: "
+        "[{0}{4:4.0f} kbps{2}].  ETA: [{0}{5:.0f} secs{2}]"
+    )
+
+    req = Request(url, headers=util.web_headers())
+    resp = urlopen(req)
+    total = int(resp.info()["Content-Length"].strip())
     chunksize, bytesdone, t0 = 16384, 0, time.time()
-    outfh = open(filename, 'wb')
-
-    while True:
-        chunk = resp.read(chunksize)
-        outfh.write(chunk)
-        elapsed = time.time() - t0
-        bytesdone += len(chunk)
-        rate = 0
-        if elapsed != 0:
-            rate = (bytesdone / 1024) / elapsed
-        if rate:
-            eta = (total - bytesdone) / (rate * 1024)
-        else:
-            eta = 0
-        stats = (c.y, bytesdone, c.w, bytesdone * 1.0 / total, rate, eta)
-
-        if not chunk:
-            outfh.close()
-            break
-
-        status = status_string.format(*stats)
-        sys.stdout.write("\r" + status + ' ' * 4 + "\r")
-        sys.stdout.flush()
+    with open(filename, "wb") as outfh:
+        while True:
+            chunk = resp.read(chunksize)
+            outfh.write(chunk)
+            elapsed = time.time() - t0
+            bytesdone += len(chunk)
+            rate = 0
+            if elapsed != 0:
+                rate = (bytesdone / 1024) / elapsed
+            if rate:
+                eta = (total - bytesdone) / (rate * 1024)
+            else:
+                eta = 0
+            stats = (c.y, bytesdone, c.w, bytesdone * 1.0 / total, rate, eta)
+
+            if not chunk:
+                break
+
+            status = status_string.format(*stats)
+            sys.stdout.write("\r" + status + " " * 4 + "\r")
+            sys.stdout.flush()
 
     active_encoder = g.encoders[config.ENCODER.get]
     ext = filename.split(".")[-1]
-    valid_ext = ext in active_encoder['valid'].split(",")
+    valid_ext = ext in active_encoder["valid"].split(",")
 
     if audio and g.muxapp:
         remux_audio(filename, song.title)
@@ -409,14 +421,20 @@ def _download(song, filename, url=None, audio=False, allow_transcode=True):
     return filename
 
 
-def menu_prompt(model, prompt=" > ", rows=None, header=None, theading=None,
-                footer=None, force=0):
-    """ Generate a list of choice, returns item from model. """
+def menu_prompt(
+    model,
+    prompt=" > ",
+    rows=None,
+    header=None,
+    theading=None,
+    footer=None,
+    force=0,
+):
+    """Generate a list of choice, returns item from model."""
     content = ""
 
     for x in header, theading, rows, footer:
         if isinstance(x, list):
-
             for line in x:
                 content += line + "\n"
 
@@ -432,8 +450,7 @@ def menu_prompt(model, prompt=" > ", rows=None, header=None, theading=None,
         return model[choice]
 
     elif force:
-        return menu_prompt(model, prompt, rows, header, theading, footer,
-                           force)
+        return menu_prompt(model, prompt, rows, header, theading, footer, force)
 
     elif not choice.strip():
         return False, False
@@ -443,29 +460,29 @@ def menu_prompt(model, prompt=" > ", rows=None, header=None, theading=None,
 
 
 def prompt_dl(song):
-    """ Prompt user do choose a stream to dl.  Return (url, extension). """
+    """Prompt user do choose a stream to dl.  Return (url, extension)."""
     # pylint: disable=R0914
     dl_data, p = get_dl_data(song)
     dl_text = gen_dl_text(dl_data, song, p)
 
-    model = [x['url'] for x in dl_data]
+    model = [x["url"] for x in dl_data]
     ed = enumerate(dl_data)
-    model = {str(n + 1): (x['url'], x['ext']) for n, x in ed}
+    model = {str(n + 1): (x["url"], x["ext"]) for n, x in ed}
     url, ext = menu_prompt(model, "Download number: ", *dl_text)
     url2 = ext2 = None
-    mediatype = [i for i in dl_data if i['url'] == url][0]['mediatype']
+    mediatype = [i for i in dl_data if i["url"] == url][0]["mediatype"]
 
     if mediatype == "video" and g.muxapp and not config.DOWNLOAD_COMMAND.get:
         # offer mux if not using external downloader
         dl_data, p = get_dl_data(song, mediatype="audio")
         dl_text = gen_dl_text(dl_data, song, p)
         au_choices = "1" if len(dl_data) == 1 else "1-%s" % len(dl_data)
-        footer = [util.F('-audio') % ext, util.F('select mux') % au_choices]
+        footer = [util.F("-audio") % ext, util.F("select mux") % au_choices]
         dl_text = tuple(dl_text[0:3]) + (footer,)
         aext = ("ogg", "m4a")
-        model = [x['url'] for x in dl_data if x['ext'] in aext]
+        model = [x["url"] for x in dl_data if x["ext"] in aext]
         ed = enumerate(dl_data)
-        model = {str(n + 1): (x['url'], x['ext']) for n, x in ed}
+        model = {str(n + 1): (x["url"], x["ext"]) for n, x in ed}
         prompt = "Audio stream: "
         url2, ext2 = menu_prompt(model, prompt, *dl_text)
 
@@ -473,7 +490,7 @@ def prompt_dl(song):
 
 
 def gen_dl_text(ddata, song, p):
-    """ Generate text for dl screen. """
+    """Generate text for dl screen."""
     hdr = []
     hdr.append("  %s%s%s" % (c.r, song.title, c.w))
     author = p.author
@@ -489,8 +506,14 @@ def gen_dl_text(ddata, song, p):
     content = []
 
     for n, d in enumerate(ddata):
-        row = (n + 1, d['ext'], d['quality'], d['mediatype'], d['size'],
-               d['notes'])
+        row = (
+            n + 1,
+            d["ext"],
+            d["quality"],
+            d["mediatype"],
+            d["size"],
+            d["notes"],
+        )
         fmt = "  {0}%-6s %-8s %-13s %-7s %5s Mb   %-16s{1}"
         row = fmt.format(c.g, c.w) % row
         content.append(row)
@@ -499,16 +522,17 @@ def gen_dl_text(ddata, song, p):
 
     footer = "Select [%s1-%s%s] to download or [%sEnter%s] to return"
     footer = [footer % (c.y, len(content) - 1, c.w, c.y, c.w)]
-    return(content, hdr, heading, footer)
+    return (content, hdr, heading, footer)
 
 
 def get_dl_data(song, mediatype="any"):
-    """ Get filesize and metadata for all streams, return dict. """
+    """Get filesize and metadata for all streams, return dict."""
+
     def mbsize(x):
-        """ Return size in MB. """
-        return str(int(x / (1024 ** 2)))
+        """Return size in MB."""
+        return str(int(x / (1024**2)))
 
-    p = util.get_pafy(song)
+    p = util.get_metadata(song)
     dldata = []
     text = " [Fetching stream info] >"
     streamlist = [x for x in p.allstreams]
@@ -516,9 +540,9 @@ def mbsize(x):
     if mediatype == "audio":
         streamlist = [x for x in p.audiostreams]
 
-    l = len(streamlist)
+    length = len(streamlist)
     for n, stream in enumerate(streamlist):
-        sys.stdout.write(text + "-" * n + ">" + " " * (l - n - 1) + "<\r")
+        sys.stdout.write(text + "-" * n + ">" + " " * (length - n - 1) + "<\r")
         sys.stdout.flush()
 
         try:
@@ -528,12 +552,14 @@ def mbsize(x):
             util.dbg(c.r + "---Error getting stream size" + c.w)
             size = 0
 
-        item = {'mediatype': stream.mediatype,
-                'size': size,
-                'ext': stream.extension,
-                'quality': stream.quality,
-                'notes': stream.notes,
-                'url': stream.url}
+        item = {
+            "mediatype": stream.mediatype,
+            "size": size,
+            "ext": stream.extension,
+            "quality": stream.quality,
+            "notes": stream.notes,
+            "url": stream.url,
+        }
 
         dldata.append(item)
 
@@ -541,9 +567,9 @@ def mbsize(x):
     return dldata, p
 
 
-@command(r'dlurl\s(.*[-_a-zA-Z0-9]{11}.*)', 'dlurl')
+@command(r"dlurl\s(.*[-_a-zA-Z0-9]{11}.*)", "dlurl")
 def dl_url(url):
-    """ Open and prompt for download of youtube video url. """
+    """Open and prompt for download of youtube video url."""
     g.browse_mode = "normal"
     yt_url(url)
 
@@ -554,9 +580,9 @@ def dl_url(url):
         sys.exit()
 
 
-@command(r'daurl\s(.*[-_a-zA-Z0-9]{11}.*)', 'daurl')
+@command(r"daurl\s(.*[-_a-zA-Z0-9]{11}.*)", "daurl")
 def da_url(url):
-    """ Open and prompt for download of youtube best audio from url. """
+    """Open and prompt for download of youtube best audio from url."""
     g.browse_mode = "normal"
     yt_url(url)
 
diff --git a/mps_youtube/commands/generate_playlist.py b/mps_youtube/commands/generate_playlist.py
index 1d9ef70d..5ca734d2 100644
--- a/mps_youtube/commands/generate_playlist.py
+++ b/mps_youtube/commands/generate_playlist.py
@@ -1,16 +1,17 @@
 """
-    Playlist Generation
+Playlist Generation
 """
+
 from os import path
 from random import choice
 import string
 
-from .. import content, g, playlists, screen, util, listview
+from .. import content, g, playlists, screen, util, listview, extractor, config
 from ..playlist import Playlist
 from . import command, search, album_search
 
 
-@command(r'mkp\s*(.{1,100})', 'mkp')
+@command(r"mkp\s*(.{1,100})", "mkp")
 def generate_playlist(sourcefile):
     """Generate a playlist from video titles in sourcefile"""
 
@@ -21,13 +22,13 @@ def generate_playlist(sourcefile):
 
     expanded_sourcefile = path.expanduser(sourcefile)
     if not check_sourcefile(expanded_sourcefile):
-        g.message = util.F('mkp empty') % expanded_sourcefile
+        g.message = util.F("mkp empty") % expanded_sourcefile
     else:
         queries = read_sourcefile(expanded_sourcefile)
-        g.message = util.F('mkp parsed') % (len(queries), sourcefile)
+        g.message = util.F("mkp parsed") % (len(queries), sourcefile)
         if queries:
             create_playlist(queries)
-            g.message = util.F('pl help')
+            g.message = util.F("pl help")
             g.content = content.playlists_display()
 
 
@@ -48,7 +49,7 @@ def check_sourcefile(filename):
     return path.isfile(filename) and path.getsize(filename) > 0
 
 
-def create_playlist(queries, title=''):
+def create_playlist(queries, title=""):
     """Add a new playlist
 
     Create playlist with a random name, get the first
@@ -58,7 +59,7 @@ def create_playlist(queries, title=''):
     if not g.userpl.get(plname):
         g.userpl[plname] = Playlist(plname)
     for query in queries:
-        g.message = util.F('mkp finding') % query
+        g.message = util.F("mkp finding") % query
         screen.update()
         qresult = find_best_match(query)
         if qresult:
@@ -68,28 +69,46 @@ def create_playlist(queries, title=''):
 
 
 def find_best_match(query):
+
+
     """Find the best(first)"""
+
+
     # This assumes that the first match is the best one
-    qs = search.generate_search_qs(query)
-    wdata = pafy.call_gdata('search', qs)
+
+
+    wdata = extractor.search_videos(query, int(config.PAGES.get))
+
+
     results = search.get_tracks_from_json(wdata)
+
+
     if results:
-        res, score = album_search._best_song_match(
-            results, query, 0.1, 1.0, 0.0)
+
+
+        res, score = album_search._best_song_match(results, query, 0.1, 1.0, 0.0)
+
+
         return res
+
+
     return None
 
 
+
+
+
 def random_plname():
     """Generates a random alphanumeric string of 6 characters"""
     n_chars = 6
-    return ''.join(choice(string.ascii_lowercase + string.digits)
-                   for _ in range(n_chars))
+    return "".join(
+        choice(string.ascii_lowercase + string.digits) for _ in range(n_chars)
+    )
 
 
 def description_generator(text):
-    """ Fetches a videos description and parses it for
-        <artist> - <track> combinations
+    """Fetches a videos description and parses it for
+    <artist> - <track> combinations
     """
     if not isinstance(g.model, Playlist):
         g.message = util.F("mkp desc unknown")
@@ -100,13 +119,10 @@ def description_generator(text):
     num = num.replace("-d", "")
     num = util.number_string_to_list(num)[0]
 
-    query = {}
-    query['id'] = g.model[num].ytid
-    query['part'] = 'snippet'
-    query['maxResults'] = '1'
-    data = pafy.call_gdata('videos', query)['items'][0]['snippet']
-    title = "mkp %s" % data['title']
-    data = util.fetch_songs(data['description'], data['title'])
+    ytid = g.model[num].ytid
+    data = extractor.get_video_info(ytid)
+    title = "mkp %s" % data["title"]
+    data = util.fetch_songs(data["description"], data["title"])
 
     columns = [
         {"name": "idx", "size": 3, "heading": "Num"},
@@ -115,8 +131,8 @@ def description_generator(text):
     ]
 
     def run_m(idx):
-        """ Create playlist based on the
-            results selected
+        """Create playlist based on the
+        results selected
         """
         create_playlist(idx, title)
 
diff --git a/mps_youtube/commands/lastfm.py b/mps_youtube/commands/lastfm.py
index fa289f9a..f48de8fc 100644
--- a/mps_youtube/commands/lastfm.py
+++ b/mps_youtube/commands/lastfm.py
@@ -3,6 +3,7 @@
 
 try:
     import pylast
+
     has_pylast = True
 except ImportError:
     has_pylast = False
@@ -10,19 +11,20 @@
 from .. import g, util, config
 from . import command
 
-@command(r'lastfm_connect', 'lastfm_connect')
+
+@command(r"lastfm_connect", "lastfm_connect")
 def init_network(verbose=True):
-    """ Initialize the global pylast network variable """
-    if not has_pylast :
+    """Initialize the global pylast network variable"""
+    if not has_pylast:
         if verbose:
-            pylast_url = 'https://github.com/pylast/pylast'
+            pylast_url = "https://github.com/pylast/pylast"
             g.message = '"pylast" module not found\n see %s' % (pylast_url)
         return
 
     # TODO: Add option to read lastfm config from file or env variable
     key = config.LASTFM_API_KEY.get
     secret = config.LASTFM_API_SECRET.get
-    password = config.LASTFM_PASSWORD.get # already hashed
+    password = config.LASTFM_PASSWORD.get  # already hashed
     username = config.LASTFM_USERNAME.get
 
     if not (key and secret and password and username):
@@ -31,28 +33,38 @@ def init_network(verbose=True):
         return
 
     try:
-        g.lastfm_network = pylast.LastFMNetwork(api_key=key, api_secret=secret,
-                                                username=username,
-                                                password_hash=password)
+        g.lastfm_network = pylast.LastFMNetwork(
+            api_key=key,
+            api_secret=secret,
+            username=username,
+            password_hash=password,
+        )
         if verbose:
             g.message = "Last.fm authentication successful!"
-    except (pylast.WSError, pylast.MalformedResponseError, pylast.NetworkError) as e:
+    except (
+        pylast.WSError,
+        pylast.MalformedResponseError,
+        pylast.NetworkError,
+    ) as e:
         if verbose:
             g.message = "Last.fm connection error: %s" % (str(e))
 
+
 def scrobble_track(artist, album, track):
-    """ Scrobble a track to the user's Last.fm account """
+    """Scrobble a track to the user's Last.fm account"""
     if not g.lastfm_network:
         return
     unix_timestamp = int(time.mktime(datetime.datetime.now().timetuple()))
     try:
-        g.lastfm_network.scrobble(artist=artist, title=track, album=album,
-                                  timestamp=unix_timestamp)
+        g.lastfm_network.scrobble(
+            artist=artist, title=track, album=album, timestamp=unix_timestamp
+        )
     except (pylast.WSError, pylast.MalformedResponseError, pylast.NetworkError):
         return
 
+
 def set_now_playing(artist, track):
-    """ Set the current track as "now playing" on the user's Last.fm account """
+    """Set the current track as "now playing" on the user's Last.fm account"""
     if not g.lastfm_network:
         return
     try:
diff --git a/mps_youtube/commands/local_playlist.py b/mps_youtube/commands/local_playlist.py
index 0cf71671..90b58e70 100644
--- a/mps_youtube/commands/local_playlist.py
+++ b/mps_youtube/commands/local_playlist.py
@@ -7,11 +7,10 @@
 from ..util import parse_video_length
 
 
-@command(r'rmp\s*(\d+|%s)' % WORD, 'rmp')
+@command(r"rmp\s*(\d+|%s)" % WORD, "rmp")
 def playlist_remove(name):
-    """ Delete a saved playlist by name - or purge working playlist if *all."""
+    """Delete a saved playlist by name - or purge working playlist if *all."""
     if name.isdigit() or g.userpl.get(name):
-
         if name.isdigit():
             name = int(name) - 1
             name = sorted(g.userpl)[name]
@@ -19,16 +18,16 @@ def playlist_remove(name):
         playlists.delete(name)
         g.message = "Deleted playlist %s%s%s" % (c.y, name, c.w)
         g.content = content.playlists_display()
-        #playlists.save()
+        # playlists.save()
 
     else:
-        g.message = util.F('pl not found advise ls') % name
+        g.message = util.F("pl not found advise ls") % name
         g.content = content.playlists_display()
 
 
-@command(r'add\s*(-?\d[-,\d\s]{1,250})(%s)' % WORD, 'add')
+@command(r"add\s*(-?\d[-,\d\s]{1,250})(%s)" % WORD, "add")
 def playlist_add(nums, playlist):
-    """ Add selected song nums to saved playlist. """
+    """Add selected song nums to saved playlist."""
     nums = util.parse_multi(nums)
     # Replacing spaces with hyphens before checking if playlist already exist.
     # See https://github.com/mps-youtube/mps-youtube/issues/1046.
@@ -41,7 +40,7 @@ def playlist_add(nums, playlist):
         g.userpl[playlist].songs.append(g.model[songnum - 1])
         dur = g.userpl[playlist].duration
         f = (len(nums), playlist, len(g.userpl[playlist]), dur)
-        g.message = util.F('added to saved pl') % f
+        g.message = util.F("added to saved pl") % f
 
     if nums:
         playlists.save()
@@ -49,22 +48,22 @@ def playlist_add(nums, playlist):
     g.content = content.generate_songlist_display()
 
 
-@command(r'mv\s*(\d{1,3})\s*(%s)' % WORD, 'mv')
+@command(r"mv\s*(\d{1,3})\s*(%s)" % WORD, "mv")
 def playlist_rename_idx(_id, name):
-    """ Rename a playlist by ID. """
+    """Rename a playlist by ID."""
     _id = int(_id) - 1
     playlist_rename(sorted(g.userpl)[_id] + " " + name)
 
 
-@command(r'mv\s*(%s\s+%s)' % (WORD, WORD), 'mv')
+@command(r"mv\s*(%s\s+%s)" % (WORD, WORD), "mv")
 def playlist_rename(playlists_):
-    """ Rename a playlist using mv command. """
+    """Rename a playlist using mv command."""
     # Deal with old playlist names that permitted spaces
     a, b = "", playlists_.split(" ")
     while a not in g.userpl:
         a = (a + " " + (b.pop(0))).strip()
         if not b and a not in g.userpl:
-            g.message = util.F('no pl match for rename')
+            g.message = util.F("no pl match for rename")
             g.content = g.content or content.playlists_display()
             return
 
@@ -72,13 +71,13 @@ def playlist_rename(playlists_):
     g.userpl[b] = Playlist(b)
     g.userpl[b].songs = list(g.userpl[a].songs)
     playlist_remove(a)
-    g.message = util.F('pl renamed') % (a, b)
+    g.message = util.F("pl renamed") % (a, b)
     playlists.save()
 
 
-@command(r'(rm|add)\s(?:\*|all)', 'rm', 'add')
+@command(r"(rm|add)\s(?:\*|all)", "rm", "add")
 def add_rm_all(action):
-    """ Add all displayed songs to current playlist.
+    """Add all displayed songs to current playlist.
 
     remove all displayed songs from view.
 
@@ -93,9 +92,9 @@ def add_rm_all(action):
         songlist_rm_add("add", "-" + str(size))
 
 
-@command(r'save', 'save')
+@command(r"save", "save")
 def save_last():
-    """ Save command with no playlist name. """
+    """Save command with no playlist name."""
     if g.last_opened:
         open_save_view("save", g.last_opened)
 
@@ -104,9 +103,11 @@ def save_last():
 
         # save using artist name in postion 1
         if g.model:
-            if g.selected_pafy_pls_id: # if a playlist was selected
-                saveas = g.pafy_pls[g.selected_pafy_pls_id][0].info['info']['title']
-            else: # user didn't selected a playlist
+            if g.selected_playlist_id:  # if a playlist was selected
+                saveas = g.playlist_cache[g.selected_playlist_id][0].info["info"][
+                    "title"
+                ]
+            else:  # user didn't selected a playlist
                 saveas = g.model[0].title[:18].strip()
             saveas = re.sub(r"[^-\w]", "-", saveas, flags=re.UNICODE)
 
@@ -124,9 +125,9 @@ def save_last():
         open_save_view("save", saveas)
 
 
-@command(r'(open|save|view)\s*(%s)' % WORD, 'open', 'save', 'view')
+@command(r"(open|save|view)\s*(%s)" % WORD, "open", "save", "view")
 def open_save_view(action, name):
-    """ Open, save or view a playlist by name.  Get closest name match. """
+    """Open, save or view a playlist by name.  Get closest name match."""
     name = name.replace(" ", "-")
     if action == "open" or action == "view":
         saved = g.userpl.get(name)
@@ -152,46 +153,57 @@ def open_save_view(action, name):
 
     elif action == "save":
         if not g.model:
-            g.message = "Nothing to save. " + util.F('advise search')
+            g.message = "Nothing to save. " + util.F("advise search")
             g.content = content.generate_songlist_display()
 
         else:
-            if g.selected_pafy_pls_id: # if a playlist was selected by user:
-                g.userpl[name] = Playlist(name, [Video(i['id'], i['title'], parse_video_length(i['duration'])) for i in g.pafy_pls[g.selected_pafy_pls_id][0].videos])
-            else: # user created custom playlist and never opened it and now wants to save it
+            if g.selected_playlist_id:  # if a playlist was selected by user:
+                g.userpl[name] = Playlist(
+                    name,
+                    [
+                        Video(
+                            i["id"],
+                            i["title"],
+                            parse_video_length(i["duration"]),
+                        )
+                        for i in g.playlist_cache[g.selected_playlist_id][0].videos
+                    ],
+                )
+            else:  # user created custom playlist and never opened it and now wants to save it
                 g.userpl[name] = Playlist(name, list(g.model.songs))
-            g.message = util.F('pl saved') % name
+            g.message = util.F("pl saved") % name
             playlists.save()
             g.content = content.generate_songlist_display()
 
 
-@command(r'(open|view)\s*(\d{1,4})', 'open', 'view')
+@command(r"(open|view)\s*(\d{1,4})", "open", "view")
 def open_view_bynum(action, num):
-    """ Open or view a saved playlist by number. """
+    """Open or view a saved playlist by number."""
     srt = sorted(g.userpl)
     name = srt[int(num) - 1]
     open_save_view(action, name)
 
 
-@command(r'ls', 'ls')
+@command(r"ls", "ls")
 def ls():
-    """ List user saved playlists. """
+    """List user saved playlists."""
     if not g.userpl:
-        g.message = util.F('no playlists')
-        g.content = g.content or \
-                content.generate_songlist_display(zeromsg=g.message)
+        g.message = util.F("no playlists")
+        g.content = g.content or content.generate_songlist_display(
+            zeromsg=g.message
+        )
 
     else:
         g.content = content.playlists_display()
-        g.message = util.F('pl help')
+        g.message = util.F("pl help")
 
 
-@command(r'vp', 'vp')
+@command(r"vp", "vp")
 def vp():
-    """ View current working playlist. """
+    """View current working playlist."""
 
-    msg = util.F('current pl')
-    txt = util.F('advise add') if g.model else util.F('advise search')
-    failmsg = util.F('pl empty') + " " + txt
+    msg = util.F("current pl")
+    txt = util.F("advise add") if g.model else util.F("advise search")
+    failmsg = util.F("pl empty") + " " + txt
 
     paginatesongs(g.active, msg=msg, failmsg=failmsg)
diff --git a/mps_youtube/commands/misc.py b/mps_youtube/commands/misc.py
index 16dea6ca..fec69ebf 100644
--- a/mps_youtube/commands/misc.py
+++ b/mps_youtube/commands/misc.py
@@ -1,5 +1,5 @@
 import re
-from datetime import datetime, timedelta
+from datetime import timedelta
 import socket
 import traceback
 from urllib.request import urlopen
@@ -9,18 +9,13 @@
 try:
     # pylint: disable=F0401
     import pyperclip
+
     has_pyperclip = True
 
 except ImportError:
     has_pyperclip = False
 
-try:
-    import readline
-    has_readline = True
-except ImportError:
-    has_readline = False
-
-from .. import g, c, __version__, content, screen, cache, pafy
+from .. import g, c, __version__, content, screen, cache, extractor
 from .. import streams, history, config, util
 from ..helptext import get_help
 from ..content import generate_songlist_display, logo, qrcode_display
@@ -28,29 +23,25 @@
 from .songlist import paginatesongs
 
 
-@command(r'clearcache')
+@command(r"clearcache")
 def clearcache():
-    """ Clear cached items - for debugging use. """
-    g.pafs = {}
+    """Clear cached items - for debugging use."""
+    g.metadata_cache = {}
     g.streams = {}
     util.dbg("%scache cleared%s", c.p, c.w)
     g.message = "cache cleared"
 
 
-@command(r'(?:help|h)(?:\s+([-_a-zA-Z]+))?', 'help')
+@command(r"(?:help|h)(?:\s+([-_a-zA-Z]+))?", "help")
 def show_help(choice):
-    """ Print help message. """
+    """Print help message."""
 
     g.content = get_help(choice)
 
 
-@command(r'(?:q|quit|exit)', 'quit', 'exit')
+@command(r"(?:q|quit|exit)", "quit", "exit")
 def quits(showlogo=True):
-    """ Exit the program. """
-    if has_readline and config.INPUT_HISTORY.get:
-        readline.write_history_file(g.READLINE_FILE)
-        util.dbg("Saved history file")
-
+    """Exit the program."""
     cache.save()
 
     screen.clear()
@@ -58,40 +49,56 @@ def quits(showlogo=True):
     msg += util.F("exitmsg", 2)
 
     if config.CHECKUPDATE.get and showlogo:
-
         try:
             url = "https://raw.githubusercontent.com/mps-youtube/yewtube/master/setup.py"
             v = urlopen(url, timeout=1).read().decode()
-            v = re.search(r'__version__\s*=\s*"\s*([\d\.]+)\s*"\s*', v, re.MULTILINE)
+            v = re.search(
+                r'__version__\s*=\s*"\s*([\d\.]+)\s*"\s*', v, re.MULTILINE
+            )
 
             if v:
                 v = v.group(1)
 
                 if v > __version__:
-                    msg += "\n\nA newer version is available (%s). Use `help new` command to check what's changed.\n" % v
+                    msg += (
+                        "\n\nA newer version is available (%s). Use `help new` command to check what's changed.\n"
+                        % v
+                    )
 
         except (URLError, HTTPError, socket.timeout):
             util.dbg("check update timed out")
 
     screen.msgexit(msg)
 
+
 def _format_comment(n, qnt, author_name, published_date, content, reply=False):
     # poster = snippet.get('authorDisplayName')
     # shortdate = util.yt_datetime(snippet.get('publishedAt', ''))[1]
     # text = snippet.get('textDisplay', '')
-    cid = ("%s%s/%s %s" % ('└── ' if reply else '', n, qnt, c.c("g", author_name)))
-    return ("%-39s %s\n" % (cid, published_date)) + \
-            c.c("y", content.strip()) + '\n\n'
+    cid = "%s%s/%s %s" % (
+        "└── " if reply else "",
+        n,
+        qnt,
+        c.c("g", author_name),
+    )
+    return (
+        ("%-39s %s\n" % (cid, published_date))
+        + c.c("y", content.strip())
+        + "\n\n"
+    )
+
 
 def _fetch_commentreplies(parentid):
-    # return pafy.call_gdata('comments', {
+    # return extractor.call_gdata('comments', {
     #     'parentId': parentid,
     #     'part': 'snippet',
     #     'textFormat': 'plainText',
     #     'maxResults': 50}).get('items', [])
     return None
+
+
 def fetch_comments(item):
-    """ Fetch comments for item using gdata. """
+    """Fetch comments for item using gdata."""
     # pylint: disable=R0912
     # pylint: disable=R0914
     ytid, title = item.ytid, item.title
@@ -104,7 +111,7 @@ def fetch_comments(item):
 
     # jsdata = None
     try:
-        all_comments = pafy.get_comments(ytid)
+        all_comments = extractor.get_comments(ytid)
     except Exception:
         raise
     # coms = [x.get('snippet', {}) for x in jsdata.get('items', [])]
@@ -118,11 +125,17 @@ def fetch_comments(item):
         g.content = generate_songlist_display()
         return
 
-    commentstext = ''
+    commentstext = ""
 
     for n, com in enumerate(all_comments, 1):
         # snippet = com.get('topLevelComment', {}).get('snippet', {})
-        commentstext += _format_comment(n, len(all_comments), com['author']['name'], com['published'], com['content'])
+        commentstext += _format_comment(
+            n,
+            len(all_comments),
+            com["author"]["name"],
+            com["published"],
+            com["content"],
+        )
         # todo fetch comment replies
         # if com.get('replyCount') > 0:
         #     replies = _fetch_commentreplies(com.get('topLevelComment').get('id'))
@@ -134,9 +147,9 @@ def fetch_comments(item):
     g.content = content.StringContent(commentstext)
 
 
-@command(r'c\s?(\d{1,4})', 'c')
+@command(r"c\s?(\d{1,4})", "c")
 def comments(number):
-    """ Receive use request to view comments. """
+    """Receive use request to view comments."""
     if g.browse_mode == "normal":
         item = g.model[int(number) - 1]
         fetch_comments(item)
@@ -146,16 +159,15 @@ def comments(number):
         g.message = "Comments only available for video items"
 
 
-@command(r'x\s*(\d+)', 'x')
+@command(r"x\s*(\d+)", "x")
 def clipcopy_video(num):
-    """ Copy video/playlist url to clipboard. """
+    """Copy video/playlist url to clipboard."""
     if g.browse_mode == "ytpl":
-
         p = g.ytpls[int(num) - 1]
-        link = "https://youtube.com/playlist?list=%s" % p['link']
+        link = "https://youtube.com/playlist?list=%s" % p["link"]
 
     elif g.browse_mode == "normal":
-        item = (g.model[int(num) - 1])
+        item = g.model[int(num) - 1]
         link = "https://youtube.com/watch?v=%s" % item.ytid
 
     else:
@@ -164,7 +176,6 @@ def clipcopy_video(num):
         return
 
     if has_pyperclip:
-
         try:
             pyperclip.copy(link)
             g.message = c.y + link + c.w + " copied"
@@ -172,8 +183,11 @@ def clipcopy_video(num):
 
         except Exception as e:
             g.content = generate_songlist_display()
-            g.message = link + "\nError - couldn't copy to clipboard.\n" + \
-                    ''.join(traceback.format_exception_only(type(e), e))
+            g.message = (
+                link
+                + "\nError - couldn't copy to clipboard.\n"
+                + "".join(traceback.format_exception_only(type(e), e))
+            )
 
     else:
         g.message = "pyperclip module must be installed for clipboard support\n"
@@ -181,14 +195,13 @@ def clipcopy_video(num):
         g.content = generate_songlist_display()
 
 
-@command(r'X\s*(\d+)', 'X')
+@command(r"X\s*(\d+)", "X")
 def clipcopy_stream(num):
-    """ Copy content stream url to clipboard. """
+    """Copy content stream url to clipboard."""
     if g.browse_mode == "normal":
-
-        item = (g.model[int(num) - 1])
+        item = g.model[int(num) - 1]
         details = player.stream_details(item)[1]
-        stream = details['url']
+        stream = details["url"]
 
     else:
         g.message = "clipboard copy not valid in this mode"
@@ -196,7 +209,6 @@ def clipcopy_stream(num):
         return
 
     if has_pyperclip:
-
         try:
             pyperclip.copy(stream)
             g.message = c.y + stream + c.w + " copied"
@@ -204,8 +216,11 @@ def clipcopy_stream(num):
 
         except Exception as e:
             g.content = generate_songlist_display()
-            g.message = stream + "\nError - couldn't copy to clipboard.\n" + \
-                    ''.join(traceback.format_exception_only(type(e), e))
+            g.message = (
+                stream
+                + "\nError - couldn't copy to clipboard.\n"
+                + "".join(traceback.format_exception_only(type(e), e))
+            )
 
     else:
         g.message = "pyperclip module must be installed for clipboard support\n"
@@ -213,101 +228,123 @@ def clipcopy_stream(num):
         g.content = generate_songlist_display()
 
 
-@command(r'i\s*(\d{1,4})', 'i')
+@command(r"i\s*(\d{1,4})", "i")
 def video_info(num):
-    """ Get video information. """
+    """Get video information."""
     if g.browse_mode == "ytpl":
         p = g.ytpls[int(num) - 1]
 
         # fetch the playlist item as it has more metadata
-        if p['link'] in g.pafy_pls:
-            ytpl = g.pafy_pls[p['link']][0]
+        if p["link"] in g.playlist_cache:
+            ytpl = g.playlist_cache[p["link"]][0]
         else:
             g.content = logo(col=c.g)
             g.message = "Fetching playlist info.."
             screen.update()
-            util.dbg("%sFetching playlist using pafy%s", c.y, c.w)
-            ytpl = pafy.get_playlist2(p['link'])
-            g.pafy_pls[p['link']] = (ytpl, util.IterSlicer(ytpl))
+            util.dbg("%sFetching playlist using extractor%s", c.y, c.w)
+            ytpl = extractor.get_playlist(p["link"])
+            g.playlist_cache[p["link"]] = (ytpl, util.IterSlicer(ytpl))
 
-        ytpl_desc = ytpl.description
+        ytpl_desc = p.get("description", "")
         g.content = generate_songlist_display()
-        created = util.yt_datetime_local(p['created'])
-        updated = util.yt_datetime_local(p['updated'])
+        created = util.yt_datetime_local(p["created"])
+        updated = util.yt_datetime_local(p["updated"])
         out = c.ul + "Playlist Info" + c.w + "\n\n"
-        out += p['title']
+        out += p["title"]
         out += "\n" + ytpl_desc
-        out += ("\n\nAuthor     : " + p['author'])
-        out += "\nSize       : " + str(p['size']) + " videos"
+        out += "\n\nAuthor     : " + p["author"]
+        out += "\nSize       : " + str(p["size"]) + " videos"
         out += "\nCreated    : " + created[1] + " " + created[2]
         out += "\nUpdated    : " + updated[1] + " " + updated[2]
-        out += "\nID         : " + str(p['link'])
-        out += ("\n\n%s[%sPress enter to go back%s]%s" % (c.y, c.w, c.y, c.w))
+        out += "\nID         : " + str(p["link"])
+        out += "\n\n%s[%sPress enter to go back%s]%s" % (c.y, c.w, c.y, c.w)
         g.content = out
 
     elif g.browse_mode == "normal":
         g.content = logo(c.b)
         screen.update()
         screen.writestatus("Fetching video metadata..")
-        item = (g.model[int(num) - 1])
+        item = g.model[int(num) - 1]
         streams.get(item)
-        p = pafy.get_video_info(item.ytid)
-        #pub = datetime.strptime(str(p.published), "%Y-%m-%d %H:%M:%SZ")
-        #pub = util.utc2local(pub)
+        p = extractor.get_video_info(item.ytid)
+        # pub = datetime.strptime(str(p.published), "%Y-%m-%d %H:%M:%SZ")
+        # pub = util.utc2local(pub)
         screen.writestatus("Fetched")
         out = c.ul + "Video Info" + c.w + "\n\n"
-        out += p['title'] or ""
-        out += "\n\nDescription:\n\n" + str(p.get('description', "")) + "\n"
-        out += "\nKeywords: " + str(p['keywords']) + "\n"
-        out += "\nIs Live Now    : " + str(p['isLiveNow'])
-        out += "\nDuration       : " + str(timedelta(seconds=int(p['duration']['secondsText'])))
-        out += "\nView count     : " + "{:,}".format(int(p['viewCount']['text']))
-        out += "\nAuthor         : " + str(p['channel']['name'] + ' ~ ' + p['channel']['link'])
-        out += "\nPublished Date : " + str(p['publishDate'])
-        out += "\nUploaded Date  : " + str(p['uploadDate'])
-        out += "\nRating         : " + str(p['averageRating'])
-        out += "\nLikes          : " + "{:,}".format(p.get('likes', 0))
-        out += "\nDislikes       : " + "{:,}".format(p.get('dislikes', 0))
-        out += "\nCategory       : " + str(p['category'])
-        out += "\nFamily Safe    : " + str(p['isFamilySafe'])
-        out += "\nLink           : " + str(p['link'])
+        out += p.title or ""
+        out += "\n\nDescription:\n\n" + str(p.get("description", "")) + "\n"
+        out += "\nKeywords: " + str(p.get("keywords", [])) + "\n"
+        out += "\nIs Live Now    : " + str(p.get("isLiveNow", False))
+
+        duration_text = "0"
+        duration_data = p.get("duration")
+        if isinstance(duration_data, dict):
+            duration_text = duration_data.get("secondsText", "0")
+        elif isinstance(duration_data, str):
+            duration_text = str(util.parse_video_length(duration_data))
+
+        out += "\nDuration       : " + str(
+            timedelta(seconds=int(duration_text))
+        )
+
+        view_count = "0"
+        view_data = p.get("viewCount")
+        if isinstance(view_data, dict):
+            view_count = view_data.get("text", "0").replace(",", "")
+        elif isinstance(view_data, str):
+            view_count = view_data.replace(",", "")
+
+        out += "\nView count     : " + "{:,}".format(int(re.sub(r"\D", "", view_count) or 0))
+
+        author_name = p.author
+        channel_data = p.get("channel", {})
+        channel_link = channel_data.get("link", "") if isinstance(channel_data, dict) else ""
+        out += "\nAuthor         : " + str(author_name + " ~ " + channel_link)
+
+        out += "\nPublished Date : " + str(p.get("publishDate", "?"))
+        out += "\nUploaded Date  : " + str(p.get("uploadDate", "?"))
+        out += "\nRating         : " + str(p.rating)
+        out += "\nLikes          : " + "{:,}".format(p.likes)
+        out += "\nDislikes       : " + "{:,}".format(p.dislikes)
+        out += "\nCategory       : " + str(p.get("category", "?"))
+        out += "\nFamily Safe    : " + str(p.get("isFamilySafe", "?"))
+        out += "\nLink           : " + str(p.get("link", "https://youtube.com/watch?v=" + str(p.ytid)))
         if config.SHOW_QRCODE.get:
             out += "\n" + qrcode_display(
-                "https://youtube.com/watch?v=%s" % p.videoid)
+                "https://youtube.com/watch?v=%s" % str(p.ytid)
+            )
 
         out += "\n\n%s[%sPress enter to go back%s]%s" % (c.y, c.w, c.y, c.w)
         g.content = out
 
 
-@command(r's\s*(\d{1,4})', 's')
+@command(r"s\s*(\d{1,4})", "s")
 def stream_info(num):
-    """ Get stream information. """
+    """Get stream information."""
     if g.browse_mode == "normal":
         g.content = logo(c.b)
         screen.update()
         screen.writestatus("Fetching stream metadata..")
-        item = (g.model[int(num) - 1])
+        item = g.model[int(num) - 1]
         streams.get(item)
-        p = util.get_pafy(item)
-        setattr(p, 'ytid', p.videoid)
-        details = player.stream_details(p)[1]
+        details = player.stream_details(item)[1]
         screen.writestatus("Fetched")
         out = "\n\n" + c.ul + "Stream Info" + c.w + "\n"
-        out += "\nExtension   : " + details['ext']
-        out += "\nSize        : " + str(details['size'])
-        out += "\nQuality     : " + details['quality']
-        out += "\nRaw bitrate : " + str(details['rawbitrate'])
-        out += "\nMedia type  : " + details['mtype']
-        out += "\nLink        : " + details['url']
+        out += "\nExtension   : " + details["ext"]
+        out += "\nSize        : " + str(details["size"])
+        out += "\nQuality     : " + details["quality"]
+        out += "\nRaw bitrate : " + str(details["rawbitrate"])
+        out += "\nMedia type  : " + details["mtype"]
+        out += "\nLink        : " + details["url"]
         out += "\n\n%s[%sPress enter to go back%s]%s" % (c.y, c.w, c.y, c.w)
         g.content = out
 
 
-@command(r'history', 'history')
+@command(r"history", "history")
 def view_history(duplicates=True):
-    """ Display the user's play history """
-    history = g.userhist.get('history')
-    #g.last_opened = ""
+    """Display the user's play history"""
+    history = g.userhist.get("history")
+    # g.last_opened = ""
     try:
         hist_list = list(reversed(history.songs))
         message = "Viewing play history"
@@ -315,7 +352,9 @@ def view_history(duplicates=True):
             # List unique elements and preserve order.
             seen = set()
             seen_add = seen.add  # it makes calls to add() faster
-            hist_list = [x for x in hist_list if not (x.ytid in seen or seen_add(x.ytid))]
+            hist_list = [
+                x for x in hist_list if not (x.ytid in seen or seen_add(x.ytid))
+            ]
             message = "Viewing recent played songs"
         paginatesongs(hist_list)
         g.message = message
@@ -324,22 +363,22 @@ def view_history(duplicates=True):
         g.content = logo(c.r)
         g.message = "History empty"
 
-
     if not config.HISTORY.get:
-        g.message += "\t{1}History recording is currently off{0}".format(c.w,c.y)
-
+        g.message += "\t{1}History recording is currently off{0}".format(
+            c.w, c.y
+        )
 
 
-@command(r'history recent', 'history recent')
+@command(r"history recent", "history recent")
 def recent_history():
-    """ Display the recent user's played songs """
+    """Display the recent user's played songs"""
     view_history(duplicates=False)
 
 
-@command(r'history clear', 'history clear')
+@command(r"history clear", "history clear")
 def clear_history():
-    """ Clears the user's play history """
-    g.userhist['history'].songs = []
+    """Clears the user's play history"""
+    g.userhist["history"].songs = []
     history.save()
     g.message = "History cleared"
     g.content = logo()
diff --git a/mps_youtube/commands/play.py b/mps_youtube/commands/play.py
index f51c4a4f..271de932 100644
--- a/mps_youtube/commands/play.py
+++ b/mps_youtube/commands/play.py
@@ -1,4 +1,3 @@
-import random
 import sys
 import typing as T
 import webbrowser
@@ -6,18 +5,20 @@
 
 from .. import c, config, content, g, streams, util
 from . import RS, WORD, command
-from .search import related, yt_url
+from .search import yt_url
 from .songlist import plist
 
-@command(r'play all', 'play all')
+
+@command(r"play all", "play all")
 def play_loaded():
     g.model.songs = content.get_last_query()
     if g.model.songs:
         play_all("", "", "")
 
-@command(r'play\s+(%s|\d+)' % WORD, 'play')
+
+@command(r"play\s+(%s|\d+)" % WORD, "play")
 def play_pl(name):
-    """ Play a playlist by name. """
+    """Play a playlist by name."""
     if name.isdigit():
         name = int(name)
         name = sorted(g.userpl)[name - 1]
@@ -37,10 +38,9 @@ def play_pl(name):
         g.content = content.playlists_display()
 
 
-@command(r'(%s{0,3})([-,\d\s\[\]]{1,250})\s*(%s{0,3})$' %
-         (RS, RS))
+@command(r"(%s{0,3})([-,\d\s\[\]]{1,250})\s*(%s{0,3})$" % (RS, RS))
 def play(pre, choice, post=""):
-    """ Play choice.  Use repeat/random if appears in pre/post. """
+    """Play choice.  Use repeat/random if appears in pre/post."""
     # pylint: disable=R0914
     # too many local variables
 
@@ -53,10 +53,9 @@ def play(pre, choice, post=""):
         return
 
     if g.browse_mode == "ytpl":
-
         if choice.isdigit():
-            g.selected_pafy_pls_id = g.ytpls[int(choice)-1]['link']
-            return plist(g.selected_pafy_pls_id)
+            g.selected_playlist_id = g.ytpls[int(choice) - 1]["link"]
+            return plist(g.selected_playlist_id)
         else:
             g.message = "Invalid playlist selection: %s" % c.y + choice + c.w
             g.content = content.generate_songlist_display()
@@ -74,8 +73,12 @@ def play(pre, choice, post=""):
         nofs = "-w" in pre + post
         forcevid = "-v" in pre + post
 
-        if ((novid and fs) or (novid and nofs) or (nofs and fs)
-           or (novid and forcevid)):
+        if (
+            (novid and fs)
+            or (novid and nofs)
+            or (nofs and fs)
+            or (novid and forcevid)
+        ):
             raise IOError("Conflicting override options specified")
 
         override = False
@@ -87,11 +90,17 @@ def play(pre, choice, post=""):
             override = "forcevid" if forcevid else override
 
         selection = util.parse_multi(choice)
-        songlist = [g.model[x - 1] for x in selection]
+        start_index = 0
+
+        if config.AUTOPLAY.get and len(selection) == 1:
+            songlist = list(g.model)
+            start_index = selection[0] - 1
+        else:
+            songlist = [g.model[x - 1] for x in selection]
 
         # cache next result of displayed items
         # when selecting a single item
-        if len(songlist) == 1:
+        if len(selection) == 1:
             chosen = selection[0] - 1
 
             if len(g.model) > chosen + 1:
@@ -103,10 +112,14 @@ def play(pre, choice, post=""):
 
         try:
             if not config.PLAYER.get or not util.has_exefile(config.PLAYER.get):
-                g.message = "Player not configured! Enter %sset player <player_app> "\
-                            "%s to set a player" % (c.g, c.w)
+                g.message = (
+                    "Player not configured! Enter %sset player <player_app> "
+                    "%s to set a player" % (c.g, c.w)
+                )
                 return
-            g.PLAYER_OBJ.play(songlist, shuffle, repeat, override)
+            g.PLAYER_OBJ.play(
+                songlist, shuffle, repeat, override, start_index=start_index
+            )
         except KeyboardInterrupt:
             return
         finally:
@@ -115,20 +128,15 @@ def play(pre, choice, post=""):
         if g.scrobble:
             g.scrobble_queue = old_queue
 
-        if config.AUTOPLAY.get:
-            related(selection.pop())
-            play(pre, str(random.randint(1, 15)), post="")
-
 
-@command(r'(%s{0,3})(?:\*|all)\s*(%s{0,3})' %
-        (RS, RS))
+@command(r"(%s{0,3})(?:\*|all)\s*(%s{0,3})" % (RS, RS))
 def play_all(pre, choice, post=""):
-    """ Play all tracks in model (last displayed). shuffle/repeat if req'd."""
+    """Play all tracks in model (last displayed). shuffle/repeat if req'd."""
     options = pre + choice + post
     play(options, "1-" + str(len(g.model)))
 
 
-@command(r'playurl\s(.*[-_a-zA-Z0-9]{11}[^\s]*)(\s-(?:f|a|w))?', 'playurl')
+@command(r"playurl\s(.*[-_a-zA-Z0-9]{11}[^\s]*)(\s-(?:f|a|w))?", "playurl")
 def play_url(url: str, override: T.Any):
     """Open and play a youtube video url.
 
@@ -151,10 +159,10 @@ def play_url(url: str, override: T.Any):
         sys.exit()
 
 
-@command(r'browserplay\s(\d{1,50})', 'browserplay')
+@command(r"browserplay\s(\d{1,50})", "browserplay")
 def browser_play(number):
     """Open a previously searched result in the browser."""
-    if (len(g.model) == 0):
+    if len(g.model) == 0:
         g.message = c.r + "No previous search." + c.w
         g.content = content.logo(c.r)
         return
@@ -162,7 +170,7 @@ def browser_play(number):
     try:
         index = int(number) - 1
 
-        if (0 <= index < len(g.model)):
+        if 0 <= index < len(g.model):
             base_url = "https://www.youtube.com/watch?v="
             video = g.model[index]
             url = base_url + video.ytid
diff --git a/mps_youtube/commands/search.py b/mps_youtube/commands/search.py
index 36a5c6e5..e4924ba5 100644
--- a/mps_youtube/commands/search.py
+++ b/mps_youtube/commands/search.py
@@ -1,21 +1,19 @@
 import base64
-import json
 import logging
 import math
 import re
-import typing as T
 from argparse import ArgumentParser
-from datetime import datetime, timedelta
-from urllib import parse
 
-from .. import pafy
+from .. import extractor
 
 parser = ArgumentParser()
-parser.add_argument('-d', '--duration', choices=('any', 'short', 'medium', 'long'))
-parser.add_argument('-a', '--after')
-parser.add_argument('-l', '--live', nargs="?", const=True)
-parser.add_argument('-c', '--category', nargs=1)
-parser.add_argument('search', nargs='+')
+parser.add_argument(
+    "-d", "--duration", choices=("any", "short", "medium", "long")
+)
+parser.add_argument("-a", "--after")
+parser.add_argument("-l", "--live", nargs="?", const=True)
+parser.add_argument("-c", "--category", nargs=1)
+parser.add_argument("search", nargs="+")
 
 
 from .. import c, config, content, contentquery, g, listview, screen, util
@@ -23,49 +21,34 @@
 from . import command
 from .songlist import paginatesongs, plist
 
-ISO8601_TIMEDUR_EX = re.compile(r'PT((\d{1,3})H)?((\d{1,3})M)?((\d{1,2})S)?')
+ISO8601_TIMEDUR_EX = re.compile(r"PT((\d{1,3})H)?((\d{1,3})M)?((\d{1,2})S)?")
 
-DAYS = dict(day = 1,
-            week = 7,
-            month = 30,
-            year = 365)
+DAYS = dict(day=1, week=7, month=30, year=365)
 
 
 def _display_search_results(progtext, wdata, msg=None, failmsg=None):
-    """ Perform memoized url fetch, display progtext. """
-
+    """Display search results using pre-fetched wdata."""
     loadmsg = "Searching for '%s%s%s'" % (c.y, progtext, c.w)
 
-    def iter_songs():
-        wdata2 = wdata
-        while True:
-            for song in get_tracks_from_json(wdata2):
-                yield song
-
-            if type(wdata2) is list or not wdata2.get('nextPageToken'):
-                break
-            query = None#wdata2['nextPageToken']
-            wdata2 = None#pafy.call_gdata('search', qs)
-
-    # The youtube search api returns a maximum of 500 results
-    length = len(wdata)
-    slicer = util.IterSlicer(iter_songs(), length)
+    songs = get_tracks_from_json(wdata)
+    length = len(songs)
 
-    paginatesongs(slicer, length=length, msg=msg, failmsg=failmsg,
-            loadmsg=loadmsg)
+    paginatesongs(
+        songs, length=length, msg=msg, failmsg=failmsg, loadmsg=loadmsg
+    )
 
 
 def token(page):
-    """ Returns a page token for a given start index. """
+    """Returns a page token for a given start index."""
     index = (page or 0) * util.getxy().max_results
-    k = index//128 - 1
+    k = index // 128 - 1
     index -= 128 * k
     f = [8, index]
     if k > 0 or index > 127:
-        f.append(k+1)
+        f.append(k + 1)
     f += [16, 0]
-    b64 = base64.b64encode(bytes(f)).decode('utf8')
-    return b64.strip('=')
+    b64 = base64.b64encode(bytes(f)).decode("utf8")
+    return b64.strip("=")
 
 
 # def generate_search_qs(term, match='term', videoDuration='any', after=None, category=None, is_live=False):
@@ -105,17 +88,20 @@ def token(page):
 
 
 def userdata_cached(userterm):
-    """ Check if user name search term found in cache """
-    userterm = ''.join([t.strip().lower() for t in userterm.split(' ')])
+    """Check if user name search term found in cache"""
+    userterm = "".join([t.strip().lower() for t in userterm.split(" ")])
     return g.username_query_cache.get(userterm)
 
 
 def cache_userdata(userterm, username, channel_id):
-    """ Cache user name and channel id tuple """
-    userterm = ''.join([t.strip().lower() for t in userterm.split(' ')])
+    """Cache user name and channel id tuple"""
+    userterm = "".join([t.strip().lower() for t in userterm.split(" ")])
     g.username_query_cache[userterm] = (username, channel_id)
-    util.dbg('Cache data for username search query "{}": {} ({})'.format(
-        userterm, username, channel_id))
+    util.dbg(
+        'Cache data for username search query "{}": {} ({})'.format(
+            userterm, username, channel_id
+        )
+    )
 
     while len(g.username_query_cache) > 300:
         g.username_query_cache.popitem(last=False)
@@ -123,29 +109,32 @@ def cache_userdata(userterm, username, channel_id):
 
 
 def channelfromname(user):
-    """ Query channel id from username. """
+    """Query channel id from username."""
 
     cached = userdata_cached(user)
     if cached:
         return cached
 
     try:
-        channel_id, channel_name = pafy.channel_id_from_name(user)
+        channel_id, channel_name = extractor.channel_id_from_name(user)
         return cache_userdata(user, channel_name, channel_id)
 
     except Exception as e:
         import traceback
+
         traceback.print_exception(type(e), e, e.__traceback__)
         g.message = "Could not retrieve information for user {}\n{}".format(
-            c.y + user + c.w, e)
-        util.dbg('Error during channel request for user {}:\n{}'.format(
-            user, e))
+            c.y + user + c.w, e
+        )
+        util.dbg(
+            "Error during channel request for user {}:\n{}".format(user, e)
+        )
 
     # at this point, we know the channel id associated to a user name
     return None
 
 
-@command(r'channels\s+(.+)')
+@command(r"channels?\s+(.+)", "channels", "channel")
 def channelsearch(q_user):
 
     # qs = {'part': 'id,snippet',
@@ -155,28 +144,29 @@ def channelsearch(q_user):
     #       'order': "relevance"
     #       }
 
-    QueryObj = contentquery.ContentQuery(listview.ListUser, 'search', q_user)
+    QueryObj = contentquery.ContentQuery(listview.ListUser, "search", q_user)
     columns = [
         {"name": "idx", "size": 3, "heading": "Num"},
         {"name": "name", "size": 30, "heading": "Username"},
         {"name": "description", "size": "remaining", "heading": "Description"},
-        ]
+    ]
 
     def run_m(user_id):
-        """ Search ! """
+        """Search !"""
         usersearch_id(*(user_id[0]))
+
     del g.content
 
     g.content = listview.ListView(columns, QueryObj, run_m)
     g.message = "Results for channel search: '%s'" % q_user
 
 
-@command(r'user\s+(.+)', 'user')
-def usersearch(q_user, identify='forUsername'):
-    """ Fetch uploads by a YouTube user. """
+@command(r"user\s+(.+)", "user")
+def usersearch(q_user, identify="forUsername"):
+    """Fetch uploads by a YouTube user."""
 
     user, _, term = (x.strip() for x in q_user.partition("/"))
-    if identify == 'forUsername':
+    if identify == "forUsername":
         ret = channelfromname(user)
         if not ret:  # Error
             return
@@ -190,17 +180,19 @@ def usersearch(q_user, identify='forUsername'):
 
 
 def usersearch_id(user, channel_id, term):
-    """ Performs a search within a user's (i.e. a channel's) uploads
+    """Performs a search within a user's (i.e. a channel's) uploads
     for an optional search term with the user (i.e. the channel)
-    identified by its ID """
+    identified by its ID"""
 
-    #query = generate_search_qs(term)
-    aliases = dict(views='viewCount')  # The value of the config item is 'views' not 'viewCount'
+    # query = generate_search_qs(term)
+    dict(
+        views="viewCount"
+    )  # The value of the config item is 'views' not 'viewCount'
     if config.USER_ORDER.get:
         pass
-        #query['order'] = aliases.get(config.USER_ORDER.get,
+        # query['order'] = aliases.get(config.USER_ORDER.get,
         #        config.USER_ORDER.get)
-    #query['channelId'] = channel_id
+    # query['channelId'] = channel_id
 
     termuser = tuple([c.y + x + c.w for x in (term, user)])
     if term:
@@ -210,46 +202,50 @@ def usersearch_id(user, channel_id, term):
     else:
         msg = "Video uploads by {2}{4}{0}"
         progtext = termuser[1]
-        if config.SEARCH_MUSIC:
+        if config.SEARCH_MUSIC.get:
             failmsg = """User %s not found or has no videos in the Music category.
-Use 'set search_music False' to show results not in the Music category.""" % termuser[1]
+Use 'set search_music False' to show results not in the Music category.""" % termuser[
+                1
+            ]
         else:
-            failmsg = "User %s not found or has no videos."  % termuser[1]
+            failmsg = "User %s not found or has no videos." % termuser[1]
     msg = str(msg).format(c.w, c.y, c.y, term, user)
 
-    videos = pafy.all_videos_from_channel(channel_id)
+    videos = extractor.all_videos_from_channel(channel_id)
     query = term.lower() if term else None
 
     if query:
-        results = [v for v in videos if query in v.get('title', '').lower() or query in v.get('description', '').lower()]
+        results = [
+            v
+            for v in videos
+            if query in v.get("title", "").lower()
+            or query in v.get("description", "").lower()
+        ]
     else:
         results = videos
     _display_search_results(progtext, results, msg, failmsg)
 
 
 def related_search(vitem):
-    """ Fetch videos related to vitem
+    """Fetch videos related to vitem
     vitem = {'description': str, 'length': int, 'title': str, 'ytid': str}
     """
 
     t = vitem.title
-    ttitle = t[:48].strip() + ".." if len(t) > 49 else t
-
-    msg = "Videos related to %s%s%s" % (c.y, ttitle, c.w)
-    failmsg = "Related to %s%s%s not found" % (c.y, vitem.ytid, c.w)
+    t[:48].strip() + ".." if len(t) > 49 else t
 
-    # todo: implement realted search in pafy
-    #_search(ttitle, vitem.title, msg, failmsg)
+    # todo: implement realted search in extractor
+    # _search(ttitle, vitem.title, msg, failmsg)
 
 
 # Livestream category search
-@command(r'live\s+(.+)', 'live')
+@command(r"live\s+(.+)", "live")
 def livestream_category_search(term):
     sel_category = g.categories.get(term, None)
 
     if not sel_category:
-        g.message = ("That is not a valid category. Valid categories are: ")
-        g.message += (", ".join(g.categories.keys()))
+        g.message = "That is not a valid category. Valid categories are: "
+        g.message += ", ".join(g.categories.keys())
         return
 
     query = {
@@ -257,21 +253,25 @@ def livestream_category_search(term):
         "eventType": "live",
         "maxResults": 50,
         "type": "video",
-        "videoCategoryId": sel_category
+        "videoCategoryId": sel_category,
     }
 
-    query_obj = contentquery.ContentQuery(listview.ListLiveStream, 'search', query)
+    query_obj = contentquery.ContentQuery(
+        listview.ListLiveStream, "search", query
+    )
     columns = [
-              {"name": "idx", "size": 3, "heading": "Num"},
-              {"name": "title", "size": 40, "heading": "Title"},
-              {"name": "description", "size": "remaining", "heading": "Description"},
-              ]
+        {"name": "idx", "size": 3, "heading": "Num"},
+        {"name": "title", "size": 40, "heading": "Title"},
+        {"name": "description", "size": "remaining", "heading": "Description"},
+    ]
 
     def start_stream(returned):
         songs = Playlist("Search Results", [Video(*x) for x in returned])
         if not config.PLAYER.get or not util.has_exefile(config.PLAYER.get):
-            g.message = "Player not configured! Enter %sset player <player_app> "\
-                        "%s to set a player" % (c.g, c.w)
+            g.message = (
+                "Player not configured! Enter %sset player <player_app> "
+                "%s to set a player" % (c.g, c.w)
+            )
             return
         g.PLAYER_OBJ.play(songs, False, False, False)
 
@@ -280,19 +280,17 @@ def start_stream(returned):
 
 
 # Note: [^./] is to prevent overlap with playlist search command
-@command(r'(?:search|\.|/)\s*([^./].{1,500})', 'search')
+@command(r"(?:search|\.|/)\s*([^./].{1,500})", "search")
 def search(term):
-    """ Perform search. """
+    """Perform search."""
     try:  # TODO make use of unknowns
         args, unknown = parser.parse_known_args(term.split())
-        video_duration = args.duration if args.duration else 'any'
         if args.category:
             if not args.category[0].isdigit():
                 args.category = g.categories.get(args.category[0])
             else:
                 args.category = "".join(args.category)
-        after = args.after
-        term = ' '.join(args.search)
+        term = " ".join(args.search)
     except SystemExit:  # <------ argsparse calls exit()
         g.message = c.b + "Bad syntax. Enter h for help" + c.w
         return
@@ -303,23 +301,23 @@ def search(term):
         return
 
     logging.info("search for %s", term)
-    #query = generate_search_qs(term, videoDuration=video_duration, after=after, category=args.category, is_live=args.live)
+    # query = generate_search_qs(term, videoDuration=video_duration, after=after, category=args.category, is_live=args.live)
 
     msg = "Search results for %s%s%s" % (c.y, term, c.w)
     failmsg = "Found nothing for %s%s%s" % (c.y, term, c.w)
-    wdata = pafy.search_videos(term, int(config.PAGES.get))
+    wdata = extractor.search_videos(term, int(config.PAGES.get))
     _display_search_results(term, wdata, msg, failmsg)
 
 
-@command(r'u(?:ser)?pl\s(.*)', 'userpl', 'upl')
+@command(r"u(?:ser)?pl\s(.*)", "userpl", "upl")
 def user_pls(user):
-    """ Retrieve user playlists. """
+    """Retrieve user playlists."""
     return pl_search(user, is_user=True)
 
 
-@command(r'(?:\.\.|\/\/|pls(?:earch)?\s)\s*(.*)', 'plsearch')
+@command(r"(?:\.\.|\/\/|pls(?:earch)?\s)\s*(.*)", "plsearch")
 def pl_search(term, page=0, splash=True, is_user=False):
-    """ Search for YouTube playlists.
+    """Search for YouTube playlists.
 
     term can be query str or dict indicating user playlist search.
 
@@ -341,11 +339,11 @@ def pl_search(term, page=0, splash=True, is_user=False):
         if not ret:
             return
         user, channel_id = ret
-        pldata = pafy.all_playlists_from_channel(channel_id)
+        pldata = extractor.all_playlists_from_channel(channel_id)
     else:
-        pldata = pafy.playlist_search(term)
+        pldata = extractor.playlist_search(term)
 
-    playlists = get_pl_from_json(pldata)[:util.getxy().max_results]
+    playlists = get_pl_from_json(pldata)[: util.getxy().max_results]
 
     if playlists:
         g.last_search_query = (pl_search, {"term": term, "is_user": is_user})
@@ -363,110 +361,142 @@ def pl_search(term, page=0, splash=True, is_user=False):
 
 
 def get_pl_from_json(pldata):
-    """ Process json playlist data. """
-
-    try:
-        items = pldata
+    """Process json playlist data."""
 
-    except KeyError:
-        items = []
+    if not pldata:
+        return []
 
+    items = pldata
     results = []
 
     for item in items:
-        results.append(dict(
-            link=item["id"],
-            size=item["videoCount"],
-            title=item["title"],
-            author= item['channel']["name"] if 'channel' in item.keys()  else None,
-            created=item.get("publishedAt"),
-            updated=item.get('publishedAt'), #XXX Not available in API?
-            description=item.get("description")))
+        try:
+            channel_data = item.get("channel", {})
+            results.append(
+                dict(
+                    link=item.get("id", ""),
+                    size=item.get("videoCount", "0"),
+                    title=item.get("title", "Unknown Playlist"),
+                    author=channel_data.get("name", "?") if isinstance(channel_data, dict) else "?",
+                    created=item.get("publishedAt", "?"),
+                    updated=item.get("publishedAt", "?"),
+                    description=item.get("description", ""),
+                )
+            )
+        except Exception as e:
+            util.dbg(f"Error during playlist extraction: {str(e)}")
+            continue
 
     return results
 
 
 def get_track_id_from_json(item):
-    """ Try to extract video Id from various response types """
-    fields = ['contentDetails/videoId',
-              'snippet/resourceId/videoId',
-              'id/videoId',
-              'id']
+    """Try to extract video Id from various response types"""
+    fields = [
+        "contentDetails/videoId",
+        "snippet/resourceId/videoId",
+        "id/videoId",
+        "id",
+    ]
     for field in fields:
         node = item
-        for p in field.split('/'):
+        for p in field.split("/"):
             if node and isinstance(node, dict):
                 node = node.get(p)
         if node:
             return node
-    return ''
+    return ""
 
 
 def get_tracks_from_json(jsons):
-    """ Get search results from API response """
+    """Get search results from API response"""
 
-    if len(jsons) == 0:
+    if not jsons or len(jsons) == 0:
         util.dbg("got unexpected data or no search results")
         return ()
 
     # populate list of video objects
     songs = []
     for item in jsons:
+        ytid = ""
         try:
             ytid = get_track_id_from_json(item)
-            duration = util.parse_video_length(item.get('duration'))
-            #stats = item.get('statistics', {})
-            #snippet = item.get('snippet', {})
-            title = item.get('title', '').strip()
+            if not ytid:
+                continue
+
+            duration = util.parse_video_length(item.get("duration"))
+            title = item.get("title", "Unknown Title").strip()
             # instantiate video representation in local model
             cursong = Video(ytid=ytid, title=title, length=duration)
-            dislike_data = {'likes': 0, 'dislikes':0, 'rating':0}#pafy.return_dislikes(ytid)
-            likes = int(dislike_data['likes'])
-            dislikes = int(dislike_data['dislikes'])
-            # this is a very poor attempt to calculate a rating value
-            rating = int(dislike_data['rating'])#5.*likes/(likes+dislikes) if (likes+dislikes) > 0 else 0
-            category = '?'#snippet.get('categoryId')
-            publishedlocaldatetime = item.get('publishedTime','?')#util.yt_datetime_local(snippet.get('publishedAt', ''))
+
+            # Default metadata values
+            likes = 0
+            dislikes = 0
+            rating = 0
+            category = "?"
+            published_time = (
+                item.get("publishedTime")
+                or item.get("publishedTimeText")
+            )
+
+            # Fallback for Playlist.get results which have age in accessibility field
+            if not published_time and "accessibility" in item:
+                # accessibility format: 'TITLE by CHANNEL AGE DURATION'
+                # we want to extract 'AGE' which is usually 'X years/months ago'
+                label = item["accessibility"].get("title", "")
+                match = re.search(r"(\d+ \w+ ago)", label)
+                if match:
+                    published_time = match.group(1)
+
+            published_time = published_time or "?"
+            display_date = util.format_yt_date(published_time)
+
+            channel_data = item.get("channel", {})
+            uploader_id = channel_data.get("id", "?")
+            uploader_name = channel_data.get("name") or channel_data.get("title") or "?"
+
+            view_count_data = item.get("viewCount", {})
+            if isinstance(view_count_data, dict):
+                view_count = view_count_data.get("text", "?")
+            else:
+                view_count = "?"
 
             # cache video information in custom global variable store
             g.meta[ytid] = dict(
-                # tries to get localized title first, fallback to normal title
                 title=title,
                 length=str(util.fmt_time(cursong.length)),
-                rating=rating,#str('{}'.format(rating))[:4].ljust(4, "0"),
-                uploader=item['channel']['id'],
-                uploaderName=item['channel']['name'],
+                rating=rating,
+                uploader=uploader_id,
+                uploaderName=uploader_name,
                 category=category,
-                aspect="custom", #XXX
-                uploaded=publishedlocaldatetime,#publishedlocaldatetime[1] if publishedlocaldatetime is not None else None,
-                uploadedTime=publishedlocaldatetime,#,publishedlocaldatetime[2] if publishedlocaldatetime is not None else None,
+                aspect="custom",
+                uploaded=display_date,
+                uploadedTime=display_date,
                 likes=str(num_repr(likes)),
                 dislikes=str(num_repr(dislikes)),
-                commentCount='?',#str(num_repr(int(stats.get('commentCount', 0)))),
-                viewCount= item['viewCount']['text'] if 'viewCount' in item.keys() else '?')#str(num_repr(int(stats.get('viewCount', 0)))))
+                commentCount="?",
+                viewCount=view_count,
+            )
             songs.append(cursong)
 
         except Exception as e:
-            import traceback
-            traceback.print_exception(type(e), e, e.__traceback__)
-            input('Press any key to continue...')
-            util.dbg(json.dumps(item, indent=2))
-            util.dbg('Error during metadata extraction/instantiation of ' +
-                'search result {}\n{}'.format(ytid, e))
-
+            util.dbg(f"Error during metadata extraction for {ytid}: {str(e)}")
+            continue
 
+    # return video objects
+    return songs
 
     # return video objects
     return songs
 
 
 def num_repr(num):
-    """ Return up to four digit string representation of a number, eg 2.6m. """
+    """Return up to four digit string representation of a number, eg 2.6m."""
     if num <= 9999:
         return str(num)
 
     def digit_count(x):
-        """ Return number of digits. """
+        """Return number of digits."""
         return int(math.floor(math.log10(x)) + 1)
 
     digits = digit_count(num)
@@ -482,9 +512,9 @@ def digit_count(x):
     return str(rounded)[0] + "." + str(rounded)[1] + suffix
 
 
-@command(r'u\s?([\d]{1,4})', 'u')
+@command(r"u\s?([\d]{1,4})", "u")
 def user_more(num):
-    """ Show more videos from user of vid num. """
+    """Show more videos from user of vid num."""
     if g.browse_mode != "normal":
         g.message = "User uploads must refer to a specific video item"
         g.message = c.y + g.message + c.w
@@ -494,20 +524,20 @@ def user_more(num):
     g.current_page = 0
     item = g.model[int(num) - 1]
 
-    #TODO: Cleaner way of doing this?
+    # TODO: Cleaner way of doing this?
     if item.ytid in g.meta:
-        channel_id = g.meta.get(item.ytid, {}).get('uploader')
-        user = g.meta.get(item.ytid, {}).get('uploaderName')
+        channel_id = g.meta.get(item.ytid, {}).get("uploader")
+        user = g.meta.get(item.ytid, {}).get("uploaderName")
     else:
-        paf = util.get_pafy(item)
+        paf = util.get_metadata(item)
         user, channel_id = channelfromname(paf.author)
 
-    usersearch_id(user, channel_id, '')
+    usersearch_id(user, channel_id, "")
 
 
-@command(r'r\s?(\d{1,4})', 'r')
+@command(r"r\s?(\d{1,4})", "r")
 def related(num):
-    """ Show videos related to to vid num. """
+    """Show videos related to to vid num."""
     if g.browse_mode != "normal":
         g.message = "Related items must refer to a specific video item"
         g.message = c.y + g.message + c.w
@@ -519,23 +549,23 @@ def related(num):
     related_search(item)
 
 
-@command(r'mix\s*(\d{1,4})', 'mix')
+@command(r"mix\s*(\d{1,4})", "mix")
 def mix(num):
-    """ Retrieves the YouTube mix for the selected video. """
+    """Retrieves the YouTube mix for the selected video."""
     g.content = g.content or content.generate_songlist_display()
     if g.browse_mode != "normal":
-        g.message = util.F('mix only videos')
+        g.message = util.F("mix only videos")
     else:
-        item = (g.model[int(num) - 1])
+        item = g.model[int(num) - 1]
         if item is None:
-            g.message = util.F('invalid item')
+            g.message = util.F("invalid item")
             return
-        item = util.get_pafy(item)
+        item = util.get_metadata(item)
         # Mix playlists are made up of 'RD' + video_id
         try:
-            plist("RD" + item.videoid)
+            plist("RD" + item.ytid)
         except OSError:
-            g.message = util.F('no mix')
+            g.message = util.F("no mix")
 
 
 @command(r"url\s(.*[-_a-zA-Z0-9]{11}.*)", "url")
@@ -561,20 +591,25 @@ def yt_url(url: str, print_title: bool = False):
     v_title = None
     for url in url_list:
         try:
-            v_id = pafy.extract_video_id(url)
+            v_id = extractor.extract_video_id(url)
             if v_id in v_ids:
                 continue
-            p = pafy.get_video_info(v_id)
+            p = extractor.get_video_info(v_id)
         except (IOError, ValueError, Exception) as e:
             g.message = c.r + str(e) + c.w
             g.content = g.content or content.generate_songlist_display(
-                    zeromsg=g.message)
+                zeromsg=g.message
+            )
             return
 
         g.browse_mode = "normal"
-        v = Video(p['id'], p['title'], int(p['duration']['secondsText']))
-        if p and isinstance(p, dict):
-            v_title = p.get("title")
+        duration = p.get("duration", 0)
+        if isinstance(duration, str):
+            duration = util.parse_video_length(duration)
+        duration = int(duration or 0)
+
+        v = Video(p["id"], p["title"], duration)
+        v_title = p.get("title")
         g.model.songs.append(v)
         v_ids.add(v_id)
 
@@ -585,20 +620,25 @@ def yt_url(url: str, print_title: bool = False):
         util.xprint(v_title)
 
 
-@command(r'url_file\s(\S+)', 'url_file')
+@command(r"url_file\s(\S+)", "url_file")
 def yt_url_file(file_name):
-    """ Access a list of urls in a text file """
+    """Access a list of urls in a text file"""
 
-    #Open and read the file
+    # Open and read the file
     try:
         with open(file_name, "r") as fo:
-            output = ' '.join([line.strip() for line in fo if line.strip()])
-
-    except (IOError):
-        g.message = c.r + 'Error while opening the file, check the validity of the path' + c.w
+            output = " ".join([line.strip() for line in fo if line.strip()])
+
+    except IOError:
+        g.message = (
+            c.r
+            + "Error while opening the file, check the validity of the path"
+            + c.w
+        )
         g.content = g.content or content.generate_songlist_display(
-                zeromsg=g.message)
+            zeromsg=g.message
+        )
         return
 
-    #Finally pass the input to yt_url
+    # Finally pass the input to yt_url
     yt_url(output)
diff --git a/mps_youtube/commands/songlist.py b/mps_youtube/commands/songlist.py
index ae4d72c0..9693e35d 100644
--- a/mps_youtube/commands/songlist.py
+++ b/mps_youtube/commands/songlist.py
@@ -2,13 +2,21 @@
 import random
 
 
-from .. import g, c, screen, streams, content, util, pafy
+from .. import g, c, screen, streams, content, util, extractor
 from ..playlist import Video
 from . import command, PL
 
 
-def paginatesongs(func, page=0, splash=True, dumps=False,
-        length=None, msg=None, failmsg=None, loadmsg=None):
+def paginatesongs(
+    func,
+    page=0,
+    splash=True,
+    dumps=False,
+    length=None,
+    msg=None,
+    failmsg=None,
+    loadmsg=None,
+):
     """
     A utility function for handling lists of songs, so that
     the pagination and the dump command will work properly.
@@ -36,7 +44,7 @@ def paginatesongs(func, page=0, splash=True, dumps=False,
     :type loadmsg: str
     """
     if splash:
-        g.message = loadmsg or ''
+        g.message = loadmsg or ""
         g.content = content.logo(col=c.b)
         screen.update()
 
@@ -57,8 +65,13 @@ def paginatesongs(func, page=0, splash=True, dumps=False,
     if length is None:
         length = len(func)
 
-    args = {'func':func, 'length':length, 'msg':msg,
-            'failmsg':failmsg, 'loadmsg': loadmsg}
+    args = {
+        "func": func,
+        "length": length,
+        "msg": msg,
+        "failmsg": failmsg,
+        "loadmsg": loadmsg,
+    }
     g.last_search_query = (paginatesongs, args)
     g.browse_mode = "normal"
     g.current_page = page
@@ -66,7 +79,7 @@ def paginatesongs(func, page=0, splash=True, dumps=False,
     g.model.songs = songs
     g.content = content.generate_songlist_display()
     g.last_opened = ""
-    g.message = msg or ''
+    g.message = msg or ""
     if not songs:
         g.message = failmsg or g.message
 
@@ -75,29 +88,34 @@ def paginatesongs(func, page=0, splash=True, dumps=False,
         streams.preload(songs[0], delay=0)
 
 
-@command(r'pl\s+%s' % PL, 'pl')
+@command(r"pl\s+%s" % PL, "pl")
 def plist(parturl):
-    """ Retrieve YouTube playlist. """
+    """Retrieve YouTube playlist."""
 
-    if parturl in g.pafy_pls:
-        ytpl, plitems = g.pafy_pls[parturl]
+    if parturl in g.playlist_cache:
+        ytpl, plitems = g.playlist_cache[parturl]
     else:
-        util.dbg("%sFetching playlist using pafy%s", c.y, c.w)
-        ytpl = pafy.get_playlist(parturl)
+        util.dbg("%sFetching playlist using extractor%s", c.y, c.w)
+        ytpl = extractor.get_playlist(parturl)
         plitems = util.IterSlicer(ytpl.videos)
-        g.pafy_pls[parturl] = (ytpl, plitems)
+        g.playlist_cache[parturl] = (ytpl, plitems)
 
     def pl_seg(s, e):
-        return [Video(i['id'], i['title'], util.parse_video_length(i['duration'])) for i in plitems[s:e]]
-
-    msg = "Showing YouTube playlist %s" % (c.y + ytpl.info['info']['title'] + c.w)
+        return [
+            Video(i["id"], i["title"], util.parse_video_length(i["duration"]))
+            for i in plitems[s:e]
+        ]
+
+    msg = "Showing YouTube playlist %s" % (
+        c.y + ytpl.info["info"]["title"] + c.w
+    )
     loadmsg = "Retrieving YouTube playlist"
     paginatesongs(pl_seg, length=len(ytpl.videos), msg=msg, loadmsg=loadmsg)
 
 
-@command(r'(rm|add)\s*(-?\d[-,\d\s]{,250})', 'rm', 'add')
+@command(r"(rm|add)\s*(-?\d[-,\d\s]{,250})", "rm", "add")
 def songlist_rm_add(action, songrange):
-    """ Remove or add tracks. works directly on user input. """
+    """Remove or add tracks. works directly on user input."""
     selection = util.parse_multi(songrange)
 
     if action == "add":
@@ -108,11 +126,11 @@ def songlist_rm_add(action, songrange):
             g.active.songs.append(g.model[songnum - 1])
 
         d = g.active.duration
-        g.message = util.F('added to pl') % (len(selection), len(g.active), d)
+        g.message = util.F("added to pl") % (len(selection), len(g.active), d)
         if duplicate_songs:
-            duplicate_songs = ', '.join(sorted(duplicate_songs))
-            g.message += '\n'
-            g.message += util.F('duplicate tracks') % duplicate_songs
+            duplicate_songs = ", ".join(sorted(duplicate_songs))
+            g.message += "\n"
+            g.message += util.F("duplicate tracks") % duplicate_songs
 
     elif action == "rm":
         selection = sorted(set(selection), reverse=True)
@@ -121,40 +139,42 @@ def songlist_rm_add(action, songrange):
         for x in selection:
             g.model.songs.pop(x - 1)
             try:
-                g.active.songs.pop(g.current_page * util.getxy().max_results + x - 1)
+                g.active.songs.pop(
+                    g.current_page * util.getxy().max_results + x - 1
+                )
             except IndexError:
                 pass
 
-        g.message = util.F('songs rm') % (len(selection), removed)
+        g.message = util.F("songs rm") % (len(selection), removed)
 
     g.content = content.generate_songlist_display()
 
 
-@command(r'(mv|sw)\s*(\d{1,4})\s*[\s,]\s*(\d{1,4})', 'mv', 'sw')
+@command(r"(mv|sw)\s*(\d{1,4})\s*[\s,]\s*(\d{1,4})", "mv", "sw")
 def songlist_mv_sw(action, a, b):
-    """ Move a song or swap two songs. """
+    """Move a song or swap two songs."""
     i, j = int(a) - 1, int(b) - 1
 
     if action == "mv":
         g.model.songs.insert(j, g.model.songs.pop(i))
-        g.message = util.F('song move') % (g.model[j].title, b)
+        g.message = util.F("song move") % (g.model[j].title, b)
 
     elif action == "sw":
         g.model[i], g.model[j] = g.model[j], g.model[i]
-        g.message = util.F('song sw') % (min(a, b), max(a, b))
+        g.message = util.F("song sw") % (min(a, b), max(a, b))
 
     g.content = content.generate_songlist_display()
 
 
-@command(r'(n|p)\s*(\d{1,2})?')
+@command(r"(n|p)\s*(\d{1,2})?")
 def nextprev(np, page=None):
-    """ Get next / previous search results. """
+    """Get next / previous search results."""
     if isinstance(g.content, content.PaginatedContent):
         page_count = g.content.numPages()
         function = g.content.getPage
         args = {}
     else:
-        page_count = math.ceil(g.result_count/util.getxy().max_results)
+        page_count = math.ceil(g.result_count / util.getxy().max_results)
         function, args = g.last_search_query
 
     good = False
@@ -166,8 +186,8 @@ def nextprev(np, page=None):
                 good = True
 
         elif np == "p":
-            if page and int(page) in range(1,20):
-                g.current_page = int(page)-1
+            if page and int(page) in range(1, 20):
+                g.current_page = int(page) - 1
                 good = True
 
             elif g.current_page > 0:
@@ -186,9 +206,9 @@ def nextprev(np, page=None):
     return good
 
 
-@command(r'(un)?dump', 'dump', 'undump')
+@command(r"(un)?dump", "dump", "undump")
 def dump(un):
-    """ Show entire playlist. """
+    """Show entire playlist."""
     func, args = g.last_search_query
 
     if func is paginatesongs:
@@ -201,16 +221,17 @@ def dump(un):
         g.content = content.generate_songlist_display()
 
 
-@command(r'shuffle', 'shuffle')
+@command(r"shuffle", "shuffle")
 def shuffle_fn():
-    """ Shuffle displayed items. """
+    """Shuffle displayed items."""
     random.shuffle(g.model.songs)
     g.message = c.y + "Items shuffled" + c.w
     g.content = content.generate_songlist_display()
 
-@command(r'shuffle all', 'shuffle all')
+
+@command(r"shuffle all", "shuffle all")
 def shuffle_playlist():
-    """ Shuffle entire loaded playlist. """
+    """Shuffle entire loaded playlist."""
     songs = content.get_last_query()
 
     if songs:
@@ -220,31 +241,68 @@ def shuffle_playlist():
         g.message = c.y + "Shuffled entire playlist" + c.w
         g.content = content.generate_songlist_display()
 
-@command(r'reverse', 'reverse')
+
+@command(r"reverse", "reverse")
 def reverse_songs():
-    """ Reverse order of displayed items. """
+    """Reverse order of displayed items."""
     g.model.songs = g.model.songs[::-1]
     g.message = c.y + "Reversed displayed songs" + c.w
     g.content = content.generate_songlist_display()
 
 
-@command(r'reverse\s*(\d{1,4})\s*-\s*(\d{1,4})\s*', 'reverse')
+@command(r"reverse\s*(\d{1,4})\s*-\s*(\d{1,4})\s*", "reverse")
 def reverse_songs_range(lower, upper):
-    """ Reverse the songs within a specified range. """
+    """Reverse the songs within a specified range."""
     lower, upper = int(lower), int(upper)
-    if lower > upper: lower, upper = upper, lower
-    
-    g.model.songs[lower-1:upper] = reversed(g.model.songs[lower-1:upper])
+    if lower > upper:
+        lower, upper = upper, lower
+
+    g.model.songs[lower - 1 : upper] = reversed(
+        g.model.songs[lower - 1 : upper]
+    )
     g.message = c.y + "Reversed range: " + str(lower) + "-" + str(upper) + c.w
     g.content = content.generate_songlist_display()
-    
 
-@command(r'reverse all', 'reverse all')
+
+@command(r"reverse all", "reverse all")
 def reverse_playlist():
-    """ Reverse order of entire loaded playlist. """
+    """Reverse order of entire loaded playlist."""
     songs = content.get_last_query()
 
-    if songs:   
+    if songs:
         paginatesongs(list(reversed(songs)))
         g.message = c.y + "Reversed entire playlist" + c.w
         g.content = content.generate_songlist_display()
+
+
+@command(r"sort\s+(name|duration|age)", "sort")
+def sort_results(arg):
+    """Sort displayed results by name, duration, or age."""
+    if not hasattr(g, "last_sort_arg"):
+        g.last_sort_arg = None
+        g.last_sort_reverse = False
+
+    reverse = False
+    if g.last_sort_arg == arg:
+        reverse = not g.last_sort_reverse
+
+    g.last_sort_arg = arg
+    g.last_sort_reverse = reverse
+
+    if arg == "name":
+        g.model.songs.sort(key=lambda x: x.title.lower(), reverse=reverse)
+    elif arg == "duration":
+        g.model.songs.sort(key=lambda x: x.length, reverse=reverse)
+    elif arg == "age":
+
+        def get_age(song):
+            meta = g.meta.get(song.ytid)
+            if meta and meta.get("uploaded"):
+                return meta.get("uploaded")
+            return ""
+
+        g.model.songs.sort(key=get_age, reverse=reverse)
+
+    order = "descending" if reverse else "ascending"
+    g.message = c.y + "Sorted by " + arg + " (" + order + ")" + c.w
+    g.content = content.generate_songlist_display()
diff --git a/mps_youtube/commands/spotify_playlist.py b/mps_youtube/commands/spotify_playlist.py
index 5952dace..45ba1795 100644
--- a/mps_youtube/commands/spotify_playlist.py
+++ b/mps_youtube/commands/spotify_playlist.py
@@ -6,13 +6,14 @@
     # pylint: disable=F0401
     import spotipy
     import spotipy.oauth2 as oauth2
+
     has_spotipy = True
 
 except ImportError:
     has_spotipy = False
 
 
-from .. import c, g, screen, __version__, __url__, content, config, util
+from .. import c, g, screen, content, config, util, extractor
 from . import command
 from .songlist import paginatesongs
 from .search import get_tracks_from_json
@@ -21,36 +22,38 @@
 def generate_credentials():
     """Generate the token. Please respect these credentials :)"""
     credentials = oauth2.SpotifyClientCredentials(
-        client_id='6451e12933bb49ed8543d41e3296a88d',
-        client_secret='40ef54678fe441bd9acd66f5d5c34e69')
+        client_id="6451e12933bb49ed8543d41e3296a88d",
+        client_secret="40ef54678fe441bd9acd66f5d5c34e69",
+    )
     return credentials
 
 
 def grab_playlist(spotify, playlist):
-    if '/' in playlist:
-        if playlist.endswith('/'):
+    if "/" in playlist:
+        if playlist.endswith("/"):
             playlist = playlist[:-1]
-        splits = playlist.split('/')
+        splits = playlist.split("/")
     else:
-        splits = playlist.split(':')
+        splits = playlist.split(":")
 
     username = splits[-3]
     playlist_id = splits[-1]
-    results = spotify.user_playlist(username, playlist_id,
-                                    fields='tracks,next,name,owner')
+    results = spotify.user_playlist(
+        username, playlist_id, fields="tracks,next,name,owner"
+    )
 
     all_tracks = []
-    tracks = results['tracks']
+    tracks = results["tracks"]
     while True:
-        for item in tracks['items']:
-            track = item['track']
+        for item in tracks["items"]:
+            track = item["track"]
             try:
                 all_tracks.append(track)
             except KeyError:
                 pass
         # 1 page = 50 results
         # check if there are more pages
-        if tracks['next']:
+        if tracks["next"]:
             tracks = spotify.next(tracks)
         else:
             break
@@ -59,7 +62,7 @@ def grab_playlist(spotify, playlist):
 
 
 def show_message(message, col=c.r, update=False):
-    """ Show message using col, update screen if required. """
+    """Show message using col, update screen if required."""
     g.content = content.generate_songlist_display()
     g.message = col + message + c.w
 
@@ -68,7 +71,7 @@ def show_message(message, col=c.r, update=False):
 
 
 def _best_song_match(songs, title, duration, titleweight, durationweight):
-    """ Select best matching song based on title, length.
+    """Select best matching song based on title, length.
 
     Score from 0 to 1 where 1 is best. titleweight and durationweight
     parameters added to enable function usage when duration can't be guessed
@@ -78,7 +81,7 @@ def _best_song_match(songs, title, duration, titleweight, durationweight):
     seqmatch = difflib.SequenceMatcher
 
     def variance(a, b):
-        """ Return difference ratio. """
+        """Return difference ratio."""
         return float(abs(a - b)) / max(a, b)
 
     candidates = []
@@ -107,8 +110,9 @@ def variance(a, b):
 
         title_score = seqmatch(None, title.lower(), tit.lower()).ratio()
         duration_score = 1 - variance(duration, dur)
-        util.dbg("Title score: %s, Duration score: %s", title_score,
-                 duration_score)
+        util.dbg(
+            "Title score: %s, Duration score: %s", title_score, duration_score
+        )
 
         # apply weightings
         score = duration_score * durationweight + title_score * titleweight
@@ -120,27 +124,28 @@ def variance(a, b):
 
 
 def _match_tracks(tracks):
-    """ Match list of tracks by performing multiple searches. """
+    """Match list of tracks by performing multiple searches."""
     # pylint: disable=R0914
 
     def dtime(x):
-        """ Format time to M:S. """
-        return time.strftime('%M:%S', time.gmtime(int(x)))
+        """Format time to M:S."""
+        return time.strftime("%M:%S", time.gmtime(int(x)))
 
     # do matching
     for track in tracks:
-        ttitle = track['name']
-        artist = track['artists'][0]['name']
-        length = track['duration_ms']/1000
-        util.xprint("Search :  %s%s - %s%s - %s" % (c.y, artist, ttitle, c.w,
-                                                    dtime(length)))
+        ttitle = track["name"]
+        artist = track["artists"][0]["name"]
+        length = track["duration_ms"] / 1000
+        util.xprint(
+            "Search :  %s%s - %s%s - %s"
+            % (c.y, artist, ttitle, c.w, dtime(length))
+        )
         q = "%s %s" % (artist, ttitle)
-        w = q = ttitle if artist == "Various Artists" else q
-        query = w#generate_search_qs(w, 0)
-        util.dbg(query)
+        q = ttitle if artist == "Various Artists" else q
+        util.dbg(q)
 
         # perform fetch
-        wdata = None#pafy.call_gdata('search', query)
+        wdata = extractor.search_videos(q, int(config.PAGES.get))
         results = get_tracks_from_json(wdata)
 
         if not results:
@@ -148,28 +153,30 @@ def dtime(x):
             continue
 
         s, score = _best_song_match(
-            results, artist + " " + ttitle, length, .5, .5)
+            results, artist + " " + ttitle, length, 0.5, 0.5
+        )
         cc = c.g if score > 85 else c.y
         cc = c.r if score < 75 else cc
-        util.xprint("Matched:  %s%s%s - %s \n[%sMatch confidence: "
-                    "%s%s]\n" % (c.y, s.title, c.w, util.fmt_time(s.length),
-                                 cc, score, c.w))
+        util.xprint(
+            "Matched:  %s%s%s - %s \n[%sMatch confidence: "
+            "%s%s]\n"
+            % (c.y, s.title, c.w, util.fmt_time(s.length), cc, score, c.w)
+        )
         yield s
 
 
-@command(r'suser\s*(.*[-_a-zA-Z0-9].*)?', 'suser')
+@command(r"suser\s*(.*[-_a-zA-Z0-9].*)?", "suser")
 def search_user(term):
-    """Search for Spotify user playlists. """
+    """Search for Spotify user playlists."""
     # pylint: disable=R0914,R0912
     if has_spotipy:
-
         if not term:
             show_message("Enter username:", c.g, update=True)
             term = input("> ")
 
             if not term or len(term) < 2:
                 g.message = c.r + "Not enough input!" + c.w
-                g.content = None#content.generate_songlist_display()
+                g.content = None  # content.generate_songlist_display()
                 return
 
         credentials = generate_credentials()
@@ -183,15 +190,15 @@ def search_user(term):
         g.content = "Playlists:\n"
 
         while True:
-            for playlist in playlists['items']:
-                if playlist['name'] is not None:
-                    g.content += (u'{0:>2}. {1:<30}  ({2} tracks)'.format(
-                        check, playlist['name'],
-                        playlist['tracks']['total']))
+            for playlist in playlists["items"]:
+                if playlist["name"] is not None:
+                    g.content += "{0:>2}. {1:<30}  ({2} tracks)".format(
+                        check, playlist["name"], playlist["tracks"]["total"]
+                    )
                     g.content += "\n"
                     links.append(playlist)
                     check += 1
-            if playlists['next']:
+            if playlists["next"]:
                 playlists = spotify.next(playlists)
             else:
                 break
@@ -200,29 +207,27 @@ def search_user(term):
         screen.update()
 
         choice = int(input("> "))
-        playlist = links[choice-1]
+        playlist = links[choice - 1]
 
-        search_playlist(playlist['external_urls']['spotify'], spotify=spotify)
+        search_playlist(playlist["external_urls"]["spotify"], spotify=spotify)
 
     else:
         g.message = "spotipy module must be installed for Spotify support\n"
         g.message += "see https://pypi.python.org/pypi/spotipy/"
 
 
-
-@command(r'splaylist\s*(.*[-_a-zA-Z0-9].*)?', 'splaylist')
+@command(r"splaylist\s*(.*[-_a-zA-Z0-9].*)?", "splaylist")
 def search_playlist(term, spotify=None):
-    """Search for Spotify playlist. """
+    """Search for Spotify playlist."""
     # pylint: disable=R0914,R0912
     if has_spotipy:
-
         if not term:
             show_message("Enter playlist url:", c.g, update=True)
             term = input("> ")
 
             if not term or len(term) < 2:
                 g.message = c.r + "Not enough input!" + c.w
-                g.content = None#content.generate_songlist_display()
+                g.content = None  # content.generate_songlist_display()
                 return
 
         if not spotify:
@@ -239,16 +244,28 @@ def search_playlist(term, spotify=None):
             show_message("Playlist '%s' not found!" % term)
             return
 
-        if not playlist['tracks']['total']:
-            show_message("Playlist '%s' by '%s' has 0 tracks!" % (playlist['name'], playlist['owner']['id']))
+        if not playlist["tracks"]["total"]:
+            show_message(
+                "Playlist '%s' by '%s' has 0 tracks!"
+                % (playlist["name"], playlist["owner"]["id"])
+            )
             return
 
-        msg = "%s%s%s by %s%s%s\n\n" % (c.g, playlist['name'], c.w, c.g, playlist['owner']['id'], c.w)
+        msg = "%s%s%s by %s%s%s\n\n" % (
+            c.g,
+            playlist["name"],
+            c.w,
+            c.g,
+            playlist["owner"]["id"],
+            c.w,
+        )
         msg += "Enter to begin matching or [q] to abort"
         g.message = msg
         g.content = "Tracks:\n"
         for n, track in enumerate(tracks, 1):
-            trackname = '{0:<20} - {1}'.format(track['artists'][0]['name'], track['name'])
+            trackname = "{0:<20} - {1}".format(
+                track["artists"][0]["name"], track["name"]
+            )
             g.content += "%03s  %s" % (n, trackname)
             g.content += "\n"
 
@@ -284,8 +301,20 @@ def search_playlist(term, spotify=None):
             input("Press Enter to continue")
 
         msg = "Contents of playlist %s%s - %s%s %s(%d/%d)%s:" % (
-            c.y, playlist['owner']['id'], playlist['name'], c.w, c.b, len(songs), len(tracks), c.w)
-        failmsg = "Found no playlist tracks for %s%s%s" % (c.y, playlist['name'], c.w)
+            c.y,
+            playlist["owner"]["id"],
+            playlist["name"],
+            c.w,
+            c.b,
+            len(songs),
+            len(tracks),
+            c.w,
+        )
+        failmsg = "Found no playlist tracks for %s%s%s" % (
+            c.y,
+            playlist["name"],
+            c.w,
+        )
 
         paginatesongs(songs, msg=msg, failmsg=failmsg)
 
diff --git a/mps_youtube/config.py b/mps_youtube/config.py
index 22c8ab51..4383b3f5 100644
--- a/mps_youtube/config.py
+++ b/mps_youtube/config.py
@@ -4,12 +4,10 @@
 import copy
 import pickle
 import json
-from urllib.request import urlopen
-from urllib.error import HTTPError
-from urllib.parse import urlencode
 
 try:
     import pylast
+
     has_pylast = True
 except ImportError:
     has_pylast = False
@@ -18,14 +16,32 @@
 
 
 mswin = os.name == "nt"
+macos = sys.platform == "darwin"
 
-class ConfigItem:
 
-    """ A configuration item. """
+def _default_aux_mpv_cli_config():
+    """Return mpv audio output defaults appropriate for each platform."""
+    if mswin:
+        return "--ao=wasapi"
+    if macos:
+        return "--ao=coreaudio"
+    return "--ao=pulse,alsa,pipewire"
 
-    def __init__(self, name, value, minval=None, maxval=None, check_fn=None,
-            require_known_player=False, allowed_values=None):
-        """ If specified, the check_fn should return a dict.
+
+class ConfigItem:
+    """A configuration item."""
+
+    def __init__(
+        self,
+        name,
+        value,
+        minval=None,
+        maxval=None,
+        check_fn=None,
+        require_known_player=False,
+        allowed_values=None,
+    ):
+        """If specified, the check_fn should return a dict.
 
         {valid: bool, message: success/fail mesage, value: value to set}
 
@@ -43,7 +59,7 @@ def __init__(self, name, value, minval=None, maxval=None, check_fn=None,
 
     @property
     def get(self):
-        """ Return value. """
+        """Return value."""
         if self.temp_value is None:
             return self.value
         else:
@@ -51,12 +67,13 @@ def get(self):
 
     @property
     def display(self):
-        """ Return value in a format suitable for display. """
+        """Return value in a format suitable for display."""
         return self.display_helper(self.value)
 
     @property
     def display_temp(self):
-        if self.temp_value is None: return ""
+        if self.temp_value is None:
+            return ""
         return self.display_helper(self.temp_value)
 
     def display_helper(self, retval):
@@ -64,12 +81,12 @@ def display_helper(self, retval):
             retval = str(retval) + "p"
 
         if self.name == "encoder":
-            retval = str(retval) + " [%s]" % (str(g.encoders[retval]['name']))
+            retval = str(retval) + " [%s]" % (str(g.encoders[retval]["name"]))
 
         return retval
 
     def set(self, value, is_temp=False):
-        """ Set value with checks. """
+        """Set value with checks."""
         # note: fail_msg should contain %s %s for self.name, value
         #       success_msg should not
         # pylint: disable=R0912
@@ -84,18 +101,18 @@ def set(self, value, is_temp=False):
         if self.allowed_values and value not in self.allowed_values:
             fail_msg = "%s must be one of * - not %s"
             allowed_values = copy.copy(self.allowed_values)
-            if '' in allowed_values:
-                allowed_values[allowed_values.index('')] = "<nothing>"
+            if "" in allowed_values:
+                allowed_values[allowed_values.index("")] = "<nothing>"
             fail_msg = fail_msg.replace("*", ", ".join(allowed_values))
 
-        if self.require_known_player and \
-                not util.is_known_player(Config.PLAYER.get):
+        if self.require_known_player and not util.is_known_player(
+            Config.PLAYER.get
+        ):
             fail_msg = "%s requires mpv or mplayer, can't set to %s"
 
         # handle true / false values
 
         elif self.type == bool:
-
             if value.upper() in "0 OFF NO DISABLED FALSE".split():
                 value = False
                 success_msg = "%s set to False" % c.c("g", self.name)
@@ -110,7 +127,6 @@ def set(self, value, is_temp=False):
         # handle int values
 
         elif self.type == int:
-
             if not value.isdigit():
                 fail_msg = "%s requires a number, got %s"
 
@@ -118,7 +134,6 @@ def set(self, value, is_temp=False):
                 value = int(value)
 
                 if self.maxval and self.minval:
-
                     if not self.minval <= value <= self.maxval:
                         m = " must be between %s and %s, got "
                         m = m % (self.minval, self.maxval)
@@ -126,8 +141,10 @@ def set(self, value, is_temp=False):
 
                 if not fail_msg:
                     dispval = value or "None"
-                    success_msg = "%s set to %s" % (c.c("g", self.name),
-                                                    dispval)
+                    success_msg = "%s set to %s" % (
+                        c.c("g", self.name),
+                        dispval,
+                    )
 
         # handle space separated list
 
@@ -139,8 +156,10 @@ def set(self, value, is_temp=False):
 
         elif self.type == str:
             dispval = value or "None"
-            success_msg = "%s set to %s" % (c.c("g", self.name),
-                                            c.c("g", dispval))
+            success_msg = "%s set to %s" % (
+                c.c("g", self.name),
+                c.c("g", dispval),
+            )
 
         # handle failure
 
@@ -153,18 +172,19 @@ def set(self, value, is_temp=False):
             checked = self.check_fn(value)
             value = checked.get("value") or value
 
-            if checked['valid']:
+            if checked["valid"]:
                 value = checked.get("value", value)
                 set_save(self, value, is_temp)
                 return checked.get("message", success_msg)
 
             else:
-                return checked.get('message', fail_msg)
+                return checked.get("message", fail_msg)
 
         elif success_msg:
             set_save(self, value, is_temp)
             return success_msg
 
+
 def set_save(self, value, is_temp):
     if not is_temp:
         self.temp_value = None
@@ -173,12 +193,15 @@ def set_save(self, value, is_temp):
     else:
         self.temp_value = value
 
+
 def check_console_width(val):
-    """ Show ruler to check console width. """
+    """Show ruler to check console width."""
     valid = True
     message = "-" * val + "\n"
-    message += "console_width set to %s, try a lower value if above line ove"\
-        "rlaps" % val
+    message += (
+        "console_width set to %s, try a lower value if above line overlaps"
+        % val
+    )
     return dict(valid=valid, message=message)
 
 
@@ -190,8 +213,8 @@ def check_console_width(val):
 #         urlopen(url + "?" + urlencode(query)).read()
 #         message = "The key, '" + key + "' will now be used for API requests."
 #
-#         # Make pafy use the same api key
-#         pafy.set_api_key(Config.API_KEY.get)
+#         # Make extractor use the same api key
+#         extractor.set_api_key(Config.API_KEY.get)
 #
 #         return dict(valid=True, message=message)
 #     except HTTPError:
@@ -200,7 +223,7 @@ def check_console_width(val):
 
 
 def check_ddir(d):
-    """ Check whether dir is a valid directory. """
+    """Check whether dir is a valid directory."""
     expanded = os.path.expanduser(d)
     if os.path.isdir(expanded):
         message = "Downloads will be saved to " + c.y + d + c.w
@@ -212,7 +235,7 @@ def check_ddir(d):
 
 
 def check_win_pos(pos):
-    """ Check window position input. """
+    """Check window position input."""
     if not pos.strip():
         return dict(valid=True, message="Window position not set (default)")
 
@@ -231,7 +254,7 @@ def check_win_pos(pos):
 
 
 def check_win_size(size):
-    """ Check window size input. """
+    """Check window size input."""
     if not size.strip():
         return dict(valid=True, message="Window size not set (default)")
 
@@ -247,7 +270,7 @@ def check_win_size(size):
 
 
 def check_encoder(option):
-    """ Check encoder value is acceptable. """
+    """Check encoder value is acceptable."""
     encs = g.encoders
 
     if option >= len(encs):
@@ -257,14 +280,14 @@ def check_encoder(option):
 
     else:
         message = "Encoder set to %s%s%s"
-        message = message % (c.y, encs[option]['name'], c.w)
+        message = message % (c.y, encs[option]["name"], c.w)
         return dict(valid=True, message=message)
 
 
 def check_player(player):
-    """ Check player exefile exists and get mpv version. """
+    """Check player exefile exists and get mpv version."""
     if util.has_exefile(player):
-        print(player)
+        util.dbg("resolved player executable: %s", player)
         util.assign_player(player)
         if "mpv" in player:
             version = "%s.%s.%s" % g.mpv_version
@@ -299,57 +322,74 @@ def check_lastfm_password(password):
 
 
 class _Config:
-
-    """ Holds various configuration values. """
+    """Holds various configuration values."""
 
     _configitems = [
-            ConfigItem("order", "relevance",
-                allowed_values="relevance date views rating title".split()),
-            ConfigItem("user_order", "", allowed_values =
-                [""] + "relevance date views rating".split()),
-            ConfigItem("max_results", 19, maxval=50, minval=1),
-            ConfigItem("console_width", 80, minval=70,
-                maxval=880, check_fn=check_console_width),
-            ConfigItem("max_res", 2160, minval=360, maxval=2160),
-            ConfigItem("player", "vlc" + ".exe" * mswin,
-                check_fn=check_player),
-            ConfigItem("playerargs", ""),
-            ConfigItem("encoder", 0, minval=0, check_fn=check_encoder),
-            ConfigItem("notifier", ""),
-            ConfigItem("checkupdate", True),
-            ConfigItem("show_player_keys", True, require_known_player=True),
-            ConfigItem("fullscreen", False, require_known_player=True),
-            ConfigItem("show_status", True),
-            ConfigItem("always_repeat", False),
-            ConfigItem("columns", "date user"),
-            ConfigItem("ddir", paths.get_default_ddir(), check_fn=check_ddir),
-            ConfigItem("overwrite", True),
-            ConfigItem("show_video", True),
-            ConfigItem("search_music", False),
-            ConfigItem("window_pos", "", check_fn=check_win_pos,
-                require_known_player=True),
-            ConfigItem("window_size", "",
-                check_fn=check_win_size, require_known_player=True),
-            ConfigItem("download_command", ''),
-            ConfigItem("lookup_metadata", True),
-            ConfigItem("lastfm_username", ''),
-            ConfigItem("lastfm_password", '', check_fn=check_lastfm_password),
-            ConfigItem("lastfm_api_key", ''),
-            ConfigItem("lastfm_api_secret", ''),
-            ConfigItem("audio_format", "auto",
-                allowed_values="auto webm m4a".split()),
-            ConfigItem("video_format", "auto",
-                allowed_values="auto webm mp4 3gp".split()),
-            ConfigItem("pages", 3, minval=1, maxval=100),
-            ConfigItem("autoplay", False),
-            ConfigItem("set_title", True),
-            ConfigItem("mpris", not mswin),
-            ConfigItem("show_qrcode", False),
-            ConfigItem("history", True), 
-            ConfigItem("input_history", True),
-            ConfigItem("vlc_dummy_interface", False),
-            ConfigItem("show_subtitles", True),
-            ]
+        ConfigItem(
+            "order",
+            "relevance",
+            allowed_values="relevance date views rating title".split(),
+        ),
+        ConfigItem(
+            "user_order",
+            "",
+            allowed_values=[""] + "relevance date views rating".split(),
+        ),
+        ConfigItem("max_results", 19, maxval=50, minval=1),
+        ConfigItem(
+            "console_width",
+            80,
+            minval=70,
+            maxval=880,
+            check_fn=check_console_width,
+        ),
+        ConfigItem("max_res", 2160, minval=360, maxval=2160),
+        ConfigItem("player", "vlc" + ".exe" * mswin, check_fn=check_player),
+        ConfigItem("playerargs", ""),
+        ConfigItem("encoder", 0, minval=0, check_fn=check_encoder),
+        ConfigItem("notifier", ""),
+        ConfigItem("checkupdate", True),
+        ConfigItem("show_player_keys", True, require_known_player=True),
+        ConfigItem("fullscreen", False, require_known_player=True),
+        ConfigItem("show_status", True),
+        ConfigItem("always_repeat", False),
+        ConfigItem("columns", "date user"),
+        ConfigItem("ddir", paths.get_default_ddir(), check_fn=check_ddir),
+        ConfigItem("overwrite", True),
+        ConfigItem("show_video", True),
+        ConfigItem("search_music", False),
+        ConfigItem(
+            "window_pos", "", check_fn=check_win_pos, require_known_player=True
+        ),
+        ConfigItem(
+            "window_size",
+            "",
+            check_fn=check_win_size,
+            require_known_player=True,
+        ),
+        ConfigItem("download_command", ""),
+        ConfigItem("lookup_metadata", True),
+        ConfigItem("lastfm_username", ""),
+        ConfigItem("lastfm_password", "", check_fn=check_lastfm_password),
+        ConfigItem("lastfm_api_key", ""),
+        ConfigItem("lastfm_api_secret", ""),
+        ConfigItem(
+            "audio_format", "auto", allowed_values="auto webm m4a".split()
+        ),
+        ConfigItem(
+            "video_format", "auto", allowed_values="auto webm mp4 3gp".split()
+        ),
+        ConfigItem("pages", 3, minval=1, maxval=100),
+        ConfigItem("autoplay", False),
+        ConfigItem("set_title", True),
+        ConfigItem("mpris", not mswin),
+        ConfigItem("show_qrcode", False),
+        ConfigItem("history", True),
+        ConfigItem("input_history", True),
+        ConfigItem("vlc_dummy_interface", False),
+        ConfigItem("show_subtitles", True),
+        ConfigItem("aux_mpv_cli_config", _default_aux_mpv_cli_config()),
+    ]
 
     def __getitem__(self, key):
         # TODO: Possibly more efficient algorithm, w/ caching
@@ -361,7 +401,7 @@ def __getitem__(self, key):
     def __getattr__(self, name):
         try:
             # todo: remove this later
-            if name != 'API_KEY':
+            if name != "API_KEY":
                 return self[name]
         except KeyError:
             raise AttributeError
@@ -370,7 +410,7 @@ def __iter__(self):
         return (i.name.upper() for i in self._configitems)
 
     def save(self):
-        """ Save current config to file. """
+        """Save current config to file."""
         config = {setting: self[setting].value for setting in self}
 
         with open(g.CFFILE, "w") as cf:
@@ -391,13 +431,12 @@ def convert_old_cf_to_json(self):
             os.remove(g.OLD_CFFILE)
 
     def load(self):
-        """ Override config if config file exists. """
+        """Override config if config file exists."""
         if os.path.exists(g.CFFILE):
             with open(g.CFFILE, "r") as cf:
                 saved_config = json.load(cf)
 
             for k, v in saved_config.items():
-
                 try:
                     self[k].value = v
 
@@ -407,8 +446,7 @@ def load(self):
             # Update config files from versions <= 0.01.41
             if isinstance(self.PLAYERARGS.get, list):
                 self.WINDOW_POS.value = "top-right"
-                redundant = ("-really-quiet --really-quiet -prefer-ipv4 -nolirc "
-                             "-fs --fs".split())
+                redundant = "-really-quiet --really-quiet -prefer-ipv4 -nolirc -fs --fs".split()
 
                 for r in redundant:
                     util.dbg("removing redundant arg %s", r)
@@ -417,8 +455,9 @@ def load(self):
                 self.PLAYERARGS.value = " ".join(self.PLAYERARGS.get)
                 self.save()
 
+
 Config = _Config()
-del _Config # _Config is a singleton and should not have more instances
+del _Config  # _Config is a singleton and should not have more instances
 # Prevent module from being deleted
 # http://stackoverflow.com/questions/5365562/why-is-the-value-of-name-changing-after-assignment-to-sys-modules-name
 ref = sys.modules[__name__]
diff --git a/mps_youtube/content.py b/mps_youtube/content.py
index 01f063cf..94fde218 100644
--- a/mps_youtube/content.py
+++ b/mps_youtube/content.py
@@ -9,6 +9,7 @@
 try:
     import qrcode
     import io
+
     HAS_QRCODE = True
 except ImportError:
     HAS_QRCODE = False
@@ -35,7 +36,7 @@ def getPage(self, page):
         return self.get_text(s, e)
 
     def numPages(self):
-        return math.ceil(self.get_count()/getxy().max_results)
+        return math.ceil(self.get_count() / getxy().max_results)
 
     def get_text(self, s, e):
         raise NotImplementedError
@@ -49,7 +50,7 @@ def __init__(self, string):
         self._lines = string.splitlines()
 
     def get_text(self, s, e):
-        return '\n'.join(self._lines[s:e])
+        return "\n".join(self._lines[s:e])
 
     def get_count(self):
         width = getxy().width
@@ -58,24 +59,26 @@ def get_count(self):
 
 
 def page_msg(page=0):
-    """ Format information about currently displayed page to a string. """
+    """Format information about currently displayed page to a string."""
     if isinstance(g.content, PaginatedContent):
         page_count = g.content.numPages()
     else:
-        page_count = math.ceil(g.result_count/getxy().max_results)
+        page_count = math.ceil(g.result_count / getxy().max_results)
 
     if page_count > 1:
         pagemsg = "{}{}/{}{}"
-        #start_index = max_results * g.current_page
-        return pagemsg.format('<' if page > 0 else '[',
-                              "%s%s%s" % (c.y, page+1, c.w),
-                              page_count,
-                              '>' if page + 1 < page_count else ']')
+        # start_index = max_results * g.current_page
+        return pagemsg.format(
+            "<" if page > 0 else "[",
+            "%s%s%s" % (c.y, page + 1, c.w),
+            page_count,
+            ">" if page + 1 < page_count else "]",
+        )
     return None
 
 
 def generate_songlist_display(song=False, zeromsg=None):
-    """ Generate list of choices from a song list."""
+    """Generate list of choices from a song list."""
     # pylint: disable=R0914
     if g.browse_mode == "ytpl":
         return generate_playlist_display()
@@ -96,37 +99,43 @@ def generate_songlist_display(song=False, zeromsg=None):
     reserved = 9 + lengthsize + len(user_columns)
     cw = getxy().width
     cw -= 1
-    title_size = cw - sum(1 + x['size'] for x in user_columns) - reserved
-    before = [{"name": "idx", "size": 3, "heading": "Num"},
-              {"name": "title", "size": title_size, "heading": "Title"}]
+    title_size = cw - sum(1 + x["size"] for x in user_columns) - reserved
+    before = [
+        {"name": "idx", "size": 3, "heading": "Num"},
+        {"name": "title", "size": title_size, "heading": "Title"},
+    ]
     after = [{"name": "length", "size": lengthsize, "heading": "Length"}]
     columns = before + user_columns + after
 
     for n, column in enumerate(columns):
-        column['idx'] = n
-        column['sign'] = "-" if not column['name'] == "length" else ""
+        column["idx"] = n
+        column["sign"] = "-" if not column["name"] == "length" else ""
 
-    fmt = ["%{}{}s  ".format(x['sign'], x['size']) for x in columns]
+    fmt = ["%{}{}s  ".format(x["sign"], x["size"]) for x in columns]
     fmtrow = fmt[0:1] + ["%s  "] + fmt[2:]
     fmt, fmtrow = "".join(fmt).strip(), "".join(fmtrow).strip()
-    titles = tuple([x['heading'][:x['size']] for x in columns])
+    titles = tuple([x["heading"][: x["size"]] for x in columns])
     hrow = c.ul + fmt % titles + c.w
     out = "\n" + hrow + "\n"
 
     for n, x in enumerate(g.model[:max_results]):
         col = (c.r if n % 2 == 0 else c.p) if not song else c.b
-        details = {'title': x.title, "length": fmt_time(x.length)}
+        details = {"title": x.title, "length": fmt_time(x.length)}
         details = copy.copy(g.meta[x.ytid]) if have_meta else details
-        otitle = details['title']
-        details['idx'] = "%2d" % (n + 1)
-        details['title'] = uea_pad(columns[1]['size'], otitle)
-        #cat = details.get('category') or '-'
-        #details['category'] = 'pafy.get_categoryname(cat)'
-        details['ytid'] = x.ytid
-        line = ''
+        otitle = details["title"]
+        details["idx"] = "%2d" % (n + 1)
+        details["title"] = uea_pad(columns[1]["size"], otitle)
+        # cat = details.get('category') or '-'
+        # details['category'] = 'extractor.get_categoryname(cat)'
+        details["ytid"] = x.ytid
+        line = ""
 
         for z in columns:
-            fieldsize, field, direction = z['size'], z['name'], "<" if z['sign'] == "-" else ">"
+            fieldsize, field, direction = (
+                z["size"],
+                z["name"],
+                "<" if z["sign"] == "-" else ">",
+            )
             line += uea_pad(fieldsize, details[field], direction)
             if not columns[-1] == z:
                 line += "  "
@@ -139,7 +148,7 @@ def generate_songlist_display(song=False, zeromsg=None):
 
 
 def generate_playlist_display():
-    """ Generate list of playlists. """
+    """Generate list of playlists."""
 
     if not g.ytpls:
         g.message = c.r + "No playlists found!"
@@ -153,34 +162,44 @@ def generate_playlist_display():
     out = "\n" + fmthd % head
 
     for n, x in enumerate(g.ytpls):
-        col = (c.g if n % 2 == 0 else c.w)
-        length = x.get('size') or "?"
+        col = c.g if n % 2 == 0 else c.w
+        length = x.get("size") or "?"
         length = "%4s" % length
-        title = x.get('title') or "unknown"
-        author = x.get('author') or "unknown"
-        updated = yt_datetime(x.get('updated'))[1]
+        title = x.get("title") or "unknown"
+        author = x.get("author") or "unknown"
+        updated = yt_datetime(x.get("updated"))[1]
         title = uea_pad(cw - 36, title)
-        out += (fmtrow % (col, str(n + 1), title, author[:12], updated, str(length), c.w))
+        out += fmtrow % (
+            col,
+            str(n + 1),
+            title,
+            author[:12],
+            updated,
+            str(length),
+            c.w,
+        )
 
     return out + "\n" * (5 - len(g.ytpls))
 
 
 def _get_user_columns():
-    """ Get columns from user config, return dict. """
+    """Get columns from user config, return dict."""
     total_size = 0
     user_columns = config.COLUMNS.get
     user_columns = user_columns.replace(",", " ").split()
 
-    defaults = {"views": dict(name="viewCount", size=4, heading="View"),
-                "rating": dict(name="rating", size=4, heading="Rtng"),
-                "comments": dict(name="commentCount", size=4, heading="Comm"),
-                "date": dict(name="uploaded", size=8, heading="Date"),
-                "time": dict(name="uploadedTime", size=11, heading="Time"),
-                "user": dict(name="uploaderName", size=10, heading="User"),
-                "likes": dict(name="likes", size=4, heading="Like"),
-                "dislikes": dict(name="dislikes", size=4, heading="Dslk"),
-                "category": dict(name="category", size=8, heading="Category"),
-                "ytid": dict(name="ytid", size=12, heading="Video ID")}
+    defaults = {
+        "views": dict(name="viewCount", size=4, heading="View"),
+        "rating": dict(name="rating", size=4, heading="Rtng"),
+        "comments": dict(name="commentCount", size=4, heading="Comm"),
+        "date": dict(name="uploaded", size=14, heading="Date"),
+        "time": dict(name="uploaded", size=14, heading="Time"),
+        "user": dict(name="uploaderName", size=10, heading="User"),
+        "likes": dict(name="likes", size=4, heading="Like"),
+        "dislikes": dict(name="dislikes", size=4, heading="Dslk"),
+        "category": dict(name="category", size=8, heading="Category"),
+        "ytid": dict(name="ytid", size=12, heading="Video ID"),
+    }
 
     ret = []
     for column in user_columns:
@@ -189,7 +208,7 @@ def _get_user_columns():
 
         if name in defaults:
             z = defaults[name]
-            nm, sz, hd = z['name'], z['size'], z['heading']
+            nm, sz, hd = z["name"], z["size"], z["heading"]
 
             if len(namesize) == 2 and namesize[1].isdigit():
                 sz = int(namesize[1])
@@ -203,16 +222,16 @@ def _get_user_columns():
 
 
 def logo(col=None, version=""):
-    """ Return text logo. """
+    """Return text logo."""
     col = col if col else random.choice((c.g, c.r, c.y, c.b, c.p, c.w))
-    logo_txt = r"""                      _         _          
-                     | |       | |         
-  _   _  _____      _| |_ _   _| |__   ___ 
+    logo_txt = r"""                      _         _
+                     | |       | |
+  _   _  _____      _| |_ _   _| |__   ___
  | | | |/ _ \ \ /\ / / __| | | | '_ \ / _ \
  | |_| |  __/\ V  V /| |_| |_| | |_) |  __/
   \__, |\___| \_/\_/  \__|\__,_|_.__/ \___|
-   __/ |                                   
-  |___/                                    
+   __/ |
+  |___/
     """
 
     version = " v" + version if version else ""
@@ -229,7 +248,7 @@ def logo(col=None, version=""):
 
 
 def playlists_display():
-    """ Produce a list of all playlists. """
+    """Produce a list of all playlists."""
     if not g.userpl:
         g.message = F("no playlists")
         return generate_songlist_display() if g.model else (logo(c.y) + "\n\n")
@@ -243,9 +262,23 @@ def playlists_display():
 
     for v, z in enumerate(sorted(g.userpl)):
         n, p = z, g.userpl[z]
-        l = fmt % (start, c.g, v + 1, n, c.w, c.y, str(len(p)), c.y,
-                   p.duration, c.w) + "\n"
-        out += l
+        line = (
+            fmt
+            % (
+                start,
+                c.g,
+                v + 1,
+                n,
+                c.w,
+                c.y,
+                str(len(p)),
+                c.y,
+                p.duration,
+                c.w,
+            )
+            + "\n"
+        )
+        out += line
 
     return out
 
@@ -260,18 +293,21 @@ def qrcode_display(url):
     qr.print_ascii(out=buf)
     return buf.getvalue()
 
+
 def get_last_query():
     # Prevent crash if no last query
-    if g.last_search_query == (None, None) or \
-            'func' not in g.last_search_query[1]:
+    if (
+        g.last_search_query == (None, None)
+        or "func" not in g.last_search_query[1]
+    ):
         g.content = logo()
         g.message = "No playlist loaded"
         return
 
-    songs_list_or_func = g.last_search_query[1]['func']
+    songs_list_or_func = g.last_search_query[1]["func"]
     if callable(songs_list_or_func):
-        songs = songs_list_or_func(0,None)
+        songs = songs_list_or_func(0, None)
     else:
         songs = songs_list_or_func
 
-    return songs
\ No newline at end of file
+    return songs
diff --git a/mps_youtube/contentquery.py b/mps_youtube/contentquery.py
index 7031ebc4..cb162d26 100644
--- a/mps_youtube/contentquery.py
+++ b/mps_youtube/contentquery.py
@@ -1,18 +1,19 @@
 """
-    ContentQuery is an abstraction layer between the the pafy.call_gdata
-    and the listViews.
+ContentQuery is an abstraction layer between the the extractor.call_gdata
+and the listViews.
 
-    It lets you treat A query as a list of all the results, even though
-    data is only queried when requested.
+It lets you treat A query as a list of all the results, even though
+data is only queried when requested.
 """
 
-from . import util, pafy
+from . import util, extractor
 
 
 class ContentQuery:
-    """ A wrapper for pafy.call_gdata. I lets you treat a search as a list,
-        but the results will only be fetched when needed.
+    """A wrapper for extractor.call_gdata. I lets you treat a search as a list,
+    but the results will only be fetched when needed.
     """
+
     maxresults = 0
     pdata = []
     nextpagetoken = None
@@ -44,7 +45,7 @@ def __getitem__(self, iid):
         return self.pdata[iid]
 
     def count(self):
-        """ Returns how many items are in the list """
+        """Returns how many items are in the list"""
         return self.maxresults
 
     def __len__(self):
@@ -58,11 +59,13 @@ def _perform_api_call(self):
         #     ) if self.nextpagetoken else self.query
 
         # Run query
-        util.dbg("CQ.query", self.query)
-        data = pafy.channel_search(self.query)#pafy.call_gdata(self.api, qry)
-        
-        self.maxresults = len(data)#int(data.get("pageInfo").get("totalResults"))
-        self.nextpagetoken = None#data.get("nextPageToken")
+        util.dbg("CQ.query: %s", self.query)
+        data = extractor.channel_search(self.query)  # extractor.call_gdata(self.api, qry)
+
+        self.maxresults = len(
+            data
+        )  # int(data.get("pageInfo").get("totalResults"))
+        self.nextpagetoken = None  # data.get("nextPageToken")
 
         for obj in data:
             self.pdata.append(self.datatype(obj))
diff --git a/mps_youtube/description_parser.py b/mps_youtube/description_parser.py
index 009f8a77..b8ff5837 100644
--- a/mps_youtube/description_parser.py
+++ b/mps_youtube/description_parser.py
@@ -1,37 +1,41 @@
 """
-    Module for trying to parse and retrieve song data from descriptions
+Module for trying to parse and retrieve song data from descriptions
 """
+
 import re
 import random
 
 
 def calculate_certainty(line):
-    """ Determine if a line contains a  """
+    """Determine if a line contains a"""
     certainty_indexes = [
-        {'regex': r"(?:\(?(?:\d{0,4}:)?\d{0,2}:\d{0,2}\)?(?: - )?){1,2}",
-         'weight': 1},
-        {'regex': r"(([\w&()\[\]'\.\/ ]+)([ ]?[-]+[ ]?)([\w&()\[\]'\.\/ ]+))+",
-         'weight': 0.75},
-        {'regex': r"^([\d]+[. ]+)",
-         'weight': 1}
+        {
+            "regex": r"(?:\(?(?:\d{0,4}:)?\d{0,2}:\d{0,2}\)?(?: - )?){1,2}",
+            "weight": 1,
+        },
+        {
+            "regex": r"(([\w&()\[\]'\.\/ ]+)([ ]?[-]+[ ]?)([\w&()\[\]'\.\/ ]+))+",
+            "weight": 0.75,
+        },
+        {"regex": r"^([\d]+[. ]+)", "weight": 1},
     ]
 
     certainty = 0.0
     for method in certainty_indexes:
-        if re.match(method['regex'], line):
-            certainty += method['weight']
+        if re.match(method["regex"], line):
+            certainty += method["weight"]
 
     return certainty / len(certainty_indexes)
 
 
 def has_artist(text):
-    """ Determine if the strìng has artist or not """
+    """Determine if the strìng has artist or not"""
     regex = r"(?:([\w&()\[\]'\.\/ ]+)(?:[ ]?[-]+[ ]?)([\w&()\[\]'\.\/ ]+))+"
     return not re.match(regex, text)
 
 
 def strip_string(text, single=False):
-    """ Strip an artist-combo string """
+    """Strip an artist-combo string"""
     # Removes timestamps
     ts_reg = r"(?:\(?(?:\d{0,4}:)?\d{1,2}:\d{1,2}\)?(?: - )?){1,2}"
     text = re.sub(ts_reg, "", text)
@@ -45,7 +49,7 @@ def strip_string(text, single=False):
     artist, track = None, None
     if not single:
         rgex = r"(?:([\w&()\[\]'\.\/ ]+)(?:[ ]?[-]+[ ]?)([\w&()\[\]'\.\/ ]+))+"
-        artist, track = (re.findall(rgex, text)[0])
+        artist, track = re.findall(rgex, text)[0]
     else:
         track = text
 
@@ -53,18 +57,18 @@ def strip_string(text, single=False):
 
 
 def long_substr(data):
-    """ https://stackoverflow.com/a/2894073 """
-    substr = ''
+    """https://stackoverflow.com/a/2894073"""
+    substr = ""
     if len(data) > 1 and len(data[0]) > 0:
         for i in range(len(data[0])):
-            for j in range(len(data[0])-i+1):
-                if j > len(substr) and is_substr(data[0][i:i+j], data):
-                    substr = data[0][i:i+j]
+            for j in range(len(data[0]) - i + 1):
+                if j > len(substr) and is_substr(data[0][i : i + j], data):
+                    substr = data[0][i : i + j]
     return substr
 
 
 def is_substr(find, data):
-    """ Check if is substring """
+    """Check if is substring"""
     if len(data) < 1 and len(find) < 1:
         return False
     for i, _ in enumerate(data):
@@ -74,19 +78,21 @@ def is_substr(find, data):
 
 
 def artist_from_title(title):
-    """ Try to determine an artist by doing a search on the video
-        and try to find the most common element by n number of times looking
-        for the most common substring in a subset of the results from youtube
+    """Try to determine an artist by doing a search on the video
+    and try to find the most common element by n number of times looking
+    for the most common substring in a subset of the results from youtube
     """
     query = {}
-    query['q'] = title
-    query['type'] = 'video'
-    query['fields'] = "items(snippet(title))"
-    query['maxResults'] = 50
-    query['part'] = "snippet"
+    query["q"] = title
+    query["type"] = "video"
+    query["fields"] = "items(snippet(title))"
+    query["maxResults"] = 50
+    query["part"] = "snippet"
+
+    from . import extractor
 
-    results = None#pafy.call_gdata('search', query)['items']
-    titles = [x['snippet']['title'].upper() for x in results]
+    results = extractor.search_videos(title, 1)
+    titles = [x["title"].upper() for x in results]
 
     alts = {}
     for _ in range(100):
@@ -115,19 +121,21 @@ def artist_from_title(title):
 
 
 def parse(text, title="Unknown"):
-    """ Main function"""
+    """Main function"""
 
     # Determine a certainty index for each line
     lines = []
-    for line in text.split('\n'):
+    for line in text.split("\n"):
         lines.append((calculate_certainty(line), line))
 
     # Get average from all strings
     certainty_average = sum([x[0] for x in lines]) / len(lines)
 
     # Single out lines with above average certainty index
-    lines = filter(lambda a: a is not None,
-                   [x if x[0] > certainty_average else None for x in lines])
+    lines = filter(
+        lambda a: a is not None,
+        [x if x[0] > certainty_average else None for x in lines],
+    )
 
     # Determine if they are artist combo strings or only title
     cmbs = []
@@ -140,22 +148,26 @@ def parse(text, title="Unknown"):
     # and without artist, and remove the anomalities IF the number of
     # anomalities are small enough
 
-    counters = {'has': 0, 'not': 0}
+    counters = {"has": 0, "not": 0}
     for combo in cmbs:
-        counters['has' if combo[0] else 'not'] += 1
+        counters["has" if combo[0] else "not"] += 1
 
-    dominant = 'has' if counters['has'] > counters['not'] else 'not'
+    dominant = "has" if counters["has"] > counters["not"] else "not"
 
-    diff = abs(counters['has'] - counters['not'])
-    if diff > sum([counters['has'], counters['not']]):
+    diff = abs(counters["has"] - counters["not"])
+    if diff > sum([counters["has"], counters["not"]]):
         print("Too many anomalities detected")
         return []
 
-    if dominant == 'has':
-        cmbs = filter(lambda a: a is not None,
-                      [x if x[0] is not None else None for x in cmbs])
+    if dominant == "has":
+        cmbs = filter(
+            lambda a: a is not None,
+            [x if x[0] is not None else None for x in cmbs],
+        )
     else:
         arti = artist_from_title(title)
-        cmbs = filter(lambda a: a is not None,
-                      [(arti, x[1]) if x[0] is None else None for x in cmbs])
+        cmbs = filter(
+            lambda a: a is not None,
+            [(arti, x[1]) if x[0] is None else None for x in cmbs],
+        )
     return list(cmbs)
diff --git a/mps_youtube/extractor.py b/mps_youtube/extractor.py
new file mode 100644
index 00000000..05505ead
--- /dev/null
+++ b/mps_youtube/extractor.py
@@ -0,0 +1,480 @@
+import concurrent.futures
+import json
+import os
+import glob
+import random
+import re
+import time
+import urllib.parse
+from urllib.parse import parse_qs, urlparse
+import urllib.request
+import urllib.error
+import typing as T
+from datetime import datetime, timezone
+
+from . import g, paths, util
+import yt_dlp
+import youtubesearchpython as ysp
+
+
+def _format_published_time(entry):
+    """Helper to get a standard ISO8601 string from data (yt-dlp format)."""
+    ts = entry.get("timestamp")
+    if ts:
+        return datetime.fromtimestamp(ts, timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    ud = entry.get("upload_date")
+    if ud and len(ud) == 8:
+        try:
+            return f"{ud[:4]}-{ud[4:6]}-{ud[6:]}T00:00:00Z"
+        except Exception:
+            pass
+
+    return None
+
+
+class VideoInfo:
+    """Standardized metadata object for videos."""
+
+    def __init__(self, data: T.Dict[str, T.Any]):
+        self._data = data
+        self._ytid = data.get("id") or data.get("videoId")
+        self.title = data.get("title") or "Unknown Title"
+        self.author = data.get("uploader") or data.get("channel", {}).get("name") or "Unknown Author"
+        
+        duration = data.get("duration") or data.get("lengthSeconds")
+        if isinstance(duration, dict):
+            duration = duration.get("secondsText")
+        self.length = int(duration) if duration else 0
+        
+        views = data.get("view_count") or data.get("viewCount")
+        if isinstance(views, dict):
+            views = views.get("text")
+        self.view_count = int(views) if views and str(views).isdigit() else 0
+        
+        self.likes = data.get("likes") or 0
+        self.dislikes = data.get("dislikes") or 0
+        self.rating = data.get("averageRating") or 0
+        
+        expires = data.get("expires")
+        self.expiry = time.time() + (expires if expires is not None else 3600)
+        self.fresh = True
+
+    @property
+    def ytid(self):
+        return self._ytid
+
+    @property
+    def videoid(self):
+        return self._ytid
+
+    def __getitem__(self, key):
+        return self._data.get(key)
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+
+class ExtractionError(Exception):
+    """Base exception for extraction issues."""
+
+    pass
+
+
+class MyLogger:
+    def __init__(self, print_info=False):
+        self.print_info = print_info
+
+    def debug(self, msg):
+        if not msg.startswith("[debug] "):
+            self.info(msg)
+
+    def info(self, msg):
+        if self.print_info:
+            print(msg)
+
+    def warning(self, msg):
+        pass
+
+    def error(self, msg):
+        print(msg)
+
+
+def get_ydl_opts(extra_opts: T.Optional[T.Dict[str, T.Any]] = None) -> T.Dict[str, T.Any]:
+    """Factory for standard yt-dlp options."""
+    opts = {
+        "logger": MyLogger(),
+        "quiet": True,
+        "no_warnings": True,
+        "nocheckcertificate": True,
+        "remote_components": "ejs:github",
+        "user_agent": util.BROWSER_USER_AGENT,
+        "http_headers": util.web_headers(),
+        "ignore_no_formats_error": True,
+    }
+    if extra_opts:
+        opts.update(extra_opts)
+    return opts
+
+
+def get_video_streams(ytid):
+    """Get video / audio stream formats for a video id using yt-dlp (Primary for reliability)."""
+    url = f"https://www.youtube.com/watch?v={ytid}"
+    try:
+        with yt_dlp.YoutubeDL(get_ydl_opts()) as ydl:
+            info_dict = ydl.extract_info(url, download=False)
+            return _extract_streams_from_info(info_dict)
+    except Exception as e:
+        util.dbg("yt-dlp get_video_streams failed for %s: %s", ytid, str(e))
+        
+        # Fallback to YSP
+        try:
+            video_data = ysp.Video.get(ytid)
+            if video_data:
+                streaming_data = video_data.get("streamingData", {})
+                formats = streaming_data.get("formats", []) + streaming_data.get("adaptiveFormats", [])
+                if formats:
+                    results = []
+                    for f in formats:
+                        url_val = f.get("url")
+                        if not url_val: continue
+                        mime = f.get("mimeType", "")
+                        vcodec = "none" if "audio" in mime and "video" not in mime else mime.split(";")[0]
+                        acodec = "none" if "video" in mime and "audio" not in mime else mime.split(";")[0]
+                        results.append({
+                            "url": url_val,
+                            "ext": mime.split(";")[0].split("/")[-1] if mime else "mp4",
+                            "quality": f.get("qualityLabel") or f.get("quality"),
+                            "resolution": f.get("qualityLabel") or f.get("quality"),
+                            "width": f.get("width"),
+                            "height": f.get("height"),
+                            "vcodec": vcodec,
+                            "acodec": acodec,
+                            "tbr": (f.get("bitrate", 0) or 0) / 1000,
+                            "filesize": int(f.get("contentLength", 0) or 0),
+                            "itag": f.get("itag"),
+                        })
+                    return results
+        except Exception:
+            pass
+            
+        raise ExtractionError(f"Failed to extract streams for {ytid}: {str(e)}")
+
+
+def _extract_streams_from_info(info_dict):
+    """Normalize yt-dlp extraction output into a list of format dictionaries."""
+    raw_formats = info_dict.get("formats") or []
+    
+    # If no formats, check requested_formats (often case for some clients)
+    if not raw_formats:
+        raw_formats = info_dict.get("requested_formats") or []
+
+    # Last resort fallback
+    if not raw_formats and info_dict.get("url"):
+        raw_formats = [info_dict]
+
+    formats = []
+    for f in raw_formats:
+        if f.get("format_note") == "storyboard":
+            continue
+        
+        # Ensure critical fields are present and normalized
+        norm_f = f.copy()
+        if "itag" not in norm_f and "format_id" in f:
+            try:
+                norm_f["itag"] = int(f["format_id"])
+            except (ValueError, TypeError):
+                pass
+
+        vcodec = f.get("vcodec")
+        acodec = f.get("acodec")
+        norm_f["vcodec"] = str(vcodec).lower() if vcodec else "none"
+        norm_f["acodec"] = str(acodec).lower() if acodec else "none"
+        norm_f["resolution"] = f.get("resolution") or f.get("qualityLabel") or f.get("quality")
+        formats.append(norm_f)
+
+    return formats
+
+
+def download_video(ytid, folder, audio_only=False):
+    """Download video or audio using yt-dlp."""
+    ytdl_format_options = {
+        "outtmpl": os.path.join(folder, "%(title)s-%(id)s.%(ext)s")
+    }
+    if audio_only:
+        ytdl_format_options["format"] = "bestaudio/best"
+        ytdl_format_options["postprocessors"] = [
+            {
+                "key": "FFmpegExtractAudio",
+                "preferredcodec": "mp3",
+                "preferredquality": "192",
+            }
+        ]
+
+    try:
+        with yt_dlp.YoutubeDL(get_ydl_opts(ytdl_format_options)) as ydl:
+            ydl.download(["https://www.youtube.com/watch?v=%s" % ytid])
+            return True
+    except Exception as e:
+        raise ExtractionError(f"Download failed for {ytid}: {str(e)}")
+
+
+def search_videos(query, pages):
+    """Search for videos using youtubesearchpython (Discovery is fast and has age metadata)."""
+    try:
+        search = ysp.VideosSearch(query, limit=pages * 20)
+        results = search.result()
+        if results and "result" in results:
+            return results["result"]
+    except Exception as e:
+        util.dbg("YSP search failed: %s", str(e))
+    return []
+
+
+def channel_search(query):
+    """Search for channels using youtubesearchpython."""
+    try:
+        search = ysp.ChannelsSearch(query, limit=20)
+        results = search.result()
+        if results and "result" in results:
+            return results["result"]
+    except Exception as e:
+        util.dbg("YSP channel search failed: %s", str(e))
+    return []
+
+
+def playlist_search(query):
+    """Search for playlists using youtubesearchpython."""
+    try:
+        search = ysp.PlaylistsSearch(query, limit=20)
+        results = search.result()
+        if results and "result" in results:
+            return results["result"]
+    except Exception as e:
+        util.dbg("YSP playlist search failed: %s", str(e))
+    return []
+
+
+def get_playlist(playlist_id):
+    """Get all videos of a playlist using youtubesearchpython."""
+    try:
+        url = f"https://www.youtube.com/playlist?list={playlist_id}"
+        return ysp.Playlist(url)
+    except Exception as e:
+        util.dbg("YSP get_playlist failed: %s", str(e))
+        raise ExtractionError(f"Playlist extraction failed: {str(e)}")
+
+
+def get_video_title_suggestions(query):
+    """Get search suggestions using direct Google API call."""
+    encoded_query = urllib.parse.quote(query)
+    url = f"https://suggestqueries.google.com/complete/search?client=youtube&ds=yt&hl=en&q={encoded_query}"
+    req = urllib.request.Request(
+        url, headers=util.web_headers({"Accept-Language": "en-US,en;q=0.9"})
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            if not isinstance(data, list) or len(data) < 2 or not data[1]:
+                return query
+            return random.choice(data[1])
+    except Exception:
+        return query
+
+
+def channel_id_from_name(query):
+    """Resolve channel ID and name from query."""
+    results = channel_search(query)
+    if not results:
+        return None, None
+    channel_info = results[0]
+    return channel_info["id"], channel_info["title"]
+
+
+import httpx
+
+def all_videos_from_channel(channel_id):
+    """Get all videos from a channel using Innertube browse for full metadata."""
+    try:
+        # Innertube browse endpoint for channel videos
+        url = "https://www.youtube.com/youtubei/v1/browse"
+        headers = util.web_headers({"Content-Type": "application/json"})
+        payload = {
+            "context": {
+                "client": {
+                    "clientName": "WEB",
+                    "clientVersion": "2.20210224.06.00"
+                }
+            },
+            "browseId": channel_id,
+            "params": "EgZ2aWRlb3PyBgQKAjoA" # Videos tab
+        }
+        
+        with httpx.Client(headers=headers) as client:
+            resp = client.post(url, json=payload)
+            if resp.status_code != 200:
+                return []
+            
+            data = resp.json()
+            videos = []
+            
+            # Try to get channel title
+            channel_name = "Unknown"
+            metadata = data.get("metadata", {}).get("channelMetadataRenderer", {})
+            if metadata:
+                channel_name = metadata.get("title", "Unknown")
+
+            # Helper to find all videoRenderers recursively
+            def find_videos(obj):
+                if isinstance(obj, dict):
+                    renderer = obj.get("videoRenderer") or obj.get("gridVideoRenderer") or obj.get("compactVideoRenderer")
+                    if renderer:
+                        v = renderer
+                        
+                        # Extract publishedTime
+                        pub_time = None
+                        if "publishedTimeText" in v:
+                            pub_time = v["publishedTimeText"].get("simpleText")
+                        
+                        # Extract duration
+                        duration = "0:00"
+                        if "lengthText" in v:
+                            duration = v["lengthText"].get("simpleText")
+                        
+                        # Extract viewCount
+                        views = "?"
+                        if "viewCountText" in v:
+                            views = v["viewCountText"].get("simpleText") or v["viewCountText"].get("runs", [{}])[0].get("text", "?")
+
+                        videos.append({
+                            "type": "video",
+                            "id": v.get("videoId"),
+                            "title": v.get("title", {}).get("runs", [{}])[0].get("text", "Unknown"),
+                            "publishedTime": pub_time,
+                            "duration": duration,
+                            "viewCount": {"text": views},
+                            "channel": {
+                                "name": v.get("ownerText", {}).get("runs", [{}])[0].get("text", channel_name),
+                                "id": channel_id
+                            }
+                        })
+                    else:
+                        for val in obj.values():
+                            find_videos(val)
+                elif isinstance(obj, list):
+                    for item in obj:
+                        find_videos(item)
+
+            find_videos(data)
+            return videos
+
+    except Exception as e:
+        util.dbg("all_videos_from_channel failed: %s", str(e))
+    return []
+
+
+def search_videos_from_channel(channel_id, query):
+    """Search videos within a specific channel."""
+    return search_videos(f"{query} channel:{channel_id}", 1)
+
+
+def get_comments(video_id):
+    """Get video comments using youtubesearchpython."""
+    try:
+        comments = ysp.Comments(video_id)
+        res = comments.result()
+        if res and "result" in res:
+            return res["result"]
+    except Exception as e:
+        util.dbg("YSP get_comments failed: %s", str(e))
+    return []
+
+
+def get_video_info(video_id):
+    """Get detailed video info using yt-dlp (Primary for metadata accuracy)."""
+    try:
+        ydl_opts = get_ydl_opts()
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(video_id, download=False)
+            dislikes = return_dislikes(video_id)
+            info["likes"] = dislikes["likes"]
+            info["dislikes"] = dislikes["dislikes"]
+            info["averageRating"] = dislikes["rating"]
+            return VideoInfo(info)
+    except Exception as e:
+        util.dbg("yt-dlp get_video_info failed for %s: %s", video_id, e)
+        # Fallback to YSP
+        try:
+            info = ysp.Video.getInfo(video_id)
+            if info:
+                dislikes = return_dislikes(video_id)
+                info["likes"] = dislikes["likes"]
+                info["dislikes"] = dislikes["dislikes"]
+                info["averageRating"] = dislikes["rating"]
+                return VideoInfo(info)
+        except Exception:
+            pass
+    
+    raise ExtractionError(f"Can't get video info for {video_id}")
+
+
+def return_dislikes(video_id):
+    """Fetch dislike counts from Return YouTube Dislike API."""
+    url = f"https://returnyoutubedislikeapi.com/votes?videoId={video_id}"
+    req = urllib.request.Request(
+        url, headers=util.web_headers({"Accept": "application/json"})
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            return {
+                "likes": data.get("likes", 0),
+                "dislikes": data.get("dislikes", 0),
+                "rating": data.get("rating", 0),
+            }
+    except Exception:
+        return {"likes": 0, "dislikes": 0, "rating": 0}
+
+
+def extract_video_id(url: str) -> str:
+    """Extract video ID from various YouTube URL formats."""
+    idregx = re.compile(r"[\w-]{11}$")
+    url = str(url).strip()
+
+    if idregx.match(url):
+        return url
+
+    if "://" not in url:
+        url = "//" + url
+    parsedurl = urlparse(url)
+    if parsedurl.netloc in (
+        "youtube.com",
+        "www.youtube.com",
+        "m.youtube.com",
+        "gaming.youtube.com",
+    ):
+        query = parse_qs(parsedurl.query)
+        if "v" in query and idregx.match(query["v"][0]):
+            return query["v"][0]
+    elif parsedurl.netloc in ("youtu.be", "www.youtu.be"):
+        vidid = parsedurl.path.split("/")[-1] if parsedurl.path else ""
+        if idregx.match(vidid):
+            return vidid
+
+    raise ValueError(f"Could not extract video ID from {url}")
+
+
+def all_playlists_from_channel(channel_id):
+    """Get all playlists belonging to a channel using youtubesearchpython."""
+    try:
+        # request_type 'EglwbGF5bGlzdHMYAyABcAA%3D' is for playlists
+        channel = ysp.Channel(channel_id)
+        return channel.result["result"] if channel.result else []
+    except Exception as e:
+        util.dbg("YSP all_playlists_from_channel failed: %s", str(e))
+        return []
+
+
+def get_subtitles(ytid, output_dir):
+    """Download and save subtitles for a video."""
+    return None
diff --git a/mps_youtube/g.py b/mps_youtube/g.py
index ce719d6c..2f2fef27 100644
--- a/mps_youtube/g.py
+++ b/mps_youtube/g.py
@@ -1,10 +1,11 @@
-""" Module for holding globals that are needed throught mps-youtube. """
+"""Module for holding globals that are needed throught mps-youtube."""
 
 import collections
 import os
 import sys
 
-from . import c, paths
+from . import paths
+from .i18n import text as _text
 from .playlist import Playlist
 
 volume = None
@@ -13,8 +14,8 @@
 encoders = []
 muxapp = False
 meta = {}
-artist = "" # Mostly used for scrobbling purposes
-album = "" # Mostly used for scrobbling purposes
+artist = ""  # Mostly used for scrobbling purposes
+album = ""  # Mostly used for scrobbling purposes
 scrobble = False
 scrobble_queue = []
 lastfm_network = None
@@ -44,12 +45,12 @@
 active = Playlist(name="active")
 userpl = {}
 userhist = {}
-pafs = collections.OrderedDict()
+metadata_cache = collections.OrderedDict()
 streams = collections.OrderedDict()
-pafy_pls = {}  #
-selected_pafy_pls_id = ''
+playlist_cache = {}  #
+selected_playlist_id = ""
 last_opened = message = content = ""
-suffix = "3" # Python 3
+suffix = "3"  # Python 3
 OLD_CFFILE = os.path.join(paths.get_config_dir(), "config")
 CFFILE = os.path.join(paths.get_config_dir(), "config.json")
 TCFILE = os.path.join(paths.get_config_dir(), "transcode")
@@ -62,14 +63,14 @@
 READLINE_FILE = None
 PLAYER_OBJ = None
 categories = {
-        "film":      1,
-        "autos":     2,
-        "music":    10,
-        "sports":   17,
-        "travel":   19,
-        "gaming":   20,
-        "blogging": 21,
-        "news":     25
+    "film": 1,
+    "autos": 2,
+    "music": 10,
+    "sports": 17,
+    "travel": 19,
+    "gaming": 20,
+    "blogging": 21,
+    "news": 25,
 }
 playerargs_defaults = {
     "mpv": {
@@ -81,108 +82,21 @@
         "fs": "--fs",
         "novid": "--no-video",
         "ignidx": "--demuxer-lavf-o=fflags=+ignidx",
-        "geo": "--geometry"},
+        "geo": "--geometry",
+    },
     "mplayer": {
         "title": "-title",
         "fs": "-fs",
         "novid": "-novideo",
         # "ignidx": "-lavfdopts o=fflags=+ignidx".split()
         "ignidx": "",
-        "geo": "-geometry"},
-    "vlc": {
-        "title": "--meta-title"}
-    }
+        "geo": "-geometry",
+    },
+    "vlc": {"title": "--meta-title"},
+}
 argument_commands = []
 commands = []
-
-text = {
-    "exitmsg": ("*yewtube - https://github.com/mps-youtube/yewtube is a fork of\nmps-youtube - *https://github.com/mps-youtube/mps-youtube*"
-                "\nReleased under the GPLv3 license\n"
-                "(c) 2021 iamtalhaasghar\n(c) 2014, 2015 np1 and contributors*\n"""),
-    "exitmsg_": (c.r, c.b, c.r, c.w),
-
-    # Error / Warning messages
-
-    'no playlists': "*No saved playlists found!*",
-    'no playlists_': (c.r, c.w),
-    'pl bad name': '*&&* is not valid a valid name. Ensure it starts with'
-                   ' a letter or _',
-    'pl bad name_': (c.r, c.w),
-    'pl not found': 'Playlist *&&* unknown. Saved playlists are shown '
-                    'above',
-    'pl not found_': (c.r, c.w),
-    'pl not found advise ls': 'Playlist "*&&*" not found. Use *ls* to '
-                              'list',
-    'pl not found advise ls_': (c.y, c.w, c.g, c.w),
-    'pl empty': 'Playlist is empty!',
-    'advise add': 'Use *add N* to add a track',
-    'advise add_': (c.g, c.w),
-    'advise search': 'Search for items and then use *add* to add them',
-    'advise search_': (c.g, c.w),
-    'no data': 'Error fetching data. Possible network issue.'
-               '\n*&&*',
-    'no data_': (c.r, c.w),
-    'use dot': 'Start your query with a *.* to perform a search',
-    'use dot_': (c.g, c.w),
-    'cant get track': 'Problem playing last item: *&&*',
-    'cant get track_': (c.r, c.w),
-    'track unresolved': 'Sorry, this track is not available',
-    'no player': '*&&* was not found on this system',
-    'no player_': (c.y, c.w),
-    'no pl match for rename': '*Couldn\'t find matching playlist to '
-                              'rename*',
-    'no pl match for rename_': (c.r, c.w),
-    'invalid range': "*Invalid item / range entered!*",
-    'invalid range_': (c.r, c.w),
-    '-audio': "*Warning* - the filetype you selected (&&) has no audio!",
-    '-audio_': (c.y, c.w),
-    'no mix': 'No mix is available for the selected video',
-    'mix only videos': 'Mixes are only available for videos',
-    'invalid item': '*Invalid item entered!*',
-    'duplicate tracks': '*Warning* - duplicate track(s) && added to '
-                        'playlist!',
-    'duplicate tracks_': (c.y, c.w),
-
-    # Info messages..
-
-    'select mux': ("Select [*&&*] to mux audio or [*Enter*] to download "
-                   "without audio\nThis feature is experimental!"),
-    'select mux_': (c.y, c.w, c.y, c.w),
-    'pl renamed': 'Playlist *&&* renamed to *&&*',
-    'pl renamed_': (c.y, c.w, c.y, c.w),
-    'pl saved': 'Playlist saved as *&&*.  Use *ls* to list playlists',
-    'pl saved_': (c.y, c.w, c.g, c.w),
-    'pl loaded': 'Loaded playlist *&&* as current playlist',
-    'pl loaded_': (c.y, c.w),
-    'pl viewed': 'Showing playlist *&&*',
-    'pl viewed_': (c.y, c.w),
-    'pl help': 'Enter *open <name or ID>* to load a playlist',
-    'pl help_': (c.g, c.w),
-    'added to pl': '*&&* tracks added (*&&* total [*&&*]). Use *vp* to '
-                   'view',
-    'added to pl_': (c.y, c.w, c.y, c.w, c.y, c.w, c.g, c.w),
-    'added to saved pl': '*&&* tracks added to *&&* (*&&* total [*&&*])',
-    'added to saved pl_': (c.y, c.w, c.y, c.w, c.y, c.w, c.y, c.w),
-    'song move': 'Moved *&&* to position *&&*',
-    'song move_': (c.y, c.w, c.y, c.w),
-    'song sw': ("Switched item *&&* with *&&*"),
-    'song sw_': (c.y, c.w, c.y, c.w),
-    'current pl': "This is the current playlist. Use *save <name>* to save"
-                  " it",
-    'current pl_': (c.g, c.w),
-    'help topic': ("  Enter *help <topic>* for specific help:"),
-    'help topic_': (c.y, c.w),
-    'songs rm': '*&&* tracks removed &&',
-    'songs rm_': (c.y, c.w),
-    'mkp empty': "*&&* is either empty or doesn't exist",
-    'mkp empty_': (c.b, c.r),
-    'mkp parsed': "*&&* entries found in *&&*",
-    'mkp parsed_': (c.g, c.w, c.b, c.w),
-    'mkp finding': "Finding the best match for *&&* ...",
-    'mkp finding_': (c.y, c.w),
-    'mkp desc unknown': "Unknown tabletype, *do a new search*",
-    'mkp desc unknown_': (c.y, c.w),
-    'mkp desc which data': "Which *tracks* to include?",
-    'mkp desc which data_': (c.y, c.w),
-    'mkp no valid': "*No valid tracks found in that description*",
-    'mkp no valid_': (c.y, c.w)}
+text = _text
+cookies_file = None
+cookies_from_browser = None
+visitor_data = None
diff --git a/mps_youtube/helptext.py b/mps_youtube/helptext.py
index a9615a45..71265a71 100644
--- a/mps_youtube/helptext.py
+++ b/mps_youtube/helptext.py
@@ -1,6 +1,7 @@
 """
-    Holds all help text
+Holds all help text
 """
+
 import pathlib
 import re
 import socket
@@ -12,10 +13,13 @@
 
 
 def helptext():
-    """ Return a list of help categories, with their contents. """
+    """Return a list of help categories, with their contents."""
 
     return [
-        ("basic", "Basics", """
+        (
+            "basic",
+            "Basics",
+            """
 
     {0}Basic Usage{1}
 
@@ -37,8 +41,12 @@ def helptext():
         Visit https://pyperclip.readthedocs.io/en/latest/index.html#not-implemented-error for more info.
 
         {2}q{1}, {2}quit{1} - exit yewtube
-    """.format(c.ul, c.w, c.y)),
-        ("search", "Searching and Retrieving", """
+    """.format(c.ul, c.w, c.y),
+        ),
+        (
+            "search",
+            "Searching and Retrieving",
+            """
     {0}Searching and Retrieving{1}
 
     {2}set search_music false{1} - search all YouTube categories.
@@ -81,9 +89,12 @@ def helptext():
     {2}r <number>{1} - show videos related to video <number>.
     {2}u <number>{1} - show videos uploaded by uploader of video <number>.
     {2}c <number>{1} - view comments for video <number>
-    """.format(c.ul, c.w, c.y, ", ".join(g.categories.keys()))),
-
-        ("edit", "Editing / Manipulating Results", """
+    """.format(c.ul, c.w, c.y, ", ".join(g.categories.keys())),
+        ),
+        (
+            "edit",
+            "Editing / Manipulating Results",
+            """
     {0}Editing and Manipulating Results{1}
 
     {2}rm <number(s)>{1} - remove items from displayed results.
@@ -96,9 +107,14 @@ def helptext():
     {2}shuffle all{1} - Shuffle entire loaded playlist.
     {2}reverse{1} or {2}reverse <number>-<number>{1} - Reverse the displayed items or item range.
     {2}reverse all{1} - Reverse order of entire loaded playlist.
-    """.format(c.ul, c.w, c.y)),
 
-        ("download", "Downloading and Playback", """
+    {2}sort name|duration|age{1} - Sort the displayed items. Subsequent command will reverse order.
+    """.format(c.ul, c.w, c.y),
+        ),
+        (
+            "download",
+            "Downloading and Playback",
+            """
     {0}Downloading and Playback{1}
 
     {2}set show_video true{1} - play video instead of audio.
@@ -121,9 +137,12 @@ def helptext():
     {2}all{1} or {2}*{1} - play all displayed items.
     {2}repeat <number(s)>{1} - play and repeat the specified items.
     {2}shuffle <number(s)>{1} - play specified items in random order.
-    """.format(c.ul, c.w, c.y)),
-
-        ("dl-command", "Downloading Using External Application", """
+    """.format(c.ul, c.w, c.y),
+        ),
+        (
+            "dl-command",
+            "Downloading Using External Application",
+            """
     {0}Download Using A Custom Application{1}
 
     Use {2}set download_command <command>{1} to specify a custom command to use for
@@ -143,10 +162,12 @@ def helptext():
 
     Note that using a custom download command does not support transcoding the
     downloaded file to another format using mps-youtube.
-    """.format(c.ul, c.w, c.y)),
-
-
-        ("encode", "Encoding to MP3 and other formats", """
+    """.format(c.ul, c.w, c.y),
+        ),
+        (
+            "encode",
+            "Encoding to MP3 and other formats",
+            """
     {0}Encoding to MP3 and other formats{1}
 
     Enter {2}encoders{1} to view available encoding presets
@@ -158,9 +179,12 @@ def helptext():
     The encoding presets can be modified by editing the text config file which
     resides at:
        {3}
-    """.format(c.ul, c.w, c.y, g.TCFILE)),
-
-        ("playlists", "Using Local Playlists", """
+    """.format(c.ul, c.w, c.y, g.TCFILE),
+        ),
+        (
+            "playlists",
+            "Using Local Playlists",
+            """
     {0}Using Local Playlists{1}
 
     {2}add <number(s)>{1} - add items to the current playlist.
@@ -180,9 +204,12 @@ def helptext():
     {2}rm <number(s)>{1} - remove items from displayed results.
     {2}sw <number>,<number>{1} - swap two items.
     {2}mv <number>,<number>{1} - move item <number> to position <number>.
-    """.format(c.ul, c.w, c.y)),
-
-        ("history", "Accessing Local History", """
+    """.format(c.ul, c.w, c.y),
+        ),
+        (
+            "history",
+            "Accessing Local History",
+            """
     {0}Accessing Local History{1}
 
     Access songs that have been played within yewtube
@@ -191,9 +218,12 @@ def helptext():
         {2}history clear{1} - clears the song history
         {2}history recent{1} - displays a list of recent played songs
         {2}set history on|off{1} - toggles history recording
-    """.format(c.ul, c.w, c.y)),
-
-        ("invoke", "Invocation Parameters", """
+    """.format(c.ul, c.w, c.y),
+        ),
+        (
+            "invoke",
+            "Invocation Parameters",
+            """
     {0}Invocation{1}
 
     All yewtube commands can be entered from the command line.  For example;
@@ -212,9 +242,12 @@ def helptext():
       {2}yt //the doors, 1, all -a{1} - open YouTube playlist and play audio
 
     If you need to enter an actual comma on the command line, use {2},,{1} instead.
-    """.format(c.ul, c.w, c.y)),
-
-        ("config", "Configuration Options", """
+    """.format(c.ul, c.w, c.y),
+        ),
+        (
+            "config",
+            "Configuration Options",
+            """
     {0}Configuration{1}
 
     {2}set{1} - view current configuration
@@ -257,11 +290,20 @@ def helptext():
 
     Additionally, {2}set -t{1} may be used to temporarily change a setting without
     saving it to disk
-    """.format(c.ul, c.w, c.y, '\n{0}set max_results <number>{1} - show <number> re'
-               'sults when searching (max 50)'.format(c.y, c.w) if not
-               g.detectable_size else '')),
-
-        ("lastfm", "Last.fm configuration", """
+    """.format(
+                c.ul,
+                c.w,
+                c.y,
+                "\n{0}set max_results <number>{1} - show <number> re"
+                "sults when searching (max 50)".format(c.y, c.w)
+                if not g.detectable_size
+                else "",
+            ),
+        ),
+        (
+            "lastfm",
+            "Last.fm configuration",
+            """
     {0}Configure Last.fm{1}
 
     pylast needs to be installed for Last.fm support. See https://github.com/pylast/pylast.
@@ -276,9 +318,12 @@ def helptext():
     with {2}lastfm_connect{1}. Additionally, {2}lastfm_connect{1} provides verbose error messages.
 
     For now, Last.fm support only works with the {2}album{1} command.
-    """.format(c.ul, c.w, c.y)),
-
-        ("tips", "Advanced Tips", """
+    """.format(c.ul, c.w, c.y),
+        ),
+        (
+            "tips",
+            "Advanced Tips",
+            """
     {0}Advanced Tips{1}
 
     Use {2}-w{1}, {2}-f{1} or {2}-a{1} with your choice to override the configured\
@@ -309,19 +354,21 @@ def helptext():
     command
 
     Use {2}clearcache{1} command to clear the cache.
-    """.format(
-                c.ul, c.w, c.y
-            ),
+    """.format(c.ul, c.w, c.y),
         ),
         (
             "new",
             "Show online changelog for the latest version",
-            """{0}What's New{1}\n{3}""".format(c.ul, c.w, c.y, "get_changelog()"),
+            """{0}What's New{1}\n{3}""".format(
+                c.ul, c.w, c.y, "get_changelog()"
+            ),
         ),
         (
             "changelog",
             "Check program changelog",
-            """{0}Changelog{1}\n{3}""".format(c.ul, c.w, c.y, "get_changelog_local()"),
+            """{0}Changelog{1}\n{3}""".format(
+                c.ul, c.w, c.y, "get_changelog_local()"
+            ),
         ),
         (
             "tor",
@@ -332,44 +379,46 @@ def helptext():
 
 
 def get_help(choice):
-    """ Return help message. """
-    helps = {"download": ("playback dl listen watch show repeat playing"
-                          "show_video playurl browserplay dlurl d da dv all *"
-                          " play browsersearch".split()),
-
-             "dl-command": ("dlcmd dl-cmd download-cmd dl_cmd download_cmd "
-                            "download-command download_command".split()),
-
-             "encode": ("encoding transcoding transcode wma mp3 format "
-                        "encode encoder".split()),
-
-             "invoke": "command commands yt invocation".split(),
-
-             "search": ("user userpl pl pls r n p url album "
-                        "editing result results related remove swop mkp --description".split()),
-
-             "edit": ("editing manupulate manipulating rm mv sw edit move "
-                      "swap shuffle".split()),
-
-             "tips": ("undump dump -f -w -a adv advanced".split(" ")),
-
-             "basic": ("basic comment basics c copy clipboard comments u "
-                       "i".split()),
-
-             "config": ("set checkupdate colours colors ddir directory player "
-                        "arguments args playerargs music search_music keys "
-                        "status show_status show_video video configuration "
-                        "fullscreen full screen folder player mpv mplayer"
-                        " settings default reset configure audio results "
-                        "max_results size lines rows height window "
-                        "position window_pos quality resolution max_res "
-                        "columns width console overwrite".split()),
-
-             "playlists": ("save rename delete move rm ls mv sw add vp open"
-                           " view".split())}
+    """Return help message."""
+    helps = {
+        "download": (
+            "playback dl listen watch show repeat playing"
+            "show_video playurl browserplay dlurl d da dv all *"
+            " play browsersearch".split()
+        ),
+        "dl-command": (
+            "dlcmd dl-cmd download-cmd dl_cmd download_cmd "
+            "download-command download_command".split()
+        ),
+        "encode": (
+            "encoding transcoding transcode wma mp3 format encode encoder".split()
+        ),
+        "invoke": "command commands yt invocation".split(),
+        "search": (
+            "user userpl pl pls r n p url album "
+            "editing result results related remove swop mkp --description".split()
+        ),
+        "edit": (
+            "editing manupulate manipulating rm mv sw edit move swap shuffle".split()
+        ),
+        "tips": ("undump dump -f -w -a adv advanced".split(" ")),
+        "basic": ("basic comment basics c copy clipboard comments u i".split()),
+        "config": (
+            "set checkupdate colours colors ddir directory player "
+            "arguments args playerargs music search_music keys "
+            "status show_status show_video video configuration "
+            "fullscreen full screen folder player mpv mplayer"
+            " settings default reset configure audio results "
+            "max_results size lines rows height window "
+            "position window_pos quality resolution max_res "
+            "columns width console overwrite".split()
+        ),
+        "playlists": (
+            "save rename delete move rm ls mv sw add vp open view".split()
+        ),
+    }
 
     for topic, aliases in helps.items():
-
         if choice in aliases:
             choice = topic
             break
@@ -380,23 +429,23 @@ def get_help(choice):
     choice = get_near_name(choice, help_names)
 
     def indent(x):
-        """ Indent. """
+        """Indent."""
         return "\n  ".join(x.split("\n"))
 
     if choice == "menu" or choice not in help_names:
         out += "  %sHelp Topics%s" % (c.ul, c.w)
-        out += F('help topic', 2, 1)
+        out += F("help topic", 2, 1)
 
         for x in all_help:
-            out += ("\n%s     %-10s%s : %s" % (c.y, x[0], c.w, x[1]))
+            out += "\n%s     %-10s%s : %s" % (c.y, x[0], c.w, x[1])
 
         out += "\n"
         return out
 
     else:
-        if choice == 'tor':
+        if choice == "tor":
             output_text = check_tor()
-        elif choice == 'new':
+        elif choice == "new":
             output_text = get_changelog()
         elif choice == "changelog":
             output_text = get_changelog_local()
@@ -406,11 +455,12 @@ def indent(x):
 
         return indent(output_text)
 
+
 def get_changelog():
     try:
         url = "https://raw.githubusercontent.com/mps-youtube/yewtube/master/CHANGELOG.md"
         v = urlopen(url, timeout=1).read().decode()
-        v = v.split('## v')[1]
+        v = v.split("## v")[1]
         return v
     except (URLError, HTTPError, socket.timeout):
         return "read changelog timed out"
@@ -428,10 +478,10 @@ def check_tor():
     try:
         url = "https://check.torproject.org/?lang=en"
         v = urlopen(url, timeout=1).read().decode()
-        ip = re.findall('<strong>(.*)</strong>', v)
-        status = re.findall('Congratulations.(.*)', v)
+        ip = re.findall("<strong>(.*)</strong>", v)
+        status = re.findall("Congratulations.(.*)", v)
         if len(status) == 0:
-            status = re.findall('Sorry.(.*)', v)
-        return str({'ip' : ip, 'status': status[0]})
+            status = re.findall("Sorry.(.*)", v)
+        return str({"ip": ip, "status": status[0]})
     except (URLError, HTTPError, socket.timeout):
         return "read check tor status timed out"
diff --git a/mps_youtube/history.py b/mps_youtube/history.py
index 83c14a3e..feb53c69 100644
--- a/mps_youtube/history.py
+++ b/mps_youtube/history.py
@@ -8,20 +8,20 @@
 
 
 def add(song):
-    """ Add song to history. """
-    if not g.userhist.get('history'):
-        g.userhist['history'] = Playlist('history')
+    """Add song to history."""
+    if not g.userhist.get("history"):
+        g.userhist["history"] = Playlist("history")
 
-    g.userhist['history'].songs.append(song)
+    g.userhist["history"].songs.append(song)
 
     save()
 
 
 def load():
-    """ Open history. Called once on script invocation. """
+    """Open history. Called once on script invocation."""
     _convert_to_m3u()
     try:
-        g.userhist['history'] = read_m3u(g.HISTFILE)
+        g.userhist["history"] = read_m3u(g.HISTFILE)
 
     except FileNotFoundError:
         # no playlist found, create a blank one
@@ -31,18 +31,19 @@ def load():
 
 
 def save():
-    """ Save history.  Called each time history is updated. """
-    with open(g.HISTFILE, 'w') as hf:
-        hf.write('#EXTM3U\n\n')
-        if 'history' in g.userhist:
-            for song in g.userhist['history'].songs:
-                hf.write('#EXTINF:%d,%s\n' % (song.length, song.title))
-                hf.write('https://www.youtube.com/watch?v=%s\n' % song.ytid)
+    """Save history.  Called each time history is updated."""
+    with open(g.HISTFILE, "w") as hf:
+        hf.write("#EXTM3U\n\n")
+        if "history" in g.userhist:
+            for song in g.userhist["history"].songs:
+                hf.write("#EXTINF:%d,%s\n" % (song.length, song.title))
+                hf.write("https://www.youtube.com/watch?v=%s\n" % song.ytid)
 
     dbg(c.r + "History saved\n---" + c.w)
 
+
 def _convert_to_m3u():
-    """ Converts the play_history file to the m3u format. """
+    """Converts the play_history file to the m3u format."""
     # Skip if m3u file already exists
     if os.path.isfile(g.HISTFILE):
         return
diff --git a/mps_youtube/i18n.py b/mps_youtube/i18n.py
new file mode 100644
index 00000000..2afaf352
--- /dev/null
+++ b/mps_youtube/i18n.py
@@ -0,0 +1,89 @@
+from . import c
+
+text = {
+    "exitmsg": (
+        """*yewtube - https://github.com/mps-youtube/yewtube is a fork of
+mps-youtube - *https://github.com/mps-youtube/mps-youtube*
+Released under the GPLv3 license
+(c) 2021 iamtalhaasghar
+(c) 2014, 2015 np1 and contributors*"""
+    ),
+    "exitmsg_": (c.r, c.b, c.r, c.w),
+    # Error / Warning messages
+    "no playlists": "*No saved playlists found!*",
+    "no playlists_": (c.r, c.w),
+    "pl bad name": "*&&* is not valid a valid name. Ensure it starts with"
+    " a letter or _",
+    "pl bad name_": (c.r, c.w),
+    "pl not found": "Playlist *&&* unknown. Saved playlists are shown above",
+    "pl not found_": (c.r, c.w),
+    "pl not found advise ls": 'Playlist "*&&*" not found. Use *ls* to list',
+    "pl not found advise ls_": (c.y, c.w, c.g, c.w),
+    "pl empty": "Playlist is empty!",
+    "advise add": "Use *add N* to add a track",
+    "advise add_": (c.g, c.w),
+    "advise search": "Search for items and then use *add* to add them",
+    "advise search_": (c.g, c.w),
+    "no data": "Error fetching data. Possible network issue.\n*&&*",
+    "no data_": (c.r, c.w),
+    "use dot": "Start your query with a *.* to perform a search",
+    "use dot_": (c.g, c.w),
+    "cant get track": "Problem playing last item: *&&*",
+    "cant get track_": (c.r, c.w),
+    "track unresolved": "Sorry, this track is not available",
+    "no player": "*&&* was not found on this system",
+    "no player_": (c.y, c.w),
+    "no pl match for rename": "*Couldn't find matching playlist to rename*",
+    "no pl match for rename_": (c.r, c.w),
+    "invalid range": "*Invalid item / range entered!*",
+    "invalid range_": (c.r, c.w),
+    "-audio": "*Warning* - the filetype you selected (&&) has no audio!",
+    "-audio_": (c.y, c.w),
+    "no mix": "No mix is available for the selected video",
+    "mix only videos": "Mixes are only available for videos",
+    "invalid item": "*Invalid item entered!*",
+    "duplicate tracks": "*Warning* - duplicate track(s) && added to playlist!",
+    "duplicate tracks_": (c.y, c.w),
+    # Info messages..
+    "select mux": (
+        "Select [*&&*] to mux audio or [*Enter*] to download "
+        "without audio\nThis feature is experimental!"
+    ),
+    "select mux_": (c.y, c.w, c.y, c.w),
+    "pl renamed": "Playlist *&&* renamed to *&&*",
+    "pl renamed_": (c.y, c.w, c.y, c.w),
+    "pl saved": "Playlist saved as *&&*.  Use *ls* to list playlists",
+    "pl saved_": (c.y, c.w, c.g, c.w),
+    "pl loaded": "Loaded playlist *&&* as current playlist",
+    "pl loaded_": (c.y, c.w),
+    "pl viewed": "Showing playlist *&&*",
+    "pl viewed_": (c.y, c.w),
+    "pl help": "Enter *open <name or ID>* to load a playlist",
+    "pl help_": (c.g, c.w),
+    "added to pl": "*&&* tracks added (*&&* total [*&&*]). Use *vp* to view",
+    "added to pl_": (c.y, c.w, c.y, c.w, c.y, c.w, c.g, c.w),
+    "added to saved pl": "*&&* tracks added to *&&* (*&&* total [*&&*])",
+    "added to saved pl_": (c.y, c.w, c.y, c.w, c.y, c.w, c.y, c.w),
+    "song move": "Moved *&&* to position *&&*",
+    "song move_": (c.y, c.w, c.y, c.w),
+    "song sw": ("Switched item *&&* with *&&*"),
+    "song sw_": (c.y, c.w, c.y, c.w),
+    "current pl": "This is the current playlist. Use *save <name>* to save it",
+    "current pl_": (c.g, c.w),
+    "help topic": ("  Enter *help <topic>* for specific help:"),
+    "help topic_": (c.y, c.w),
+    "songs rm": "*&&* tracks removed &&",
+    "songs rm_": (c.y, c.w),
+    "mkp empty": "*&&* is either empty or doesn't exist",
+    "mkp empty_": (c.b, c.r),
+    "mkp parsed": "*&&* entries found in *&&*",
+    "mkp parsed_": (c.g, c.w, c.b, c.w),
+    "mkp finding": "Finding the best match for *&&* ...",
+    "mkp finding_": (c.y, c.w),
+    "mkp desc unknown": "Unknown tabletype, *do a new search*",
+    "mkp desc unknown_": (c.y, c.w),
+    "mkp desc which data": "Which *tracks* to include?",
+    "mkp desc which data_": (c.y, c.w),
+    "mkp no valid": "*No valid tracks found in that description*",
+    "mkp no valid_": (c.y, c.w),
+}
diff --git a/mps_youtube/init.py b/mps_youtube/init.py
index a5db6c67..a476f21f 100644
--- a/mps_youtube/init.py
+++ b/mps_youtube/init.py
@@ -10,19 +10,12 @@
 try:
     # pylint: disable=F0401
     import colorama
+
     has_colorama = True
 
 except ImportError:
     has_colorama = False
 
-try:
-    import readline
-    readline.set_history_length(2000)
-    has_readline = True
-
-except ImportError:
-    has_readline = False
-
 from . import __version__, c, cache, config, g, paths, screen
 from .helptext import helptext
 from .util import assign_player, dbg, has_exefile, load_player_info, xprint
@@ -30,10 +23,10 @@
 mswin = os.name == "nt"
 
 
-def init():
-    """ Initial setup. """
+def init(cli_args=None):
+    """Initial setup."""
 
-    _process_cl_args()
+    _process_cl_args(cli_args=cli_args)
 
     # set player to mpv or mplayer if found, otherwise unset
     suffix = ".exe" if mswin else ""
@@ -43,7 +36,6 @@ def init():
     config.convert_old_cf_to_json()
 
     if not os.path.exists(g.CFFILE):
-
         if has_exefile(vlc):
             config.PLAYER.set(vlc)
 
@@ -57,15 +49,25 @@ def init():
 
     else:
         config.load()
+
+        # check mpv/mplayer version early to cache for assign_player
+        if has_exefile(config.PLAYER.get):
+            load_player_info(config.PLAYER.get)
+
         try:
-            assign_player(config.PLAYER.get)  # Player is not assigned when config is loaded
-        except Exception as ex:
-            g.message = "%sFailed to get %s`s version. Probabily it is not installed. Try installing it again or change player using `set player <player_name>` %s" %(c.y, config.PLAYER.get , c.w)
+            assign_player(
+                config.PLAYER.get
+            )  # Player is not assigned when config is loaded
+        except Exception:
+            g.message = (
+                "%sFailed to get %s`s version. Probabily it is not installed. Try installing it again or change player using `set player <player_name>` %s"
+                % (c.y, config.PLAYER.get, c.w)
+            )
             screen.update()
             input("Press Enter to go back to main menu.")
 
-    # Make pafy use the same api key
-    # pafy.set_api_key(config.API_KEY.get)
+    # Make extractor use the same api key
+    # extractor.set_api_key(config.API_KEY.get)
 
     _init_readline()
     cache.load()
@@ -75,10 +77,6 @@ def init():
     if config.ENCODER.get >= len(g.encoders):
         config.ENCODER.set("0")
 
-    # check mpv/mplayer version
-    if has_exefile(config.PLAYER.get):
-        load_player_info(config.PLAYER.get)
-
     # setup colorama
     if has_colorama and mswin:
         # Colorama converts ansi escape codes to Windows system calls
@@ -95,6 +93,7 @@ def init():
     if config.MPRIS.get:
         try:
             from . import mpris
+
             conn1, conn2 = multiprocessing.Pipe()
             g.mprisctl = mpris.MprisConnection(conn1)
             t = multiprocessing.Process(target=mpris.main, args=(conn2,))
@@ -105,7 +104,7 @@ def init():
 
 
 def _init_transcode():
-    """ Create transcoding presets if not present.
+    """Create transcoding presets if not present.
 
     Read transcoding presets.
     """
@@ -178,7 +177,6 @@ def _init_transcode():
         e = {}
 
         for line in tcf.readlines():
-
             if line.startswith("TRANSCODER_PATH:"):
                 m = re.match("TRANSCODER_PATH:(.*)", line).group(1)
                 g.transcoder_path = m.strip()
@@ -189,16 +187,16 @@ def _init_transcode():
                 g.delete_orig = do
 
             elif line.startswith("name:"):
-                e['name'] = re.match("name:(.*)", line).group(1).strip()
+                e["name"] = re.match("name:(.*)", line).group(1).strip()
 
             elif line.startswith("extension:"):
-                e['ext'] = re.match("extension:(.*)", line).group(1).strip()
+                e["ext"] = re.match("extension:(.*)", line).group(1).strip()
 
             elif line.startswith("valid for:"):
-                e['valid'] = re.match("valid for:(.*)", line).group(1).strip()
+                e["valid"] = re.match("valid for:(.*)", line).group(1).strip()
 
             elif line.startswith("command:"):
-                e['command'] = re.match("command:(.*)", line).group(1).strip()
+                e["command"] = re.match("command:(.*)", line).group(1).strip()
 
                 if "name" in e and "ext" in e and "valid" in e:
                     g.encoders.append(e)
@@ -206,72 +204,83 @@ def _init_transcode():
 
 
 def _init_readline():
-    """ Enable readline for input history. """
-    if g.command_line:
-        return
-
-    if has_readline:
-        g.READLINE_FILE = os.path.join(paths.get_config_dir(), "input_history")
-
-        if os.path.exists(g.READLINE_FILE):
-            readline.read_history_file(g.READLINE_FILE)
-            dbg(c.g + "Read history file" + c.w)
-
-
-def _process_cl_args():
-    """ Process command line arguments. """
-
-    parser = argparse.ArgumentParser(add_help=False)
-    parser.add_argument('commands', nargs='*')
-    parser.add_argument('--help', '-h', action='store_true')
-    parser.add_argument('--version', '-v', action='store_true')
-    parser.add_argument('--debug', '-d', action='store_true')
-    parser.add_argument('--logging', '-l', action='store_true')
-    parser.add_argument('--no-autosize', action='store_true')
-    parser.add_argument('--no-preload', action='store_true')
-    parser.add_argument('--no-textart', action='store_true')
-    args = parser.parse_args()
+    """Enable history file path setting."""
+    g.READLINE_FILE = os.path.join(paths.get_config_dir(), "input_history")
+    dbg(c.g + "Set history file path to: " + g.READLINE_FILE + c.w)
+
+
+def _process_cl_args(cli_args=None):
+    """Process command line arguments."""
+
+    if cli_args is None:
+        parser = argparse.ArgumentParser(add_help=False)
+        parser.add_argument("commands", nargs="*")
+        parser.add_argument("--help", "-h", action="store_true")
+        parser.add_argument("--version", "-v", action="store_true")
+        parser.add_argument("--debug", "-d", action="store_true")
+        parser.add_argument("--logging", "-l", action="store_true")
+        parser.add_argument("--no-autosize", action="store_true")
+        parser.add_argument("--no-preload", action="store_true")
+        parser.add_argument("--no-textart", action="store_true")
+        parser.add_argument("--cookies")
+        parser.add_argument("--cookies-from-browser")
+        parser.add_argument("--visitor-data")
+        args = parser.parse_args()
+    else:
+        args = cli_args
 
-    if args.version:
+    if getattr(args, "version", False):
         screen.msgexit(_get_version_info())
 
-    elif args.help:
-        screen.msgexit('\n'.join(i[2] for i in helptext()))
+    elif getattr(args, "help", False):
+        screen.msgexit("\n".join(i[2] for i in helptext()))
 
-    if args.debug or os.environ.get("mpsytdebug") == "1":
+    if getattr(args, "debug", False) or os.environ.get("mpsytdebug") == "1":
         xprint(_get_version_info())
         g.debug_mode = True
         g.no_clear_screen = True
 
-    if args.logging or os.environ.get("mpsytlog") == "1" or g.debug_mode:
+    if getattr(args, "logging", False) or os.environ.get("mpsytlog") == "1" or g.debug_mode:
         logfile = os.path.join(tempfile.gettempdir(), "mpsyt.log")
         logging.basicConfig(level=logging.DEBUG, filename=logfile)
-        logging.getLogger("pafy").setLevel(logging.DEBUG)
+        logging.getLogger("extractor").setLevel(logging.DEBUG)
 
-    if args.no_autosize:
+    if getattr(args, "no_autosize", False):
         g.detectable_size = False
 
     g.command_line = "playurl" in args.commands or "dlurl" in args.commands
     if g.command_line:
         g.no_clear_screen = True
 
-    if args.no_preload:
+    if getattr(args, "no_preload", False):
         g.preload_disabled = True
 
-    if args.no_textart:
+    if getattr(args, "no_textart", False):
         g.no_textart = True
 
+    # Resolve cookies source
+    g.cookies_file = getattr(args, "cookies", None) or os.environ.get("COOKIES")
+    if g.cookies_file:
+        g.cookies_file = os.path.expanduser(g.cookies_file)
+
+    g.cookies_from_browser = getattr(args, "cookies_from_browser", None)
+    if g.cookies_file and g.cookies_from_browser:
+        dbg("Both --cookies and --cookies-from-browser were set; using --cookies")
+        g.cookies_from_browser = None
+
+    g.visitor_data = getattr(args, "visitor_data", None)
+    if g.visitor_data and (g.cookies_file or g.cookies_from_browser):
+        dbg(
+            "--visitor-data was set; disabling cookie-based auth to use visitor-data flow"
+        )
+        g.cookies_file = None
+        g.cookies_from_browser = None
+
     g.argument_commands = args.commands
 
 
 def _get_version_info():
-    """ Return version and platform info. """
-    # pafy_version = pafy.__version__
-    # youtube_dl_version = None
-    # if tuple(map(int, pafy_version.split('.'))) >= (0, 5, 0):
-    #     pafy_version += " (" + pafy.backend + " backend)"
-    #     if pafy.backend == "youtube-dl":
-
+    """Return version and platform info."""
     from yt_dlp.version import __version__ as ytdlp_version
 
     dbus_version = None
@@ -283,8 +292,6 @@ def _get_version_info():
     except Exception:
         pass
     try:
-        from gi.repository import GLib
-
         glib = True
     except Exception:
         pass
diff --git a/mps_youtube/listview/__init__.py b/mps_youtube/listview/__init__.py
index a9ec4ae3..8a52784d 100644
--- a/mps_youtube/listview/__init__.py
+++ b/mps_youtube/listview/__init__.py
@@ -1,6 +1,7 @@
 """
-    DOCSTING COMES HERE
+DOCSTING COMES HERE
 """
+
 import re
 import math
 
@@ -12,33 +13,34 @@
 
 
 class ListView(content.PaginatedContent):
-    """ Content Agnostic Numbered List
-
-        This class, using ListViewItems as abstractions you can
-        give it a list of data and which columns to show and it will
-        show it.
-
-        Todo:
-            Currently we rely on the commands/play code to send information
-            about which elements are being picked.
-
-        Attributes:
-            func        The function that will be run on the selected items
-            objects     List of objects(or a ContentQuery object)
-            columns     A list of Hashes containing information about which
-                        columns to show
-            page        Current Page
-
-        Column format:
-            {"name": "idx", "size": 3, "heading": "Num"}
-            name:    The method name that will be called from the ListViewItem
-            size:    How much size is allocated to the columns,
-                     see ListView.content for more information about
-                     the dynamic options
-            heading: The text shown in the header
-
-            "idx" is generated in the content function, not by the ListViewItem
+    """Content Agnostic Numbered List
+
+    This class, using ListViewItems as abstractions you can
+    give it a list of data and which columns to show and it will
+    show it.
+
+    Todo:
+        Currently we rely on the commands/play code to send information
+        about which elements are being picked.
+
+    Attributes:
+        func        The function that will be run on the selected items
+        objects     List of objects(or a ContentQuery object)
+        columns     A list of Hashes containing information about which
+                    columns to show
+        page        Current Page
+
+    Column format:
+        {"name": "idx", "size": 3, "heading": "Num"}
+        name:    The method name that will be called from the ListViewItem
+        size:    How much size is allocated to the columns,
+                 see ListView.content for more information about
+                 the dynamic options
+        heading: The text shown in the header
+
+        "idx" is generated in the content function, not by the ListViewItem
     """
+
     func = None
     objects = None
     columns = None
@@ -61,7 +63,7 @@ def __init__(self, columns, objects, function_call=None):
         self.object_type = [obj.__class__ for obj in objects][0]
 
     def numPages(self):
-        """ Returns # of pages """
+        """Returns # of pages"""
         return max(1, math.ceil(len(self.objects) / self.views_per_page()))
 
     def getPage(self, page):
@@ -70,56 +72,64 @@ def getPage(self, page):
 
     def _page_slice(self):
         chgt = self.views_per_page()
-        return slice(self.page * chgt, (self.page+1) * chgt)
+        return slice(self.page * chgt, (self.page + 1) * chgt)
 
     def content(self):
-        """ Generates content
+        """Generates content
 
-            ===============
-            Dynamic fields
-            ===============
+        ===============
+        Dynamic fields
+        ===============
 
-            Column.size may instead of an integer be a string
-            containing either "length" or "remaining".
+        Column.size may instead of an integer be a string
+        containing either "length" or "remaining".
 
-            Length is for time formats like 20:40
-            Remaining will allocate all remaining space to that
-            column.
+        Length is for time formats like 20:40
+        Remaining will allocate all remaining space to that
+        column.
 
-            TODO: Make it so set columns can set "remaining" ?
+        TODO: Make it so set columns can set "remaining" ?
         """
         # Sums all ints, deal with strings later
-        remaining = (util.getxy().width) - sum(1 + (x['size'] if x['size'] and x['size'].__class__ == int else 0) for x in self.columns) - (len(self.columns))
+        remaining = (
+            (util.getxy().width)
+            - sum(
+                1
+                + (x["size"] if x["size"] and x["size"].__class__ == int else 0)
+                for x in self.columns
+            )
+            - (len(self.columns))
+        )
         lengthsize = 0
-        if "length" in [x['size'] for x in self.columns]:
+        if "length" in [x["size"] for x in self.columns]:
             max_l = max((getattr(x, "length")() for x in self.objects))
             lengthsize = 8 if max_l > 35999 else 7
             lengthsize = 6 if max_l < 6000 else lengthsize
 
         for col in self.columns:
-            if col['size'] == "remaining":
-                col['size'] = remaining - lengthsize
-            if col['size'] == "length":
-                col['size'] = lengthsize
+            if col["size"] == "remaining":
+                col["size"] = remaining - lengthsize
+            if col["size"] == "length":
+                col["size"] = lengthsize
 
         for num, column in enumerate(self.columns):
-            column['idx'] = num
-            column['sign'] = "-" if not column['name'] == "length" else ""
+            column["idx"] = num
+            column["sign"] = "-" if not column["name"] == "length" else ""
 
-        fmt = ["%{}{}s  ".format(x['sign'], x['size']) for x in self.columns]
+        fmt = ["%{}{}s  ".format(x["sign"], x["size"]) for x in self.columns]
         fmtrow = fmt[0:1] + ["%s  "] + fmt[2:]
         fmt, fmtrow = "".join(fmt).strip(), "".join(fmtrow).strip()
-        titles = tuple([x['heading'][:x['size']] for x in self.columns])
+        titles = tuple([x["heading"][: x["size"]] for x in self.columns])
         out = "\n" + (c.ul + fmt % titles + c.w) + "\n"
 
         for num, obj in enumerate(self.objects[self._page_slice()]):
-            col = (c.r if num % 2 == 0 else c.p)
+            col = c.r if num % 2 == 0 else c.p
             idx = num + (self.views_per_page() * self.page) + 1
 
-            line = ''
+            line = ""
             for column in self.columns:
-                fieldsize, field = column['size'], column['name']
-                direction = "<" if column['sign'] == "-" else ">"
+                fieldsize, field = column["size"], column["name"]
+                direction = "<" if column["sign"] == "-" else ">"
 
                 if field == "idx":
                     field = "%2d" % idx
@@ -135,12 +145,12 @@ def content(self):
 
             line = col + line + c.w
             out += line + "\n"
-        
+
         return out
 
     def _play(self, _, choice, __):  # pre, choice, post
-        """ Handles what happends when a user selects something from the list
-            Currently this functions hooks into commands/play
+        """Handles what happends when a user selects something from the list
+        Currently this functions hooks into commands/play
         """
 
         uids = []
@@ -157,6 +167,5 @@ def _play(self, _, choice, __):  # pre, choice, post
         self.func([getattr(self.objects[x], var)() for x in uids])
 
     def views_per_page(self):
-        """ Determines how many views can be per page
-        """
+        """Determines how many views can be per page"""
         return util.getxy().max_results
diff --git a/mps_youtube/listview/base.py b/mps_youtube/listview/base.py
index 71fdaef6..2adac438 100644
--- a/mps_youtube/listview/base.py
+++ b/mps_youtube/listview/base.py
@@ -1,7 +1,8 @@
 class ListViewItem:
-    """ Base class for items
-        Used by Listview
+    """Base class for items
+    Used by Listview
     """
+
     data = None
 
     def __init__(self, data):
@@ -11,8 +12,8 @@ def __getattr__(self, key):
         return self.data[key] if key in self.data.keys() else None
 
     def length(self, _=0):
-        """ Returns length of ListViewItem
-            A LVI has to return something for length
-            even if the item does not have one.
+        """Returns length of ListViewItem
+        A LVI has to return something for length
+        even if the item does not have one.
         """
         return 0
diff --git a/mps_youtube/listview/livestream.py b/mps_youtube/listview/livestream.py
index 70a67e0e..185f5fad 100644
--- a/mps_youtube/listview/livestream.py
+++ b/mps_youtube/listview/livestream.py
@@ -3,24 +3,26 @@
 
 
 class ListLiveStream(ListViewItem):
-    """ Class exposing necessary components of a live stream """
+    """Class exposing necessary components of a live stream"""
+
     # pylint: disable=unused-argument
     def ytid(self, lngt=10):
-        """ Exposes ytid(string) """
+        """Exposes ytid(string)"""
         return self.data.get("id").get("videoId")
 
     def ret(self):
-        """ Returns content.video compatible tuple """
+        """Returns content.video compatible tuple"""
         return (self.ytid(), self.title(), self.length())
 
     def title(self, lngt=10):
-        """ exposes title """
+        """exposes title"""
         return util.uea_pad(lngt, self.data.get("snippet").get("title"))
+
     def description(self, lngt=10):
-        """ exposes description """
+        """exposes description"""
         return util.uea_pad(lngt, self.data.get("snippet").get("description"))
-       
+
     @staticmethod
     def return_field():
-        """ ret """
+        """ret"""
         return "ret"
diff --git a/mps_youtube/listview/songtitle.py b/mps_youtube/listview/songtitle.py
index e14a51b2..a3432961 100644
--- a/mps_youtube/listview/songtitle.py
+++ b/mps_youtube/listview/songtitle.py
@@ -3,8 +3,8 @@
 
 
 class ListSongtitle(ListViewItem):
-    """ Describes a user
-    """
+    """Describes a user"""
+
     # pylint: disable=unused-argument
     _checked = False
     _certainty = 1.0
@@ -15,34 +15,34 @@ def __init__(self, data, certainty=1.0):
         super(ListSongtitle, self).__init__(data)
 
     def artist(self, l=10):
-        """ Get artist """
+        """Get artist"""
         return u.uea_pad(l, self.data[0])
 
     def title(self, l=10):
-        """ Get title """
+        """Get title"""
         return u.uea_pad(l, self.data[1])
 
     def checked(self, l=10):
-        """ String from for checked """
+        """String from for checked"""
         return "  X  " if self._checked else "     "
 
     def certainty(self):
-        """ Float """
+        """Float"""
         return self._certainty
 
     def is_checked(self):
-        """ Returns true if checked """
+        """Returns true if checked"""
         return self._checked
 
     def toggle(self):
-        """ Toggle checked status """
+        """Toggle checked status"""
         self._checked = not self._checked
 
     def ret(self):
-        """ Used in the ListView play function """
+        """Used in the ListView play function"""
         return "%s - %s" % (self.artist().strip(), self.title().strip())
 
     @staticmethod
     def return_field():
-        """ Determines which function will be called on selected items """
+        """Determines which function will be called on selected items"""
         return "ret"
diff --git a/mps_youtube/listview/user.py b/mps_youtube/listview/user.py
index ba0442b3..07974cca 100644
--- a/mps_youtube/listview/user.py
+++ b/mps_youtube/listview/user.py
@@ -1,33 +1,39 @@
 from .base import ListViewItem
 from .. import util as u
 
+
 class ListUser(ListViewItem):
-    """ Describes a user
-    """
+    """Describes a user"""
+
     # pylint: disable=unused-argument
     def id(self, length=0):
-        """ Returns YTID """
+        """Returns YTID"""
         return self.data.get("id")
 
     def name(self, length=10):
-        """ Returns channel name """
+        """Returns channel name"""
         return u.uea_pad(length, self.data.get("title"))
 
     def description(self, length=10):
-        """ Channel description"""
-        return u.uea_pad(length, self.data["descriptionSnippet"][0]['text'] if self.data['descriptionSnippet'] is not None else 'No description found')
+        """Channel description"""
+        desc = self.data.get("description")
+        if not desc:
+            snippet = self.data.get("descriptionSnippet")
+            desc = snippet[0]["text"] if snippet else "No description found"
+        
+        return u.uea_pad(length, desc)
 
     def kind(self, length=10):
-        """ Returns the youtube datatype
-            Example: youtube#channel, youtube#video
+        """Returns the youtube datatype
+        Example: youtube#channel, youtube#video
         """
         return self.data.get("type")
 
     def ret(self):
-        """ Used in the ListView play function """
+        """Used in the ListView play function"""
         return (self.name(), self.id(), "")
 
     @staticmethod
     def return_field():
-        """ Determines which function will be called on selected items """
+        """Determines which function will be called on selected items"""
         return "ret"
diff --git a/mps_youtube/main.py b/mps_youtube/main.py
index 3dfceb33..30e05cae 100644
--- a/mps_youtube/main.py
+++ b/mps_youtube/main.py
@@ -20,37 +20,22 @@
 
 """
 
+import argparse
 import locale
 import logging
-import os
 import sys
 import traceback as traceback_py
+import click
+from prompt_toolkit import prompt as pt_prompt
+from prompt_toolkit.history import FileHistory
 
-from . import util
-
-completer = None
-readline = None
-try:
-    import readline
-except ImportError:
-    try:
-        from pyreadline3 import Readline
-        readline = Readline()
-    except ImportError:
-        has_readline = False
-if readline:
-    readline.set_history_length(2000)
-    has_readline = True
-    completer = util.CommandCompleter()
-    readline.parse_and_bind('tab: complete')
-    readline.set_completer(completer.complete_command)
-    readline.set_completer_delims('')
-
-from . import g, c, commands, screen, history, init
-from . import __version__, playlists, content, listview
+from . import g, c, commands, screen, history, init, util
+from . import __version__, playlists, content
 from . import config
 
-mswin = os.name == "nt"
+has_readline = (
+    True  # We use prompt_toolkit now, which provides equivalent features
+)
 
 try:
     locale.setlocale(locale.LC_ALL, "")  # for date formatting
@@ -58,60 +43,50 @@
     logging.debug(f"locale not set: {err}")
 
 
-def matchfunction(func, regex, userinput):
-    """ Match userinput against regex.
+def handle_command_exception(e):
+    """Centralized error reporting for command execution."""
+    if g.debug_mode:
+        g.content = "".join(traceback_py.format_exception(*sys.exc_info()))
+
+    if isinstance(e, IndexError):
+        g.message = util.F("invalid range")
+    elif isinstance(e, (ValueError, IOError)):
+        g.message = util.F("cant get track") % str(e)
+    else:
+        template = util.F("no data")
+        g.message = template % str(e) if "%s" in template else f"{template}: {e}"
+        if not g.debug_mode:
+            logging.debug(traceback_py.format_exc())
+
+    g.content = g.content or content.generate_songlist_display()
 
-    Call func, return True if matches.
 
-    """
-    # Not supported in python 3.3 or lower
-    # match = regex.fullmatch(userinput)
-    # if match:
+def matchfunction(func, regex, userinput):
+    """Match userinput against regex. Call func, return True if matches."""
     match = regex.match(userinput)
     if match and match.group(0) == userinput:
         matches = match.groups()
         util.dbg("input: %s", userinput)
         util.dbg("function call: %s", func.__name__)
-        util.dbg("regx matches: %s", matches)
 
         try:
             func(*matches)
-
-        except IndexError:
-            if g.debug_mode:
-                g.content = ''.join(traceback_py.format_exception(
-                    *sys.exc_info()))
-            g.message = util.F('invalid range')
-            g.content = g.content or content.generate_songlist_display()
-
-        except (ValueError, IOError) as e:
-            if g.debug_mode:
-                g.content = ''.join(traceback_py.format_exception(
-                    *sys.exc_info()))
-            g.message = util.F('cant get track') % str(e)
-            g.content = g.content or\
-                content.generate_songlist_display(zeromsg=g.message)
-
-        except Exception as e:#pafy.GdataError as e:
-            import traceback
-            traceback.print_exception(type(e), e, e.__traceback__)
-            if g.debug_mode:
-                g.content = ''.join(traceback.format_exception(
-                    *sys.exc_info()))
-            g.message = util.F('no data') % e
-            g.content = g.content
+        except Exception as e:
+            handle_command_exception(e)
 
         return True
 
 
-def prompt_for_exit():
-    """ Ask for exit confirmation. """
+def prompt_for_exit(history=None, completer=None):
+    """Ask for exit confirmation."""
     g.message = c.r + "Press ctrl-c again to exit" + c.w
     g.content = content.generate_songlist_display()
     screen.update()
 
     try:
-        userinput = input(c.r + " > " + c.w)
+        userinput = pt_prompt(
+            c.r + " > " + c.w, history=history, completer=completer
+        ).strip()
 
     except (KeyboardInterrupt, EOFError):
         commands.misc.quits(showlogo=False)
@@ -119,9 +94,72 @@ def prompt_for_exit():
     return userinput
 
 
-def main():
-    init.init()
-    """ Main control loop. """
+@click.command(
+    context_settings=dict(
+        help_option_names=["-h", "--help"],
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+        allow_interspersed_args=False,
+    )
+)
+@click.version_option(version=__version__)
+@click.pass_context
+@click.option("--debug", "-d", is_flag=True, help="Enable debug mode")
+@click.option("--logging", "-l", "enable_logging", is_flag=True, help="Enable logging")
+@click.option("--no-autosize", is_flag=True, help="Disable terminal autosizing")
+@click.option("--no-preload", is_flag=True, help="Disable preloading of tracks")
+@click.option("--no-textart", is_flag=True, help="Disable ASCII art")
+@click.option(
+    "--cookies",
+    type=click.Path(exists=True, dir_okay=False),
+    help="Path to a Netscape-format cookies file for authenticated requests",
+)
+@click.option(
+    "--cookies-from-browser",
+    help="Load cookies from browser (for example: chrome, firefox, edge)",
+)
+@click.option(
+    "--visitor-data",
+    help="YouTube visitor data token for authenticated extraction without cookies",
+)
+@click.argument("commands_args", nargs=-1, type=click.UNPROCESSED)
+def main(
+    ctx,
+    debug,
+    enable_logging,
+    no_autosize,
+    no_preload,
+    no_textart,
+    cookies,
+    cookies_from_browser,
+    visitor_data,
+    commands_args,
+):
+    """yewtube - Terminal based YouTube player and downloader."""
+    passthrough_args = list(commands_args) + list(ctx.args)
+    cli_args = argparse.Namespace(
+        commands=passthrough_args,
+        help=False,
+        version=False,
+        debug=debug,
+        logging=enable_logging,
+        no_autosize=no_autosize,
+        no_preload=no_preload,
+        no_textart=no_textart,
+        cookies=cookies,
+        cookies_from_browser=cookies_from_browser,
+        visitor_data=visitor_data,
+    )
+
+    # Initialize
+    try:
+        init.init(cli_args=cli_args)
+    except Exception as e:
+        print(f"Initialization failed: {e}", file=sys.stderr)
+        if g.debug_mode:
+            traceback_py.print_exc()
+        return sys.exit(1)
+
     if config.SET_TITLE.get:
         util.set_window_title("yewtube")
 
@@ -141,11 +179,17 @@ def main():
     prev_model = []
     scrobble_funcs = [commands.album_search.search_album]
 
-    arg_inp = " ".join(g.argument_commands)
+    arg_inp = [
+        cmd.replace(r",,", "[mpsyt-comma]") for cmd in g.argument_commands
+    ]
+    # Emulate the existing comma-split behavior for compatibility if args are concatenated
+    if len(arg_inp) == 1 and "," in arg_inp[0]:
+        arg_inp = arg_inp[0].split(",")
 
-    prompt = "> "
-    arg_inp = arg_inp.replace(r",,", "[mpsyt-comma]")
-    arg_inp = arg_inp.split(",")
+    prompt_str = "> "
+
+    # Initialize prompt_toolkit history
+    pt_history = FileHistory(g.READLINE_FILE) if g.READLINE_FILE else None
 
     while True:
         next_inp = ""
@@ -155,28 +199,48 @@ def main():
             next_inp = next_inp.replace("[mpsyt-comma]", ",")
 
         try:
-            userinput = next_inp or input(prompt).strip()
+            if next_inp:
+                userinput = next_inp
+            else:
+                userinput = pt_prompt(
+                    prompt_str,
+                    completer=util.completer,
+                    history=pt_history,
+                    complete_while_typing=False,
+                ).strip()
 
         except (KeyboardInterrupt, EOFError):
-            userinput = prompt_for_exit()
-
-        for i in g.commands:
-            if matchfunction(i.function, i.regex, userinput):
-                if prev_model != g.model and not i.function in scrobble_funcs:
-                    g.scrobble = False
-                prev_model = g.model
-                break
+            userinput = prompt_for_exit(
+                history=pt_history, completer=util.completer
+            )
 
-        else:
-            g.content = g.content or content.generate_songlist_display()
-
-            if g.command_line:
-                g.content = ""
-
-            if userinput and not g.command_line:
-                g.message = c.b + "Bad syntax. Enter h for help" + c.w
-
-            elif userinput and g.command_line:
-                sys.exit("Bad syntax")
+        try:
+            matched = False
+            for i in g.commands:
+                if matchfunction(i.function, i.regex, userinput):
+                    if (
+                        prev_model != g.model
+                        and i.function not in scrobble_funcs
+                    ):
+                        g.scrobble = False
+                    prev_model = g.model
+                    matched = True
+                    break
+
+            if not matched:
+                g.content = g.content or content.generate_songlist_display()
+
+                if g.command_line:
+                    g.content = ""
+
+                if userinput and not g.command_line:
+                    g.message = c.b + "Bad syntax. Enter h for help" + c.w
+
+                elif userinput and g.command_line:
+                    sys.exit("Bad syntax")
+        except Exception as e:
+            if g.debug_mode:
+                traceback_py.print_exc()
+            g.message = f"{c.r}Error: {e}{c.w}"
 
         screen.update()
diff --git a/mps_youtube/mpris.py b/mps_youtube/mpris.py
index d518e204..f1144209 100644
--- a/mps_youtube/mpris.py
+++ b/mps_youtube/mpris.py
@@ -33,23 +33,23 @@
 import dbus.service
 from dbus.mainloop.glib import DBusGMainLoop
 
-IDENTITY = 'mps-youtube'
+IDENTITY = "mps-youtube"
 
-BUS_NAME = 'org.mpris.MediaPlayer2.' + IDENTITY + '.instance' + str(os.getpid())
-ROOT_INTERFACE = 'org.mpris.MediaPlayer2'
-PLAYER_INTERFACE = 'org.mpris.MediaPlayer2.Player'
-PROPERTIES_INTERFACE = 'org.freedesktop.DBus.Properties'
-MPRIS_PATH = '/org/mpris/MediaPlayer2'
+BUS_NAME = "org.mpris.MediaPlayer2." + IDENTITY + ".instance" + str(os.getpid())
+ROOT_INTERFACE = "org.mpris.MediaPlayer2"
+PLAYER_INTERFACE = "org.mpris.MediaPlayer2.Player"
+PROPERTIES_INTERFACE = "org.freedesktop.DBus.Properties"
+MPRIS_PATH = "/org/mpris/MediaPlayer2"
 
-class Mpris2Controller:
 
+class Mpris2Controller:
     """
-        Controller for various MPRIS objects.
+    Controller for various MPRIS objects.
     """
 
     def __init__(self):
         """
-            Constructs an MPRIS controller. Note, you must call acquire()
+        Constructs an MPRIS controller. Note, you must call acquire()
         """
         # Do not import in main process to prevent conflict with pyperclip
         # (https://github.com/mps-youtube/mps-youtube/issues/461)
@@ -61,7 +61,7 @@ def __init__(self):
 
     def release(self):
         """
-            Releases all objects from D-Bus and unregisters the bus
+        Releases all objects from D-Bus and unregisters the bus
         """
         if self.mpris is not None:
             self.mpris.remove_from_connection()
@@ -71,15 +71,15 @@ def release(self):
 
     def acquire(self):
         """
-            Connects to D-Bus and registers all components
+        Connects to D-Bus and registers all components
         """
         self._acquire_bus()
         self._add_interfaces()
 
     def run(self, connection):
         """
-            Runs main loop, processing all calls
-            binds on connection (Pipe) and listens player changes
+        Runs main loop, processing all calls
+        binds on connection (Pipe) and listens player changes
         """
         t = Thread(target=self._run_main_loop)
         t.daemon = True
@@ -88,18 +88,18 @@ def run(self, connection):
 
     def listenstatus(self, conn):
         """
-            Notifies interfaces that player connection changed
+        Notifies interfaces that player connection changed
         """
         while True:
             try:
                 data = conn.recv()
                 if isinstance(data, tuple):
                     name, val = data
-                    if name == 'socket':
+                    if name == "socket":
                         Thread(target=self.mpris.bindmpv, args=(val,)).start()
-                    elif name == 'mplayer-fifo':
+                    elif name == "mplayer-fifo":
                         self.mpris.bindfifo(val)
-                    elif name == 'mpv-fifo':
+                    elif name == "mpv-fifo":
                         self.mpris.bindfifo(val, mpv=True)
                     else:
                         self.mpris.setproperty(name, val)
@@ -110,23 +110,24 @@ def listenstatus(self, conn):
 
     def _acquire_bus(self):
         """
-            Connect to D-Bus and set self.bus to be a valid connection
+        Connect to D-Bus and set self.bus to be a valid connection
         """
         if self.bus is not None:
             self.bus.get_bus().request_name(BUS_NAME)
         else:
-            self.bus = dbus.service.BusName(BUS_NAME,
-                bus=dbus.SessionBus(mainloop=DBusGMainLoop()))
+            self.bus = dbus.service.BusName(
+                BUS_NAME, bus=dbus.SessionBus(mainloop=DBusGMainLoop())
+            )
 
     def _add_interfaces(self):
         """
-            Connects all interfaces to D-Bus
+        Connects all interfaces to D-Bus
         """
         self.mpris = Mpris2MediaPlayer(self.bus)
 
     def _run_main_loop(self):
         """
-            Runs glib main loop, ignoring keyboard interrupts
+        Runs glib main loop, ignoring keyboard interrupts
         """
         while True:
             try:
@@ -136,70 +137,72 @@ def _run_main_loop(self):
 
 
 class Mpris2MediaPlayer(dbus.service.Object):
-
     """
-        main dbus object for MPRIS2
-        implementing interfaces:
-            org.mpris.MediaPlayer2
-            org.mpris.MediaPlayer2.Player
+    main dbus object for MPRIS2
+    implementing interfaces:
+        org.mpris.MediaPlayer2
+        org.mpris.MediaPlayer2.Player
     """
 
     def __init__(self, bus):
         """
-            initializes mpris object on dbus
+        initializes mpris object on dbus
         """
         dbus.service.Object.__init__(self, bus, MPRIS_PATH)
         self.socket = None
         self.fifo = None
         self.mpv = False
         self.properties = {
-            ROOT_INTERFACE : {
-                'read_only' : {
-                    'CanQuit' : False,
-                    'CanSetFullscreen' : False,
-                    'CanRaise' : False,
-                    'HasTrackList' : False,
-                    'Identity' : IDENTITY,
-                    'DesktopEntry' : 'mps-youtube',
-                    'SupportedUriSchemes' : dbus.Array([], 's', 1),
-                    'SupportedMimeTypes' : dbus.Array([], 's', 1),
+            ROOT_INTERFACE: {
+                "read_only": {
+                    "CanQuit": False,
+                    "CanSetFullscreen": False,
+                    "CanRaise": False,
+                    "HasTrackList": False,
+                    "Identity": IDENTITY,
+                    "DesktopEntry": "mps-youtube",
+                    "SupportedUriSchemes": dbus.Array([], "s", 1),
+                    "SupportedMimeTypes": dbus.Array([], "s", 1),
                 },
-                'read_write' : {
-                    'Fullscreen' : False,
+                "read_write": {
+                    "Fullscreen": False,
                 },
             },
-            PLAYER_INTERFACE : {
-                'read_only' : {
-                    'PlaybackStatus' : 'Stopped',
-                    'Metadata' : { 'mpris:trackid' : dbus.ObjectPath(
-                                '/CurrentPlaylist/UnknownTrack', variant_level=1) },
-                    'Position' : dbus.Int64(0),
-                    'MinimumRate' : 1.0,
-                    'MaximumRate' : 1.0,
-                    'CanGoNext' : True,
-                    'CanGoPrevious' : True,
-                    'CanPlay' : True,
-                    'CanPause' : True,
-                    'CanSeek' : True,
-                    'CanControl' : True,
+            PLAYER_INTERFACE: {
+                "read_only": {
+                    "PlaybackStatus": "Stopped",
+                    "Metadata": {
+                        "mpris:trackid": dbus.ObjectPath(
+                            "/CurrentPlaylist/UnknownTrack", variant_level=1
+                        )
+                    },
+                    "Position": dbus.Int64(0),
+                    "MinimumRate": 1.0,
+                    "MaximumRate": 1.0,
+                    "CanGoNext": True,
+                    "CanGoPrevious": True,
+                    "CanPlay": True,
+                    "CanPause": True,
+                    "CanSeek": True,
+                    "CanControl": True,
                 },
-                'read_write' : {
-                    'Rate' : 1.0,
-                    'Volume' : 1.0,
+                "read_write": {
+                    "Rate": 1.0,
+                    "Volume": 1.0,
                 },
             },
         }
 
     def bindmpv(self, sockpath):
         """
-            init JSON IPC for new versions of mpv >= 0.7
+        init JSON IPC for new versions of mpv >= 0.7
         """
         self.mpv = True
         self.socket = socket.socket(socket.AF_UNIX)
         # wait on socket initialization
         tries = 0
         while tries < 10:
-            time.sleep(.5)
+            time.sleep(0.5)
             try:
                 self.socket.connect(sockpath)
                 break
@@ -217,14 +220,14 @@ def bindmpv(self, sockpath):
                 resp = json.loads(line)
 
                 # deals with bug in mpv 0.7 - 0.7.3
-                if resp.get('event') == 'property-change' and not observe_full:
+                if resp.get("event") == "property-change" and not observe_full:
                     self._sendcommand(["observe_property", 2, "volume"])
                     self._sendcommand(["observe_property", 3, "pause"])
                     self._sendcommand(["observe_property", 4, "seeking"])
                     observe_full = True
 
-                if resp.get('event') == 'property-change':
-                    self.setproperty(resp['name'], resp.get('data'))
+                if resp.get("event") == "property-change":
+                    self.setproperty(resp["name"], resp.get("data"))
 
         except socket.error:
             self.socket = None
@@ -232,12 +235,12 @@ def bindmpv(self, sockpath):
 
     def bindfifo(self, fifopath, mpv=False):
         """
-            init command fifo for mplayer and old versions of mpv
+        init command fifo for mplayer and old versions of mpv
         """
-        time.sleep(1) # give it some time so fifo could be properly created
+        time.sleep(1)  # give it some time so fifo could be properly created
         try:
-            self.fifo = open(fifopath, 'w')
-            self._sendcommand(['get_property', 'volume'])
+            self.fifo = open(fifopath, "w")
+            self._sendcommand(["get_property", "volume"])
             self.mpv = mpv
 
         except IOError:
@@ -245,95 +248,120 @@ def bindfifo(self, fifopath, mpv=False):
 
     def setproperty(self, name: str, val: T.Optional[T.Any]):
         """
-            Properly sets properties on player interface
+        Properly sets properties on player interface
 
-            don't use this method from dbus interface, all values should
-            be set from player (to keep them correct)
+        don't use this method from dbus interface, all values should
+        be set from player (to keep them correct)
         """
-        if name == 'pause':
-            oldval = self.properties[PLAYER_INTERFACE]['read_only']['PlaybackStatus']
+        if name == "pause":
+            oldval = self.properties[PLAYER_INTERFACE]["read_only"][
+                "PlaybackStatus"
+            ]
             newval = None
             if val:
-                newval = 'Paused'
+                newval = "Paused"
             else:
-                newval = 'Playing'
+                newval = "Playing"
 
             if newval != oldval:
-                self.properties[PLAYER_INTERFACE]['read_only']['PlaybackStatus'] = newval
-                self.PropertiesChanged(PLAYER_INTERFACE, { 'PlaybackStatus': newval }, [])
-
-        elif name == 'stop':
-            oldval = self.properties[PLAYER_INTERFACE]['read_only']['PlaybackStatus']
+                self.properties[PLAYER_INTERFACE]["read_only"][
+                    "PlaybackStatus"
+                ] = newval
+                self.PropertiesChanged(
+                    PLAYER_INTERFACE, {"PlaybackStatus": newval}, []
+                )
+
+        elif name == "stop":
+            oldval = self.properties[PLAYER_INTERFACE]["read_only"][
+                "PlaybackStatus"
+            ]
             newval = None
             if val:
-                newval = 'Stopped'
+                newval = "Stopped"
             else:
-                newval = 'Playing'
+                newval = "Playing"
 
             if newval != oldval:
-                self.properties[PLAYER_INTERFACE]['read_only']['PlaybackStatus'] = newval
-                self.PropertiesChanged(PLAYER_INTERFACE, { 'PlaybackStatus': newval },
-                    ['Metadata', 'Position'])
-
-        elif name == 'volume' and val is not None:
-            oldval = self.properties[PLAYER_INTERFACE]['read_write']['Volume']
+                self.properties[PLAYER_INTERFACE]["read_only"][
+                    "PlaybackStatus"
+                ] = newval
+                self.PropertiesChanged(
+                    PLAYER_INTERFACE,
+                    {"PlaybackStatus": newval},
+                    ["Metadata", "Position"],
+                )
+
+        elif name == "volume" and val is not None:
+            oldval = self.properties[PLAYER_INTERFACE]["read_write"]["Volume"]
             newval = float(val) / 100
 
             if newval != oldval:
-                self.properties[PLAYER_INTERFACE]['read_write']['Volume'] = newval
-                self.PropertiesChanged(PLAYER_INTERFACE, { 'Volume': newval }, [])
+                self.properties[PLAYER_INTERFACE]["read_write"]["Volume"] = (
+                    newval
+                )
+                self.PropertiesChanged(PLAYER_INTERFACE, {"Volume": newval}, [])
 
-        elif name == 'time-pos' and val:
-            oldval = self.properties[PLAYER_INTERFACE]['read_only']['Position']
+        elif name == "time-pos" and val:
+            oldval = self.properties[PLAYER_INTERFACE]["read_only"]["Position"]
             newval = dbus.Int64(val * 10**6) if val else dbus.Int64(0)
 
             if newval != oldval:
-                self.properties[PLAYER_INTERFACE]['read_only']['Position'] = newval
+                self.properties[PLAYER_INTERFACE]["read_only"]["Position"] = (
+                    newval
+                )
             if abs(newval - oldval) >= 4 * 10**6:
                 self.Seeked(newval)
 
-        elif name == 'metadata' and val:
+        elif name == "metadata" and val:
             trackid, title, length, arturl, artist, album = val
             # sanitize ytid - it uses '-_' which are not valid in dbus paths
-            trackid_sanitized = re.sub('[^a-zA-Z0-9]', '', trackid)
-            yturl = 'https://www.youtube.com/watch?v=' + trackid
+            trackid_sanitized = re.sub("[^a-zA-Z0-9]", "", trackid)
+            yturl = "https://www.youtube.com/watch?v=" + trackid
 
-            oldval = self.properties[PLAYER_INTERFACE]['read_only']['Metadata']
+            oldval = self.properties[PLAYER_INTERFACE]["read_only"]["Metadata"]
             newval = {
-                'mpris:trackid' : dbus.ObjectPath(
-                    '/CurrentPlaylist/ytid/' + trackid_sanitized, variant_level=1),
-                'mpris:length' : dbus.Int64(length * 10**6, variant_level=1),
-                'mpris:artUrl' : dbus.String(arturl, variant_level=1),
-                'xesam:title' : dbus.String(title, variant_level=1),
-                'xesam:artist' : dbus.Array(artist, 's', 1),
-                'xesam:album' : dbus.String(album, variant_level=1),
-                'xesam:url' : dbus.String(yturl, variant_level=1),
+                "mpris:trackid": dbus.ObjectPath(
+                    "/CurrentPlaylist/ytid/" + trackid_sanitized,
+                    variant_level=1,
+                ),
+                "mpris:length": dbus.Int64(length * 10**6, variant_level=1),
+                "mpris:artUrl": dbus.String(arturl, variant_level=1),
+                "xesam:title": dbus.String(title, variant_level=1),
+                "xesam:artist": dbus.Array(artist, "s", 1),
+                "xesam:album": dbus.String(album, variant_level=1),
+                "xesam:url": dbus.String(yturl, variant_level=1),
             }
 
             if newval != oldval:
-                self.properties[PLAYER_INTERFACE]['read_only']['Metadata'] = newval
-                self.PropertiesChanged(PLAYER_INTERFACE, { 'Metadata': newval }, [])
-
-        elif name == 'seeking':
+                self.properties[PLAYER_INTERFACE]["read_only"]["Metadata"] = (
+                    newval
+                )
+                self.PropertiesChanged(
+                    PLAYER_INTERFACE, {"Metadata": newval}, []
+                )
+
+        elif name == "seeking":
             # send signal to keep time-pos synced between player and client
             if not val:
-                self.Seeked(self.properties[PLAYER_INTERFACE]['read_only']['Position'])
+                self.Seeked(
+                    self.properties[PLAYER_INTERFACE]["read_only"]["Position"]
+                )
 
     def _sendcommand(self, command):
         """
-            sends commands to binded player
+        sends commands to binded player
         """
         if self.socket:
-            self.socket.send(json.dumps({"command": command}).encode() + b'\n')
+            self.socket.send(json.dumps({"command": command}).encode() + b"\n")
         elif self.fifo:
             command = command[:]
             for x, i in enumerate(command):
                 if i is True:
-                    command[x] = 'yes' if self.mpv else 1
+                    command[x] = "yes" if self.mpv else 1
                 elif i is False:
-                    command[x] = 'no' if self.mpv else 0
+                    command[x] = "no" if self.mpv else 0
 
-            cmd = " ".join([str(i) for i in command]) + '\n'
+            cmd = " ".join([str(i) for i in command]) + "\n"
             self.fifo.write(cmd)
             self.fifo.flush()
 
@@ -344,15 +372,15 @@ def _sendcommand(self, command):
     @dbus.service.method(dbus_interface=ROOT_INTERFACE)
     def Raise(self):
         """
-            Brings the media player's user interface to the front using
-            any appropriate mechanism available.
+        Brings the media player's user interface to the front using
+        any appropriate mechanism available.
         """
         pass
 
     @dbus.service.method(dbus_interface=ROOT_INTERFACE)
     def Quit(self):
         """
-            Causes the media player to stop running.
+        Causes the media player to stop running.
         """
         pass
 
@@ -363,34 +391,41 @@ def Quit(self):
     @dbus.service.method(dbus_interface=PLAYER_INTERFACE)
     def Next(self):
         """
-            Skips to the next track in the tracklist.
+        Skips to the next track in the tracklist.
         """
-        self._sendcommand(["quit"])
+        # Use dedicated exit code so player can distinguish MPRIS skip
+        # from natural player exit.
+        self._sendcommand(["quit", 44])
 
     @dbus.service.method(PLAYER_INTERFACE)
     def Previous(self):
         """
-            Skips to the previous track in the tracklist.
+        Skips to the previous track in the tracklist.
         """
-        self._sendcommand(["quit", 42])
+        # Use dedicated exit code so player can distinguish MPRIS skip
+        # from natural player exit.
+        self._sendcommand(["quit", 45])
 
     @dbus.service.method(PLAYER_INTERFACE)
     def Pause(self):
         """
-            Pauses playback.
-            If playback is already paused, this has no effect.
+        Pauses playback.
+        If playback is already paused, this has no effect.
         """
         if self.mpv:
             self._sendcommand(["set_property", "pause", True])
         else:
-            if self.properties[PLAYER_INTERFACE]['read_only']['PlaybackStatus'] != 'Paused':
-                self._sendcommand(['pause'])
+            if (
+                self.properties[PLAYER_INTERFACE]["read_only"]["PlaybackStatus"]
+                != "Paused"
+            ):
+                self._sendcommand(["pause"])
 
     @dbus.service.method(PLAYER_INTERFACE)
     def PlayPause(self):
         """
-            Pauses playback.
-            If playback is already paused, resumes playback.
+        Pauses playback.
+        If playback is already paused, resumes playback.
         """
         if self.mpv:
             self._sendcommand(["cycle", "pause"])
@@ -400,65 +435,75 @@ def PlayPause(self):
     @dbus.service.method(PLAYER_INTERFACE)
     def Stop(self):
         """
-            Stops playback.
+        Stops playback.
         """
         self._sendcommand(["quit", 43])
 
     @dbus.service.method(PLAYER_INTERFACE)
     def Play(self):
         """
-            Starts or resumes playback.
+        Starts or resumes playback.
         """
         if self.mpv:
             self._sendcommand(["set_property", "pause", False])
         else:
-            if self.properties[PLAYER_INTERFACE]['read_only']['PlaybackStatus'] != 'Playing':
-                self._sendcommand(['pause'])
+            if (
+                self.properties[PLAYER_INTERFACE]["read_only"]["PlaybackStatus"]
+                != "Playing"
+            ):
+                self._sendcommand(["pause"])
 
-    @dbus.service.method(PLAYER_INTERFACE, in_signature='x')
+    @dbus.service.method(PLAYER_INTERFACE, in_signature="x")
     def Seek(self, offset):
         """
-            Offset - x (offset)
-                The number of microseconds to seek forward.
+        Offset - x (offset)
+            The number of microseconds to seek forward.
 
-            Seeks forward in the current track by the specified number
-            of microseconds.
+        Seeks forward in the current track by the specified number
+        of microseconds.
         """
         self._sendcommand(["seek", offset / 10**6])
 
-    @dbus.service.method(PLAYER_INTERFACE, in_signature='ox')
+    @dbus.service.method(PLAYER_INTERFACE, in_signature="ox")
     def SetPosition(self, track_id, position):
         """
-            TrackId - o (track_id)
-                The currently playing track's identifier.
-                If this does not match the id of the currently-playing track,
-                the call is ignored as "stale".
-            Position - x (position)
-                Track position in microseconds.
-
-            Sets the current track position in microseconds.
-        """
-        if track_id == self.properties[PLAYER_INTERFACE]['read_only']['Metadata']['mpris:trackid']:
-            self._sendcommand(["seek", position / 10**6, 'absolute' if self.mpv else 2])
-
-    @dbus.service.method(PLAYER_INTERFACE, in_signature='s')
+        TrackId - o (track_id)
+            The currently playing track's identifier.
+            If this does not match the id of the currently-playing track,
+            the call is ignored as "stale".
+        Position - x (position)
+            Track position in microseconds.
+
+        Sets the current track position in microseconds.
+        """
+        if (
+            track_id
+            == self.properties[PLAYER_INTERFACE]["read_only"]["Metadata"][
+                "mpris:trackid"
+            ]
+        ):
+            self._sendcommand(
+                ["seek", position / 10**6, "absolute" if self.mpv else 2]
+            )
+
+    @dbus.service.method(PLAYER_INTERFACE, in_signature="s")
     def OpenUri(self, uri):
         """
-            Uri - s (uri)
-                Uri of the track to load.
+        Uri - s (uri)
+            Uri of the track to load.
 
-            Opens the Uri given as an argument.
+        Opens the Uri given as an argument.
         """
         pass
 
-    @dbus.service.signal(PLAYER_INTERFACE, signature='x')
+    @dbus.service.signal(PLAYER_INTERFACE, signature="x")
     def Seeked(self, position):
         """
-            Position - x (position)
-                The new position, in microseconds.
+        Position - x (position)
+            The new position, in microseconds.
 
-            Indicates that the track position has changed in a way that
-            is inconsistant with the current playing state.
+        Indicates that the track position has changed in a way that
+        is inconsistant with the current playing state.
         """
         pass
 
@@ -466,98 +511,115 @@ def Seeked(self, position):
     # implementing org.freedesktop.DBus.Properties
     #
 
-    @dbus.service.method(dbus_interface=PROPERTIES_INTERFACE,
-                         in_signature='ss', out_signature='v')
+    @dbus.service.method(
+        dbus_interface=PROPERTIES_INTERFACE,
+        in_signature="ss",
+        out_signature="v",
+    )
     def Get(self, interface_name, property_name):
         """
-            getter for org.freedesktop.DBus.Properties on this object
+        getter for org.freedesktop.DBus.Properties on this object
         """
         return self.GetAll(interface_name)[property_name]
 
-    @dbus.service.method(dbus_interface=PROPERTIES_INTERFACE,
-                         in_signature='s', out_signature='a{sv}')
+    @dbus.service.method(
+        dbus_interface=PROPERTIES_INTERFACE,
+        in_signature="s",
+        out_signature="a{sv}",
+    )
     def GetAll(self, interface_name):
         """
-            getter for org.freedesktop.DBus.Properties on this object
+        getter for org.freedesktop.DBus.Properties on this object
         """
         if interface_name in self.properties:
-            t = copy.copy(self.properties[interface_name]['read_only'])
-            t.update(self.properties[interface_name]['read_write'])
+            t = copy.copy(self.properties[interface_name]["read_only"])
+            t.update(self.properties[interface_name]["read_write"])
 
             return t
         else:
             raise dbus.exceptions.DBusException(
-                'com.example.UnknownInterface',
-                'This object does not implement the %s interface'
-                % interface_name)
-
-    @dbus.service.method(dbus_interface=PROPERTIES_INTERFACE,
-                         in_signature='ssv')
+                "com.example.UnknownInterface",
+                "This object does not implement the %s interface"
+                % interface_name,
+            )
+
+    @dbus.service.method(
+        dbus_interface=PROPERTIES_INTERFACE, in_signature="ssv"
+    )
     def Set(self, interface_name, property_name, new_value):
         """
-            setter for org.freedesktop.DBus.Properties on this object
+        setter for org.freedesktop.DBus.Properties on this object
         """
         if interface_name in self.properties:
-            if property_name in self.properties[interface_name]['read_write']:
-                if property_name == 'Volume':
-                    self._sendcommand(["set_property", "volume", new_value * 100])
-                    if self.fifo: # fix for mplayer (force update)
-                        self._sendcommand(['get_property', 'volume'])
+            if property_name in self.properties[interface_name]["read_write"]:
+                if property_name == "Volume":
+                    self._sendcommand(
+                        ["set_property", "volume", new_value * 100]
+                    )
+                    if self.fifo:  # fix for mplayer (force update)
+                        self._sendcommand(["get_property", "volume"])
         else:
             raise dbus.exceptions.DBusException(
-                'com.example.UnknownInterface',
-                'This object does not implement the %s interface'
-                % interface_name)
+                "com.example.UnknownInterface",
+                "This object does not implement the %s interface"
+                % interface_name,
+            )
 
-    @dbus.service.signal(dbus_interface=PROPERTIES_INTERFACE,
-                         signature='sa{sv}as')
-    def PropertiesChanged(self, interface_name, changed_properties,
-                          invalidated_properties):
+    @dbus.service.signal(
+        dbus_interface=PROPERTIES_INTERFACE, signature="sa{sv}as"
+    )
+    def PropertiesChanged(
+        self, interface_name, changed_properties, invalidated_properties
+    ):
         """
-            signal for org.freedesktop.DBus.Properties on this object
+        signal for org.freedesktop.DBus.Properties on this object
 
-            this informs of changed properties
+        this informs of changed properties
         """
         pass
 
+
 class MprisConnection(object):
     """
-        Object encapsulating pipe for communication with Mpris2Controller.
-        This object wraps send to ensure communicating process never crashes,
-        even when Mpris2Controller existed or crashed.
+    Object encapsulating pipe for communication with Mpris2Controller.
+    This object wraps send to ensure communicating process never crashes,
+    even when Mpris2Controller existed or crashed.
     """
+
     def __init__(self, connection):
         super(MprisConnection, self).__init__()
         self.connection = connection
 
     def send(self, obj):
         """
-            Send an object to the other end of the connection
+        Send an object to the other end of the connection
         """
         if self.connection:
             try:
                 self.connection.send(obj)
             except BrokenPipeError:
                 self.connection = None
-                print('MPRIS process exited or crashed.')
+                print("MPRIS process exited or crashed.")
 
 
 def main(connection):
     """
-        runs mpris interface and listens for changes
-        connection - pipe to communicate with this module
+    runs mpris interface and listens for changes
+    connection - pipe to communicate with this module
     """
 
     try:
         mprisctl = Mpris2Controller()
-    except ImportError: # gi.repository import GLib
+    except ImportError:  # gi.repository import GLib
         print("could not load MPRIS interface. missing libraries.")
         return
     try:
         mprisctl.acquire()
     except dbus.exceptions.DBusException as e:
-        print('mpris interface couldn\'t be initialized. reason: %s'
-               % e.get_dbus_message())
+        print(
+            "mpris interface couldn't be initialized. reason: %s"
+            % e.get_dbus_message()
+        )
         return
     mprisctl.run(connection)
     mprisctl.release()
diff --git a/mps_youtube/pafy.py b/mps_youtube/pafy.py
deleted file mode 100644
index b8c818cd..00000000
--- a/mps_youtube/pafy.py
+++ /dev/null
@@ -1,245 +0,0 @@
-import json
-import os, glob
-import random
-import re
-from urllib.parse import parse_qs, urlparse
-
-import requests
-import yt_dlp
-from youtubesearchpython import VideosSearch, ChannelsSearch, PlaylistsSearch, Suggestions, Playlist, playlist_from_channel_id, Comments, Video, Channel, ChannelSearch
-
-
-class MyLogger:
-
-    def __init__(self, print_info=False):
-        self.print_info = print_info
-
-    def debug(self, msg):
-        # For compatibility with youtube-dl, both debug and info are passed into debug
-        # You can distinguish them by the prefix '[debug] '
-        if msg.startswith('[debug] '):
-            pass
-        else:
-            self.info(msg)
-
-    def info(self, msg):
-        if self.print_info:
-            print(msg)
-
-    def warning(self, msg):
-        pass
-
-    def error(self, msg):
-        print(msg)
-
-
-def get_video_streams(ytid):
-
-    '''
-    given a youtube video id returns different video / audio stream formats' \
-    '''
-
-    with yt_dlp.YoutubeDL({'logger':MyLogger()}) as ydl:
-        info_dict = ydl.extract_info(ytid, download=False)
-        return [i for i in info_dict['formats'] if i.get('format_note') != 'storyboard']
-
-def download_video(ytid, folder, audio_only=False):
-
-    '''
-    Given a youtube video id and target folder, this function will download video to that folder
-    '''
-
-    ytdl_format_options = {
-        'outtmpl': os.path.join(folder, '%(title)s-%(id)s.%(ext)s')
-    }
-    if audio_only:
-        ytdl_format_options['format'] = 'bestaudio/best'
-        ytdl_format_options['postprocessors'] =[{
-            'key': 'FFmpegExtractAudio',
-            'preferredcodec': 'mp3',
-            'preferredquality': '192',
-        }]
-
-    with yt_dlp.YoutubeDL(ytdl_format_options) as ydl:
-        ydl.download('https://www.youtube.com/watch?v=%s' % ytid)
-        return True
-
-def search_videos(query, pages):
-
-    '''
-    Given a keyword / query this function will return youtube video results against those keywords / query
-    '''
-
-    videosSearch = VideosSearch(query, limit=50)
-    wdata = videosSearch.result()['result']
-    for i in range(pages-1):
-        videosSearch.next()
-        wdata.extend(videosSearch.result()['result'])
-    return wdata
-
-
-def channel_search(query):
-
-    '''
-    Search channel based on keyword / query provided by user
-    '''
-
-    channelsSearch = ChannelsSearch(query, limit=50, region='US')
-    return channelsSearch.result()['result']
-
-def playlist_search(query):
-
-    '''
-    Returns all playlists having similar names as keyword / query provided
-    '''
-
-    playlistsSearch = PlaylistsSearch(query, limit=50)
-    return playlistsSearch.result()['result']
-
-def get_playlist(playlist_id):
-
-    '''
-    Get all videos of a playlist identified by playlist_id
-    '''
-
-    playlist = Playlist('https://www.youtube.com/playlist?list=%s' % playlist_id)
-    while playlist.hasMoreVideos:
-        playlist.getNextVideos()
-    return playlist
-
-def get_video_title_suggestions(query):
-    suggestions = Suggestions(language = 'en', region = 'US')
-    related_searches = suggestions.get(query)['result']
-    return related_searches[random.randint(0,len(related_searches))]
-
-def channel_id_from_name(query):
-    channel_info = channel_search(query)[0]
-    channel_id = channel_info['id']
-    channel_name = channel_info['title']
-    return (channel_id, channel_name)
-
-def all_videos_from_channel(channel_id):
-    '''
-    Get all videos of a playlist identified by channel_id
-    '''
-
-    playlist = Playlist(playlist_from_channel_id(channel_id))
-    while playlist.hasMoreVideos:
-        playlist.getNextVideos()
-    return playlist.videos
-
-def search_videos_from_channel(channel_id, query):
-    search = ChannelSearch(query , channel_id)
-    return search.result()
-
-def get_comments(video_id):
-    comments = Comments.get(video_id)
-    return comments['result']
-
-def get_video_info(video_id):
-    try:
-        videoInfo = Video.getInfo(video_id)
-        response = return_dislikes(video_id)
-        videoInfo['likes'] = response['likes']
-        videoInfo['dislikes'] = response['dislikes']
-        videoInfo['averageRating'] = response['rating']
-        return videoInfo
-    except:
-        raise Exception("Can't get video info. Video is either private or unavailable in your country.")
-
-def return_dislikes(video_id):
-    return json.loads(requests.get('https://returnyoutubedislikeapi.com/votes?videoId=' + video_id).text)
-
-
-def extract_video_id(url: str) -> str:
-    """Extract the video id from a url, return video id as str.
-
-    Args:
-        url: url contain video id
-
-    Returns:
-        video id
-
-    Raises:
-        ValueError: If no video id found
-
-    Examples:
-
-        >>> extract_video_id('http://example.com')
-        >>> extract_video_id('https://www.youtube.com/watch?v=LDU_Txk06tM')
-        LDU_Txk06tM
-        >>> extract_video_id('https://youtu.be/LDU_Txk06tM')
-        LDU_Txk06tM
-    """
-    idregx = re.compile(r'[\w-]{11}$')
-    url = str(url).strip()
-
-    if idregx.match(url):
-        return url # ID of video
-
-    if '://' not in url:
-        url = '//' + url
-    parsedurl = urlparse(url)
-    if parsedurl.netloc in ('youtube.com', 'www.youtube.com', 'm.youtube.com', 'gaming.youtube.com'):
-        query = parse_qs(parsedurl.query)
-        if 'v' in query and idregx.match(query['v'][0]):
-            return query['v'][0]
-    elif parsedurl.netloc in ('youtu.be', 'www.youtu.be'):
-        vidid = parsedurl.path.split('/')[-1] if parsedurl.path else ''
-        if idregx.match(vidid):
-            return vidid
-
-    err = "Need 11 character video id or the URL of the video. Got %s"
-    raise ValueError(err % url)
-
-def all_playlists_from_channel(channel_id):
-    channel = Channel(channel_id)
-    playlists = channel.result['playlists']
-    while channel.has_more_playlists():
-         channel.next()
-         playlists.extend(channel.result["playlists"])
-    return playlists
-
-def get_subtitles(ytid, output_dir):
-    '''
-    Downloads and saves the .vtt subtitle of give youtube video id under path {output_dir}/subtitles
-    Subtitles are selected as follows:
-    1. Select first user provided subtitle. If none then
-    2. Select auto generated 'en' subtitles
-    '''
-
-    if output_dir.endswith('/'):
-        output_dir = output_dir[:-1]
-    outtmpl = f'{output_dir}/subtitles/{ytid}'
-    # check if subtitles already exist
-    existing_subtitles = glob.glob(os.path.join(outtmpl+'*.vtt'))
-    if existing_subtitles:
-        return existing_subtitles[0]
-
-    url = f'https://www.youtube.com/watch?v={ytid}'
-    ydl_opts = {
-        'skip_download': True,
-        'writesubtitles': True,
-        'writeautomaticsub': True,
-        'subtitlesformat': 'vtt',
-        'outtmpl': outtmpl,
-        'logger': MyLogger(print_info=False),
-    }
-    # Create a YoutubeDL instance with the options
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-        info_dict = ydl.extract_info(url, download=False)
-        subtitles = info_dict.get('subtitles', {})
-        available_formats = list(subtitles.keys())
-        if available_formats:
-            lang = available_formats[0] # pick first subtitle from user-uploaded subtitles
-        else:
-            lang = 'en' # otherwise use english auto-generated subtitles
-        ydl.params['subtitleslangs'] = [lang]
-        # Add the new options to the existing ydl_opts dictionary
-        ydl.add_default_info_extractors()
-        # Create a new yt-dlp object with the updated ydl_opts dictionary
-        ydl = yt_dlp.YoutubeDL(ydl_opts)
-        # Download the subtitle
-        ydl.download([url])
-        path = f'{outtmpl}.{lang}.vtt'
-        return path if os.path.isfile(path) else None
\ No newline at end of file
diff --git a/mps_youtube/paths.py b/mps_youtube/paths.py
index 99d32f77..96bd1682 100644
--- a/mps_youtube/paths.py
+++ b/mps_youtube/paths.py
@@ -4,7 +4,7 @@
 
 
 def get_default_ddir():
-    """ Get system default Download directory, append mps dir. """
+    """Get system default Download directory, append mps dir."""
     user_home = os.path.expanduser("~")
     join, exists = os.path.join, os.path.exists
 
@@ -17,15 +17,15 @@ def get_default_ddir():
     # define ddir by (1) env var, (2) user-dirs.dirs file,
     #                (3) existing ~/Downloads dir (4) ~
 
-    if 'XDG_DOWNLOAD_DIR' in os.environ:
-        ddir = os.environ['XDG_DOWNLOAD_DIR']
+    if "XDG_DOWNLOAD_DIR" in os.environ:
+        ddir = os.environ["XDG_DOWNLOAD_DIR"]
 
     elif exists(USER_DIRS):
         lines = open(USER_DIRS).readlines()
         defn = [x for x in lines if x.startswith("XDG_DOWNLOAD_DIR")]
 
         if len(defn) == 1:
-            ddir = defn[0].split("=")[1].replace('"', '')
+            ddir = defn[0].split("=")[1].replace('"', "")
             ddir = ddir.replace("$HOME", user_home).strip()
 
         else:
@@ -39,15 +39,18 @@ def get_default_ddir():
 
 
 def get_config_dir():
-    """ Get user's configuration directory. Migrate to new mps name if old."""
+    """Get user's configuration directory. Migrate to new mps name if old."""
     if mswin:
-        confdir = os.environ["APPDATA"]
+        confdir = os.environ.get("APPDATA")
+        if not confdir:
+            userprofile = os.environ.get("USERPROFILE", os.path.expanduser("~"))
+            confdir = os.path.join(userprofile, "AppData", "Roaming")
 
-    elif 'XDG_CONFIG_HOME' in os.environ:
-        confdir = os.environ['XDG_CONFIG_HOME']
+    elif "XDG_CONFIG_HOME" in os.environ:
+        confdir = os.environ["XDG_CONFIG_HOME"]
 
     else:
-        confdir = os.path.join(os.path.expanduser("~"), '.config')
+        confdir = os.path.join(os.path.expanduser("~"), ".config")
 
     mps_confdir = os.path.join(confdir, "mps-youtube")
 
diff --git a/mps_youtube/player.py b/mps_youtube/player.py
index 8de5a631..035e71bf 100644
--- a/mps_youtube/player.py
+++ b/mps_youtube/player.py
@@ -5,18 +5,16 @@
 import shlex
 import socket
 import subprocess
-import sys
 import time
-from abc import ABCMeta, abstractmethod
 from urllib.error import HTTPError, URLError
 
 from . import c, config, content, g, history, screen, streams, util
 from .commands import lastfm
-from .util import not_utf8_environment
-from . import pafy
+from . import extractor
 
 mswin = os.name == "nt"
 
+
 class BasePlayer:
     _playbackStatus = "Paused"
     _last_displayed_line = None
@@ -28,14 +26,16 @@ def PlaybackStatus(self):
     @PlaybackStatus.setter
     def PlaybackStatus(self, value):
         self._playbackStatus = value
-        if value == 'Playing':
+        if value == "Playing":
             paused = False
         else:
             paused = True
-        g.mprisctl.send(('pause', paused))
+        g.mprisctl.send(("pause", paused))
 
-    def play(self, songlist, shuffle=False, repeat=False, override=False):
-        """ Play a range of songs, exit cleanly on keyboard interrupt. """
+    def play(
+        self, songlist, shuffle=False, repeat=False, override=False, start_index=0
+    ):
+        """Play a range of songs, exit cleanly on keyboard interrupt."""
 
         if config.ALWAYS_REPEAT.get:
             repeat = True
@@ -47,11 +47,12 @@ def play(self, songlist, shuffle=False, repeat=False, override=False):
         if shuffle:
             random.shuffle(self.songlist)
 
-        self.song_no = 0
-        while 0 <= self.song_no <= len(self.songlist)-1:
+        self.song_no = start_index
+        while 0 <= self.song_no <= len(self.songlist) - 1:
             self.song = self.songlist[self.song_no]
-            g.content = self._playback_progress(self.song_no, self.songlist,
-                                                repeat=repeat)
+            g.content = self._playback_progress(
+                self.song_no, self.songlist, repeat=repeat
+            )
 
             if not g.command_line:
                 screen.update(fill_blank=False)
@@ -59,8 +60,9 @@ def play(self, songlist, shuffle=False, repeat=False, override=False):
             hasnext = len(self.songlist) > self.song_no + 1
 
             if hasnext:
-                streams.preload(self.songlist[self.song_no + 1],
-                                override=self.override)
+                streams.preload(
+                    self.songlist[self.song_no + 1], override=self.override
+                )
 
             if config.SET_TITLE.get:
                 util.set_window_title(self.song.title + " - yewtube")
@@ -72,11 +74,22 @@ def play(self, songlist, shuffle=False, repeat=False, override=False):
 
             try:
                 if config.SHOW_VIDEO and config.SHOW_SUBTITLES:
-                    self.subtitle_path = pafy.get_subtitles(self.song.ytid, config.DDIR.get)
+                    self.subtitle_path = extractor.get_subtitles(
+                        self.song.ytid, config.DDIR.get
+                    )
                 self.video, self.stream, self.override = stream_details(
-                                                            self.song,
-                                                            override=self.override,
-                                                            softrepeat=self.softrepeat)
+                    self.song,
+                    override=self.override,
+                    softrepeat=self.softrepeat,
+                )
+
+                if self.stream is None:
+                    util.dbg("Failed to get stream details, skipping playback.")
+                    if config.AUTOPLAY.get:
+                        self.song_no += 1
+                        continue
+                    return
+
                 self._playsong()
 
             except KeyboardInterrupt:
@@ -90,6 +103,7 @@ def play(self, songlist, shuffle=False, repeat=False, override=False):
             # skip forbidden, video removed/no longer available, etc. tracks
             except (TypeError, Exception) as e:
                 import traceback
+
                 traceback.print_exception(type(e), e, e.__traceback__)
                 self.song_no += 1
                 pass
@@ -114,28 +128,30 @@ def previous(self):
 
     def stop(self):
         pass
+
     ###############
 
     def seek(self):
         pass
 
     def _playsong(self, failcount=0, softrepeat=False):
-        """ Play song using config.PLAYER called with args config.PLAYERARGS.
-
-        """
+        """Play song using config.PLAYER called with args config.PLAYERARGS."""
         # pylint: disable=R0911,R0912
         if not config.PLAYER.get or not util.has_exefile(config.PLAYER.get):
-            g.message = "Player not configured! Enter %sset player <player_app> "\
+            g.message = (
+                "Player not configured! Enter %sset player <player_app> "
                 "%s to set a player" % (c.g, c.w)
+            )
             return
 
         if config.NOTIFIER.get:
-            subprocess.Popen(shlex.split(config.NOTIFIER.get) + [self.song.title])
+            subprocess.Popen(
+                shlex.split(config.NOTIFIER.get) + [self.song.title]
+            )
 
-        size = streams.get_size(self.song.ytid, self.stream['url'])
-        songdata = (self.song.ytid, '' if self.stream.get('ext') is None else self.stream.get('ext') + " " + self.stream['quality'],
-                    int(size / (1024 ** 2)))
-        self.songdata = "%s; %s; %s Mb" % songdata
+        size = streams.get_size(self.song.ytid, self.stream["url"])
+        mbsize = str(int(size / (1024**2))) if size > 0 else "?"
+        self.songdata = f"{self.stream['ext']}:{mbsize}MB"
         screen.writestatus(self.songdata)
 
         self._launch_player()
@@ -144,27 +160,42 @@ def _playsong(self, failcount=0, softrepeat=False):
             history.add(self.song)
 
     def _launch_player(self):
-        """ Launch player application. """
+        """Launch player application."""
         pass
 
     def send_metadata_mpris(self):
-        metadata = util._get_metadata(self.song.title) if config.LOOKUP_METADATA.get else None
+        metadata = (
+            util._get_metadata(self.song.title)
+            if config.LOOKUP_METADATA.get
+            else None
+        )
 
         if metadata is None:
             arturl = "https://i.ytimg.com/vi/%s/default.jpg" % self.song.ytid
-            metadata = (self.song.ytid, self.song.title, self.song.length,
-                        arturl, [''], '')
+            metadata = (
+                self.song.ytid,
+                self.song.title,
+                self.song.length,
+                arturl,
+                [""],
+                "",
+            )
         else:
-            arturl = metadata['album_art_url']
-            metadata = (self.song.ytid, metadata['track_title'],
-                        self.song.length, arturl,
-                        [metadata['artist']], metadata['album'])
+            arturl = metadata["album_art_url"]
+            metadata = (
+                self.song.ytid,
+                metadata["track_title"],
+                self.song.length,
+                arturl,
+                [metadata["artist"]],
+                metadata["album"],
+            )
 
         if g.mprisctl:
-            g.mprisctl.send(('metadata', metadata))
+            g.mprisctl.send(("metadata", metadata))
 
     def _playback_progress(self, idx, allsongs, repeat=False):
-        """ Generate string to show selected tracks, indicate current track. """
+        """Generate string to show selected tracks, indicate current track."""
         # pylint: disable=R0914
         # too many local variables
         cw = util.getxy().width
@@ -188,7 +219,11 @@ def _playback_progress(self, idx, allsongs, repeat=False):
         pos = 8 * " ", c.y, idx + 1, c.w, c.y, len(allsongs), c.w
         playing = "{}{}{}{} of {}{}{}\n\n".format(*pos) if multi else "\n\n"
         keys = self._help(short=(not multi and not repeat))
-        out = out if multi else content.generate_songlist_display(song=allsongs[0])
+        out = (
+            out
+            if multi
+            else content.generate_songlist_display(song=allsongs[0])
+        )
 
         if config.SHOW_PLAYER_KEYS.get and keys is not None:
             out += "\n" + keys
@@ -197,21 +232,25 @@ def _playback_progress(self, idx, allsongs, repeat=False):
             playing = "{}{}{}{} of {}{}{}\n".format(*pos) if multi else "\n"
             out += "\n" + " " * (cw - 19) if multi else ""
 
-        fmt = playing, c.r, cur[0].strip()[:cw - 19], c.w, c.w, cur[2], c.w
+        fmt = playing, c.r, cur[0].strip()[: cw - 19], c.w, c.w, cur[2], c.w
         out += "%s    %s%s%s %s[%s]%s" % fmt
         out += "    REPEAT MODE" if repeat else ""
         return out
 
     def make_status_line(self, elapsed_s, prefix, songlength=0, volume=None):
-        self._line = self._make_status_line(elapsed_s, prefix, songlength,
-                                            volume=volume)
+        # Display file format and size
+        new_prefix = "%s " % (self.songdata)
+
+        self._line = self._make_status_line(
+            elapsed_s, new_prefix, songlength, volume=volume
+        )
 
         if self._line != self._last_displayed_line:
             screen.writestatus(self._line)
             self._last_displayed_line = self._line
 
     def _make_status_line(self, elapsed_s, prefix, songlength=0, volume=None):
-        """ Format progress line output.  """
+        """Format progress line output."""
         # pylint: disable=R0914
 
         display_s = elapsed_s
@@ -228,8 +267,10 @@ def _make_status_line(self, elapsed_s, prefix, songlength=0, volume=None):
         pct = (float(elapsed_s) / songlength * 100) if songlength else 0
 
         status_line = "%02i:%02i:%02i %s" % (
-            display_h, display_m, display_s,
-            ("[%.0f%%]" % pct).ljust(6)
+            display_h,
+            display_m,
+            display_s,
+            ("[%.0f%%]" % pct).ljust(6),
         )
 
         if volume:
@@ -239,33 +280,72 @@ def _make_status_line(self, elapsed_s, prefix, songlength=0, volume=None):
             vol_suffix = ""
 
         cw = util.getxy().width
-        prog_bar_size = cw - len(prefix) - len(status_line) - len(vol_suffix) - 7
+        prog_bar_size = (
+            cw - len(prefix) - len(status_line) - len(vol_suffix) - 7
+        )
         progress = int(math.ceil(pct / 100 * prog_bar_size))
-        status_line += " [%s]" % ("=" * (progress - 1) +
-                                  ">").ljust(prog_bar_size, ' ')
+        status_line += " [%s]" % ("=" * (progress - 1) + ">").ljust(
+            prog_bar_size, " "
+        )
         return prefix + status_line + vol_suffix
 
 
 class CmdPlayer(BasePlayer):
-
     def next(self):
         if g.scrobble:
-            lastfm.scrobble_track(g.artist, g.album,
-                                  g.scrobble_queue[self.song_no])
+            lastfm.scrobble_track(
+                g.artist, g.album, g.scrobble_queue[self.song_no]
+            )
         self.terminate_process()
-        self.song_no += 1
+        if self.repeat and self.song_no == len(self.songlist) - 1:
+            self.song_no = 0
+        else:
+            self.song_no += 1
 
     def previous(self):
         if g.scrobble:
-            lastfm.scrobble_track(g.artist, g.album,
-                                  g.scrobble_queue[self.song_no])
+            lastfm.scrobble_track(
+                g.artist, g.album, g.scrobble_queue[self.song_no]
+            )
         self.terminate_process()
-        self.song_no -= 1
+        if not config.AUTOPLAY.get:
+            raise KeyboardInterrupt
+
+        if self.song_no == 0:
+            if self.repeat:
+                self.song_no = len(self.songlist) - 1
+            else:
+                pass  # Stay at track 1
+        else:
+            self.song_no -= 1
 
     def stop(self):
+        # util.dbg("player.stop() called, autoplay=%s", config.AUTOPLAY.get)
+        self.terminate_process()
+        if not config.AUTOPLAY.get:
+            raise KeyboardInterrupt
+        else:
+            if self.song_no < len(self.songlist):
+                self.song_no += 1
+
+    def mpris_next(self):
+        """Skip to next track from an explicit MPRIS command."""
+        self.terminate_process()
+        if self.repeat and self.song_no == len(self.songlist) - 1:
+            self.song_no = 0
+        else:
+            self.song_no += 1
+
+    def mpris_previous(self):
+        """Skip to previous track from an explicit MPRIS command."""
         self.terminate_process()
-        raise KeyboardInterrupt
-        #self.song_no = len(self.songlist)
+        if self.song_no == 0:
+            if self.repeat:
+                self.song_no = len(self.songlist) - 1
+            else:
+                self.song_no = 0
+        else:
+            self.song_no -= 1
 
     def terminate_process(self):
         self.p.terminate()
@@ -286,7 +366,7 @@ def _help(self, short=True):
         pass
 
     def _launch_player(self):
-        """ Launch player application. """
+        """Launch player application."""
 
         cmd = self._generate_real_playerargs()
 
@@ -302,12 +382,12 @@ def _launch_player(self):
             self.launch_player(cmd)
 
         except OSError:
-            g.message = util.F('no player') % config.PLAYER.get
+            g.message = util.F("no player") % config.PLAYER.get
             return None
 
         finally:
             if g.mprisctl:
-                g.mprisctl.send(('stop', True))
+                g.mprisctl.send(("stop", True))
 
             if self.p and self.p.poll() is None:
                 self.p.terminate()  # make sure to kill mplayer if yewtube crashes
@@ -329,20 +409,25 @@ def stream_details(song, failcount=0, override=False, softrepeat=False):
         util.dbg("--ioerror in stream_details call to streams.get %s", str(e))
 
         if "Youtube says" in str(e):
-            g.message = util.F('cant get track') % (song.title + " " + str(e))
+            g.message = util.F("cant get track") % (song.title + " " + str(e))
             return
 
         elif failcount < g.max_retries:
             util.dbg("--ioerror - trying next stream")
             failcount += 1
-            return stream_details(song, failcount=failcount, override=override, softrepeat=softrepeat)
-
-        elif "pafy" in str(e):
+            return stream_details(
+                song,
+                failcount=failcount,
+                override=override,
+                softrepeat=softrepeat,
+            )
+
+        elif "extractor" in str(e):
             g.message = str(e) + " - " + song.ytid
             return
 
     except ValueError:
-        g.message = util.F('track unresolved')
+        g.message = util.F("track unresolved")
         util.dbg("----valueerror in stream_details call to streams.get")
         return
 
@@ -350,11 +435,14 @@ def stream_details(song, failcount=0, override=False, softrepeat=False):
         raise TypeError()
 
     try:
-        video = ((config.SHOW_VIDEO.get and override != "audio") or
-                 (override in ("fullscreen", "window", "forcevid")))
+        video = (config.SHOW_VIDEO.get and override != "audio") or (
+            override in ("fullscreen", "window", "forcevid")
+        )
         m4a = "mplayer" not in config.PLAYER.get
         cached = g.streams[song.ytid]
-        stream = streams.select(cached, q=failcount, audio=(not video), m4a_ok=m4a)
+        stream = streams.select(
+            cached, q=failcount, audio=(not video), m4a_ok=m4a
+        )
 
         # handle no audio stream available, or m4a with mplayer
         # by switching to video stream and suppressing video output.
@@ -362,24 +450,44 @@ def stream_details(song, failcount=0, override=False, softrepeat=False):
             util.dbg(c.r + "no audio or mplayer m4a, using video stream" + c.w)
             override = "a-v"
             video = True
-            stream = streams.select(cached, q=failcount, audio=False, maxres=1600)
+            stream = streams.select(
+                cached, q=failcount, audio=False, maxres=1600
+            )
 
         if not stream:
-            raise IOError("No streams available")
+            # Last-resort fallback: use the first stream-like entry if present.
+            slist = cached["meta"] if isinstance(cached, dict) else cached
+            stream = next((x for x in slist if x.get("url")), None)
+            if stream:
+                util.dbg(
+                    "%sno preferred stream found; using fallback stream%s",
+                    c.y,
+                    c.w,
+                )
+                video = stream.get("mtype") != "audio"
+                if not video:
+                    override = "audio"
+            else:
+                raise IOError("No streams available")
 
         return (video, stream, override)
 
-    except (HTTPError) as e:
-
+    except HTTPError as e:
         # Fix for invalid streams (gh-65)
-        util.dbg("----htterror in stream_details call to gen_real_args %s", str(e))
+        util.dbg(
+            "----htterror in stream_details call to gen_real_args %s", str(e)
+        )
         if failcount < g.max_retries:
             failcount += 1
-            return stream_details(song, failcount=failcount,
-                                  override=override, softrepeat=softrepeat)
+            return stream_details(
+                song,
+                failcount=failcount,
+                override=override,
+                softrepeat=softrepeat,
+            )
         else:
             g.message = str(e)
-            return
+            return (None, None, None)
 
     except IOError as e:
         # this may be cause by attempting to play a https stream with
@@ -387,4 +495,4 @@ def stream_details(song, failcount=0, override=False, softrepeat=False):
         # ====
         errmsg = e.message if hasattr(e, "message") else str(e)
         g.message = c.r + str(errmsg) + c.w
-        return
+        return (None, None, None)
diff --git a/mps_youtube/players/GenericPlayer.py b/mps_youtube/players/GenericPlayer.py
index 2a14336d..788e6530 100644
--- a/mps_youtube/players/GenericPlayer.py
+++ b/mps_youtube/players/GenericPlayer.py
@@ -1,10 +1,13 @@
 import os
+import shlex
 import subprocess
 
 from .. import config
 
 from ..player import CmdPlayer
 
+mswin = os.name == "nt"
+
 #
 # This class can be used as a templete for new players
 #
@@ -19,22 +22,18 @@ def __init__(self, player):
         self.player = player
 
     def _generate_real_playerargs(self):
-        '''Generates player arguments to called using Popen
-
-        '''
-        args = config.PLAYERARGS.get.strip().split()
+        """Generates player arguments to called using Popen"""
+        args = shlex.split(config.PLAYERARGS.get.strip(), posix=not mswin)
 
         ############################################
         # Define your arguments below this line
 
         ###########################################
 
-        return [self.player] + args + [self.stream['url']]
+        return [self.player] + args + [self.stream["url"]]
 
     def clean_up(self):
-        ''' Cleans up temp files after process exits.
-
-        '''
+        """Cleans up temp files after process exits."""
         pass
 
     def launch_player(self, cmd):
@@ -52,9 +51,9 @@ def launch_player(self, cmd):
         self.next()
 
     def _help(self, short=True):
-        ''' Help keys shown when the song is played.
+        """Help keys shown when the song is played.
 
         See mpv.py for reference.
 
-        '''
+        """
         pass
diff --git a/mps_youtube/players/mplayer.py b/mps_youtube/players/mplayer.py
index 72f976b1..8f4de0a9 100644
--- a/mps_youtube/players/mplayer.py
+++ b/mps_youtube/players/mplayer.py
@@ -1,11 +1,12 @@
 import os
 import re
+import shlex
 import subprocess
 import sys
 import tempfile
 import typing as T
 
-from .. import c, config, g, paths, screen, util
+from .. import c, config, g, paths, util
 from ..player import CmdPlayer
 from ..util import not_utf8_environment
 
@@ -18,25 +19,28 @@ def __init__(self, player):
         self.mplayer_version = _get_mplayer_version(player)
 
     def _generate_real_playerargs(self):
-        """ Generate args for player command.
+        """Generate args for player command.
 
         Return args.
 
         """
 
-        if "uiressl=yes" in self.stream['url']:
+        if "uiressl=yes" in self.stream["url"]:
             ver = self.mplayer_version
             # Mplayer too old to support https
             if not (ver > (1, 1) if isinstance(ver, tuple) else ver >= 37294):
-                raise IOError("%s : Sorry mplayer doesn't support this stream. "
-                              "Use mpv or update mplayer to a newer version" % self.song.title)
+                raise IOError(
+                    "%s : Sorry mplayer doesn't support this stream. "
+                    "Use mpv or update mplayer to a newer version"
+                    % self.song.title
+                )
 
-        args = config.PLAYERARGS.get.strip().split()
+        args = shlex.split(config.PLAYERARGS.get.strip(), posix=not mswin)
 
-        pd = g.playerargs_defaults['mplayer']
+        pd = g.playerargs_defaults["mplayer"]
         args.extend((pd["title"], '"{0}"'.format(self.song.title)))
 
-        if pd['geo'] not in args:
+        if pd["geo"] not in args:
             geometry = config.WINDOW_SIZE.get or ""
 
             if config.WINDOW_POS.get:
@@ -46,18 +50,19 @@ def _generate_real_playerargs(self):
                 geometry += xx + yy
 
             if geometry:
-                args.extend((pd['geo'], geometry))
+                args.extend((pd["geo"], geometry))
 
         # handle no audio stream available
         if self.override == "a-v":
             util.list_update(pd["novid"], args)
 
-        elif ((config.FULLSCREEN.get and self.override != "window")
-                or self.override == "fullscreen"):
+        elif (
+            config.FULLSCREEN.get and self.override != "window"
+        ) or self.override == "fullscreen":
             util.list_update(pd["fs"], args)
 
         # prevent ffmpeg issue (https://github.com/mpv-player/mpv/issues/579)
-        if not self.video and self.stream['ext'] == "m4a":
+        if not self.video and self.stream["ext"] == "m4a":
             util.dbg("%susing ignidx flag%s")
             util.list_update(pd["ignidx"], args)
 
@@ -70,37 +75,50 @@ def _generate_real_playerargs(self):
         util.list_update("-cache", args)
         util.list_update("4096", args)
 
-        return [self.player] + args + [self.stream['url']]
+        return [self.player] + args + [self.stream["url"]]
 
     def clean_up(self):
-        if self.fifopath:
+        if self.fifopath and os.path.exists(self.fifopath):
             os.unlink(self.fifopath)
 
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            import shutil
+
+            shutil.rmtree(self.temp_dir)
+
     def launch_player(self, cmd):
         self.input_file = _get_input_file()
         self.sockpath = None
         self.fifopath = None
+        self.temp_dir = None
 
-        cmd.append('-input')
+        cmd.append("-input")
 
         if mswin:
             # Mplayer does not recognize path starting with drive letter,
             # or with backslashes as a delimiter.
-            self.input_file = self.input_file[2:].replace('\\', '/')
+            self.input_file = self.input_file[2:].replace("\\", "/")
 
-        cmd.append('conf=' + self.input_file)
+        cmd.append("conf=" + self.input_file)
 
         if g.mprisctl:
-            self.fifopath = tempfile.mktemp('.fifo', 'mpsyt-mplayer')
+            self.temp_dir = tempfile.mkdtemp(prefix="mpsyt-mplayer-")
+            self.fifopath = os.path.join(self.temp_dir, "mplayer.fifo")
             os.mkfifo(self.fifopath)
-            cmd.extend(['-input', 'file=' + self.fifopath])
-            g.mprisctl.send(('mplayer-fifo', self.fifopath))
-
-        self.p = subprocess.Popen(cmd, shell=False, stdout=subprocess.PIPE,
-                              stderr=subprocess.STDOUT, bufsize=0)
+            cmd.extend(["-input", "file=" + self.fifopath])
+            g.mprisctl.send(("mplayer-fifo", self.fifopath))
+
+        self.p = subprocess.Popen(
+            cmd,
+            shell=False,
+            stdin=sys.stdin,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            bufsize=0,
+        )
         self._player_status(self.songdata + "; ", self.song.length)
         returncode = self.p.wait()
-        print(returncode)
+        util.dbg("mplayer exited with code %s", returncode)
 
         if returncode == 42:
             self.previous()
@@ -108,16 +126,21 @@ def launch_player(self, cmd):
         elif returncode == 43:
             self.stop()
 
+        elif returncode == 44:
+            self.mpris_next()
+
+        elif returncode == 45:
+            self.mpris_previous()
+
         else:
             self.next()
 
     def _player_status(self, prefix, songlength=0):
-        """ Capture time progress from player output. Write status line. """
+        """Capture time progress from player output. Write status line."""
         # pylint: disable=R0914, R0912
         re_player = re.compile(r"A:\s*(?P<elapsed_s>\d+)\.\d\s*")
         re_volume = re.compile(r"Volume:\s*(?P<volume>\d+)\s*%")
-        last_displayed_line = None
-        buff = ''
+        buff = ""
         volume_level = None
         last_pos = None
 
@@ -126,8 +149,7 @@ def _player_status(self, prefix, songlength=0):
             stdstream = self.p.stdout
             char = stdstream.read(1).decode("utf-8", errors="ignore")
 
-            if char in '\r\n':
-
+            if char in "\r\n":
                 mv = re_volume.search(buff)
 
                 if mv:
@@ -136,42 +158,42 @@ def _player_status(self, prefix, songlength=0):
                 match_object = re_player.match(buff)
 
                 if match_object:
-
                     try:
                         h, m, s = map(int, match_object.groups())
                         elapsed_s = h * 3600 + m * 60 + s
 
                     except ValueError:
-
                         try:
-                            elapsed_s = int(match_object.group('elapsed_s') or
-                                            '0')
+                            elapsed_s = int(
+                                match_object.group("elapsed_s") or "0"
+                            )
 
                         except ValueError:
                             continue
 
                     if volume_level and volume_level != g.volume:
                         g.volume = volume_level
-                    self.make_status_line(elapsed_s, prefix, songlength,
-                                          volume=volume_level)
+                    self.make_status_line(
+                        elapsed_s, prefix, songlength, volume=volume_level
+                    )
 
-                if buff.startswith('ANS_volume='):
-                    volume_level = round(float(buff.split('=')[1]))
+                if buff.startswith("ANS_volume="):
+                    volume_level = round(float(buff.split("=")[1]))
 
                 paused = ("PAUSE" in buff) or ("Paused" in buff)
                 if (elapsed_s != last_pos or paused) and g.mprisctl:
                     last_pos = elapsed_s
-                    g.mprisctl.send(('pause', paused))
-                    g.mprisctl.send(('volume', volume_level))
-                    g.mprisctl.send(('time-pos', elapsed_s))
+                    g.mprisctl.send(("pause", paused))
+                    g.mprisctl.send(("volume", volume_level))
+                    g.mprisctl.send(("time-pos", elapsed_s))
 
-                buff = ''
+                buff = ""
 
             else:
                 buff += char
 
     def _help(self, short=True):
-        """ Mplayer help.  """
+        """Mplayer help."""
 
         volume = "[{0}9{1}] volume [{0}0{1}]      [{0}CTRL-C{1}] return"
         seek = "[{0}\u2190{1}] seek [{0}\u2192{1}]"
@@ -181,10 +203,10 @@ def _help(self, short=True):
             seek = "[{0}<-{1}] seek [{0}->{1}]"
             pause = "[{0}DN{1}] SEEK [{0}UP{1}]       [{0}space{1}] pause"
 
-        single = "[{0}q{1}] next"
+        single = "[{0}p{1}] prev [{0}q{1}] next"
         next_prev = "[{0}>{1}] next/prev [{0}<{1}]"
         # ret = "[{0}q{1}] %s" % ("return" if short else "next track")
-        ret = single if short and config.AUTOPLAY.get else ""
+        ret = single if short and config.AUTOPLAY.get else "[{0}q{1}] Stop"
         ret = next_prev if not short else ret
         fmt = "    %-20s       %-20s"
         lines = fmt % (seek, volume) + "\n" + fmt % (pause, ret)
@@ -192,11 +214,11 @@ def _help(self, short=True):
 
 
 def _get_input_file():
-    """ Check for existence of custom input file.
+    """Check for existence of custom input file.
 
     Return file name of temp input file with yewtube mappings included
     """
-    confpath = conf = ''
+    confpath = conf = ""
 
     confpath = os.path.join(paths.get_config_dir(), "mplayer-input.conf")
 
@@ -204,15 +226,22 @@ def _get_input_file():
         util.dbg("using %s for input key file", confpath)
 
         with open(confpath) as conffile:
-            conf = conffile.read() + '\n'
+            conf = conffile.read() + "\n"
 
     conf = conf.replace("quit", "quit 43")
     conf = conf.replace("playlist_prev", "quit 42")
     conf = conf.replace("pt_step -1", "quit 42")
     conf = conf.replace("playlist_next", "quit")
     conf = conf.replace("pt_step 1", "quit")
-    standard_cmds = ['q quit 43\n', '> quit\n', '< quit 42\n', 'NEXT quit\n',
-                     'PREV quit 42\n', 'ENTER quit\n']
+    standard_cmds = [
+        "q quit 43\n",
+        "p quit 42\n",
+        "> quit\n",
+        "< quit 42\n",
+        "NEXT quit\n",
+        "PREV quit 42\n",
+        "ENTER quit\n",
+    ]
     bound_keys = [i.split()[0] for i in conf.splitlines() if i.split()]
 
     for i in standard_cmds:
@@ -221,8 +250,9 @@ def _get_input_file():
         if key not in bound_keys:
             conf += i
 
-    with tempfile.NamedTemporaryFile('w', prefix='mpsyt-input',
-                                     delete=False) as tmpfile:
+    with tempfile.NamedTemporaryFile(
+        "w", prefix="mpsyt-input", delete=False
+    ) as tmpfile:
         tmpfile.write(conf)
         return tmpfile.name
 
@@ -247,13 +277,15 @@ def _get_mplayer_version(exename: str) -> T.Union[int, T.Tuple[int, ...]]:
     except FileNotFoundError:
         raise
 
-    m = re.search(r"MPlayer \S*?SVN[\s-]r([0-9]+)", o, re.MULTILINE | re.IGNORECASE)
+    m = re.search(
+        r"MPlayer \S*?SVN[\s-]r([0-9]+)", o, re.MULTILINE | re.IGNORECASE
+    )
 
     ver = 0
     if m:
         ver = int(m.groups()[0])
     else:
-        m = re.search('MPlayer ([0-9])+.([0-9]+)', o, re.MULTILINE)
+        m = re.search("MPlayer ([0-9])+.([0-9]+)", o, re.MULTILINE)
         if m:
             ver = tuple(int(i) for i in m.groups())
 
diff --git a/mps_youtube/players/mpv.py b/mps_youtube/players/mpv.py
index 3d427713..86437ddb 100644
--- a/mps_youtube/players/mpv.py
+++ b/mps_youtube/players/mpv.py
@@ -1,13 +1,22 @@
 import json
 import os
 import re
+import shlex
 import socket
 import subprocess
 import sys
 import tempfile
 import time
+import select
 
-from .. import c, config, g, paths, screen, util
+try:
+    import termios
+    import tty
+    has_termios = True
+except ImportError:
+    has_termios = False
+
+from .. import c, config, g, paths, util
 from ..player import CmdPlayer
 from ..util import not_utf8_environment
 
@@ -17,9 +26,22 @@
 class mpv(CmdPlayer):
     def __init__(self, player):
         self.player = player
-        self.mpv_version = _get_mpv_version(player)
-        self.mpv_options = subprocess.check_output(
-                [player, "--list-options"]).decode()
+
+        if g.mpv_version and g.mpv_version != (0, 0, 0):
+            self.mpv_version = g.mpv_version
+        else:
+            self.mpv_version = _get_mpv_version(player)
+
+        if g.mpv_options:
+            self.mpv_options = g.mpv_options
+        else:
+            try:
+                self.mpv_options = subprocess.check_output(
+                    [player, "--list-options"], timeout=5
+                ).decode()
+            except (subprocess.SubprocessError, subprocess.TimeoutExpired):
+                self.mpv_options = ""
+                util.dbg(c.r + "Failed to get mpv options (timeout or error)" + c.w)
 
         self.mpv_usesock = ""
         if not mswin:
@@ -30,22 +52,23 @@ def __init__(self, player):
                 self.mpv_usesock = "--input-ipc-server"
                 util.dbg(c.g + "mpv supports --input-ipc-server" + c.w)
 
+
     def _generate_real_playerargs(self):
-        """ Generate args for player command.
+        """Generate args for player command.
 
         Return args.
 
         """
 
-        args = config.PLAYERARGS.get.strip().split()
+        args = shlex.split(config.PLAYERARGS.get.strip(), posix=not mswin)
 
-        pd = g.playerargs_defaults['mpv']
+        pd = g.playerargs_defaults["mpv"]
         # Use new mpv syntax
         # https://github.com/mps-youtube/mps-youtube/issues/1052
-        completetitle = '='.join((pd["title"], '"{0}"'.format(self.song.title)))
+        completetitle = "=".join((pd["title"], self.song.title))
         util.list_update(completetitle, args)
 
-        if pd['geo'] not in args:
+        if pd["geo"] not in args:
             geometry = config.WINDOW_SIZE.get or ""
 
             if config.WINDOW_POS.get:
@@ -57,19 +80,16 @@ def _generate_real_playerargs(self):
             if geometry:
                 # Use new mpv syntax
                 # See: https://github.com/mps-youtube/mps-youtube/issues/1052
-                newgeometry = '='.join((pd['geo'], geometry))
+                newgeometry = "=".join((pd["geo"], geometry))
                 util.list_update(newgeometry, args)
 
-        # handle no audio stream available
-        if self.override == "a-v":
-            util.list_update(pd["novid"], args)
-
-        elif ((config.FULLSCREEN.get and self.override != "window")
-                or self.override == "fullscreen"):
+        if (
+            config.FULLSCREEN.get and self.override != "window"
+        ) or self.override == "fullscreen":
             util.list_update(pd["fs"], args)
 
         # prevent ffmpeg issue (https://github.com/mpv-player/mpv/issues/579)
-        if not self.video and self.stream['ext'] == "m4a":
+        if not self.video and self.stream["ext"] == "m4a":
             util.dbg("%susing ignidx flag%s")
             util.list_update(pd["ignidx"], args)
 
@@ -78,7 +98,7 @@ def _generate_real_playerargs(self):
 
         msglevel = pd["msglevel"]["<0.4"]
 
-        #  undetected (negative) version number assumed up-to-date
+        # undetected (negative) version number assumed up-to-date
         if self.mpv_version[0:2] < (0, 0) or self.mpv_version[0:2] >= (0, 4):
             msglevel = pd["msglevel"][">=0.4"]
 
@@ -94,11 +114,16 @@ def _generate_real_playerargs(self):
         if self.softrepeat:
             util.list_update("--loop-file", args)
 
-        if not config.SHOW_VIDEO.get:
-            util.list_update('--no-video', args)
-            util.list_update('--vid=no', args)
+        # Additional user-defined CLI arguments
+        for arg in shlex.split(
+            config.AUX_MPV_CLI_CONFIG.get.strip(), posix=not mswin
+        ):
+            util.list_update(arg, args)
+
+        if not config.SHOW_VIDEO.get or self.override == "a-v":
+            util.list_update("--no-video", args)
 
-        return [self.player] + args + [self.stream['url']]
+        return [self.player] + args + [self.stream["url"]]
 
     def clean_up(self):
         if self.input_file:
@@ -107,39 +132,92 @@ def clean_up(self):
         if self.sockpath and os.path.exists(self.sockpath):
             os.unlink(self.sockpath)
 
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            import shutil
+
+            shutil.rmtree(self.temp_dir)
+
         if self.fifopath and os.path.exists(self.fifopath):
             os.unlink(self.fifopath)
 
     def launch_player(self, cmd):
         self.input_file = _get_input_file()
-        cmd.append('--input-conf=' + self.input_file)
+        cmd.append("--input-conf=" + self.input_file)
         self.conf_dir = _get_conf_dir()
         if self.conf_dir is not None:
-            cmd.append('--config-dir=' + self.conf_dir)
+            cmd.append("--config-dir=" + self.conf_dir)
         self.sockpath = None
         self.fifopath = None
+        self.temp_dir = None
+        self.error_log = []
 
-        if self.mpv_usesock:
-            self.sockpath = tempfile.mktemp('.sock', 'mpsyt-mpv')
-            cmd.append(self.mpv_usesock + '=' + self.sockpath)
+        def capture_stderr(pipe):
+            for line in pipe:
+                line = line.decode("utf-8", errors="ignore").strip()
+                if line:
+                    self.error_log.append(line)
 
-            with open(os.devnull, "w") as devnull:
-                self.p = subprocess.Popen(cmd, shell=False, stderr=devnull)
+        if self.mpv_usesock:
+            self.temp_dir = tempfile.mkdtemp(prefix="mpsyt-mpv-")
+            self.sockpath = os.path.join(self.temp_dir, "mpv.sock")
+            cmd.append(self.mpv_usesock + "=" + self.sockpath)
+            util.dbg("launching mpv with socket: %s", " ".join(cmd))
+            self.p = subprocess.Popen(
+                cmd,
+                shell=False,
+                stdin=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                bufsize=0,
+            )
+
+            import threading
+
+            t = threading.Thread(target=capture_stderr, args=(self.p.stderr,))
+            t.daemon = True
+            t.start()
 
             if g.mprisctl:
-                g.mprisctl.send(('socket', self.sockpath))
+                g.mprisctl.send(("socket", self.sockpath))
         else:
             if g.mprisctl:
-                self.fifopath = tempfile.mktemp('.fifo', 'mpsyt-mpv')
+                self.fifopath = tempfile.mktemp(".fifo", "mpsyt-mpv")
                 os.mkfifo(self.fifopath)
-                cmd.append('--input-file=' + self.fifopath)
-                g.mprisctl.send(('mpv-fifo', self.fifopath))
-
-            self.p = subprocess.Popen(cmd, shell=False, stderr=subprocess.PIPE,
-                                      bufsize=0)
+                cmd.append("--input-file=" + self.fifopath)
+                g.mprisctl.send(("mpv-fifo", self.fifopath))
+
+            self.p = subprocess.Popen(
+                cmd,
+                shell=False,
+                stdin=sys.stdin,
+                stderr=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                bufsize=0,
+            )
 
         self._player_status(self.songdata + "; ", self.song.length)
         returncode = self.p.wait()
+        util.dbg("mpv exited with code %s", returncode)
+
+        if returncode != 0 and returncode not in (42, 43):
+            # Try to find meaningful error messages
+            interesting = [
+                l
+                for l in self.error_log
+                if "Error" in l or "failed" in l or "[ffmpeg]" in l
+            ]
+            util.dbg(
+                "Captured %s log lines, %s interesting",
+                len(self.error_log),
+                len(interesting),
+            )
+            if not interesting:
+                interesting = self.error_log[-5:]
+
+            if interesting:
+                g.message = (
+                    f"{c.r}mpv error ({returncode}): {interesting[0]}{c.w}"
+                )
 
         if returncode == 42:
             self.previous()
@@ -147,16 +225,21 @@ def launch_player(self, cmd):
         elif returncode == 43:
             self.stop()
 
+        elif returncode == 44:
+            self.mpris_next()
+
+        elif returncode == 45:
+            self.mpris_previous()
+
         else:
             self.next()
 
     def _player_status(self, prefix, songlength=0):
-        """ Capture time progress from player output. Write status line. """
+        """Capture time progress from player output. Write status line."""
         # pylint: disable=R0914, R0912
         re_player = re.compile(r".{,15}AV?:\s*(\d\d):(\d\d):(\d\d)")
         re_volume = re.compile(r"Volume:\s*(?P<volume>\d+)\s*%")
-        last_displayed_line = None
-        buff = ''
+        buff = ""
         volume_level = None
         last_pos = None
 
@@ -165,7 +248,7 @@ def _player_status(self, prefix, songlength=0):
 
             tries = 0
             while tries < 10 and self.p.poll() is None:
-                time.sleep(.5)
+                time.sleep(0.5)
                 try:
                     s.connect(self.sockpath)
                     break
@@ -173,92 +256,169 @@ def _player_status(self, prefix, songlength=0):
                     pass
                 tries += 1
             else:
+                if self.p.poll() is not None:
+                    g.message = (
+                        c.r
+                        + "mpv failed to start. Check stderr for details."
+                        + c.w
+                    )
                 return
 
             try:
                 observe_full = False
                 cmd = {"command": ["observe_property", 1, "time-pos"]}
-                s.send(json.dumps(cmd).encode() + b'\n')
+                s.send(json.dumps(cmd).encode() + b"\n")
                 volume_level = elapsed_s = None
 
-                for line in s.makefile():
-                    resp = json.loads(line)
-
-                    # deals with bug in mpv 0.7 - 0.7.3
-                    if resp.get('event') == 'property-change' and not observe_full:
-                        cmd = {"command": ["observe_property", 2, "volume"]}
-                        s.send(json.dumps(cmd).encode() + b'\n')
-                        observe_full = True
+                fd = sys.stdin.fileno()
+                is_tty = os.isatty(fd)
+                old_settings = termios.tcgetattr(fd) if is_tty and has_termios else None
 
-                    if resp.get('event') == 'property-change' and resp['id'] == 1:
-                        if resp.get('data') is not None:
-                            elapsed_s = int(resp['data'])
-
-                    elif resp.get('event') == 'property-change' and resp['id'] == 2:
-                        volume_level = int(resp['data'])
-
-                    if(volume_level and volume_level != g.volume):
-                        g.volume = volume_level
-                    if elapsed_s:
-                        self.make_status_line(elapsed_s, prefix, songlength,
-                                              volume=volume_level)
-
-            except socket.error:
-                pass
+                try:
+                    if old_settings:
+                        tty.setcbreak(fd)
+
+                    sock_file = s.makefile()
+                    while self.p.poll() is None:
+                        inputs = [s]
+                        if is_tty:
+                            inputs.append(sys.stdin)
+
+                        r, _, _ = select.select(inputs, [], [], 0.1)
+
+                        if s in r:
+                            line = sock_file.readline()
+                            if not line:
+                                break
+                            resp = json.loads(line)
+
+                            if (
+                                resp.get("event") == "property-change"
+                                and not observe_full
+                            ):
+                                cmd = {"command": ["observe_property", 2, "volume"]}
+                                s.send(json.dumps(cmd).encode() + b"\n")
+                                observe_full = True
+
+                            if (
+                                resp.get("event") == "property-change"
+                                and resp["id"] == 1
+                            ):
+                                if resp.get("data") is not None:
+                                    elapsed_s = int(resp["data"])
+
+                            elif (
+                                resp.get("event") == "property-change"
+                                and resp["id"] == 2
+                            ):
+                                volume_level = int(resp["data"])
+
+                            if volume_level and volume_level != g.volume:
+                                g.volume = volume_level
+                            if elapsed_s:
+                                self.make_status_line(
+                                    elapsed_s, prefix, songlength, volume=volume_level
+                                )
+
+                        if is_tty and sys.stdin in r:
+                            key = sys.stdin.read(1)
+                            if key == '\x1b':  # Start of escape sequence
+                                # Set a short timeout to read the rest of the sequence
+                                r_esc, _, _ = select.select([sys.stdin], [], [], 0.05)
+                                if r_esc:
+                                    key += sys.stdin.read(1)
+                                    if key.endswith('['):
+                                        r_esc, _, _ = select.select([sys.stdin], [], [], 0.05)
+                                        if r_esc:
+                                            key += sys.stdin.read(1)
+
+                            if key == ' ':
+                                cmd = {"command": ["cycle", "pause"]}
+                                s.send(json.dumps(cmd).encode() + b"\n")
+                            elif key in ('q', 'Q'):
+                                self.p.terminate()
+                                break
+                            elif key == '\x1b[A':  # Up
+                                cmd = {"command": ["seek", 60]}
+                                s.send(json.dumps(cmd).encode() + b"\n")
+                            elif key == '\x1b[B':  # Down
+                                cmd = {"command": ["seek", -60]}
+                                s.send(json.dumps(cmd).encode() + b"\n")
+                            elif key == '\x1b[C':  # Right
+                                cmd = {"command": ["seek", 5]}
+                                s.send(json.dumps(cmd).encode() + b"\n")
+                            elif key == '\x1b[D':  # Left
+                                cmd = {"command": ["seek", -5]}
+                                s.send(json.dumps(cmd).encode() + b"\n")
+                            elif key in ('9', '('):
+                                cmd = {"command": ["add", "volume", -2]}
+                                s.send(json.dumps(cmd).encode() + b"\n")
+                            elif key in ('0', ')'):
+                                cmd = {"command": ["add", "volume", 2]}
+                                s.send(json.dumps(cmd).encode() + b"\n")
+
+                finally:
+                    if old_settings:
+                        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+            except (socket.error, json.JSONDecodeError) as e:
+                util.dbg("IPC communication error: %s", e)
 
         else:
             elapsed_s = 0
 
-            while self.p.poll() is None:
-                stdstream = self.p.stderr
-                char = stdstream.read(1).decode("utf-8", errors="ignore")
-
-                if char in '\r\n':
-
-                    mv = re_volume.search(buff)
-
-                    if mv:
-                        volume_level = int(mv.group("volume"))
-
-                    match_object = re_player.match(buff)
-
-                    if match_object:
+            # Use a buffered reader to handle lines efficiently
+            for line_bytes in self.p.stderr:
+                line = line_bytes.decode("utf-8", errors="ignore")
+                for char in line:
+                    if char in "\r\n":
+                        mv = re_volume.search(buff)
+                        if mv:
+                            volume_level = int(mv.group("volume"))
 
-                        try:
-                            h, m, s = map(int, match_object.groups())
-                            elapsed_s = h * 3600 + m * 60 + s
-
-                        except ValueError:
+                        match_object = re_player.match(buff)
 
+                        if match_object:
                             try:
-                                elapsed_s = int(match_object.group('elapsed_s')
-                                                or '0')
+                                h, m, s = map(int, match_object.groups())
+                                elapsed_s = h * 3600 + m * 60 + s
 
                             except ValueError:
-                                continue
-
-                        if volume_level and volume_level != g.volume:
-                            g.volume = volume_level
-                        self.make_status_line(elapsed_s, prefix, songlength,
-                                              volume=volume_level)
-
-                    if buff.startswith('ANS_volume='):
-                        volume_level = round(float(buff.split('=')[1]))
-
-                    paused = ("PAUSE" in buff) or ("Paused" in buff)
-                    if (elapsed_s != last_pos or paused) and g.mprisctl:
-                        last_pos = elapsed_s
-                        g.mprisctl.send(('pause', paused))
-                        g.mprisctl.send(('volume', volume_level))
-                        g.mprisctl.send(('time-pos', elapsed_s))
-
-                    buff = ''
-
-                else:
-                    buff += char
+                                try:
+                                    elapsed_s = int(
+                                        match_object.group("elapsed_s") or "0"
+                                    )
+
+                                except ValueError:
+                                    continue
+
+                            if volume_level and volume_level != g.volume:
+                                g.volume = volume_level
+                            self.make_status_line(
+                                elapsed_s, prefix, songlength, volume=volume_level
+                            )
+
+                        else:
+                            # Collect potentially interesting error/status lines
+                            if buff.strip() and not buff.startswith("AV:"):
+                                self.error_log.append(buff.strip())
+
+                        if buff.startswith("ANS_volume="):
+                            volume_level = round(float(buff.split("=")[1]))
+
+                        paused = ("PAUSE" in buff) or ("Paused" in buff)
+                        if (elapsed_s != last_pos or paused) and g.mprisctl:
+                            last_pos = elapsed_s
+                            g.mprisctl.send(("pause", paused))
+                            g.mprisctl.send(("volume", volume_level))
+                            g.mprisctl.send(("time-pos", elapsed_s))
+
+                        buff = ""
+                    else:
+                        buff += char
 
     def _help(self, short=True):
-        """ Mplayer help.  """
+        """Mplayer help."""
 
         volume = "[{0}9{1}] volume [{0}0{1}]      [{0}CTRL-C{1}] return"
         seek = "[{0}\u2190{1}] seek [{0}\u2192{1}]"
@@ -268,10 +428,13 @@ def _help(self, short=True):
             seek = "[{0}<-{1}] seek [{0}->{1}]"
             pause = "[{0}DN{1}] SEEK [{0}UP{1}]       [{0}space{1}] pause"
 
-        single = "[{0}q{1}] next"
+        single = "[{0}q{1}] Stop"
+        if config.AUTOPLAY.get:
+            single = "[{0}p{1}] prev [{0}q{1}] next"
+
         next_prev = "[{0}>{1}] next/prev [{0}<{1}]"
         # ret = "[{0}q{1}] %s" % ("return" if short else "next track")
-        ret = single if short and config.AUTOPLAY.get else ""
+        ret = single if short else ""
         ret = next_prev if not short else ret
         fmt = "    %-20s       %-20s"
         lines = fmt % (seek, volume) + "\n" + fmt % (pause, ret)
@@ -279,11 +442,11 @@ def _help(self, short=True):
 
 
 def _get_input_file():
-    """ Check for existence of custom input file.
+    """Check for existence of custom input file.
 
     Return file name of temp input file with yewtube mappings included
     """
-    confpath = conf = ''
+    confpath = conf = ""
 
     confpath = os.path.join(paths.get_config_dir(), "mpv-input.conf")
 
@@ -291,15 +454,28 @@ def _get_input_file():
         util.dbg("using %s for input key file", confpath)
 
         with open(confpath) as conffile:
-            conf = conffile.read() + '\n'
+            conf = conffile.read() + "\n"
 
     conf = conf.replace("quit", "quit 43")
     conf = conf.replace("playlist_prev", "quit 42")
     conf = conf.replace("pt_step -1", "quit 42")
     conf = conf.replace("playlist_next", "quit")
     conf = conf.replace("pt_step 1", "quit")
-    standard_cmds = ['q quit 43\n', '> quit\n', '< quit 42\n', 'NEXT quit\n',
-                     'PREV quit 42\n', 'ENTER quit\n', 'Q quit-watch-later']
+    standard_cmds = [
+        "SPACE cycle pause\n",
+        "RIGHT seek 5\n",
+        "LEFT seek -5\n",
+        "UP seek 60\n",
+        "DOWN seek -60\n",
+        "q quit 43\n",
+        "p quit 42\n",
+        "> quit\n",
+        "< quit 42\n",
+        "NEXT quit\n",
+        "PREV quit 42\n",
+        "ENTER quit\n",
+        "Q quit-watch-later",
+    ]
     bound_keys = [i.split()[0] for i in conf.splitlines() if i.split()]
 
     for i in standard_cmds:
@@ -308,11 +484,13 @@ def _get_input_file():
         if key not in bound_keys:
             conf += i
 
-    with tempfile.NamedTemporaryFile('w', prefix='mpsyt-input',
-                                     delete=False) as tmpfile:
+    with tempfile.NamedTemporaryFile(
+        "w", prefix="mpsyt-input", delete=False
+    ) as tmpfile:
         tmpfile.write(conf)
         return tmpfile.name
 
+
 def _get_conf_dir():
     """
     Check if an mpv configuration directory is present in the
@@ -326,12 +504,12 @@ def _get_conf_dir():
 
 
 def _get_mpv_version(exename):
-    """ Get version of mpv as 3-tuple. """
+    """Get version of mpv as 3-tuple."""
     o = subprocess.check_output([exename, "--version"]).decode()
     re_ver = re.compile(r"mpv (\d+)\.(\d+)\.(\d+)")
 
     for line in o.split("\n"):
-        m = re_ver.match(line)
+        m = re_ver.search(line)
 
         if m:
             v = tuple(map(int, m.groups()))
diff --git a/mps_youtube/players/vlc.py b/mps_youtube/players/vlc.py
index 20e97d42..2a89162e 100644
--- a/mps_youtube/players/vlc.py
+++ b/mps_youtube/players/vlc.py
@@ -1,51 +1,159 @@
 import os
+import re
+import shlex
+import shutil
+import socket
 import subprocess
+import tempfile
+import time
 
-from .. import config, g, util
+from .. import c, config, g, util
 from ..player import CmdPlayer
 
+mswin = os.name == "nt"
+
 
 class vlc(CmdPlayer):
     def __init__(self, player):
         self.player = player
+        self.rc_sockpath = None
+        self.rc_temp_dir = None
 
     def _generate_real_playerargs(self):
-        args = config.PLAYERARGS.get.strip().split()
+        args = shlex.split(config.PLAYERARGS.get.strip(), posix=not mswin)
 
-        pd = g.playerargs_defaults['vlc']
+        pd = g.playerargs_defaults["vlc"]
         args.extend((pd["title"], '"{0}"'.format(self.song.title)))
 
         if config.VLC_DUMMY_INTERFACE.get:
-            print('[VLC DUMMY INTERFACE] Playing "{0}" ...'.format(self.song.title))
-            args.extend(('-I', 'dummy')) # vlc without gui
+            print(
+                '[VLC DUMMY INTERFACE] Playing "{0}" ...'.format(
+                    self.song.title
+                )
+            )
+            args.extend(("-I", "dummy"))  # vlc without gui
         if not config.SHOW_VIDEO.get:
             args.extend(("--no-video",))
 
         if self.subtitle_path:
-            args.extend(('--sub-file', self.subtitle_path))
+            args.extend(("--sub-file", self.subtitle_path))
 
         util.list_update("--play-and-exit", args)
 
-        return [self.player] + args + [self.stream['url']]
+        return [self.player] + args + [self.stream["url"]]
 
     def clean_up(self):
         self._kill_instance()
+        if self.rc_sockpath and os.path.exists(self.rc_sockpath):
+            os.unlink(self.rc_sockpath)
+        self.rc_sockpath = None
+
+        if self.rc_temp_dir and os.path.exists(self.rc_temp_dir):
+            shutil.rmtree(self.rc_temp_dir, ignore_errors=True)
+        self.rc_temp_dir = None
 
     def launch_player(self, cmd):
+        if not mswin:
+            self.rc_temp_dir = tempfile.mkdtemp(prefix="mpsyt-vlc-")
+            self.rc_sockpath = os.path.join(self.rc_temp_dir, "vlc.sock")
+            cmd.extend(
+                [
+                    "--extraintf",
+                    "oldrc",
+                    "--rc-unix",
+                    self.rc_sockpath,
+                    "--rc-fake-tty",
+                ]
+            )
+
         with open(os.devnull, "w") as devnull:
             self.p = subprocess.Popen(cmd, shell=False, stderr=devnull)
+        self._player_status(self.songdata + "; ", self.song.length)
         self.p.wait()
         self.next()
 
     def _help(self, short=True):
-        pass
+        return (
+            "    [{0}CTRL-C{1}] return "
+            "(Use VLC controls in player window)"
+        ).format(c.g, c.w)
+
+    def _player_status(self, prefix, songlength=0):
+        """Track VLC progress using RC socket, fallback to coarse timer."""
+        if self._player_status_via_socket(prefix, songlength):
+            return
+
+        start = time.time()
+        while self.p.poll() is None:
+            elapsed_s = int(max(0, time.time() - start))
+            self.make_status_line(elapsed_s, prefix, songlength)
+            time.sleep(1)
+
+    def _query_rc_int(self, rc_sock, command):
+        """Send an RC command and parse an integer response if available."""
+        rc_sock.sendall((command + "\n").encode())
+        chunks = []
+        deadline = time.time() + 0.4
+
+        while time.time() < deadline:
+            try:
+                chunk = rc_sock.recv(4096)
+            except socket.timeout:
+                break
+            if not chunk:
+                break
+            chunks.append(chunk.decode(errors="ignore"))
+            if "\n" in chunks[-1]:
+                break
+
+        response = "".join(chunks)
+        for line in response.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            if line.isdigit():
+                return int(line)
+            match = re.search(r"(-?\d+)$", line)
+            if match:
+                return int(match.group(1))
+        return None
+
+    def _player_status_via_socket(self, prefix, songlength=0):
+        """Read current position from VLC oldrc Unix socket."""
+        if mswin or not self.rc_sockpath:
+            return False
+
+        for _ in range(20):
+            if self.p.poll() is not None:
+                return False
+            if os.path.exists(self.rc_sockpath):
+                break
+            time.sleep(0.1)
+        else:
+            return False
+
+        rc_sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        rc_sock.settimeout(0.2)
+        try:
+            rc_sock.connect(self.rc_sockpath)
+            known_length = songlength
+            while self.p.poll() is None:
+                if not known_length:
+                    reported_length = self._query_rc_int(rc_sock, "get_length")
+                    if reported_length and reported_length > 0:
+                        known_length = reported_length
+
+                elapsed_s = self._query_rc_int(rc_sock, "get_time")
+                if elapsed_s is not None and elapsed_s >= 0:
+                    self.make_status_line(elapsed_s, prefix, known_length)
+                time.sleep(1)
+            return True
+        except OSError as err:
+            util.dbg("VLC RC socket unavailable, using fallback status: %s", err)
+            return False
+        finally:
+            rc_sock.close()
 
     def _kill_instance(self):
-        import os
-        from sys import platform
-        if platform == "linux" or platform == "linux2":
-            os.system('pkill -f vlc')
-        elif platform == "darwin":
-            os.system('killall vlc')
-        elif platform == "win32":
-            os.system('taskkill /im vlc.exe /f') # https://stackoverflow.com/questions/49988/really-killing-a-process-in-windows
+        if self.p and self.p.poll() is None:
+            self.p.terminate()
diff --git a/mps_youtube/playlist.py b/mps_youtube/playlist.py
index 613b631f..731383f7 100644
--- a/mps_youtube/playlist.py
+++ b/mps_youtube/playlist.py
@@ -1,14 +1,13 @@
 class Playlist:
-
-    """ Representation of a playist, has list of songs. """
+    """Representation of a playist, has list of songs."""
 
     def __init__(self, name=None, songs=None):
-        """ class members. """
+        """class members."""
         self.name = name
         self.songs = songs or []
 
     def __len__(self):
-        """ Return number of tracks. """
+        """Return number of tracks."""
         return len(self.songs)
 
     def __getitem__(self, sliced):
@@ -23,20 +22,21 @@ def __iter__(self):
 
     @property
     def duration(self):
-        """ Sum duration of the playlist. """
+        """Sum duration of the playlist."""
         duration = sum(s.length for s in self.songs)
         mins, secs = divmod(duration, 60)
         hours, mins = divmod(mins, 60)
-        duration = '{H:02}:{M:02}:{S:02}'.format(H=hours, M=mins, S=secs)
+        duration = "{H:02}:{M:02}:{S:02}".format(H=hours, M=mins, S=secs)
         return duration
 
 
 class Video:
+    """Class to represent a YouTube video."""
 
-    """ Class to represent a YouTube video. """
     description = ""
+
     def __init__(self, ytid, title, length):
-        """ class members. """
+        """class members."""
         self.ytid = ytid
         self.title = title
         self.length = int(length)
diff --git a/mps_youtube/playlists.py b/mps_youtube/playlists.py
index 57b93292..20360afd 100644
--- a/mps_youtube/playlists.py
+++ b/mps_youtube/playlists.py
@@ -2,29 +2,31 @@
 import sys
 import pickle
 
-from . import g, c, screen, util, pafy
+from . import g, c, screen, util, extractor
 from .playlist import Playlist, Video
 
 
 def save():
-    """ Save playlists.  Called each time a playlist is saved or deleted. """
+    """Save playlists.  Called each time a playlist is saved or deleted."""
     for pl in g.userpl:
-        with open(os.path.join(g.PLFOLDER, pl+'.m3u'), 'w') as plf:
-            plf.write('#EXTM3U\n\n')
+        with open(os.path.join(g.PLFOLDER, pl + ".m3u"), "w") as plf:
+            plf.write("#EXTM3U\n\n")
             for song in g.userpl[pl].songs:
-                plf.write('#EXTINF:%d,%s\n' % (song.length, song.title))
-                plf.write('https://www.youtube.com/watch?v=%s\n' % song.ytid)
+                plf.write("#EXTINF:%d,%s\n" % (song.length, song.title))
+                plf.write("https://www.youtube.com/watch?v=%s\n" % song.ytid)
 
     util.dbg(c.r + "Playlist saved\n---" + c.w)
 
 
 def load():
-    """ Open playlists. Called once on script invocation. """
+    """Open playlists. Called once on script invocation."""
     _convert_playlist_to_v2()
     _convert_playlist_to_m3u()
     try:
         # Loop through all files ending in '.m3u'
-        for m3u in [m3u for m3u in os.listdir(g.PLFOLDER) if m3u[-4:] == '.m3u']:
+        for m3u in [
+            m3u for m3u in os.listdir(g.PLFOLDER) if m3u[-4:] == ".m3u"
+        ]:
             g.userpl[m3u[:-4]] = read_m3u(os.path.join(g.PLFOLDER, m3u))
 
     except FileNotFoundError:
@@ -51,27 +53,33 @@ def load():
 
 
 def delete(name):
-    """ Delete playlist, including m3u file. """
+    """Delete playlist, including m3u file."""
     del g.userpl[name]
-    os.remove(os.path.join(g.PLFOLDER, name + '.m3u'))
-    
+    os.remove(os.path.join(g.PLFOLDER, name + ".m3u"))
+
 
 def read_m3u(m3u):
-    """ Processes an m3u file into a Playlist object. """
+    """Processes an m3u file into a Playlist object."""
     name = os.path.basename(m3u)[:-4]
     songs = []
     expect_ytid = False
 
-    with open(m3u, 'r') as plf:
-        if plf.readline().startswith('#EXTM3U'):
+    with open(m3u, "r") as plf:
+        if plf.readline().startswith("#EXTM3U"):
             for line in plf:
-                if line.startswith('#EXTINF:') and not expect_ytid:
-                    duration, title = line.replace('#EXTINF:', '').strip().split(',', 1)
+                if line.startswith("#EXTINF:") and not expect_ytid:
+                    duration, title = (
+                        line.replace("#EXTINF:", "").strip().split(",", 1)
+                    )
                     expect_ytid = True
-                elif not line.startswith('\n') and not line.startswith('#') and expect_ytid:
+                elif (
+                    not line.startswith("\n")
+                    and not line.startswith("#")
+                    and expect_ytid
+                ):
                     try:
                         expect_ytid = False
-                        ytid = pafy.extract_video_id(line).strip()
+                        ytid = extractor.extract_video_id(line).strip()
                         songs.append(Video(ytid, title, int(duration)))
                     except ValueError as ex:
                         util.dbg(c.r + str(ex) + c.w)
@@ -79,10 +87,10 @@ def read_m3u(m3u):
         else:
             plf.seek(0)
             for line in plf:
-                if not line.startswith('#'):
+                if not line.startswith("#"):
                     try:
-                        p = util.get_pafy(line)
-                        songs.append(Video(p.videoid, p.title, p.length))
+                        p = util.get_metadata(line)
+                        songs.append(Video(p.ytid, p.title, p.length))
                     except (IOError, ValueError) as e:
                         util.dbg(c.r + "Error loading video: " + str(e) + c.w)
 
@@ -90,7 +98,7 @@ def read_m3u(m3u):
 
 
 def _convert_playlist_to_v2():
-    """ Convert previous playlist file to v2 playlist. """
+    """Convert previous playlist file to v2 playlist."""
     # skip if previously done
     if os.path.isfile(g.PLFILE):
         return
@@ -116,11 +124,10 @@ def _convert_playlist_to_v2():
 
     # do the conversion
     for plname, plitem in old_playlists.items():
-
         songs = []
 
         for video in plitem.songs:
-            v = Video(video['link'], video['title'], video['duration'])
+            v = Video(video["link"], video["title"], video["duration"])
             songs.append(v)
 
         g.userpl[plname] = Playlist(plname, songs)
@@ -131,8 +138,8 @@ def _convert_playlist_to_v2():
 
 
 def _convert_playlist_to_m3u():
-    """ Convert playlist_v2 file to the m3u format. 
-        This should create a .m3u playlist for each playlist in playlist_v2. """
+    """Convert playlist_v2 file to the m3u format.
+    This should create a .m3u playlist for each playlist in playlist_v2."""
     # Skip if playlists folder exists
     if os.path.isdir(g.PLFOLDER):
         return
@@ -141,18 +148,20 @@ def _convert_playlist_to_m3u():
     elif not os.path.isfile(g.PLFILE):
         return
 
-    try: 
-        with open(g.PLFILE, 'rb') as plf:
+    try:
+        with open(g.PLFILE, "rb") as plf:
             old_playlists = pickle.load(plf)
 
     except AttributeError:
         # playlist is from a time when this module was __main__
         # https://github.com/np1/mps-youtube/issues/214
         import __main__
+
         __main__.Playlist = Playlist
         __main__.Video = Video
 
         from . import main
+
         main.Playlist = Playlist
         main.Video = Video
 
diff --git a/mps_youtube/screen.py b/mps_youtube/screen.py
index 0f724de6..07e53ff7 100644
--- a/mps_youtube/screen.py
+++ b/mps_youtube/screen.py
@@ -9,7 +9,7 @@
 
 
 def update(fill_blank=True):
-    """ Display content, show message, blank screen."""
+    """Display content, show message, blank screen."""
     clear()
 
     if isinstance(g.content, content.PaginatedContent):
@@ -20,9 +20,9 @@ def update(fill_blank=True):
         g.content = False
 
     if g.message or g.rprompt:
-        out = g.message or ''
-        blanks = util.getxy().width - len(out) - len(g.rprompt or '')
-        out += ' ' * blanks + (g.rprompt or '')
+        out = g.message or ""
+        blanks = util.getxy().width - len(out) - len(g.rprompt or "")
+        out += " " * blanks + (g.rprompt or "")
         util.xprint(out)
 
     elif fill_blank:
@@ -34,37 +34,37 @@ def update(fill_blank=True):
 def clear():
     """Clear all text from screen."""
     if g.no_clear_screen:
-        util.xprint('--\n')
+        util.xprint("--\n")
     else:
-        util.xprint('\n' * 200)
+        util.xprint("\n" * 200)
 
 
 def reset_terminal():
-    """ Reset terminal control character and modes for non Win OS's. """
+    """Reset terminal control character and modes for non Win OS's."""
     if not mswin:
         subprocess.call(["tset", "-c"])
 
 
 def writestatus(text, mute=False):
-    """ Update status line. """
+    """Update status line."""
     if not mute and config.SHOW_STATUS.get:
         _writeline(text)
 
 
 def _writeline(text):
-    """ Print text on same line. """
+    """Print text on same line."""
     width = util.getxy().width
     spaces = width - len(text) - 1
     if mswin:
         # Avoids creating new line every time it is run
         # TODO: Figure out why this is needed
-        spaces =- 1
-    text = text[:width - 3]
+        spaces = -1
+    text = text[: width - 3]
     sys.stdout.write(" " + text + (" " * spaces) + "\r")
     sys.stdout.flush()
 
 
 def msgexit(msg, code=0):
-    """ Print a message and exit. """
+    """Print a message and exit."""
     util.xprint(msg)
     sys.exit(code)
diff --git a/mps_youtube/streams.py b/mps_youtube/streams.py
index 8062b25b..00b1a7ac 100644
--- a/mps_youtube/streams.py
+++ b/mps_youtube/streams.py
@@ -1,14 +1,14 @@
 import time
 import threading
 from urllib.request import urlopen
-from . import pafy
+from . import extractor
 from . import g, c, screen, config, util
 
 
 def prune():
-    """ Keep cache size in check. """
-    while len(g.pafs) > g.max_cached_streams:
-        g.pafs.popitem(last=False)
+    """Keep cache size in check."""
+    while len(g.metadata_cache) > g.max_cached_streams:
+        g.metadata_cache.popitem(last=False)
 
     while len(g.streams) > g.max_cached_streams:
         g.streams.popitem(last=False)
@@ -16,15 +16,23 @@ def prune():
     # prune time expired items
 
     now = time.time()
-    oldpafs = [k for k in g.pafs if g.pafs[k] is not None and g.pafs[k].expiry < now]
+    old_metadata = [
+        k
+        for k in g.metadata_cache
+        if g.metadata_cache[k] is not None and g.metadata_cache[k].expiry < now
+    ]
 
-    if len(oldpafs):
-        util.dbg(c.r + "%s old pafy items pruned%s", len(oldpafs), c.w)
+    if len(old_metadata):
+        util.dbg(c.r + "%s old extractor items pruned%s", len(old_metadata), c.w)
 
-    for oldpaf in oldpafs:
-        g.pafs.pop(oldpaf, 0)
+    for old_entry in old_metadata:
+        g.metadata_cache.pop(old_entry, 0)
 
-    oldstreams = [k for k in g.streams if g.streams[k]['expiry'] is None or g.streams[k]['expiry'] < now]
+    oldstreams = [
+        k
+        for k in g.streams
+        if g.streams[k]["expiry"] is None or g.streams[k]["expiry"] < now
+    ]
 
     if len(oldstreams):
         util.dbg(c.r + "%s old stream items pruned%s", len(oldstreams), c.w)
@@ -32,51 +40,74 @@ def prune():
     for oldstream in oldstreams:
         g.streams.pop(oldstream, 0)
 
-    util.dbg(c.b + "paf: %s, streams: %s%s", len(g.pafs), len(g.streams), c.w)
+    util.dbg(
+        c.b + "metadata: %s, streams: %s%s",
+        len(g.metadata_cache),
+        len(g.streams),
+        c.w,
+    )
 
 
 def get(vid, force=False, callback=None, threeD=False):
-    """ Get all streams as a dict.  callback function passed to get_pafy. """
+    """Get all streams as a dict.  callback function passed to get_extractor."""
     now = time.time()
     ytid = vid.ytid
-    have_stream = g.streams.get(ytid) and (g.streams[ytid]['expiry'] > now if g.streams[ytid]['expiry'] is not None else False)
+    have_stream = g.streams.get(ytid) and (
+        g.streams[ytid]["expiry"] > now
+        if g.streams[ytid]["expiry"] is not None
+        else False
+    )
     prfx = "preload: " if not callback else ""
 
     if not force and have_stream:
-        ss = str(int(g.streams[ytid]['expiry'] - now) // 60)
-        util.dbg("%s%sGot streams from cache (%s mins left)%s",
-                c.g, prfx, ss, c.w)
-        return g.streams.get(ytid)['meta']
-
-
-    #p = None#util.get_pafy(vid, force=force, callback=callback)
-    #ps = p.allstreams if threeD else [x for x in p.allstreams if not x.threed]
-    ps = pafy.get_video_streams(ytid)
-
+        ss = str(int(g.streams[ytid]["expiry"] - now) // 60)
+        util.dbg(
+            "%s%sGot streams from cache (%s mins left)%s", c.g, prfx, ss, c.w
+        )
+        return g.streams.get(ytid)["meta"]
+
+    # p = None#util.get_metadata(vid, force=force, callback=callback)
+    # ps = p.allstreams if threeD else [x for x in p.allstreams if not x.threed]
+    ps = extractor.get_video_streams(ytid)
+
+    streams = []
+    for s in ps:
+        # Determine stream type (audio, video, or both)
+        vcodec = s.get("vcodec", "none")
+        acodec = s.get("acodec", "none")
+
+        if vcodec == "none" and acodec != "none":
+            mtype = "audio"
+        elif vcodec != "none" and acodec != "none":
+            mtype = "video" # Mixed
+        elif vcodec != "none" and acodec == "none":
+            mtype = "video" # Video only
+        else:
+            mtype = "?"
+
+        streams.append({
+            "url": s["url"],
+            "ext": s["ext"],
+            "quality": s.get("resolution") or f"{s.get('width')}x{s.get('height')}",
+            "rawbitrate": s.get("tbr") or s.get("abr") or -1,
+            "mtype": mtype,
+            "size": int(
+                s.get("filesize")
+                if s.get("filesize") is not None
+                else s.get("filesize_approx", -1)
+            ),
+        })
+
+    # Find expiry in URL if possible
+    expiry = now + 3600 # Default fallback
     try:
-        # test urls are valid
-        [x['url'] for x in ps]
-
-    except TypeError:
-        # refetch if problem
-        util.dbg("%s****Type Error in get_streams. Retrying%s", c.r, c.w)
-        p = util.get_pafy(vid, force=True, callback=callback)
-        ps = p.allstreams if threeD else [x for x in p.allstreams
-                                          if not x.threed]
-
-    streams = [{"url": s['url'],
-                "ext": s['ext'],
-                "quality": s['resolution'],
-                "rawbitrate": s.get('bitrate',-1),
-                "mtype": 'audio' if 'audio' in s['resolution'] else ('video' if s['acodec'] != 'none' else '?'),
-                "size": int(s.get('filesize') if s.get('filesize') is not None else s.get('filesize_approx', -1))} for s in ps]
-
-
-    if 'manifest' in streams[0]['url']:
-        expiry = float(streams[0]['url'].split('/expire/')[1].split('/')[0])
-    else:
-        temp = streams[0]['url'].split('expire=')[1]
-        expiry = float(temp[:temp.find('&')])
+        if "manifest" in streams[0]["url"]:
+            expiry = float(streams[0]["url"].split("/expire/")[1].split("/")[0])
+        elif "expire=" in streams[0]["url"]:
+            temp = streams[0]["url"].split("expire=")[1]
+            expiry = float(temp[: temp.find("&")])
+    except (IndexError, ValueError):
+        pass
 
     g.streams[ytid] = dict(expiry=expiry, meta=streams)
     prune()
@@ -84,45 +115,56 @@ def get(vid, force=False, callback=None, threeD=False):
 
 
 def select(slist, q=0, audio=False, m4a_ok=True, maxres=None):
-    """ Select a stream from stream list. """
+    """Select a stream from stream list."""
     maxres = maxres or config.MAX_RES.get
-    slist = slist['meta'] if isinstance(slist, dict) else slist
+    slist = slist["meta"] if isinstance(slist, dict) else slist
 
     def okres(x):
-        """ Return True if resolution is within user specified maxres. """
-        return int(x['quality'].split("x")[1]) <= maxres
+        """Return True if resolution is within user specified maxres."""
+        try:
+            res = x["quality"].split("x")
+            height = int(res[1] if len(res) > 1 else res[0].strip("p"))
+            return height <= maxres
+        except (ValueError, IndexError, AttributeError):
+            return True
 
     def getq(x):
-        """ Return height aspect of resolution, eg 640x480 => 480. """
-        return int(x['quality'].split("x")[1])
+        """Return height aspect of resolution, eg 640x480 => 480."""
+        try:
+            res = x["quality"].split("x")
+            return int(res[1] if len(res) > 1 else res[0].strip("p"))
+        except (ValueError, IndexError, AttributeError):
+            return 0
 
     def getbitrate(x):
         """Return the bitrate of a stream."""
-        return x['rawbitrate']
+        return x["rawbitrate"]
 
     if audio:
-        streams = [x for x in slist if x['mtype'] == "audio"]
+        streams = [x for x in slist if x["mtype"] == "audio"]
         if not m4a_ok:
-            streams = [x for x in streams if not x['ext'] == "m4a"]
+            streams = [x for x in streams if not x["ext"] == "m4a"]
         if not config.AUDIO_FORMAT.get == "auto":
             if m4a_ok and config.AUDIO_FORMAT.get == "m4a":
-                streams = [x for x in streams if x['ext'] == "m4a"]
+                streams = [x for x in streams if x["ext"] == "m4a"]
             if config.AUDIO_FORMAT.get == "webm":
-                streams = [x for x in streams if x['ext'] == "webm"]
+                streams = [x for x in streams if x["ext"] == "webm"]
             if not streams:
-                streams = [x for x in slist if x['mtype'] == "audio"]
+                streams = [x for x in slist if x["mtype"] == "audio"]
         streams = sorted(streams, key=getbitrate, reverse=True)
     else:
-        streams = [x for x in slist if x['mtype'] == "video" and okres(x)]
+        streams = [x for x in slist if x["mtype"] == "video" and okres(x)]
         if not config.VIDEO_FORMAT.get == "auto":
             if config.VIDEO_FORMAT.get == "mp4":
-                streams = [x for x in streams if x['ext'] == "mp4"]
+                streams = [x for x in streams if x["ext"] == "mp4"]
             if config.VIDEO_FORMAT.get == "webm":
-                streams = [x for x in streams if x['ext'] == "webm"]
+                streams = [x for x in streams if x["ext"] == "webm"]
             if config.VIDEO_FORMAT.get == "3gp":
-                streams = [x for x in streams if x['ext'] == "3gp"]
+                streams = [x for x in streams if x["ext"] == "3gp"]
             if not streams:
-                streams = [x for x in slist if x['mtype'] == "video" and okres(x)]
+                streams = [
+                    x for x in slist if x["mtype"] == "video" and okres(x)
+                ]
         streams = sorted(streams, key=getq, reverse=True)
 
     util.dbg("select stream, q: %s, audio: %s, len: %s", q, audio, len(streams))
@@ -137,10 +179,10 @@ def getbitrate(x):
 
 
 def get_size(ytid, url, preloading=False):
-    """ Get size of stream, try stream cache first. """
+    """Get size of stream, try stream cache first."""
     # try cached value
-    stream = [x for x in g.streams[ytid]['meta'] if x['url'] == url][0]
-    size = stream['size']
+    stream = [x for x in g.streams[ytid]["meta"] if x["url"] == url][0]
+    size = stream["size"]
     prefix = "preload: " if preloading else ""
 
     if not size == -1:
@@ -148,24 +190,30 @@ def get_size(ytid, url, preloading=False):
 
     else:
         screen.writestatus("Getting content length", mute=preloading)
-        stream['size'] = _get_content_length(url, preloading=preloading)
-        util.dbg("%s%s - content-length: %s%s", c.y, prefix, stream['size'], c.w)
+        stream["size"] = _get_content_length(url, preloading=preloading)
+        util.dbg(
+            "%s%s - content-length: %s%s", c.y, prefix, stream["size"], c.w
+        )
 
-    return stream['size']
+    return stream["size"]
 
 
 def _get_content_length(url, preloading=False):
-    """ Return content length of a url. """
+    """Return content length of a url using HEAD request."""
     prefix = "preload: " if preloading else ""
     util.dbg(c.y + prefix + "getting content-length header" + c.w)
-    response = urlopen(url)
-    headers = response.headers
-    cl = headers['content-length']
-    return int(cl)
+    try:
+        from urllib.request import Request
+        req = Request(url, headers=util.web_headers(), method="HEAD")
+        with urlopen(req, timeout=10) as response:
+            return int(response.headers.get("content-length", -1))
+    except Exception as e:
+        util.dbg("%sfailed to get content-length: %s", prefix, e)
+        return -1
 
 
 def preload(song, delay=2, override=False):
-    """  Get streams. """
+    """Get streams."""
     args = (song, delay, override)
     t = threading.Thread(target=_preload, args=args)
     t.daemon = True
@@ -173,7 +221,7 @@ def preload(song, delay=2, override=False):
 
 
 def _preload(song, delay, override):
-    """  Get streams (runs in separate thread). """
+    """Get streams (runs in separate thread)."""
     if g.preload_disabled:
         return
 
@@ -193,13 +241,11 @@ def _preload(song, delay, override):
             # preload video stream, no audio available
             stream = select(streamlist, audio=False)
 
-        get_size(ytid, stream['url'], preloading=True)
+        get_size(ytid, stream["url"], preloading=True)
 
-    except (ValueError, AttributeError, IOError) as e:
-        import traceback
-        traceback.print_exception(type(e), e, e.__traceback__)
-        input("Press any key to continue...")
-        util.dbg(e)  # Fail silently on preload
+    except Exception as e:
+        util.dbg("Preload failed for %s: %s", ytid, e)
+        # Never call input() in a background thread!
 
     finally:
         g.preloading.remove(song.ytid)
diff --git a/mps_youtube/streamurlfetcher.py b/mps_youtube/streamurlfetcher.py
new file mode 100644
index 00000000..c2033139
--- /dev/null
+++ b/mps_youtube/streamurlfetcher.py
@@ -0,0 +1,38 @@
+"""Lightweight stream URL fetcher built on yt-dlp."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+import yt_dlp
+from . import extractor
+
+
+class StreamURLFetcher:
+    """Resolve stream URLs using yt-dlp."""
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def get_all(
+        self, video_id: str, player_response: Optional[Dict[str, Any]] = None
+    ) -> List[Dict[str, Any]]:
+        """Return all deciphered formats from player response."""
+        url = f"https://www.youtube.com/watch?v={video_id}"
+        try:
+            with yt_dlp.YoutubeDL(extractor.get_ydl_opts()) as ydl:
+                info_dict = ydl.extract_info(url, download=False)
+                return extractor._extract_streams_from_info(info_dict)
+        except Exception:
+            return []
+
+    def get(
+        self,
+        video_id: str,
+        itag: int,
+        player_response: Optional[Dict[str, Any]] = None,
+    ) -> Optional[str]:
+        """Return one URL for a specific itag if available."""
+        for fmt in self.get_all(video_id):
+            if fmt.get("itag") == itag:
+                return fmt.get("url")
+        return None
diff --git a/mps_youtube/terminalsize.py b/mps_youtube/terminalsize.py
index 7a08c524..1bcf8616 100644
--- a/mps_youtube/terminalsize.py
+++ b/mps_youtube/terminalsize.py
@@ -1,10 +1,9 @@
 # https://gist.github.com/jtriley/1108174
 
-""" Terminal Size. """
+"""Terminal Size."""
 
 import os
 import sys
-import shlex
 import shutil
 import struct
 import platform
@@ -12,7 +11,7 @@
 
 
 def get_terminal_size():
-    """ getTerminalSize().
+    """getTerminalSize().
 
     - get width and height of console
     - works on linux,os x,windows,cygwin(windows)
@@ -20,13 +19,13 @@ def get_terminal_size():
     http://stackoverflow.com/questions/566746/how-to-get-console-window-width-in-python
     """
 
-    if sys.version_info >= (3,3):
+    if sys.version_info >= (3, 3):
         return shutil.get_terminal_size()
 
     current_os = platform.system()
     tuple_xy = None
 
-    if current_os == 'Windows':
+    if current_os == "Windows":
         tuple_xy = _get_terminal_size_windows()
 
         if tuple_xy is None:
@@ -37,17 +36,18 @@ def get_terminal_size():
         tuple_xy = _get_terminal_size_linux()
 
     if tuple_xy is None:
-        tuple_xy = (80, 25)      # default value
+        tuple_xy = (80, 25)  # default value
 
     return tuple_xy
 
 
 def _get_terminal_size_windows():
-    """ Get terminal size on MS Windows. """
+    """Get terminal size on MS Windows."""
     # pylint: disable=R0914
     # too many local variables
     try:
         from ctypes import windll, create_string_buffer
+
         # stdin handle is -10
         # stdout handle is -11
         # stderr handle is -12
@@ -56,61 +56,81 @@ def _get_terminal_size_windows():
         res = windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
 
         if res:
-            (bufx, bufy, curx, cury, wattr,
-             left, top, right, bottom,
-             maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
+            (
+                bufx,
+                bufy,
+                curx,
+                cury,
+                wattr,
+                left,
+                top,
+                right,
+                bottom,
+                maxx,
+                maxy,
+            ) = struct.unpack("hhhhHhhhhhh", csbi.raw)
             sizex = right - left + 1
             sizey = bottom - top + 1
             return sizex, sizey
 
-    except:
+    except Exception:
         pass
 
 
 def _get_terminal_size_tput():
-    """ Get terminal size using tput. """
+    """Get terminal size using tput."""
     # src: http://stackoverflow.com/questions/263890/
     # how-do-i-find-the-width-height-of-a-terminal-window
     try:
-        cols = int(subprocess.check_call(shlex.split('tput cols')))
-        rows = int(subprocess.check_call(shlex.split('tput lines')))
+        with open(os.devnull, "w") as devnull:
+            cols = int(
+                subprocess.check_output(
+                    ["tput", "cols"], stderr=devnull, text=True
+                ).strip()
+            )
+            rows = int(
+                subprocess.check_output(
+                    ["tput", "lines"], stderr=devnull, text=True
+                ).strip()
+            )
         return (cols, rows)
-    except:
+    except Exception:
         pass
 
 
 def _get_terminal_size_linux():
-    """ Get terminal size Linux. """
+    """Get terminal size Linux."""
+
     def ioctl_GWINSZ(fd):
-        """ ioctl_GWINSZ. """
+        """ioctl_GWINSZ."""
         try:
             import fcntl
             import termios
-            cr = struct.unpack('hh',
-                               fcntl.ioctl(fd, termios.TIOCGWINSZ, '1234'))
+
+            cr = struct.unpack(
+                "hh", fcntl.ioctl(fd, termios.TIOCGWINSZ, "1234")
+            )
             return cr
 
-        except:
+        except Exception:
             pass
 
     cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
 
     if not cr or cr == (0, 0):
-
         try:
             fd = os.open(os.ctermid(), os.O_RDONLY)
             cr = ioctl_GWINSZ(fd)
             os.close(fd)
 
-        except:
+        except Exception:
             pass
 
     if not cr or cr == (0, 0):
-
         try:
-            cr = (os.environ['LINES'], os.environ['COLUMNS'])
+            cr = (os.environ["LINES"], os.environ["COLUMNS"])
 
-        except:
+        except Exception:
             return
 
     return int(cr[1]), int(cr[0])
diff --git a/mps_youtube/test/test_main.py b/mps_youtube/test/test_main.py
deleted file mode 100644
index 72c1179d..00000000
--- a/mps_youtube/test/test_main.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import unittest
-
-import pytest
-
-import mps_youtube.main as mps
-
-
-class TestMain(unittest.TestCase):
-    def test_fmt_time(self):
-        pytest.skip('main not have tested attribute')
-        self.assertEqual(mps.fmt_time(0), '00:00')
-        self.assertEqual(mps.fmt_time(59), '00:59')
-        self.assertEqual(mps.fmt_time(100), '01:40')
-        self.assertEqual(mps.fmt_time(1000), '16:40')
-        self.assertEqual(mps.fmt_time(5000), '83:20')
-        self.assertEqual(mps.fmt_time(6500), '1:48:20')
-
-    def test_num_repr(self):
-        pytest.skip('main not have tested attribute')
-        self.assertEqual(mps.num_repr(0), '0')
-        self.assertEqual(mps.num_repr(1001), '1001')
-        self.assertEqual(mps.num_repr(10001), '10k')
-        self.assertEqual(mps.num_repr(100001), '100k')
-        self.assertEqual(mps.num_repr(1000001), '1.0m')
-        self.assertEqual(mps.num_repr(10000001), '10m')
-        self.assertEqual(mps.num_repr(100000001), '100m')
-        self.assertEqual(mps.num_repr(1000000001), '1.0B')
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/mps_youtube/test/test_mpris.py b/mps_youtube/test/test_mpris.py
deleted file mode 100644
index 0f4a2352..00000000
--- a/mps_youtube/test/test_mpris.py
+++ /dev/null
@@ -1,112 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-from unittest.mock import MagicMock
-
-import dbus
-import pytest
-
-from mps_youtube import mpris
-
-
-def test_mprsi2controller_init():
-    assert mpris.Mpris2Controller()
-
-
-def test_mpris2mediaplayer_init():
-    bus = MagicMock()
-    obj = mpris.Mpris2MediaPlayer(bus)
-    assert obj
-    v_obj = vars(obj)
-    v_obj.pop("_locations_lock")
-    #  '_locations_lock': <unlocked _thread.lock object at 0x7f0af1d20240>,
-    assert vars(obj) == {
-        "_connection": bus,
-        "_fallback": False,
-        "_locations": [(bus, "/org/mpris/MediaPlayer2", False)],
-        "_name": None,
-        "_object_path": "/org/mpris/MediaPlayer2",
-        "fifo": None,
-        "mpv": False,
-        "properties": {
-            "org.mpris.MediaPlayer2": {
-                "read_only": {
-                    "CanQuit": False,
-                    "CanRaise": False,
-                    "CanSetFullscreen": False,
-                    "DesktopEntry": "mps-youtube",
-                    "HasTrackList": False,
-                    "Identity": "mps-youtube",
-                    "SupportedMimeTypes": dbus.Array([], signature=dbus.Signature("s")),
-                    "SupportedUriSchemes": dbus.Array(
-                        [], signature=dbus.Signature("s")
-                    ),
-                },
-                "read_write": {"Fullscreen": False},
-            },
-            "org.mpris.MediaPlayer2.Player": {
-                "read_only": {
-                    "CanControl": True,
-                    "CanGoNext": True,
-                    "CanGoPrevious": True,
-                    "CanPause": True,
-                    "CanPlay": True,
-                    "CanSeek": True,
-                    "MaximumRate": 1.0,
-                    "Metadata": {
-                        "mpris:trackid": dbus.ObjectPath(
-                            "/CurrentPlaylist/UnknownTrack", variant_level=1
-                        )
-                    },
-                    "MinimumRate": 1.0,
-                    "PlaybackStatus": "Stopped",
-                    "Position": dbus.Int64(0),
-                },
-                "read_write": {"Rate": 1.0, "Volume": 1.0},
-            },
-        },
-        "socket": None,
-    }
-
-
-@pytest.mark.parametrize("val", (None, 0, 3, 5))
-def test_mpris2mediaplayer_set_property_time_pos(val):
-    obj = mpris.Mpris2MediaPlayer(MagicMock())
-    obj.Seeked = MagicMock()
-    obj.setproperty("time-pos", val)
-    exp_res = dbus.Int64(val * 10**6) if val else dbus.Int64(0)
-    assert obj.properties[mpris.PLAYER_INTERFACE]["read_only"]["Position"] == exp_res
-    seeked_call_args = None
-    try:
-        seeked_call_args = obj.Seeked.mock_calls[0].args
-    except IndexError:
-        pass
-    if val and val >= 4:
-        assert seeked_call_args == (exp_res,)
-    else:
-        assert seeked_call_args is None
-
-
-@pytest.mark.parametrize(
-    "val1, val2",
-    (
-        (0, 2),
-        (2, 6),
-        (2, 5),
-        (2, 7),
-    ),
-)
-def test_mpris2mediaplayer_set_property_time_pos_seeked(val1, val2):
-    obj = mpris.Mpris2MediaPlayer(MagicMock())
-    obj.Seeked = MagicMock()
-    obj.setproperty("time-pos", val1)
-    obj.setproperty("time-pos", val2)
-    seeked_call_args = None
-    try:
-        seeked_call_args = obj.Seeked.mock_calls[0].args
-    except IndexError:
-        pass
-    d2 = dbus.Int64(val2 * 10**6)
-    if abs(d2 - dbus.Int64(val1 * 10**6)) >= 4 * 10**6:
-        assert seeked_call_args == (d2,)
-    else:
-        assert seeked_call_args is None
diff --git a/mps_youtube/test/test_players_mplayer.py b/mps_youtube/test/test_players_mplayer.py
deleted file mode 100644
index e3c12b3f..00000000
--- a/mps_youtube/test/test_players_mplayer.py
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-from unittest import mock
-
-import pytest
-
-from mps_youtube.players import mplayer
-
-
-@pytest.mark.parametrize(
-    "exename, exp_err",
-    [
-        ("", (OSError, PermissionError)),
-        ("mplayersomething", FileNotFoundError),
-    ],
-)
-def test_get_mplayer_version_no_mplayer(exename, exp_err):
-    with pytest.raises(exp_err):
-        mplayer._get_mplayer_version(exename)
-
-
-def test_get_mplayer_version_invalid_input():
-    with mock.patch("mps_youtube.players.mplayer.subprocess"), pytest.raises(TypeError):
-        mplayer._get_mplayer_version(mock.MagicMock())
-
-
-@pytest.mark.parametrize(
-    "output, exp_res",
-    [
-        (
-            "MPlayer Redxii-SVN-r38151-6.2.0 (x86_64) (C) 2000-2019 MPlayer Team...",
-            38151,
-        ),
-        ("MPlayer SVN-r38151-6.2.0 (x86_64) (C) 2000-2019 MPlayer Team...", 38151),
-        ("MPlayer 1.4 (Debian), built with gcc-10 (C) 2000-2019 MPlayer Team", (1, 4)),
-    ],
-)
-def test_get_mplayer_version(output, exp_res):
-    with mock.patch("mps_youtube.players.mplayer.subprocess") as m_subprocess:
-        m_subprocess.check_output.return_value.decode.return_value = output
-        assert mplayer._get_mplayer_version(mock.MagicMock()) == exp_res
diff --git a/mps_youtube/test/test_util.py b/mps_youtube/test/test_util.py
deleted file mode 100644
index 7a44b85e..00000000
--- a/mps_youtube/test/test_util.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-import pytest
-
-import mps_youtube.util as util
-
-
-@pytest.mark.parametrize(
-    "num,t,exp_res",
-    (
-        (0, "", ""),
-        (0, None, ""),
-    ),
-)
-def test_uea_pad(num, t, exp_res):
-    res = util.uea_pad(num, t)
-    assert res == exp_res
diff --git a/mps_youtube/util.py b/mps_youtube/util.py
index c51bdcdc..66c87f33 100644
--- a/mps_youtube/util.py
+++ b/mps_youtube/util.py
@@ -10,10 +10,15 @@
 import time
 import unicodedata
 import urllib
+
+try:
+    from prompt_toolkit.completion import Completer, Completion
+except ImportError:
+    Completer = object
 from datetime import datetime, timezone
 from importlib import import_module
 
-from . import c, description_parser, g, terminalsize
+from . import c, description_parser, g
 from .playlist import Video
 
 macos = platform.system() == "Darwin"
@@ -22,13 +27,17 @@
 not_utf8_environment = mswin or (
     "UTF-8" not in sys.stdout.encoding if sys.stdout.encoding else False
 )
+BROWSER_USER_AGENT = (
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36"
+)
 
-XYTuple = collections.namedtuple('XYTuple', 'width height max_results')
+XYTuple = collections.namedtuple("XYTuple", "width height max_results")
 
 
-class IterSlicer():
-    """ Class that takes an iterable and allows slicing,
-        loading from the iterable as needed."""
+class IterSlicer:
+    """Class that takes an iterable and allows slicing,
+    loading from the iterable as needed."""
 
     def __init__(self, iterable, length=None):
         self.ilist = []
@@ -62,15 +71,20 @@ def __len__(self):
         return self.length
 
 
+_exefile_cache = {}
+
 def has_exefile(filename):
-    """ Check whether file exists in path and is executable.
+    """Check whether file exists in path and is executable.
 
     :param filename: name of executable
     :type filename: str
     :returns: Path to file or False if not found
     :rtype: str or False
     """
-    paths = [os.getcwd()] + os.environ.get("PATH", '').split(os.pathsep)
+    if filename in _exefile_cache:
+        return _exefile_cache[filename]
+
+    paths = [os.getcwd()] + os.environ.get("PATH", "").split(os.pathsep)
     paths = [i for i in paths if i]
     dbg("searching path for %s", filename)
 
@@ -80,15 +94,33 @@ def has_exefile(filename):
         if os.path.isfile(exepath):
             if os.access(exepath, os.X_OK):
                 dbg("found at %s", exepath)
+                _exefile_cache[filename] = exepath
                 return exepath
 
+    _exefile_cache[filename] = False
     return False
 
 
 def dbg(*args):
     """Emit a debug message."""
-    # Uses xenc to deal with UnicodeEncodeError when writing to terminal
-    logging.debug(*(xenc(i) for i in args))
+    if not args:
+        return
+
+    # If multiple arguments, check if first is a format string
+    if len(args) > 1:
+        if isinstance(args[0], str) and "%" in args[0]:
+            try:
+                # Use logging's internal formatting
+                logging.debug(xenc(args[0]), *(xenc(i) for i in args[1:]))
+                return
+            except (TypeError, ValueError):
+                # Fallback if formatting fails
+                pass
+
+        # Otherwise join with spaces
+        logging.debug(" ".join(str(xenc(i)) for i in args))
+    else:
+        logging.debug(xenc(args[0]))
 
 
 def utf8_replace(txt):
@@ -107,17 +139,30 @@ def utf8_replace(txt):
 
 
 def xenc(stuff):
-    """ Replace unsupported characters. """
+    """Replace unsupported characters."""
     return utf8_replace(stuff) if not_utf8_environment else stuff
 
 
 def xprint(stuff, end=None):
-    """ Compatible print. """
+    """Compatible print."""
     print(xenc(stuff), end=end)
 
 
+def web_headers(extra=None):
+    """Return browser-like HTTP headers for outbound web requests."""
+    headers = {
+        "User-Agent": BROWSER_USER_AGENT,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9",
+        "Connection": "keep-alive",
+    }
+    if extra:
+        headers.update(extra)
+    return headers
+
+
 def mswinfn(filename):
-    """ Fix filename for Windows. """
+    """Fix filename for Windows."""
     if mswin:
         filename = utf8_replace(filename) if not_utf8_environment else filename
         allowed = re.compile(r'[^\\/?*$\'"%&:<>|]')
@@ -125,12 +170,13 @@ def mswinfn(filename):
 
     return filename
 
+
 def sanitize_filename(filename, ignore_slashes=False):
-    """ Sanitize filename """
+    """Sanitize filename"""
     if not ignore_slashes:
-        filename = filename.replace('/', '-')
+        filename = filename.replace("/", "-")
     if macos:
-        filename = filename.replace(':', '_')
+        filename = filename.replace(":", "_")
     if mswin:
         filename = utf8_replace(filename) if not_utf8_environment else filename
         allowed = re.compile(r'[^\\?*$\'"%&:<>|]')
@@ -138,16 +184,17 @@ def sanitize_filename(filename, ignore_slashes=False):
 
     return filename
 
+
 def set_window_title(title):
-    """ Set terminal window title. """
+    """Set terminal window title."""
     if mswin:
         ctypes.windll.kernel32.SetConsoleTitleW(xenc(title))
     else:
-        sys.stdout.write(xenc('\x1b]2;' + title + '\x07'))
+        sys.stdout.write(xenc("\x1b]2;" + title + "\x07"))
 
 
 def list_update(item, lst, remove=False):
-    """ Add or remove item from list, checking first to avoid exceptions. """
+    """Add or remove item from list, checking first to avoid exceptions."""
     if not remove and item not in lst:
         lst.append(item)
 
@@ -156,7 +203,7 @@ def list_update(item, lst, remove=False):
 
 
 def get_near_name(begin, items):
-    """ Return the closest matching playlist name that starts with begin. """
+    """Return the closest matching playlist name that starts with begin."""
     for name in sorted(items):
         if name.lower().startswith(begin.lower()):
             return name
@@ -189,50 +236,45 @@ def F(key, nb=0, na=0, textlib=None):
     return "\n" * nb + text + c.w + "\n" * na
 
 
-def get_pafy(item, force=False, callback=None):
+def get_metadata(item, force=False, callback=None):
     """
-    Get pafy object for an item.
+    Get metadata (VideoInfo) object for an item.
 
     :param item: video to retrieve
     :type item: :class:`mps_youtube.playlist.Video` or str
     :param force: ignore cache and retrieve anyway
     :type force: bool
-    :param callback: callpack to pass to pafy
-    :type callback: func
-    :rtype: Pafy
+    :param callback: callback (legacy, for compatibility)
+    :rtype: VideoInfo
     """
+    # Import here to avoid circular dependency.
+    from . import extractor
 
     if isinstance(item, Video):
         ytid = item.ytid
     else:
         ytid = item
-    callback_fn = callback or (lambda x: None)
-    cached = g.pafs.get(ytid)
+
+    cached = g.metadata_cache.get(ytid)
 
     if not force and cached and cached.expiry > time.time():
-        dbg("get pafy cache hit for %s", cached.title)
+        dbg("metadata cache hit for %s", cached.title)
         cached.fresh = False
         return cached
 
     else:
-
         try:
-            p = None#pafy.new(ytid, callback=callback_fn)
+            p = extractor.get_video_info(ytid)
 
-        except IOError as e:
+        except Exception as e:
+            dbg(c.p + "Failed to get metadata: " + str(e) + c.w)
+            raise
 
-            if "pafy" in str(e):
-                dbg(c.p + "retrying failed pafy get: " + ytid + c.w)
-                p = None#pafy.new(ytid, callback=callback)
-
-            else:
-                raise
-
-        g.pafs[ytid] = p
+        g.metadata_cache[ytid] = p
         p.fresh = True
         thread = "preload: " if not callback else ""
-        dbg("%s%sgot new pafy object: %s%s" % (c.y, thread, p.title[:26], c.w))
-        dbg("%s%sgot new pafy object: %s%s" % (c.y, thread, p.videoid, c.w))
+        dbg("%s%sgot metadata: %s%s" % (c.y, thread, p.title[:26], c.w))
+        dbg("%s%sgot metadata: %s%s" % (c.y, thread, p.ytid, c.w))
         return p
 
 
@@ -244,8 +286,11 @@ def getxy():
     """
     # Import here to avoid circular dependency
     from . import config
+    import shutil
+
     if g.detectable_size:
-        x, y = terminalsize.get_terminal_size()
+        size = shutil.get_terminal_size()
+        x, y = size.columns, size.lines
         max_results = y - 4 if y < 54 else 50
         max_results = 1 if y <= 5 else max_results
 
@@ -257,8 +302,8 @@ def getxy():
 
 
 def fmt_time(seconds):
-    """ Format number of seconds to %H:%M:%S. """
-    hms = time.strftime('%H:%M:%S', time.gmtime(int(seconds)))
+    """Format number of seconds to %H:%M:%S."""
+    hms = time.strftime("%H:%M:%S", time.gmtime(int(seconds)))
     H, M, S = hms.split(":")
 
     if H == "00":
@@ -272,15 +317,16 @@ def fmt_time(seconds):
 
     return hms
 
+
 def correct_truncate(text, max_len):
-    """ Truncate a string taking into account East Asian width chars."""
-    str_len, out = 0, ''
+    """Truncate a string taking into account East Asian width chars."""
+    str_len, out = 0, ""
 
-    for c in text:
-        str_len += real_len(c)
+    for char in text:
+        str_len += real_len(char)
 
         if str_len <= max_len:
-            out += c
+            out += char
 
         else:
             break
@@ -289,14 +335,14 @@ def correct_truncate(text, max_len):
 
 
 def uea_pad(num, t, direction="<", notrunc=False):
-    """ Right pad with spaces taking into account East Asian width chars. """
+    """Right pad with spaces taking into account East Asian width chars."""
     direction = direction.strip() or "<"
 
-    t = ' '.join(str(t).split('\n'))
+    t = " ".join(str(t).split("\n"))
 
     # TODO: Find better way of dealing with this?
     if num <= 0:
-        return ''
+        return ""
 
     if not notrunc:
         # Truncate to max of num characters
@@ -322,17 +368,17 @@ def uea_pad(num, t, direction="<", notrunc=False):
 
 
 def real_len(u, alt=False):
-    """ Try to determine width of strings displayed with monospace font. """
+    """Try to determine width of strings displayed with monospace font."""
     if not isinstance(u, str):
         u = u.decode("utf8")
 
-    u = xenc(u) # Handle replacements of unsuported characters
+    u = xenc(u)  # Handle replacements of unsuported characters
 
     ueaw = unicodedata.east_asian_width
 
     if alt:
         # widths = dict(W=2, F=2, A=1, N=0.75, H=0.5)  # original
-        widths = dict(N=.75, Na=1, W=2, F=2, A=1)
+        widths = dict(N=0.75, Na=1, W=2, F=2, A=1)
 
     else:
         widths = dict(W=2, F=2, A=1, N=1, H=0.5)
@@ -340,10 +386,38 @@ def real_len(u, alt=False):
     return int(round(sum(widths.get(ueaw(char), 1) for char in u)))
 
 
+def format_yt_date(date_str):
+    """Convert ISO8601, YYYYMMDD, or YYYY-MM-DD to a concise display date."""
+    if not date_str or date_str in ("?", "Unknown"):
+        return "?"
+    
+    # Already relative? (e.g. "5 months ago")
+    if " ago" in date_str:
+        return date_str
+
+    try:
+        # Try ISO8601 (e.g. 2024-04-25T00:00:00Z)
+        if "T" in date_str:
+            t = datetime.strptime(date_str.split(".")[0].rstrip("Z"), "%Y-%m-%dT%H:%M:%S")
+        # Try YYYY-MM-DD
+        elif "-" in date_str and len(date_str) == 10:
+            t = datetime.strptime(date_str, "%Y-%m-%d")
+        # Try YYYYMMDD
+        elif len(date_str) == 8 and date_str.isdigit():
+            t = datetime.strptime(date_str, "%Y%m%d")
+        else:
+            return date_str
+            
+        return t.strftime("%d-%m-%y")
+    except Exception as e:
+        logging.debug("Failed to format date '%s': %s", date_str, e)
+        return date_str
+
+
 def yt_datetime(yt_date_time):
-    """ Return a time object, locale formated date string and locale formatted time string. """
+    """Return a time object, locale formated date string and locale formatted time string."""
     if yt_date_time is None:
-        return ['Unknown', 'Unknown', 'Unknown']
+        return ["Unknown", "Unknown", "Unknown"]
     time_obj = time.strptime(yt_date_time, "%Y-%m-%dT%H:%M:%SZ")
     locale_date = time.strftime("%x", time_obj)
     locale_time = time.strftime("%X", time_obj)
@@ -353,7 +427,7 @@ def yt_datetime(yt_date_time):
 
 
 def yt_datetime_local(yt_date_time):
-    """ Return a datetime object, locale converted and formated date string and locale converted and formatted time string. """
+    """Return a datetime object, locale converted and formated date string and locale converted and formatted time string."""
     datetime_obj = datetime.strptime(yt_date_time, "%Y-%m-%dT%H:%M:%SZ")
     datetime_obj = utc2local(datetime_obj)
     locale_date = datetime_obj.strftime("%x")
@@ -377,7 +451,9 @@ def parse_multi(choice, end=None):
 
     """
     end = end or str(len(g.model))
-    pattern = r'(?<![-\d\[\]])(\d+-\d+|-\d+|\d+-|\d+)(?:\[(\d+)\])?(?![-\d\[\]])'
+    pattern = (
+        r"(?<![-\d\[\]])(\d+-\d+|-\d+|\d+-|\d+)(?:\[(\d+)\])?(?![-\d\[\]])"
+    )
     items = re.findall(pattern, choice)
     alltracks = []
 
@@ -385,7 +461,6 @@ def parse_multi(choice, end=None):
         # nreps is in the inclusive range [1,100]
         nreps = min(int(nreps), 100) if nreps else 1
         for _ in range(nreps):
-
             if x.startswith("-"):
                 x = "1" + x
 
@@ -421,9 +496,9 @@ def _bi_range(start, end):
 
 
 def is_known_player(player):
-    """ Return true if the set player is known. """
+    """Return true if the set player is known."""
     for allowed_player in g.playerargs_defaults:
-        regex = r'(?:\b%s($|\.[a-zA-Z0-9]+$))' % re.escape(allowed_player)
+        regex = r"(?:\b%s($|\.[a-zA-Z0-9]+$))" % re.escape(allowed_player)
         match = re.search(regex, player)
 
         if mswin:
@@ -436,10 +511,19 @@ def is_known_player(player):
 
 
 def load_player_info(player):
+    """Load player version and options into globals."""
     if "mpv" in player:
-        g.mpv_version = _get_mpv_version(player)
-        g.mpv_options = subprocess.check_output(
-                [player, "--list-options"]).decode()
+        if not g.mpv_version or g.mpv_version == (0, 0, 0):
+            g.mpv_version = _get_mpv_version(player)
+
+        if not g.mpv_options:
+            try:
+                g.mpv_options = subprocess.check_output(
+                    [player, "--list-options"], timeout=5
+                ).decode()
+            except (subprocess.SubprocessError, subprocess.TimeoutExpired):
+                g.mpv_options = ""
+                dbg(c.r + "Failed to get mpv options (timeout or error)" + c.w)
 
         if not mswin:
             if "--input-unix-socket" in g.mpv_options:
@@ -458,14 +542,14 @@ def fetch_songs(text, title="Unknown"):
 
 
 def number_string_to_list(text):
-    """ Parses comma separated lists """
+    """Parses comma separated lists"""
     text = [x.strip() for x in text.split(",")]
     vals = []
     for line in text:
         k = line
         if "-" in line:
             separated = [int(x.strip()) for x in k.split("-")]
-            for number in list(range(separated[0]-1, separated[1])):
+            for number in list(range(separated[0] - 1, separated[1])):
                 vals.append(number)
         else:
             vals.append(k)
@@ -474,12 +558,12 @@ def number_string_to_list(text):
 
 
 def _get_mpv_version(exename):
-    """ Get version of mpv as 3-tuple. """
+    """Get version of mpv as 3-tuple."""
     o = subprocess.check_output([exename, "--version"]).decode()
     re_ver = re.compile(r"mpv (\d+)\.(\d+)\.(\d+)")
 
     for line in o.split("\n"):
-        m = re_ver.match(line)
+        m = re_ver.search(line)
 
         if m:
             v = tuple(map(int, m.groups()))
@@ -492,13 +576,13 @@ def _get_mpv_version(exename):
 
 def _get_mplayer_version(exename):
     o = subprocess.check_output([exename]).decode()
-    m = re.search(r'MPlayer SVN[\s-]r([0-9]+)', o, re.MULTILINE|re.IGNORECASE)
+    m = re.search(r"MPlayer SVN[\s-]r([0-9]+)", o, re.MULTILINE | re.IGNORECASE)
 
     ver = 0
     if m:
         ver = int(m.groups()[0])
     else:
-        m = re.search('MPlayer ([0-9])+.([0-9]+)', o, re.MULTILINE)
+        m = re.search("MPlayer ([0-9])+.([0-9]+)", o, re.MULTILINE)
         if m:
             ver = tuple(int(i) for i in m.groups())
 
@@ -509,16 +593,20 @@ def _get_mplayer_version(exename):
 
 
 def _get_metadata(song_title):
-    ''' Get metadata from a song title '''
+    """Get metadata from a song title"""
     t = re.sub(r"[\(\[].*?[\)\]]", "", song_title.lower())
-    t = t.split('-')
+    t = t.split("-")
 
-    if len(t) != 2:  # If len is not 2, no way of properly knowing title for sure
+    if (
+        len(t) != 2
+    ):  # If len is not 2, no way of properly knowing title for sure
         t = t[0]
-        t = t.split(':')
-        if len(t) != 2:  # Ugly, but to be safe in case all these chars exist, Will improve
+        t = t.split(":")
+        if (
+            len(t) != 2
+        ):  # Ugly, but to be safe in case all these chars exist, Will improve
             t = t[0]
-            t = t.split('|')
+            t = t.split("|")
             if len(t) != 2:
                 return None
 
@@ -538,21 +626,22 @@ def _get_metadata(song_title):
 
 
 def _get_metadata_from_lastfm(artist, track):
-    ''' Try to get metadata with a given artist and track '''
-    url = 'https://ws.audioscrobbler.com/2.0/?method=track.getInfo&api_key=12dec50313f885d407cf8132697b8712&'
-    url += urllib.parse.urlencode({"artist":  artist}) + '&'
-    url += urllib.parse.urlencode({"track":  track}) + '&'
-    url += '&format=json'
+    """Try to get metadata with a given artist and track"""
+    url = "https://ws.audioscrobbler.com/2.0/?method=track.getInfo&api_key=12dec50313f885d407cf8132697b8712&"
+    url += urllib.parse.urlencode({"artist": artist}) + "&"
+    url += urllib.parse.urlencode({"track": track}) + "&"
+    url += "&format=json"
 
     try:
-        resp = urllib.request.urlopen(url)
+        req = urllib.request.Request(url, headers=web_headers())
+        resp = urllib.request.urlopen(req)
         metadata = dict()
         # Prior to Python 3.6, json.loads cannot take a bytes object
-        data = json.loads(resp.read().decode('utf-8'))
-        metadata['track_title'] = data['track']['name']
-        metadata['artist'] = data['track']['artist']['name']
-        metadata['album'] = data['track']['album']['title']
-        metadata['album_art_url'] = data['track']['album']['image'][-1]['#text']
+        data = json.loads(resp.read().decode("utf-8"))
+        metadata["track_title"] = data["track"]["name"]
+        metadata["artist"] = data["track"]["artist"]["name"]
+        metadata["album"] = data["track"]["album"]["title"]
+        metadata["album_art_url"] = data["track"]["album"]["image"][-1]["#text"]
     except (KeyError, IndexError):
         return None
     except (urllib.error.HTTPError, urllib.error.URLError):
@@ -563,48 +652,110 @@ def _get_metadata_from_lastfm(artist, track):
 def assign_player(player):
     module_name = player
 
-    if '/' in module_name:
-        module_name = module_name.split('/')[-1]
-    if module_name.endswith('.com') or module_name.endswith('.exe'):
-        module_name = module_name.split('.')[0]
+    if "/" in module_name:
+        module_name = module_name.split("/")[-1]
+    if module_name.endswith(".com") or module_name.endswith(".exe"):
+        module_name = module_name.split(".")[0]
 
     try:
-        module = import_module('mps_youtube.players.{0}'.format(module_name))
+        module = import_module("mps_youtube.players.{0}".format(module_name))
         pl = getattr(module, module_name)
         g.PLAYER_OBJ = pl(player)
 
     except ImportError:
         from mps_youtube.players import GenericPlayer
-        g.PLAYER_OBJ = GenericPlayer.GenericPlayer(player)
 
+        g.PLAYER_OBJ = GenericPlayer.GenericPlayer(player)
 
-class CommandCompleter:
 
+class CommandCompleter(Completer):
     COMMANDS = []
 
     def __init__(self):
         from . import config
-        self.SET_COMMANDS = ['set ' + i.lower() for i in config]
 
-    def complete_command(self, text, state):
-        if text.startswith('set'):
-            results = [x for x in self.SET_COMMANDS if x.startswith(text)] + [None]
-        else:
-            results = [x for x in self.COMMANDS if x.startswith(text)] + [None]
-        return results[state]
+        self.SET_COMMANDS = [i.lower() for i in config]
+
+    def get_completions(self, document, complete_event):
+        from . import g
+
+        text = document.text_before_cursor
+
+        # 'set' command completions for configuration keys
+        if text.startswith("set "):
+            arg_text = text[4:]
+            if " " in arg_text:
+                parts = arg_text.split(" ", 1)
+                key = parts[0]
+                val_prefix = parts[1]
+                if key.lower() in self.SET_COMMANDS:
+                    from . import config
+
+                    try:
+                        item = config[key.upper()]
+                        if hasattr(item, "type") and item.type == bool:
+                            for val in ("true", "false"):
+                                if val.startswith(val_prefix.lower()):
+                                    yield Completion(
+                                        val, start_position=-len(val_prefix)
+                                    )
+                    except (KeyError, AttributeError):
+                        pass
+                return
+
+            for cmd in self.SET_COMMANDS:
+                if cmd.startswith(arg_text.lower()):
+                    yield Completion(cmd, start_position=-len(arg_text))
+            return
+
+        # Playlist name completions for commands that take a playlist name
+        for cmd_prefix in ("open ", "save ", "view ", "rmp ", "mv ", "add "):
+            if text.startswith(cmd_prefix):
+                arg_text = text[len(cmd_prefix) :]
+                pl_names = sorted(g.userpl.keys())
+                for name in pl_names:
+                    if name.startswith(arg_text):
+                        yield Completion(name, start_position=-len(arg_text))
+                return
+
+        # Sort command completions
+        if text.startswith("sort "):
+            arg_text = text[5:]
+            for sub in ("name", "duration", "age"):
+                if sub.startswith(arg_text.lower()):
+                    yield Completion(sub, start_position=-len(arg_text))
+            return
+
+        # Default: complete the command itself
+        word = document.get_word_before_cursor()
+        for cmd in self.COMMANDS:
+            if cmd.startswith(word):
+                yield Completion(cmd, start_position=-len(word))
+
+        if word.startswith("set"):
+            yield Completion("set", start_position=-len(word))
+
     def add_cmd(self, val):
-        if(not val in self.COMMANDS):
+        if val not in self.COMMANDS:
             self.COMMANDS.append(val)
 
+
 def parse_video_length(duration):
-    '''
-    Converts HH:MM:SS to a single integer .i.e. total number of seconds
-    '''
-    if duration:
-        duration_tokens = duration.split(":")
-        if len(duration_tokens) == 2:
-            return int(duration_tokens[0]) * 60 + int(duration_tokens[1])
-        else:
-            return int(duration_tokens[0]) * 3600 + int(duration_tokens[1]) * 60 + int(duration_tokens[2])
-    else:
+    """Converts duration (string HH:MM:SS or integer seconds) to total seconds."""
+    if not duration:
         return 10
+    if isinstance(duration, (int, float)):
+        return int(duration)
+
+    tokens = str(duration).split(":")
+    try:
+        if len(tokens) == 1:
+            return int(tokens[0])
+        if len(tokens) == 2:
+            return int(tokens[0]) * 60 + int(tokens[1])
+        return int(tokens[0]) * 3600 + int(tokens[1]) * 60 + int(tokens[2])
+    except (ValueError, IndexError):
+        return 10
+
+
+completer = CommandCompleter()
diff --git a/pyproject.toml b/pyproject.toml
index e200cf7e..979191e0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,2 +1,47 @@
-[tool.semantic_release]
-version_variables = ["setup.py:__version__"]
+[project]
+name = "yewtube"
+version = "2.12.0"
+description = "Terminal based YouTube player and downloader"
+dependencies = [
+    "click>=8.1.7",
+    "prompt-toolkit>=3.0.43",
+    "pylast>=5.2.0",
+    "pyperclip>=1.8.2",
+    "httpx>=0.26.0",
+    "anyio>=4.2.0",
+    "yt-dlp>=2026.3.3",
+    "youtube-search-next>=1.0.4",
+]
+requires-python = ">=3.10"
+
+[project.scripts]
+yt = "mps_youtube.main:main"
+
+[tool.ruff]
+# Same as Black.
+line-length = 80
+
+[tool.ruff.lint]
+# Enable standard rules
+select = ["E", "F", "W"]
+ignore = ["E501", "E721", "E741", "F523"]
+
+# Allow fix for some rules
+fixable = ["ALL"]
+unfixable = []
+
+[tool.ruff.lint.per-file-ignores]
+"mps_youtube/commands/__init__.py" = ["E402", "F401"]
+"mps_youtube/commands/search.py" = ["E402"]
+"mps_youtube/listview/__init__.py" = ["F401"]
+"mps_youtube/players/__init__.py" = ["F401"]
+"mps_youtube/__init__.py" = ["F401"]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.15.4",
+]
diff --git a/requirements.txt b/requirements.txt
index 904c4c47..69ad7929 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,8 +1,8 @@
-httpx<0.28
-requests
-pyreadline3 ; platform_system=="Windows"
+httpx
 pyperclip
-youtube-search-python>=1.6.5
 yt-dlp>=2023.9.24
+click
+youtube-search-next
+prompt-toolkit
 colorama ; platform_system=="Windows"
 pylast
diff --git a/test_mpv_direct.py b/test_mpv_direct.py
new file mode 100644
index 00000000..67616073
--- /dev/null
+++ b/test_mpv_direct.py
@@ -0,0 +1,14 @@
+import subprocess
+import os
+
+# A known working stream (small file)
+url = "https://www.w3schools.com/html/mov_bbb.mp4"
+cmd = ["mpv", "--no-video", "--ao=null", url]
+
+print(f"Running: {' '.join(cmd)}")
+process = subprocess.Popen(cmd, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+stdout, stderr = process.communicate()
+
+print(f"Exit code: {process.returncode}")
+print("Stderr output:")
+print(stderr.decode())