misc_scripts

Miscellaneous scripts to automate common tasks.

User Scripts: Tampermonkey userscripts that enhance supported sites with faster actions and metadata helpers.
- plex-playlist-watch-status.user.js: Shows Plex playlist watch status with simple triangle indicators.
- myanimelist-addtolist-improved.user-script.js: Adds quick MyAnimeList watch-status dropdowns directly to anime pages.
Libraries: Reusable helper modules shared by multiple scripts in this repository.
- browser_utils.py: Cross-platform browser launcher with popup, new-window, and maximized modes.
Projects: Larger multi-file tools with dedicated packages, helpers, tests, or service components.
- plex_db_tool: Package-backed Plex database transfer and playlist sync CLI with root shim.
- video-optimizer-v2: Multi-file video transcoder with metadata providers, cache tooling, and tests.
- youtube-video-downloader: Bundle of CLI, TUI, web, userscript, and helper download tools.
- mini-dlna-server: Experimental DLNA server project with multiple networking and service modules.
Scripts: Standalone utilities for media, metadata, downloads, reports, and local tooling.
- Media Conversion & Transcription
  - cbr_to_cbz_converter.py: Converts CBR archives to CBZ files using parallel in-memory processing.
  - media-to-mp3.py: Converts media files to MP3 using each file's first audio track.
  - srt_to_transcript.py: Extracts plain-text transcripts from SRT subtitle files.
  - transcribe_to_srt.py: Transcribes media files into SRT subtitles using SubsAI models.
  - transcribe_audio.py: Transcribes audio with diarization and exports SRT, VTT, JSON, and TXT.
  - insanely-fast-whisper.py: Minimal Whisper transcription script for fast speech-to-text generation.
  - mp4-to-mp3-converter-with-origin.py: Converts MP4 files to tagged MP3s with thumbnail and source metadata.
  - merge-audio-files-to-one-output.py: Interactive tool for merging multiple audio files into one output.
  - music_style_classifier.py: Classifies music genre from audio or video files.
- Metadata, Cataloging & Reports
  - compare_package_versions.py: Compares proposed package versions against installed ones, highlighting upgrades and downgrades.
  - imdb_title_query.py: Queries IMDb TSV datasets with filtering, column selection, and downloads.
  - smartls.py: Metadata-aware directory explorer with rich filtering, sorting, and report exports.
  - series_info_tool.py: Groups video files and fetches series metadata with MyAnimeList integration.
  - netflix_watch_status.py: Builds Netflix viewing history reports with metadata and standalone HTML output.
  - file_metadata_scanner.py: Scans files for metadata and exports CSV, JSON, and HTML bundles.
  - gog_galaxy_exporter.py: Exports GOG Galaxy library data to CSV, JSON, and Excel.
  - gog_csv_to_html.py: Builds an interactive HTML game library viewer from GOG exports.
  - file_grouper.py: Groups related files by filename patterns and series metadata.
  - series_completeness_checker.py: Analyzes series collections for missing episodes, gaps, and completeness.
  - series_archiver.py: Archives series into organized folders with optional integrity checks.
  - series_bundler.py: Bundles episodes into standardized archive folders using parsed filename metadata.
  - latest_episodes_viewer.py: Generates an HTML page listing the latest episodes in a collection.
- Local Tooling & Automation
  - ollama_tool_agent.py: Approval-gated local Ollama tool agent with streamed reasoning, persistent task state, and file tools.
- Web Services, Networking & Downloads
  - simple_scraper_proxy.py: Fetches pages with YAML selectors and returns scraped RSS feeds.
  - m3u8-to-mp4-flask-webservice.py: Flask service that inspects and converts M3U8 streams to MP4.
  - m3u8-to-mp4-flask-webservice-simple.py: Simplified Flask service that streams M3U8 inputs directly into MP4 files.
  - udio-flask-webservice.py: Downloads songs with embedded metadata, cover art, and optional enrichment.
  - rss-feed-downloader.py: Downloads selected RSS enclosures with terminal-based selection and progress.
  - simple_http_proxy.py: Serves remote resources through simple URL-based local proxying.
  - socks5_http_tunneler.py: Local HTTP tunnel that forwards upstream traffic through SOCKS5.
  - radio_station_checker.py: Checks radio stream availability with a high-performance terminal interface.
  - serve_local.py: Serves local files or folders with optional live-reload and file proxy.
- File, Clipboard & Document Utilities
  - clipboard-monitor.py: Monitors clipboard changes and appends captured content to CSV.
  - file-renamer-script.py: Builds CSV-based rename mappings from clipboard IDs before applying changes.
  - md_to_docx.py: Converts Markdown documents into formatted DOCX files.
Bash Scripts: Shell utilities for platform-specific maintenance tasks.
- macos-uninstall-python3.10.sh: Safely removes python.org Python 3.10 installations from macOS.
Experimental: Early-stage ideas and prototypes that are not yet stable.
- lyrics-timing-generator.py: Experimental timed-lyrics generator built from transcription and LLM formatting.

User Scripts

These user scripts enhance the webservice functionality by integrating download buttons directly into the respective web interfaces. They automatically capture song metadata and cover art, then send this information to the webservice for processing, making the download process seamless and efficient. They have been tested with Tampermonkey on Chrome.

udio-download_ext-button.user.js: Adds a "Download with metadata" button to Udio song pages
riffusion-download_ext-button.user.js: Adds a "Download with metadata" button to Riffusion song pages

plex-playlist-watch-status.user.js

A Tampermonkey script that adds simple triangle indicators to Plex playlist items, showing their watch status (watched/unwatched) based on metadata from the Plex API. It fetches the watch status of each item in a Plex playlist and displays a triangle icon next to each item, indicating whether it has been watched or not. The script is designed to enhance the user experience by providing quick visual feedback on the watch status of playlist items.

myanimelist-addtolist-improved.user-script.js

A Tampermonkey script that augments every watch-status button on MyAnimeList season and anime pages with a quick-status chevron dropdown, allowing you to set or change the watch status of any title without leaving the page.

Features

Adds a seamless chevron trigger to the right of every .btn-anime-watch-status button, styled to look like a native extension of the host button (matching background, border, height, and border-radius)
Dropdown lists all five statuses: Plan to Watch, Watching, On Hold, Completed, Dropped
Applies status changes in-page via fetch (same-origin form POST) — no page navigation required
Automatically detects whether the title is being added or edited by following MAL's server-side redirect
Reloads the page after a successful save so button state reflects the new status
Disables invalid statuses (Watching, Completed, On Hold, Dropped) for not-yet-aired titles, keeping only Plan to Watch enabled
Toast notifications for success and error feedback
Keyboard navigation (Escape, Arrow Up/Down) and full ARIA support
Observes dynamic content and SPA navigation to augment newly added buttons automatically
DEBUG constant at the top of the script to toggle verbose console logging on/off

Matches

https://myanimelist.net/anime/season/*
https://myanimelist.net/anime/*

Libraries

browser_utils.py

A cross-platform browser launcher library with support for different window modes. Provides functionality to open URLs in the default browser with control over window size, position, and behavior. Used by other scripts to provide consistent browser interaction across platforms.

Features

Automatic detection of default browser on Windows, macOS, and Linux
Multiple window modes:
- Default: Opens in new tab or reuses existing window
- New Window: Opens in a new browser window
- Popup: Chromeless window, half screen width, centered
- Maximized: Full screen window
Custom window size and position support
Platform-specific optimizations for Chrome, Firefox, Edge, Safari
Screen dimension detection for popup positioning

API

BrowserLauncher class with methods:
- get_screen_dimensions(): Detect primary screen size
- get_browser_command(): Find default browser executable
- open_urls(urls, new_window, popup, maximized, window_size, window_position): Open URLs with specified mode
Convenience function: open_urls_in_browser(urls, ...)

Requires

Platform-specific: winreg (Windows), ctypes (Windows)

Projects

Larger tools in this repository that have their own subfolders, packages, helpers, or tests.

plex_db_tool

A CLI for transferring Plex watch history and playlists between Plex library databases, matching items by exact filename basename only. The user provides source and target locations, and the tool discovers com.plexapp.plugins.library.db by exact filename under those locations, validates that each file is a usable Plex SQLite database, and then performs watch-history or playlist operations without relying on media paths.

The main entrypoint is the root shim plex_db_tool.py, which forwards into the plex_db_tool package. You can also run the package directly with python -m plex_db_tool. The older root script plex_watch_status_transfer.py is still available as a compatibility alias.

Features

