cheater ffmpeg
┃ 'ffmpeg' — pick a cheat or action
┃       2. Convert all .m4a files in the current dir to .mp3
┃         $ for f in *.m4a; do ffmpeg -i "$f" -acodec libmp3lame -vn -b:a 320k "${f%.m4a}.mp3"; done
┃ >     3. Combine separate video and audio tracks into one file (no re-encode)
┃         $ ffmpeg -i <video> -i <audio> -c:v copy -c:a copy <output>
┃       4. Burn an .ass subtitle track into a video
┃         $ ffmpeg -i <input> -vf ass=<subtitle> <output>
┃       5. Convert WebM to MP4
┃         $ ffmpeg -i <input> <output>
┃       6. Repackage MP4 to MOV without re-encoding
┃         $ ffmpeg -i <input> -acodec copy -vcodec copy -f mov <output>
┃       7. Repackage MOV to MP4 without re-encoding
┃         $ ffmpeg -i <input> -vcodec copy -acodec copy <output>
┃       8. Render an image sequence as a video (glob, vp9)
┃         $ ffmpeg -r <fps> -pattern_type glob -i '<glob>' -b:v <bitrate> -s hd1080 -vcodec vp9 -an -pix_fmt yuv420p -
┃   deinterlace <output>
┃       9. Extract a chunk of audio from a video file and pipe to ffplay
┃         $ ffmpeg -ss <start> -t <duration> -i <input> -f mp3 pipe:play | ffplay -i pipe:play -autoexit
┃      10. Concatenate files listed in a text file (codec copy)
┃         $ ffmpeg -f concat -safe 0 -i <list> -c copy <output>
┃    +  Add a new cheat
┃    ~  Edit a personal cheat
┃    -  Remove a personal cheat
┃ >  q  Quit

from get_around import GetAround

# Route requests through a proxy server.
client = GetAround(server="https://proxy-server", password="password")

# Mirrors httpx's request API and returns standard httpx.Response objects.
response = client.get("https://httpbin.org/get", params={"foo": "bar"})

# POST with a JSON body.
response = client.post("https://httpbin.org/post", json={"key": "value"})

# Upstream HTTP errors (404, 500, etc.) are returned as normal responses,
# not raised. Check response.status_code as you would with httpx.
print(response.status_code)

from good_ass_pydantic_integrator import GAPI

gapi = GAPI(class_name="User")
gapi.add_object_from_dict(
    {
        "id": "3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a",
        "name": "Ada",
        "created_at": "2025-01-01T12:00:00Z",
        "tags": ["admin", "early-access"],
    }
)
print(gapi.get_pydantic_model_content())

# ───────────────────────── Printed output ─────────────────────────
from typing import TYPE_CHECKING

from pydantic import AwareDatetime, BaseModel, ConfigDict

if TYPE_CHECKING:
    from uuid import UUID


class User(BaseModel):
    model_config = ConfigDict(extra="forbid")
    id: UUID
    name: str
    created_at: AwareDatetime
    tags: list[str]

import datetime
from degenson import SchemaBuilder

builder = SchemaBuilder()
builder.add_object(datetime.date(2018, 11, 13))
schema = builder.to_schema()
print(schema)

# ───────────────────────── Printed output ─────────────────────────
{'$schema': 'http://json-schema.org/schema#', 'type': 'string', 'format': 'date'}

from chirashi import Chirashi

client = Chirashi()

# A series, by series ID.
series = client.series.get("GY8VEQ95Y")

# The seasons of a series, by series ID.
seasons = client.seasons.get("GY8VEQ95Y")

# The episodes of a season, by season ID.
episodes = client.episodes.get("GR3VWXP96")

# Browse series, sorted and paginated.
browse = client.browse_series.get(n=36, sort_by="newly_added")

# Search across music, series, episodes, and top results.
results = client.search.get("naruto")
series_hits = client.search.extract_series(results)
episode_hits = client.search.extract_episodes(results)
music_hits = client.search.extract_music(results)
top_hits = client.search.extract_top_results(results)

from diving_board import DivingBoard

client = DivingBoard()

# A series, by series ID.
series = client.series.get(1091)

# A season, by season ID.
season = client.season.get(19078)

# A single VOD, by VOD ID.
vod = client.vod.get(542391)

# A playlist, by playlist ID.
playlist = client.playlist.get(19078)

# Search, by query string.
results = client.search.get("frieren")

# Other series in the same franchise, by series ID and season ID.
adjacent = client.adjacent_series.get(1091, 19078)

# The release schedule. Defaults to the current month.
schedule = client.schedule.get()

# Every schedule page from a starting date up to a given end date.
from datetime import datetime

pages = client.schedule.get_until_datetime(
    from_=datetime(2026, 1, 1),
    end_datetime=datetime(2026, 6, 1),
)

from not_yt_dlapi import NotYTDLAPI

# Authenticate with an API key for public data...
client = NotYTDLAPI(api_key="YOUR_API_KEY")

# ...or with OAuth credentials (refreshed automatically when expired).
client = NotYTDLAPI(credentials=credentials)

# A single video, by video ID.
video = client.videos.get("jNQXAC9IVRw")

# Multiple videos at once, by a list of video IDs (batched in groups of 50).
videos = client.videos.get_multiple(["jNQXAC9IVRw", "9bZkp7q19f0"])

# A channel, by channel ID, handle, or legacy username.
channel = client.channels.get(channel_id="UC4QobU6STFB0P71PMvOGN5A")
channel = client.channels.get(handle="jawed")
channel = client.channels.get(username="jawed")

# A single page of a channel's playlists, by channel ID.
playlists = client.playlists.get("UC4QobU6STFB0P71PMvOGN5A")

# All of a channel's playlists, with automatic pagination.
playlists = client.playlists.get_all("UC4QobU6STFB0P71PMvOGN5A")

# A single page of the items in a playlist, by playlist ID.
items = client.playlist_items.get("PLuhl9TnQPDCnWIhy_KSbtFwXVQnNvgfSh")

# All items in a playlist, with automatic pagination.
items = client.playlist_items.get_all("PLuhl9TnQPDCnWIhy_KSbtFwXVQnNvgfSh")

from yt_dlapi import YTDLAPI

client = YTDLAPI()

# A single video, by video ID.
video = client.video.get("jNQXAC9IVRw")

# A channel, by handle/name or by channel ID.
channel = client.channel.get_by_name("jawed")
channel = client.channel.get_by_id("UC4QobU6STFB0P71PMvOGN5A")

# A playlist, by playlist ID.
playlist = client.playlist.get("PLuhl9TnQPDCnWIhy_KSbtFwXVQnNvgfSh")

# The videos in a playlist. Accepts a normal playlist ID (PL...) or a
# channel-derived uploads playlist ID (UU...).
videos = client.playlist_videos.get("UU4QobU6STFB0P71PMvOGN5A")

from just_scrape import JustScrape

client = JustScrape()

# Search for titles, by query string.
results = client.search.get("Breaking")

# Title details, by full URL path (the part after the domain).
movie = client.url_title_details.get("/us/movie/the-thursday-murder-club")
show = client.url_title_details.get("/us/tv-show/strip-law")

# The episodes in a season, by season node ID.
episodes = client.season_episodes.get("tss337460")

# Streaming/buy/rent offers for a title, by node ID.
offers = client.buy_box_offers.get("tse9298997")

# Newly released titles. Defaults to today; accepts filters.
new_titles = client.new_titles.get(
    filter_packages=["net"],
    available_to_packages=["net"],
)

# A title's editorial article, by full URL path.
article = client.title_detail_article.get("/us/movie/the-thursday-murder-club")