transfer-watch-status, transfer-playlists, sync-metadata-playlists, list-playlists, list-libraries, and list-accounts subcommands for transfer and inspection workflows
Accepts source and target locations instead of requiring the full DB filename path
Locates com.plexapp.plugins.library.db by exact filename and verifies the schema before continuing
Exact basename matching only; no partial filename matching
Optional source and target library section filters by library name
Separate source and target account ids for account-scoped read and write operations
Interactive mode when required transfer inputs are omitted, including library, account, and playlist selection from the discovered source and target DB contents
Smart interactive defaults for shared named accounts and existing CLI-provided values
Dry-run by default with table, CSV, or JSON console output and JSON, CSV, or table report output
Configurable table columns with compact labels, right-aligned numeric columns, truncation, and optional column:width overrides
Dry-run filters for all, warnings, and errors
Conservative merge behavior for existing target history with optional overwrite or skip policies
Planned mutations are only created when the target actually needs to change; in-sync and target-ahead rows are left untouched unless conflict policy explicitly allows overwrite behavior
Guarded write path that inspects the target metadata_item_views schema before inserting history rows
Updates Plex account-scoped watch state in both metadata_item_views and metadata_item_settings when supported by the target schema
Playlist listing supports library scoping, optional inclusion of empty playlists, and shows playlist ownership via account_id when available
Playlist transfer uses the same filename-based matching strategy as watch transfer for playlist members
Playlist transfer supports selecting specific playlists by id or exact name and conflict handling via unique, merge, replace, or skip
Metadata-playlist sync creates or updates one Plex playlist per selected JSON group from grouped metadata exports such as series_completeness_checker.py
Metadata-playlist sync supports the same --status-filter, --modified, --episodes-found, --episodes-expected, and --sort group filters used by series_archiver.py
Metadata-playlist sync supports --playlist-prefix and --playlist-suffix so generated playlists can be namespaced without changing the source JSON
Metadata-playlist sync supports --playlist-status-prefix to derive prefixes automatically from each group's status, such as [Incomplete] or [Complete]
Metadata-playlist sync supports --playlist-status-suffix to derive suffixes automatically from each group's status instead of putting the status at the front
Metadata-playlist sync also supports --playlist-complete-suffix so playlists can be labeled differently when all expected episodes are available for the season
Metadata-playlist sync supports JSON, CSV, and table console output plus matching JSON, CSV, or table report files
Metadata-playlist sync tracks previously generated playlists by the stored source group_key, so changing or removing a prefix/suffix updates the same playlist instead of creating a duplicate when the group identity still matches
Empty playlists are excluded by default for both list-playlists and transfer-playlists unless --include-empty-playlists is used
Playlist transfer requires an explicit --target-account-id in non-interactive mode so created or updated target playlists are assigned to the intended Plex account
Apply mode blocks until Plex Media Server is no longer running

Usage Examples

# Show top-level help through the main root shim
python plex_db_tool.py --help

# Preview transfer results without writing changes
python plex_db_tool.py transfer-watch-status --source-path "C:\Users\you\AppData\Local\Plex Media Server" --target-path "D:\Backup\Plex Media Server" --source-account-id 1 --target-account-id 1 --report transfer-report.json

# Restrict transfer to named libraries and apply changes
python plex_db_tool.py transfer-watch-status --source-path "C:\Users\you\AppData\Local\Plex Media Server" --target-path "D:\Backup\Plex Media Server" --source-library TV --target-library TV --source-account-id 1 --target-account-id 1 --apply

# Show a compact console table during dry-run
python plex_db_tool.py transfer-watch-status --source-path "C:\Users\you\AppData\Local\Plex Media Server" --target-path "D:\Backup\Plex Media Server" --source-account-id 1 --target-account-id 1 --console-format table --columns status,dry_run_status,source_watch_count,target_watch_count,source_filename,target_filename

# Export a CSV review report
python plex_db_tool.py transfer-watch-status --source-path "C:\Users\you\AppData\Local\Plex Media Server" --target-path "D:\Backup\Plex Media Server" --source-account-id 1 --target-account-id 1 --report transfer-report.csv

# Inspect available libraries and accounts before transferring
python plex_db_tool.py list-libraries --path "C:\Users\you\AppData\Local\Plex Media Server"
python plex_db_tool.py list-accounts --path "C:\Users\you\AppData\Local\Plex Media Server"

# List playlists in a DB and show owner account ids when available
python plex_db_tool.py list-playlists --path "C:\Users\you\AppData\Local\Plex Media Server" --library TV --console-format table

# Preview transferring selected playlists into a target account
python plex_db_tool.py transfer-playlists --source-path "C:\Users\you\AppData\Local\Plex Media Server" --target-path "D:\Backup\Plex Media Server" --source-library TV --target-library TV --target-account-id 1 --playlist "Favorites" --playlist-conflict-policy merge

# Build or refresh one Plex playlist per filtered JSON group
python plex_db_tool.py sync-metadata-playlists --input-json ".\series-results.json" --target-path "C:\Users\you\AppData\Local\Plex Media Server" --target-library "TV Shows" --target-account-id 1 --status-filter "+incomplete +watched_partial" --episodes-found ">=2" --sort

# Namespace generated playlist names and write a JSON review report
python plex_db_tool.py sync-metadata-playlists --input-json ".\series-results.json" --playlist-prefix "[Incomplete] " --playlist-suffix " [Review]" --console-format json --report .\sync-playlists.json

# Automatically prefix playlist names from each group's status
python plex_db_tool.py sync-metadata-playlists --input-json ".\series-results.json" --playlist-status-prefix

# Automatically suffix playlist names from each group's status
python plex_db_tool.py sync-metadata-playlists --input-json ".\series-results.json" --playlist-status-suffix

# Append an extra suffix only when a season is complete
python plex_db_tool.py sync-metadata-playlists --input-json ".\series-results.json" --playlist-prefix "[Anime] " --playlist-complete-suffix " [Complete]"

# Combine every selected episodes_expected=1 group into one playlist
python plex_db_tool.py sync-metadata-playlists --input-json ".\series-results.json" --one-of-one-playlist "[A] One Of One"

# Export a compact table report with custom columns
python plex_db_tool.py sync-metadata-playlists --input-json ".\series-results.json" --console-format table --columns target_playlist,status,matched_item_count,unmatched_item_count,notes --report .\sync-playlists.txt --report-format table

# Omit required transfer values to use the interactive workflow
python plex_db_tool.py transfer-watch-status

# Or run the package directly
python -m plex_db_tool --help

# Or use the older compatibility script name
python plex_watch_status_transfer.py --help

Notes

In apply mode the script waits until Plex Media Server has fully stopped before it starts writing.
Dry-run mode can be used while Plex is still running, but copied DBs are still safer.
If the provided location contains multiple matching DB files, the script refuses to guess and asks for a narrower path.
If multiple target records share the same basename, the tool uses secondary metadata to decide whether the match is safe enough to apply.
If you omit the subcommand entirely, the CLI defaults to transfer-watch-status.
Interactive transfer mode first performs a dry-run, shows only rows with planned mutations by default, and then asks whether to apply the changes.
By default, rows that are already in sync or where the target is already ahead do not produce planned mutations.
Depending on the Plex schema version, source and target account ids may be required for account-scoped reads and writes.
Playlist discovery can read both legacy/custom playlist rows and metadata-backed Plex playlists.
transfer-playlists excludes empty playlists by default and prints a notice explaining how to include them.
transfer-playlists requires --target-account-id in non-interactive mode; interactive mode can prompt for it.
sync-metadata-playlists defaults --playlist-conflict-policy to replace, so rerunning it refreshes existing playlists from the current JSON selection.
sync-metadata-playlists also removes previously synced playlists when their stored group_key is no longer present in the current metadata selection for the chosen target account and library scope.
sync-metadata-playlists uses the standard %LOCALAPPDATA%\Plex Media Server folder as the target when --target-path is omitted.
sync-metadata-playlists requires --target-library and --target-account-id in non-interactive mode; if you omit them in an interactive terminal session, the command prompts you to choose them.
sync-metadata-playlists table output supports --columns with column or column:width entries; mandatory columns are status and target_playlist.
--one-of-one-playlist collapses all selected groups whose original metadata reports episodes_expected=1 into one synthetic playlist, which is useful when movie-like metadata should still be synced as a single mixed collection.
If a playlist was previously created with a prefix or suffix, later syncs can rename it to the new configured name as long as the stored metadata group_key still identifies the same JSON group.
--playlist-status-prefix turns a group's stored status value into a prefix automatically, so incomplete becomes [Incomplete] and complete_with_extras becomes [Complete With Extras].
--playlist-status-suffix does the same at the end of the playlist name instead of the beginning.
Prefix options are mutually exclusive with each other, and suffix options are mutually exclusive with each other, so each sync run can use at most one prefix mode and one suffix mode.
--playlist-complete-suffix is applied when episodes_found >= episodes_expected for groups with a known expected count; if no expected count is present, complete and complete_with_extras statuses are treated as complete.

video-optimizer-v2

A script that allows for quick and easy optimization of videos. Just supply a list of videos on the command line or drag and drop them onto the script. You get a list of choices based on the contents of the videos such as which subtitles to make default, and which audio to make default along with target quality and resolution.

It is made specifically for transcoding for example tv-shows from your legacy media in a quick and simple way. Just drag a whole season onto the script and easily convert it for use on your phone.

It now also supports lookup of meta data from common anime databases and imdb. It will automatically download the metadata and add it to the video.

Check out branch mediaoptimizer_v1 for the old version.

Project Files

metadata_cache_manager.py

CLI helper for the video-optimizer providers to inspect and control cache TTLs. Supports status, refresh, invalidate, and set-expiry (accepts long form like "3 days" or short form like 2m7d). TTL is persisted per provider (IMDb, Anime) and invalidate forces TTL to 0 so cache refreshes on next access. Optional --no-color disables colored output.

metadata_provider.py

Base metadata provider class that defines the interface for metadata retrieval services. This abstract class provides a common structure for implementing different metadata sources, handling search functionality, and managing metadata formatting for video files.

anime_metadata.py

Implements metadata retrieval from anime databases such as AniList and MyAnimeList. Provides specialized handling for anime series metadata including episode information, season data, air dates, and anime-specific details like studio information and Japanese titles.

imdb_metadata.py

Implements metadata retrieval from the Internet Movie Database (IMDb). Handles both movies and TV series metadata including cast information, directors, release dates, ratings, and plot summaries. Integrates with IMDb's API or web scraping for comprehensive movie and TV show information.

plex_metadata.py

Implements metadata retrieval from Plex Media Server. Connects to a local or remote Plex server to fetch metadata for movies and TV shows stored in the Plex library. Retrieves details such as titles, descriptions, genres, ratings, and artwork associated with the media files.

myanimelist_watch_status.py

Reads MyAnimeList watch-status data for the optimizer's metadata and tagging workflows.

Requires

Use the video-optimizer-v2/requirements.txt file to install the requirements.

ffmpeg-python
requests
pandas
tqdm
rapidfuzz
inquirer
mutagen

youtube-video-downloader

A collection of youtube download scripts using the ytdl_helper library. It includes a command-line interface and a text-based user interface (TUI) for downloading YouTube videos and audio. It also includes a Flask web service for downloading YouTube videos and audio via a web interface, and a user script for adding a download button to YouTube pages. Now integrates with music_style_classifier.py to classify the music style of downloaded audio files.

Project Files

ytdl_helper library

This library provides functionalities for downloading YouTube videos and audio efficiently. Users can fetch video information (metadata, available formats) and download content directly. The library supports various output formats (e.g., mp4, mp3) and allows users to specify desired resolution, audio bitrate, and target directory. It is used by both the command-line and TUI scripts.

youtube-video-downloader-cli.py

A command-line tool for downloading YouTube videos and audio using the ytdl_helper library. It allows fetching video information (metadata, available formats) as JSON or downloading content directly. Users can specify desired resolution, audio bitrate, output format (e.g., mp4, mp3), and target directory via command-line arguments. Download progress is displayed using tqdm progress bars.

Usage (Examples)

# Get video info as JSON
python youtube-video-downloader-cli.py info "VIDEO_URL"

# Download best available video+audio (defaults to mp4)
python youtube-video-downloader-cli.py download "VIDEO_URL"

# Download audio only as mp3 to a specific directory
python youtube-video-downloader-cli.py download "VIDEO_URL" -a --format mp3 -o ./downloads

# Download 720p video (closest) with 192k audio (closest) as mkv
python youtube-video-downloader-cli.py download "VIDEO_URL" -r 720p -b 192k -f mkv

Requires

ytdl_helper (and its dependencies, likely yt-dlp)
tqdm
ffmpeg (must be installed and in the system PATH)
music_style_classifier.py

youtube-video-downloader-gui.py

A Text-based User Interface (TUI) built with urwid for downloading YouTube videos. It takes video URLs as command-line arguments, fetches their information asynchronously using ytdl_helper, and displays them in an interactive list. Users can select items, choose specific video and audio formats via a detailed dialog, and initiate downloads. The TUI shows status updates and progress bars for each item. Batch pre-selection of best audio or video is possible via command-line flags (--audio-only, --video).

Features

Interactive TUI powered by urwid.
Handles multiple URLs provided via command line.
Displays video title, duration, status, and progress.
Item selection using +/- keys.
Detailed format selection dialog (Enter key) allowing choice of:
Mode (Video+Audio, Video Only, Audio Only).
Specific video streams (resolution, codec, etc.).
Specific audio streams (bitrate, codec, etc.).
Initiates downloads for selected items (d key).
Real-time status and progress updates.
Batch mode flags (--audio-only, --video) for quick downloads.
Logs activity to logs/youtube_downloader.log.

Requires

ytdl_helper (and its dependencies, likely yt-dlp)
urwid
ffmpeg (must be installed and in the system PATH)
music_style_classifier.py
Note! (Windows specific): ctypes (standard library, used for console setup)

youtube-video-downloader-flask-ws.py & youtube-video-downloader.user-script.js

A Flask web service that allows downloading YouTube videos and audio via a web interface. It accepts video URLs via POST requests, fetches metadata, and downloads the content. The service supports various output formats (e.g., mp4, mp3) and allows users to specify desired resolution, audio bitrate, and target directory. It returns download progress and status updates in JSON format. To use it, run the Flask web service and send POST requests with the video URL and desired parameters. The web service can be accessed via a user script (e.g., Tampermonkey) that adds a button to download videos directly from YouTube pages. The user script can be installed in a browser extension like Tampermonkey, which allows users to add custom scripts to web pages. The script adds a button to YouTube video pages, enabling users to download videos directly from the page.

Usage (Examples)

# Start the Flask web service
python youtube-video-downloader-flask-ws.py

# Send a POST request to download a video
curl -X POST -H "Content-Type: application/json" -d '{"url": "VIDEO_URL", "format": "mp4", "resolution": "720p", "audio_bitrate": "192k", "output_dir": "./downloads"}' http://localhost:5000/download

Features

Accepts video URLs via POST requests.
Fetches metadata and downloads content in various formats.
Provides download progress and status updates in JSON format.
Supports output formats (e.g., mp4, mp3) and allows users to specify desired resolution, audio bitrate, and target directory.
Returns download progress and status updates in JSON format.
Logs activity to logs/youtube_downloader.log.

Requires

Flask
ytdl_helper (and its dependencies, likely yt-dlp)
ffmpeg (must be installed and in the system PATH)
music_style_classifier.py

mini-dlna-server

A script that runs a local dlna server instance on the computer, taking as input a command line argument pointing out the folder to serve to clients.

It is intended if I get time to do it, to stabilize it to properly handle conenctions, work better with Windows 11, and transcode media to the client using ffmpeg.

Note! Currently it is extremely unstable and mostly doesn't work. If anyone wants to refactor it and fix some of the remaining issues that would be cool. :)

Requires

mutagen

Scripts

cbr_to_cbz_converter.py

A script to convert Comic Book RAR (CBR) files to Comic Book ZIP (CBZ) files using in-memory processing. It does this to avoid first extracting the files onto the drive and then recompressing them, generating additional IO operations. Recursively scans directories for CBR files and converts them in parallel with progress tracking.

Features

In-memory processing to minimize disk I/O
Recursive directory scanning for CBR files
Multi-threaded parallel conversion for faster processing
Progress bars with tqdm for visual feedback
Automatic CBZ duplicate detection (skips existing files)
Optional deletion of original CBR files after successful conversion
Dual extraction method support:
- libarchive-c (preferred, faster, requires an installation of libarchive library)
- rarfile (fallback if libarchive unavailable, requires unrar tool installed)
Detailed logging with configurable verbosity levels
Comprehensive conversion statistics and error reporting
Thread-safe statistics tracking
Automatic cleanup of partial files on failure

Usage Examples

# Convert all CBR files in a directory (deletes originals by default)
python cbr_to_cbz_converter.py /path/to/comics

# Keep original CBR files after conversion
python cbr_to_cbz_converter.py /path/to/comics --keep-original

# Use parallel processing with 4 workers
python cbr_to_cbz_converter.py /path/to/comics -j 4

# Verbose output (INFO level)
python cbr_to_cbz_converter.py /path/to/comics -v

# Very verbose output (DEBUG level)
python cbr_to_cbz_converter.py /path/to/comics -vv

# Quiet mode (errors only)
python cbr_to_cbz_converter.py /path/to/comics --quiet

# Combine options
python cbr_to_cbz_converter.py /path/to/comics --keep-original -j 4 -v

Requires

tqdm
libarchive-c (recommended) or rarfile (fallback)
- libarchive-c requires libarchive DLL installed on system
- rarfile requires UnRAR tool installed and on PATH

password_generator.py

A small CLI for generating strong, easy-to-remember passwords.

Features

Secure random generation using the secrets module
Modes: random, pronounceable (syllable-based), and diceware (wordlist)
Options to exclude ambiguous characters (0/O, 1/l, etc.), include/exclude digits and symbols
Enforces at least two characters from each enabled subset (upper/lower/digits/symbols)
Built-in small wordlist plus support for the EFF large diceware list (downloadable)

Usage examples

# Random 12-char password (mixed case, digits)
python password_generator.py --length 12

# Pronounceable password using 4 syllables
python password_generator.py --mode pronounceable --pronounceable-syllables 4 --length 12

# Diceware using bundled builtin wordlist (3 words)
python password_generator.py --mode diceware --wordlist builtin --dice-words 3

# Install the recommended EFF wordlist for diceware mode
python password_generator.py --install-wordlist

compare_package_versions.py

Compares proposed package versions against installed versions. Useful for inspecting pip output or a list of package-version pairs and highlighting downgrades, upgrades, and local version changes.

Usage Examples

# Compare from pip output
pip install -r requirements.txt | python compare_package_versions.py

# Compare from a string argument
python compare_package_versions.py "requests==2.31.0 urllib3==2.2.1"

# Disable ANSI colors
python compare_package_versions.py --no-color "requests==2.31.0"

Requires

packaging

ollama_tool_agent.py

A local Ollama-based task agent that can inspect files and execute approved tool actions step by step. It streams visible thinking to the console, requires explicit user approval before each tool execution, preserves recent turn context across turns, and keeps the session open for follow-up requests.

Features

Streams user-visible thinking and response progress in the console
Uses structured JSON responses with a single next action per turn
Requires explicit approval before any tool call is executed
Persists recent thinking, plans, answers, guidance, tool inputs, and tool outputs as task state
Includes built-in tools for list_files, crc32, and batch rename_files
Supports follow-up guidance so the agent can continue the same task instead of restarting from scratch
Exposes CLI options for model name, host, read timeout, max steps, working directory, and requested context size

Usage Examples

# Start an interactive session
python ollama_tool_agent.py

# Run a single task from the command line
python ollama_tool_agent.py "List the files in C:\Media and tell me how many there are"

# Override the model and requested context size
python ollama_tool_agent.py --model gemma4:e2b --num-ctx 65536 "Compute CRC32 for files in C:\Downloads\Season 1"

Requires

ollama
httpx
colorama
tqdm

simple_scraper_proxy.py

A standalone scraping proxy that fetches an upstream HTML page, extracts feed data using a local YAML selector template, and returns an RSS 2.0 feed.

Features

Keeps the original simple_http_proxy.py untouched while reusing its simple local server model
Fetches a remote HTML page and parses it with BeautifulSoup
Loads scraping rules from local YAML templates in simple_scraper_proxy_templates
Renders RSS 2.0 output with an atom:self link and optional nyaa:* namespaced fields
Includes an example Nyaa template that maps torrent table rows into RSS items

Usage Examples

# Start the scraper proxy
python simple_scraper_proxy.py --port 8081

# Request RSS using the bundled Nyaa template
http://localhost:8081/?url=<url>&template=nyaa_rss

Requires

beautifulsoup4
PyYAML

imdb_title_query.py

A simple CLI for querying IMDb title.*.tsv.gz datasets using the declared dataset schemas, substring search, basic filters, and plain-text table output. It can read a specific file, scan a directory for the matching dataset, or use the same default cache folder as the video-optimizer-v2 IMDb provider.

Features

Declared schemas for title.basics, title.akas, title.crew, title.episode, title.principals, and title.ratings
Simple filtering with operators such as =, !=, ~, !~, >, >=, <, and <=
Selectable output columns and optional query restriction to specific search columns
Reads .tsv.gz files directly without extracting them first
Defaults to %USERPROFILE%\.video_metadata_cache\imdb when no path is provided
Prompts before downloading a missing dataset interactively, with --download and --force-download options for unattended or refresh workflows

Usage Examples

# Query a specific IMDb dataset file
python imdb_title_query.py C:\path\to\title.basics.tsv.gz --query matrix --where titleType=movie

# Use the shared IMDb cache folder and auto-download if missing
python imdb_title_query.py --dataset title.ratings --download --where numVotes>=100000

# Force re-download of a cached dataset into a custom cache directory
python imdb_title_query.py --dataset title.akas --force-download --cache-dir D:\imdb-cache --query ghost

# Show only selected columns
python imdb_title_query.py --dataset title.basics --columns tconst,primaryTitle,startYear --query alien

# Print the declared schema for a dataset
python imdb_title_query.py --show-schema title.episode

Requires

No external dependencies required (uses only Python standard libraries)

media-to-mp3.py

Converts one or more media files to .mp3 in the same folder, always using the first audio track from each input. Shows a per-file conversion progress bar and keeps FFmpeg's default MP3 encoding settings.

Usage Examples

# Convert one file
python media-to-mp3.py video.mkv

# Convert multiple files
python media-to-mp3.py file1.mkv file2.mp4 file3.webm

# Convert using wildcard patterns (quoted so the script expands them itself)
python media-to-mp3.py "*.mkv" "subfolder/**/*.mp4"

# Overwrite existing MP3 outputs
python media-to-mp3.py --force file1.mkv file2.mp4

Requires

FFmpeg (ffmpeg and ffprobe on PATH)
tqdm (optional, for a richer progress bar)

smartls.py

A smart directory explorer for querying files and folders with composable filters, metadata-aware sorting, and multiple output modes. It scans a filesystem tree once, aggregates directory metadata, and can render the filtered result set as a tree, flat list, JSON, or CSV.

Features

Recursive traversal with optional depth limiting
Composable filters for direct child counts, recursive file counts, direct directory counts, sizes, ages, names, extensions, entry type, and depth
Numeric expression syntax for exact matches, inequalities, ranges, enumerations, modulo checks, and approximate values
Directory metadata including direct file and directory counts, recursive file counts, total descendant size, empty and sparse flags, and deepest nesting
File metadata including size, timestamps, MIME type, symlink details, and optional MD5 or SHA256 hashing
Output modes for tree view, flat list, formatted console tables, JSON, CSV, self-contained HTML web reports, and summary statistics
Sorting, limiting, grouping, relative or absolute paths, human-readable or raw byte sizes, optional icons, and ANSI color control

Usage Examples

# All directories with no files anywhere below them
python smartls.py --type d --files =0 --long

# Directories with 1 to 3 recursive files, sorted by total size descending
python smartls.py --type d --files 1..3 --sort -size --stats

# Large files modified within the last week
python smartls.py --type f --size >=50MB --mtime <7d --flat

# Python and JavaScript files excluding test names
python smartls.py ./src --ext py,js --not --name "*test*" --long

# Export matching directories to JSON
python smartls.py --type d --files =0 --json

# Render console output in aligned columns like the web report
python smartls.py --type f --flat --columns type,size,modified,relative-path --bytes

# Export a self-contained HTML report
python smartls.py --type f --size >=10MB --export-html smartls-report.html

Notes

--or separates filter groups and --not negates only the next filter
In tree mode, matching descendants keep their ancestor path visible for context
--columns takes a comma-separated list of metadata columns: type, size, modified, created, accessed, children, recursive_files, mime, extension, relative_path, full_path, owner, group, permissions
The HTML export is self-contained and can be opened directly in a browser without external assets
Presets, config files, and parallel traversal are not included in this implementation

series_info_tool.py

A comprehensive tool to extract and display series information for video files, with MyAnimeList integration. Groups video files by series title, retrieves metadata from anime and movie databases, and provides convenient ways to access online information. Designed for Windows shell:sendto and drag-drop operations.

Features

Groups video files by series title using FileGrouper
Retrieves metadata from MyAnimeList, IMDb, and other sources
Extracts and displays comprehensive series information including:
- Basic metadata (Type, Year, Status, Rating, Episodes, Seasons)
- MyAnimeList information (Score, Rank, Studios, Genres, Themes)
- IMDb information (Rating, Votes, Metascore)
- Watch status from MyAnimeList XML exports
Multiple output formats:
- default: Simple text output
- aligned: Right-aligned labels for better readability
- color: ANSI colored output
- json: Machine-readable JSON format
URL operations:
- Display MyAnimeList URLs
- Copy URLs to clipboard (Windows)
- Open URLs in browser with window mode control
Browser window modes via browser_utils:
- default: New tab/window
- popup: Chromeless, half-width, centered
- maximized: Full screen
Configurable logging levels including DEBUG2 for regex debugging
Extended metadata mode for verbose output

Usage Examples

# Display information about files
series_info_tool.py file1.mkv file2.mkv

# Copy MyAnimeList URLs to clipboard
series_info_tool.py --copy file1.mkv file2.mkv

# Open URLs in browser (new tab)
series_info_tool.py --open file1.mkv

# Open in popup mode (chromeless, half-width, centered)
series_info_tool.py --open=popup file1.mkv

# Open maximized
series_info_tool.py --open=maximized file1.mkv

# Use with MyAnimeList XML for watch status
series_info_tool.py --mal-xml animelist.xml file1.mkv

# Different output formats
series_info_tool.py --format aligned file1.mkv
series_info_tool.py --format color file1.mkv
series_info_tool.py --format json file1.mkv

# Extended metadata with all sources and full tags
series_info_tool.py --extended-metadata file1.mkv

# Debug mode with regex debugging
series_info_tool.py --log-level DEBUG2 file1.mkv

Requires

file_grouper (local module)
browser_utils (local module)

netflix_watch_status.py

Reads a Netflix viewing history CSV, classifies entries as movies or series episodes, resolves metadata from IMDb and anime providers when available, and generates both console and standalone HTML watch-status reports. It also produces a CSV template of titles that still need IMDb-oriented override mappings.

Features

Parses Netflix viewing-history CSV exports with fallback CSV encodings and basic mojibake repair
Uses Netflix-specific title parsing plus optional metadata lookups to improve movie/series classification and resolve season, episode, year, runtime, genres, rating, vote count, and source IDs
Multiple output modes:
- default: Text summary of unique movies and series
- json: Machine-readable export of the summary and resolved entries
- table: Treegrid-style console table grouped by title, season, and episode
- webapp: Self-contained HTML report with filtering, selection details, and artwork thumbnails
Table and webapp rows can show watched progress such as watched/total episodes when provider episode lists are available, including synthetic unwatched episode rows in the grouped view
Supports CSV-based episode title overrides via netflix_episode_title_overrides.csv and --episode-title-overrides, including canonical title, year, source ID, and episode-title remapping
Automatically exports an *_unmapped_imdb_titles.csv helper file to make missing override mappings easier to review and fill in
Webapp export caches thumbnails locally and prefers direct IMDb-backed poster URLs when available

Usage Examples

python netflix_watch_status.py path/to/NetflixViewingHistory.csv
python netflix_watch_status.py path/to/NetflixViewingHistory.csv --json
python netflix_watch_status.py path/to/NetflixViewingHistory.csv --table
python netflix_watch_status.py path/to/NetflixViewingHistory.csv --table --columns title,year,episode,views,average_rating
python netflix_watch_status.py path/to/NetflixViewingHistory.csv --webapp-export netflix-watch-status.html
python netflix_watch_status.py path/to/NetflixViewingHistory.csv --episode-title-overrides my_overrides.csv
python netflix_watch_status.py path/to/NetflixViewingHistory.csv --no-metadata

srt_to_transcript.py

Saves contents of the specified .srt files to a plain text transcripts.

Requires

srt

transcribe_to_srt.py

Transcribes the specified media files such as .mkv to .srt subtitles. Defaults to model WhisperX and language English ("en") for transcription. The model should automatically download and install when the script is run.

Requires

SubsAI (https://github.com/abdeladim-s/subsai)
- Model: m-bain/whisperX

transcribe_audio.py

Object-oriented CLI to transcribe meeting audio with faster-whisper, WhisperX 3.7.6 alignment, lightweight WhisperX VAD segmentation, and ECAPA-TDNN speaker clustering. Produces SRT, VTT, JSON, and TXT outputs with optional SRT speaker tags. Designed for Python 3.11 and 3.13 and optimized for CPU.

Usage Examples

# Transcribe with default outputs (SRT, JSON, TXT)
python transcribe_audio.py meeting.wav

# Add WebVTT output
python transcribe_audio.py meeting.wav --outputs srt vtt json txt

# Disable speaker tags in SRT output
python transcribe_audio.py meeting.wav --no-srt-speaker-tags

Requires

faster-whisper
whisperx==3.7.6
torch
speechbrain
scikit-learn
numpy

insanely-fast-whisper.py

Minimalistic script to generate transcription using Whisper.

Requires

torch
transformers

mp4-to-mp3-converter-with-origin.py

Converts mp4 files to mp3 files. I use this to easily convert my Udio songs to .mp3s for my iPhone.

The converted MP3-files include:

the audio from the video file
a thumbnail based on the first frame of the video
the following metadata:
- Title & Artist (based on the filename, "Artist - Title.mp4")
  - Defaults to "Udio" if nothing else is specified
- Comments: Refferer and HostUrl based on the Windows 10/11 metadata stored with the file when downloaded

Requires

Windows 10 or Windows 11.

moviepy
eyed3

clipboard-monitor.py

Monitors the clipboard for changes and appends the contents to "clipboard.csv" file. It plays a sound when a change is detected and saved to the file.

Requires

Windows 10 or Windows 11.

winsound
win32clipboard

file-renamer-script.py

Takes a "clipboard.csv" file as input and uses the first column as a file_id that it tries to find in the files in the same folder as the script. If it finds the file, it is added to the list, with the proposed filename in the second column.

It then outputs the full list of proposed changes as file "rename_mappings.csv", so the user can verify the changes.

If the user approves them, the user simply responds "y", or "yes" or presses enter to confirm that they want to rename the files in the folder with the proposed filenames.

Requires

csv
logging
traceback

file_metadata_scanner.py

A comprehensive tool for extracting metadata from files and folders with support for various file types. Scans directories recursively or non-recursively, extracts basic file information (size, timestamps, attributes) and optional extended metadata (audio/video properties via ffmpeg, image dimensions, comic archive contents), and exports results to CSV, JSON, and an interactive HTML webapp. Supports thumbnail generation for video files and provides flexible filtering options.

Features

Recursive and non-recursive directory scanning with progress tracking
Basic metadata extraction:
- File/directory name, type, size (bytes and human-readable)
- Timestamps (created, modified, accessed)
- File attributes (hidden, readonly, system)
- File extensions
Extended metadata extraction (optional):
- Video/Audio: Duration, bitrate, codec, resolution, frame rate, audio channels, sample rate
- Images: Dimensions, format, color mode, DPI
- Comic Archives (CBR/CBZ): Page count, image formats, dimensions
Thumbnail generation for video files using video_thumbnail_generator:
- Static thumbnails (3x3 grid of frames)
- Animated WEBM thumbnails
- Configurable minimum duration filter
- Batch processing with progress tracking
Flexible filtering and exclusion:
- Filter by file extensions (e.g., only .mp4, .mkv)
- Exclude specific paths or directories
Multiple export formats:
- CSV: Tabular data for spreadsheet analysis
- JSON: Structured data for programmatic use
- HTML Webapp: Standalone interactive file explorer with search, filtering, and thumbnail viewing
Customizable export location for metadata bundles
Regenerate webapp from existing metadata without rescanning
CBR processing can be skipped to improve performance (RAR extraction is slow)

Usage Examples

# Basic scan of current directory (exports to ./metadata/)
python file_metadata_scanner.py .

# Recursive scan with custom export location
python file_metadata_scanner.py /path/to/folder -r --export-bundle /output/location

# Scan only video files with extended metadata and thumbnails
python file_metadata_scanner.py /path/to/videos -r -e mp4,mkv,avi --extended --thumbnails

# Exclude specific paths (node_modules, cache directories, etc.)
python file_metadata_scanner.py /path/to/folder -r --exclude node_modules,__pycache__,.git

# Full scan with all features and custom export location
python file_metadata_scanner.py /path/to/media -r --extended --thumbnails --export-bundle C:\MyMetadata

# Skip slow CBR processing, only process CBZ comic archives
python file_metadata_scanner.py /path/to/comics -r --extended --skip-cbr

# Set minimum video duration for thumbnail generation (e.g., 10 minutes)
python file_metadata_scanner.py /path/to/videos -r --thumbnails --min-duration 600

# Regenerate webapp from existing metadata bundle
python file_metadata_scanner.py --regenerate-bundle /path/to/bundle

# Regenerate webapp with missing thumbnails
python file_metadata_scanner.py --regenerate-bundle /path/to/bundle --thumbnails

# Verbose logging for troubleshooting
python file_metadata_scanner.py /path/to/folder -r --extended --log-level DEBUG

Requires

tqdm (for progress bars)
Pillow (for image metadata extraction)
video_thumbnail_generator (local module, for thumbnail generation)
ffmpeg and ffprobe (system binaries, for extended video/audio metadata)
libarchive-c or rarfile (for CBR comic archive extraction)
- libarchive-c (preferred): Requires libarchive DLL
- rarfile (fallback): Requires UnRAR tool on PATH

m3u8-to-mp4-flask-webservice.py

A flask web service that takes a m3u8 file as input and converts it into an MP4 file.

The webservice exposes the following interfaces:

Interface	Methods	Functions	Parameters
stream_info	GET	stream_info	url
convert	POST & GET	convert_m3u8_to_mp4	url, alt_url, title, video_id, description

Endpoints

stream_info

Returns a JSON structure describing the overall metadata of the base stream, and the contained audio and video streams.

Parameter	Description
url	The URL of the m3u8 file to be queried.

convert

Converts an input m3u8 file into a MP4 file. The input is sent as a multipart/form-data request, with the key "file" and the value being the m3u8 file to be converted.

Parameter	Description
url	The URL of the m3u8 file to be converted.
alt_url	Can be used to provide the web page where the video was located for example.
title	The title of the video.
video_id	A unique ID that is used to identify the video.
description	A description of the video.

Requires

flask
requests
m3u8
ollama

m3u8-to-mp4-flask-webservice-simple.py

A flask web service that takes a m3u8 file as input and converts it into an MP4 file.

The webservice exposes the following interfaces:

Interface	Methods	Functions	Parameters
get	POST & GET	convert_m3u8_to_mp4	url, filename

Endpoints

get

Streams a m3u8 to save it as a mp4, real-time saving only, so will take as long as the stream itself is.

Parameter	Description
url	The URL of the m3u8 file to be converted.
filename	Target filename (optional).

Requires

flask
requests
m3u8

merge-audio-files-to-one-output.py

Simple merge a bunch of audio files into one single output file. Just drag all the input files onto the script and it will be output in the same folder as the first file with the name "combined_output.<ext>". The script will ask what format, bitrate etc the output shall get.

Requires

pydub
inquirer
tqdm

udio-flask-webservice.py (udio-download_ext-button.user.js)

A flask web service that adds metadata including cover art to your song files downloaded from Udio. It comes with a user script (e.g. Tampermonkey) that simplifies this process by adding a new button to the song pages "Download with metadata" that calls the webservice. This webservice now also supports Riffusion and .m4a audio files.

The webservice exposes the following interfaces:

Interface	Methods	Functions	Parameters
/api/download_ext	POST & GET	download_ext	mp3_url, image_url, title, artist, album, genre, year, cannonical, lyrics

/api/download_ext

Downloads the specified .mp3 file and adds the provided metadata to it.

Parameter	Tag	Description
mp3_url	Not used	The URL of the `.mp3` file to be converted.
image_url	Images (Cover)	The URL of the cover art in .jpg format to use.
title	Title	The title of the track.
artist	Artist	Artist name(s) and/or alias(es).
album	Album	The title of the album.
genre	Genre	The genre of the track.
year	Year	Year of release.
cannonical	WWWAUDIOFILE	The source url of the track where it can be found permanently.

Requires

flask
requests
python-magic-bin
audio_metadata
bidict
importlib-resources
moviepy
eyed3
ffmpeg
pillow

Optional Dependencies

music_style_classifier.py
- librosa
- tensorflow
- numpy
- transformers

rss-feed-downloader.py

A script to parse RSS feeds and download enclosures (e.g., audio, video, or other files) with a console-based GUI for selection and progress tracking.

Features

Parses RSS feeds from local files or URLs.
Extracts enclosures and allows users to select files for download.
Downloads files with progress tracking and optional HTTP Basic Authentication.
Saves downloaded files to a specified directory and generates a mapping file in JSON format.

Requires

curses
urllib
json

music_style_classifier.py

A script that takes as imput an audio/video file to classify the music style of the file. It uses a pre-trained model to classify the music style and outputs the result. It is intended to be used as a command line tool, but it can also be used as a library (get_music_genre(file_path: str, track_index: int = None) -> str | None:).

Requires

librosa
tensorflow
numpy
ffmpeg
transformers

md_to_docx.py

A script that converts Markdown files to Microsoft Word DOCX format. It processes Markdown content by first converting it to HTML using mistletoe, then parsing the HTML with BeautifulSoup to create properly formatted Word documents. The converter handles various Markdown elements including headings, paragraphs, lists (ordered and unordered with nesting), tables, bold/italic text, code blocks, links, and blockquotes. Tables are automatically formatted with proper styling and column widths.

The script can be used from the command line by specifying an input Markdown file and optionally an output DOCX file. If no output filename is provided, it will generate one based on the input filename and avoid overwriting existing files.

Usage (Examples)

# Convert README.md to README.docx
python md_to_docx.py README.md

# Convert with specific output filename
python md_to_docx.py input.md output.docx

Features

Converts Markdown to properly formatted Word documents
Handles headings (H1-H9), paragraphs, lists, and tables
Supports inline formatting (bold, italic, code)
Processes nested lists with appropriate indentation
Formats tables with automatic column sizing and styling
Generates debug HTML file for troubleshooting
Automatic output filename generation to avoid overwriting

Requires

mistletoe
beautifulsoup4
python-docx

gog_galaxy_exporter.py

A script that exports game library data from GOG Galaxy 2.0 database to CSV, JSON, and Excel formats. It extracts comprehensive game information including titles, platforms, playtime, purchase dates, ratings, features, and enhanced metadata from the GamePieces system.

The script automatically locates the GOG Galaxy database, processes game data with proper title extraction (especially for non-GOG platforms like Amazon, Steam, Epic), and exports the data in multiple formats for analysis and backup purposes.

Features

Exports to CSV, JSON, and Excel (.xlsx) formats with professional table formatting
Extracts comprehensive game metadata including:
- Game titles, descriptions, and platform information
- Image URLs (background, square icon, vertical cover)
Supports all platforms integrated with GOG Galaxy (GOG, Steam, Epic, Xbox, Amazon, etc.)
Automatic database discovery with read-only access for safety
Professional Excel export with formatted tables and auto-adjusted columns
Game data consolidation to merge duplicate entries across platforms
Command-line interface with flexible export format selection

Usage (Examples)

# Export to both JSON and CSV (default)
python gog_galaxy_exporter.py

# Export to Excel only
python gog_galaxy_exporter.py xlsx

# Export to all formats
python gog_galaxy_exporter.py all

# Export to CSV only
python gog_galaxy_exporter.py csv

Requires

openpyxl (optional, for Excel export functionality)

gog_csv_to_html.py

A Python script that converts GOG Galaxy CSV export files into a modern, interactive HTML game library viewer. It creates a responsive web application with game browsing, filtering, search functionality, rich media integration, and advanced AI-powered game analysis including clustering visualization and similarity recommendations.

The script automatically fetches additional media content from online sources and caches it locally for improved performance. It provides a professional game library interface similar to modern gaming platforms, with detailed game information, ratings, playtime tracking, visual elements, and intelligent game analysis features.

Features

Modern Interactive Interface: Responsive React-based web application with dual-pane layout
Rich Media Integration:
- Automatic YouTube trailer and gameplay video embedding
- Game screenshot galleries with carousel navigation and modal view
- Cover art and background images from game metadata
Advanced Filtering & Search:
- Real-time search across titles, descriptions, genres, and tags
- Filter by played/unplayed games and recently played titles
- Platform-based filtering and sorting options
Game Information Display:
- Comprehensive game details including playtime, ratings, release dates
- Developer/publisher information and genre classifications
- Platform badges and compatibility information
- Purchase and last played date tracking
AI-Powered Game Analysis (Enhanced):
- 14-axis game scoring system using Ollama and deepseek-r1 model for analyzing:
  - Core mechanics complexity and count
  - Player agency and world impact
  - Narrative density and integration
  - Scope, pacing, and replayability
  - Technical execution and aesthetics
- Interactive cluster visualization using t-SNE and K-means clustering
- Game similarity recommendations based on comprehensive vector analysis
- Visual axis comparison in compact grid format for quick game assessment
Machine Learning Features:
- MiniLM text embeddings for semantic game similarity analysis
- Hybrid vector space combining structured axis data with semantic embeddings
- Real-time clustering with meaningful cluster naming and analysis
- Intelligent game recommendations using euclidean distance in high-dimensional space
Performance Optimizations:
- Local SQLite database for media content and axis scoring caching
- React virtualization for smooth scrolling of large game libraries
- Lazy loading of images and content
- Standardized vector preprocessing for improved clustering results
Professional Presentation:
- Modern gradient backgrounds and card-based layouts
- Star rating displays and playtime formatting
- Responsive design for desktop and mobile viewing
- Bootstrap-based styling with custom enhancements
Game Analysis Integration (Optional):
- AI-powered game axis scoring using Ollama and deepseek-r1 model
- 14-axis game comparison system for analyzing game mechanics, narrative, and design
- Cached scoring results for improved performance on repeated runs

Usage (Examples)

# Convert CSV to HTML with full AI analysis (recommended)
python gog_csv_to_html.py gog_export.csv

# Convert with custom output filename
python gog_csv_to_html.py gog_export.csv -o my_game_library.html

# Skip media fetching for faster processing (disables AI features)
python gog_csv_to_html.py gog_export.csv --no-media

# Disable media caching
python gog_csv_to_html.py gog_export.csv --no-cache

# Open result in browser automatically
python gog_csv_to_html.py gog_export.csv --open

# Show cache statistics including AI analysis data
python gog_csv_to_html.py --cache-stats

# Use custom Ollama host for AI analysis
python gog_csv_to_html.py gog_export.csv --ollama-host http://192.168.1.100:11434

AI Analysis Features

The script now includes sophisticated AI-powered game analysis:

Axis Scoring: Each game is analyzed across 14 dimensions using the deepseek-r1 model
Cluster Analysis: Games are automatically grouped using machine learning clustering algorithms
Similarity Engine: Find games similar to your favorites using hybrid semantic + structured analysis
Visual Analytics: Interactive t-SNE plots show your game library's structure and patterns

Template Dependency

gog_csv_to_html_template.html: Jinja2 template file containing the HTML structure, CSS styling, and React-based JavaScript application with ML clustering features. Must be present in the same directory as the Python script.
gog_csv_to_html_template.css: CSS styling file with responsive design and clustering modal styles.

Requires

requests
beautifulsoup4
jinja2
ollama (for AI-powered game axis scoring - requires deepseek-r1 model)
pydantic (for structured output validation with Ollama)

Optional Dependencies

Image Processing: gzip, zlib, brotli (for handling compressed web responses)
Web Browser Integration: webbrowser (standard library, for --open flag)
AI Game Analysis: Ollama server with deepseek-r1 model (for axis scoring and clustering features)

Setup for AI Features

To enable the full AI analysis capabilities:

Install Ollama: Download from ollama.ai
Install deepseek-r1 model: ollama pull deepseek-r1
Start Ollama server: ollama serve
Run with AI features: python gog_csv_to_html.py your_games.csv

The script will automatically detect Ollama availability and enable advanced features when the server and model are accessible.

file_grouper.py

A script that organizes files in a directory by grouping them based on their filenames using intelligent pattern matching. It identifies files that belong together (such as episodes of a TV series, parts of a multi-part archive, or related documents) and creates subdirectories to organize them logically.

The script uses advanced string matching algorithms to detect patterns in filenames, handle various naming conventions, and group related files while preserving the original file structure. It's particularly useful for organizing large collections of media files, software downloads, or document archives.

Now integrates with MyAnimeList as the primary source for anime information, providing enhanced metadata and series validation. Supports public MyAnimeList lists and exported lists for tracking watch status and completion data.

Features

Intelligent filename pattern detection and grouping
Support for various naming conventions (TV shows, movies, archives, documents)
MyAnimeList integration for anime metadata and series validation
Watch status tracking via public or exported MyAnimeList lists
Configurable grouping sensitivity and pattern matching
Recursive directory processing with configurable depth
Detailed logging and progress reporting

Requires

rapidfuzz
pathlib

series_completeness_checker.py

A script that analyzes TV series collections to identify missing episodes, gaps in seasons, and incomplete series. It scans directory structures and filenames to build a comprehensive view of your media library, highlighting what episodes or seasons might be missing from your collection.

The script supports various TV series naming conventions and provides detailed reports on series completeness, making it easy to identify and fill gaps in your media collection. It can also suggest potential naming inconsistencies and provide recommendations for organizing your series.

Now features MyAnimeList as the primary source for anime information, providing accurate episode counts, season data, and series metadata. Supports integration with public MyAnimeList lists and exported lists to track watch status and completion progress.

Features

Comprehensive TV series analysis and gap detection
Support for multiple naming conventions and formats
MyAnimeList integration for accurate anime metadata and episode validation
Watch status integration with public or exported MyAnimeList lists
Season and episode numbering validation
Missing episode identification with detailed reporting
Series metadata integration for enhanced accuracy
Export results to various formats (JSON, HTML reports)
Integration with metadata providers for series validation
Batch processing of multiple series directories

Usage (Examples)

# Check completeness of series in current directory
python series_completeness_checker.py

# Generate JSON report
python series_completeness_checker.py /path/to/series --export series.json

# Generate HTML webapp
python series_completeness_checker.py /path/to/series --webapp-export series.html

Requires

rapidfuzz
requests
pandas
pathlib

series_archiver.py

A script that archives anime series files based on series completeness checker output. It organizes files into structured folders with standardized naming patterns and provides both command-line interface and programmatic access for integration with other tools.

The script processes JSON output from series_completeness_checker.py and allows users to select specific series groups for archiving. It creates organized folder structures following the pattern [release_group] show_name (start_ep-last_ep) (resolution) and can either copy or move files to the destination. It also includes a standalone integrity-check workflow for validating archived or source files.

Enhanced with MyAnimeList integration as the primary source for anime information, providing accurate series metadata, episode counts, and watch status data. Supports public MyAnimeList lists and exported lists for comprehensive watch status tracking during the archiving process.

Features

Dual Interface: Command-line tool and importable Python class for programmatic use
MyAnimeList Integration: Primary source for anime metadata and series validation
Watch Status Support: Integration with public or exported MyAnimeList lists
Intelligent Organization: Creates standardized folder names based on series metadata
Flexible Selection: Archive specific series or all series with simple selection syntax
Safe Operations: Dry-run mode to preview changes before execution
Integrity Validation: check-crc command and archive-time --verify-crc support for validating files by filename CRC or torrent-backed piece verification
Torrent-Backed Recovery: Optional in-situ torrent-piece repair workflow for damaged files without filename CRCs when matching .torrent metadata is available
Shared Progress Reporting: Tqdm-aware status output for file operations, integrity checks, torrent verification, and torrent repair
Comprehensive Logging: Multiple verbosity levels for detailed operation tracking
File Operations: Support for both copying and moving files with progress feedback
Error Handling: Robust error reporting and validation of source files and destinations

Usage (Examples)

# Get help for specific commands
python series_archiver.py list --help
python series_archiver.py archive --help
python series_archiver.py check-crc --help

# List available series (basic)
python series_archiver.py list --input-json files.json

# List series with detailed information
python series_archiver.py -v list --input-json files.json

# Archive specific series (move files)
python series_archiver.py archive --input-json files.json --destination /dest/path --select "1,3,5"

# Archive all series (copy instead of move)
python series_archiver.py archive --input-json files.json --destination --select "all" --copy

# Preview what would happen (dry run)
python series_archiver.py archive --input-json files.json --destination --select "1,2" --dry-run

# Verify files after archiving and enable torrent-backed repair for failures
python series_archiver.py -v archive files.json /dest/path --select "all" --verify-crc --recover-by-torrent --torrent-files-path /path/to/torrents

# Check integrity for groups from JSON
python series_archiver.py check-crc --input-json files.json --select "185"

# Check integrity for individual files
python series_archiver.py check-crc --files episode01.mkv episode02.mkv

# Check integrity and allow torrent-backed repair after the scan completes
python series_archiver.py -v check-crc --input-json files.json --select "185" --recover-by-torrent --torrent-files-path /path/to/torrents

# Skip the repair confirmation prompt
python series_archiver.py check-crc --input-json files.json --select "185" --recover-by-torrent --auto-repair-by-torrent --torrent-files-path /path/to/torrents

Programmatic Usage

from series_archiver import SeriesArchiver

# Initialize archiver with verbosity
archiver = SeriesArchiver(verbose=1)

# Load series data
archiver.load_data('files.json')

# List available groups
groups = archiver.list_groups(show_details=True)

# Archive selected groups
results = archiver.archive_groups(
    selected_groups=['group1', 'group2'], 
    destination_root='/dest/path',
    copy_files=True,
    dry_run=True,
    verify_crc=True,
    torrent_recovery={
        'enabled': True,
        'auto_repair': False,
        'torrent_files_path': '/path/to/torrents',
        'timeout_seconds': 120,
    },
)

# Or run a standalone integrity check
crc_results = archiver.check_files_crc(['/path/to/file1.mkv', '/path/to/file2.mkv'])

Commands

list/ls: Display available series groups with episode counts and completion status
archive: Archive selected series groups to organized destination folders
check-crc/crc: Validate files by filename CRC when present, otherwise by matching torrent piece data when torrent recovery metadata is enabled

Options

-v, --verbose: Increase verbosity level (use -v, -vv, or -vvv for different detail levels)
archive --select: Specify which series to archive using comma-separated numbers or all
archive --copy: Copy files instead of moving them (preserves originals)
archive --dry-run: Show what would be done without actually performing file operations
archive --verify-crc: Validate processed destination files after archiving
check-crc --input-json / --files: Choose whether integrity checks operate on grouped JSON input or explicit file paths
check-crc --select: Restrict JSON-backed integrity checks to selected group numbers or all
--recover-by-torrent: Enable torrent-backed verification/recovery flows
--auto-repair-by-torrent: Skip the confirmation prompt before modifying failed files
--torrent-files-path DIR: Directory containing .torrent files used for matching and repair
--torrent-recovery-timeout SECONDS: Maximum time to wait for torrent-backed verification or repair

Notes

--recover-by-torrent requires --torrent-files-path and the optional libtorrent package.
On the archive command, --recover-by-torrent also requires --verify-crc.
Torrent-backed checks follow a two-step flow: first the scan validates integrity, then repair is offered only after the scan completes.
Torrent-backed verification and repair are piece-based and can reuse already valid local torrent pieces during in-situ repair.

Requires

pathlib
shutil
json
tqdm (for progress bars)

Optional Dependencies

libtorrent (required for --recover-by-torrent)
bencodepy (optional torrent metadata parser fallback)

series_bundler.py

A script that groups series files and creates organized folder structures for archiving. It analyzes video files using guessit to extract metadata, groups them by series, release group, and resolution, then creates standardized folder names following the pattern [Release Group] Series Name (YYYY) (xx-yy) (Resolution).

The script is designed to bundle anime/TV series episodes into organized folders suitable for long-term archiving. It handles various filename patterns, supports both drag-and-drop and command-line usage, and can process decimal episode numbers (like episode 12.5) and series with years in the title.

Features

Intelligent Metadata Extraction: Uses guessit to parse filenames and extract series information
Flexible Episode Handling: Supports regular episodes, decimal episodes (12.5), and handles year misclassification
Dual Interface: Interactive drag-and-drop mode and full command-line interface
Smart Grouping: Groups files by series, release group, resolution, and season
Standardized Naming: Creates consistent folder names for archival organization
Preview Mode: Dry-run functionality to preview changes before execution
Progress Tracking: Visual progress bars and detailed logging options
File Operations: Support for both copying and moving files with error handling

Usage (Examples)

# Drag-and-drop mode (interactive) - just drag files onto the script
python series_bundler.py file1.mkv file2.mkv file3.mkv

# Analyze files in current directory (preview only)
python series_bundler.py . --summary-only

# Bundle files to destination (dry run preview)
python series_bundler.py /path/to/series -d /path/to/archive --dry-run

# Actually move files to organized folders
python series_bundler.py /path/to/series -d /path/to/archive

# Copy files instead of moving them
python series_bundler.py /path/to/series -d /path/to/archive --copy

# Process files recursively with verbose output
python series_bundler.py /path/to/library -d /path/to/archive --recursive -vv

# Disable interactive mode for scripting
python series_bundler.py *.mkv -d /dest --no-interactive

Requires

guessit
tqdm

simple_http_proxy.py

A simple script that allows you to fetch a remote file or resource by appending the full remote URL to the end of your request to the app, e.g.:

http://<host-ip>:8080/<remote-url>

This is not a real HTTP proxy, but a tool to fetch a specific file or similar resource via another URL, making it accessible to local computers on your network.

Requires

No external dependencies required (uses only Python standard libraries)

socks5_http_tunneler.py

A one-file local HTTP tunneler that accepts a target URL via query string and forwards upstream traffic through a configured SOCKS5 proxy. It rewrites redirected and embedded upstream URLs into local proxy paths so navigation continues through the local endpoint while upstream requests still look native to the target host.

Features

Accepts entry URLs in the form http://localhost:8080/?url=http://example.com
Forwards both HTTP and HTTPS upstream requests through a user-supplied SOCKS5 proxy
Rewrites Location headers, common HTML URL attributes, CSS url(...) references, srcset, and meta refresh redirects into local proxy paths
Injects a small client-side shim so browser-side fetch, XMLHttpRequest, history, window.open, and form submissions continue using the local tunnel
Supports verbose --debug logging for request resolution, upstream headers, response metadata, and rewrite previews
Supports strict upstream TLS verification by default, optional private CA trust with --ca-bundle, or explicit bypass with --insecure

Usage Examples

# Start the tunnel through a SOCKS5 proxy
python socks5_http_tunneler.py --socks5 127.0.0.1:1080

# Enable debug logging
python socks5_http_tunneler.py --socks5 socks5://127.0.0.1:1080 --debug

# Trust a private proxy root CA bundle for upstream HTTPS
python socks5_http_tunneler.py --socks5 socks5://127.0.0.1:1080 --ca-bundle C:\path\to\proxy-root-ca.pem

# Disable upstream HTTPS verification entirely
python socks5_http_tunneler.py --socks5 socks5://127.0.0.1:1080 --insecure

Requires

requests with SOCKS support: pip install "requests[socks]"

radio_station_checker.py

A multi-threaded Python script that checks the availability of radio stations from SII, PLS, and M3U playlist files. It provides a real-time terminal interface with virtualized rendering for performance, displaying station status, response times, and metadata in an organized table format.

The script features intelligent performance optimizations, only updating the display when necessary, and includes full user interaction capabilities with keyboard navigation and graceful shutdown handling. It's designed to efficiently monitor large collections of radio stations while providing a smooth, responsive user experience.

Features

Multi-format Support: Handles Truck Simulator SII, PLS, and M3U playlist formats
High-Performance Virtualized Rendering: Smart display updates only when station status changes or user interactions occur
Multi-threaded Station Checking: Concurrent HTTP requests with configurable thread pool for optimal performance
Interactive Terminal Interface: Rich terminal UI with real-time status updates and progress tracking

Requires

rich
requests
concurrent.futures (standard library)

Usage

Install Tampermonkey or a similar userscript manager in your browser.
Import the script into Tampermonkey.
Make sure your local IP addresses are whitelisted in the script.
Navigate to your Plex playlist page, open a playlist and see the watch status indicators appear next to each item thumbnail.

Requires

Tampermonkey or a similar userscript manager

latest_episodes_viewer.py

A script that generates a simple HTML page listing the latest episodes from a collection of TV series. It scans a specified directory for video files, extracts metadata using guessit and some custom metadata providers, and creates an organized list of the most recent episodes based on their air dates. The generated HTML page includes links to the episodes, making it easy to access and view the latest content.

Features

Scans a specified directory for video files
Extracts metadata using guessit and custom metadata providers
Generates an organized HTML page listing the latest episodes
Includes links to the episodes for easy access

Requires

guessit
requests
tqdm

serve_local.py

Serve a file or folder as a simple local webhost with optional live-reload and a small file-proxy helper.

Features

Serve a single file as the site index or serve a whole folder (directory listing when no index.html).
Sandbox served paths to the configured web root; blocks requests outside that root.
Optional forced-index --live mode with Server-Sent-Events (SSE) live-reload for the chosen index file.
/file-proxy endpoint to allow pages served over HTTP to fetch local file:/// resources (restricted to webroot and the user's home on Windows).
Windows GUI helper to pick a file/folder when no path is provided (Tkinter-based).

Usage

# Drag-and-drop a file or folder onto the script (Windows)
python serve_local.py "C:\path\to\file_or_folder" [-p PORT] [--live]

Key functions & classes

get_local_ip() — returns a likely LAN IP address for advertising the server on the local network.
CustomHandler — subclass of SimpleHTTPRequestHandler that implements forced index handling, SSE /__watch, /file-proxy, richer directory listings, and sandbox enforcement.
_watch_file_for_changes(path) — background watcher that notifies connected SSE clients when the forced index file changes.
choose_path_interactive() — Windows file/folder chooser (uses Tkinter) when no path argument is provided.
main() — CLI entrypoint that configures logging, determines web root, optionally starts the watcher, and runs a threaded HTTP server.

Bash Scripts

macos-uninstall-python3.10.sh

Safe uninstall script for Python 3.10 installed via the official python.org macOS package installer. It performs sanity checks, lists matching framework/app/symlink targets, asks for confirmation, removes matching files, and forgets matching pkgutil receipts.

Usage

# Make executable
chmod +x macos-uninstall-python3.10.sh

# Run
./macos-uninstall-python3.10.sh

Experimental

lyrics-timing-generator.py

Intended to generate timed lyrics for audio files (.lrc). Uses whisper library to generate timed lyrics, and ollama and an llm to structure them.

But it is not good. Really not good. It's a start, but not quite there yet. Need to restart from a known base to generate the timed subtitles which is a known working thing, and then convert that to lyrics, using an llm to format them.

Requires

pydub
mutagen
numpy
librosa
tensorflow
spleeter
soundfile
whisper
tqdm
dataclasses

Name		Name	Last commit message	Last commit date
Latest commit History 693 Commits
docs/superpowers		docs/superpowers
mini-dlna-server		mini-dlna-server
plex_db_tool		plex_db_tool
simple_scraper_proxy_templates		simple_scraper_proxy_templates
styles		styles
tests		tests
video-optimizer-v2		video-optimizer-v2
youtube-video-downloader		youtube-video-downloader
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
anime_metadata_test.py		anime_metadata_test.py
audio_metadata.py		audio_metadata.py
browser_utils.py		browser_utils.py
cbr_to_cbz_converter.py		cbr_to_cbz_converter.py
clipboard-monitor.py		clipboard-monitor.py
compare_package_versions.py		compare_package_versions.py
csv_diff_merge.html		csv_diff_merge.html
csv_to_excel_sheets.py		csv_to_excel_sheets.py
extract_media_metadata.py		extract_media_metadata.py
file-renamer-script.py		file-renamer-script.py
file_grouper.py		file_grouper.py
file_metadata_scanner.py		file_metadata_scanner.py
file_metadata_scanner_template.css		file_metadata_scanner_template.css
file_metadata_scanner_template.html		file_metadata_scanner_template.html
file_metadata_scanner_template.js		file_metadata_scanner_template.js
gamecomparison-strategy.md		gamecomparison-strategy.md
gog_csv_to_html.py		gog_csv_to_html.py
gog_csv_to_html_template.css		gog_csv_to_html_template.css
gog_csv_to_html_template.html		gog_csv_to_html_template.html
gog_galaxy_exporter.py		gog_galaxy_exporter.py
guessit-options.json		guessit-options.json
guessit_wrapper.py		guessit_wrapper.py
imdb_metadata_test.py		imdb_metadata_test.py
imdb_title_query.py		imdb_title_query.py
insanely-fast-whisper.py		insanely-fast-whisper.py
latest_episodes_viewer.py		latest_episodes_viewer.py
latest_episodes_viewer.requirements.txt		latest_episodes_viewer.requirements.txt
latest_episodes_virtual_list.js		latest_episodes_virtual_list.js
latest_episodes_webapp_template.css		latest_episodes_webapp_template.css
latest_episodes_webapp_template.html		latest_episodes_webapp_template.html
latest_episodes_webapp_template.js		latest_episodes_webapp_template.js
lyrics-timing-generator.py		lyrics-timing-generator.py
m3u8-to-mp4-flask-webservice-simple.py		m3u8-to-mp4-flask-webservice-simple.py
m3u8-to-mp4-flask-webservice.py		m3u8-to-mp4-flask-webservice.py
macos-uninstall-python3.10.sh		macos-uninstall-python3.10.sh
md_to_docx.py		md_to_docx.py
md_to_docx.requirements.txt		md_to_docx.requirements.txt
media-to-mp3.py		media-to-mp3.py
merge-audio-files-to-one-output.py		merge-audio-files-to-one-output.py
mp4-to-mp3-converter-with-origin.py		mp4-to-mp3-converter-with-origin.py
music_style_classifier.py		music_style_classifier.py
music_style_classifier.requirements.txt		music_style_classifier.requirements.txt
myanimelist-addtolist-improved.user-script.js		myanimelist-addtolist-improved.user-script.js
myanimelist.xsd		myanimelist.xsd
netflix_episode_title_overrides.csv		netflix_episode_title_overrides.csv
netflix_title_parser.py		netflix_title_parser.py
netflix_watch_status.py		netflix_watch_status.py
netflix_watch_status_webapp_template.css		netflix_watch_status_webapp_template.css
netflix_watch_status_webapp_template.html		netflix_watch_status_webapp_template.html
netflix_watch_status_webapp_template.js		netflix_watch_status_webapp_template.js
ollama_tool_agent.py		ollama_tool_agent.py
ollama_tool_agent.requirements.txt		ollama_tool_agent.requirements.txt
password_generator.py		password_generator.py
plex-library-play-status.userscript.js		plex-library-play-status.userscript.js
plex-playlist-watch-status.user.js		plex-playlist-watch-status.user.js
plex_db_tool.py		plex_db_tool.py
presentation.py		presentation.py
pytest.ini		pytest.ini
radio_station_checker.py		radio_station_checker.py
reddit-video-link-webservice-redirector.user.js		reddit-video-link-webservice-redirector.user.js
riffusion-download_ext-button.user.js		riffusion-download_ext-button.user.js
rss-feed-downloader.py		rss-feed-downloader.py
series_archiver.py		series_archiver.py
series_archiver.requirements.txt		series_archiver.requirements.txt
series_bundler.py		series_bundler.py
series_bundler.requirements.txt		series_bundler.requirements.txt
series_completeness_checker.py		series_completeness_checker.py
series_completeness_checker.requirements.txt		series_completeness_checker.requirements.txt
series_completeness_webapp_template.css		series_completeness_webapp_template.css
series_completeness_webapp_template.html		series_completeness_webapp_template.html
series_completeness_webapp_template.js		series_completeness_webapp_template.js
series_info_tool.py		series_info_tool.py
serve_local.py		serve_local.py
serve_local.requirements.txt		serve_local.requirements.txt
set_music_genre.py		set_music_genre.py
simple_http_proxy.py		simple_http_proxy.py
simple_scraper_proxy.py		simple_scraper_proxy.py
smartls.py		smartls.py
smartls_webapp_template.css		smartls_webapp_template.css
smartls_webapp_template.html		smartls_webapp_template.html
smartls_webapp_template.js		smartls_webapp_template.js
socks5_http_tunneler.py		socks5_http_tunneler.py
socks5_http_tunneler.requirements.txt		socks5_http_tunneler.requirements.txt
srt_to_transcript.py		srt_to_transcript.py
test_guessit_wrapper.py		test_guessit_wrapper.py
test_netflix_title_parser.py		test_netflix_title_parser.py
test_netflix_watch_status.py		test_netflix_watch_status.py
test_netflix_watch_status.requirements.txt		test_netflix_watch_status.requirements.txt
test_smartls.py		test_smartls.py

Folders and files

Latest commit

History

Repository files navigation

misc_scripts

Table of Contents

User Scripts

plex-playlist-watch-status.user.js

myanimelist-addtolist-improved.user-script.js

Features

Matches

Libraries

browser_utils.py

Features

API

Requires

Projects

plex_db_tool

Features

Usage Examples

Notes

video-optimizer-v2

Project Files

metadata_cache_manager.py

metadata_provider.py

anime_metadata.py

imdb_metadata.py

plex_metadata.py

myanimelist_watch_status.py

Requires

youtube-video-downloader

Project Files

ytdl_helper library

youtube-video-downloader-cli.py

Usage (Examples)

Requires

youtube-video-downloader-gui.py

Features

Requires

youtube-video-downloader-flask-ws.py & youtube-video-downloader.user-script.js

Usage (Examples)

Features

Requires

mini-dlna-server

Requires

Scripts

cbr_to_cbz_converter.py

Features

Usage Examples

Requires

password_generator.py

compare_package_versions.py

Usage Examples

Requires

ollama_tool_agent.py

Features

Usage Examples

Requires

simple_scraper_proxy.py

Features

Usage Examples

Requires

imdb_title_query.py

Features

Usage Examples

Requires

media-to-mp3.py

Usage Examples

Requires

smartls.py

Features

Usage Examples

Notes

series_info_tool.py

Features

Usage Examples

Requires

netflix_watch_status.py

Features

Usage Examples