Skip to main content

wyzie-subs

Python client for the Wyzie Subs API: subtitle search, download, sync, transcribe, fix and extract, plus Wyzie Censored. Sync and async, one dependency (httpx), Python 3.9+.

Install

pip install wyzie-subs

You need an API key. Get a free one at sub.wyzie.io/redeem. You can make up to 3 keys per account in the dashboard (API Keys > Extra Keys); they all share one balance and one set of limits.

Quick start

from wyzie_subs import Wyzie

wyzie = Wyzie("YOUR_KEY")
results = wyzie.search("tt0111161", language="en")
srt = wyzie.download(results[0], to="vtt", shift="-1.5")
print(wyzie.last_cost, wyzie.last_balance)  # from X-Wyzie-Cost / X-Wyzie-Balance

Async: AsyncWyzie has the same methods; await each call.

from wyzie_subs import AsyncWyzie

async with AsyncWyzie("YOUR_KEY") as wyzie:
    best = await wyzie.search_best("tt0111161", language="en")

Constructor: Wyzie(key, base_url="https://sub.wyzie.io", timeout=15.0, retries=2).

Methods

All return plain dicts and lists unless noted. Download options (to, offset, shift, fps, plain, sdh, clean, dual, lines, maxlines, mindur) work wherever they are listed; download and with_download_options also take censor=True and censor_level (masked downloads, free).

Method Example
search(id, season, episode, language, format, hi, source, release, filename, origin, video, hash, sort, machine, limit, page, refresh) wyzie.search("tt0903747", season=1, episode=1, language="es") returns [] when nothing matches
search_best(...) wyzie.search_best("tt0111161") returns one dict, or None on a 404
search_batch(items, best=False, **defaults) wyzie.search_batch(["tt0111161", 286217], language="en")
download(url_or_result, **download_options) wyzie.download(results[0], to="srt", lines=42) returns text (JSON format too)
download_best(id, **search_and_download_options) wyzie.download_best("tt0111161", language="en", to="vtt")
with_download_options(url, **options) wyzie.with_download_options(results[0], to="vtt", shift="+2s") returns a URL, no request
sources(key=True) wyzie.sources()
languages() wyzie.languages()
status(days=0) wyzie.status(days=7)
quote(q, language, limit) wyzie.quote("may the force be with you")
sync_own_subtitle(subtitle, speech, covered=None, format=None) Wyzie Synced for your own SRT, VTT or ASS text (Pro, 60 requests only on success): wyzie.sync_own_subtitle(srt_text, [[129.1, 131.2], [131.4, 133.6]])["content"] is the retimed text; also offset, fps, confidence, inSync, format, tried (a SyncOwnResult). format srt, vtt or ass (default: the input's). No match is a WyzieError 422
transcribe(media, format="srt", language, speakers, sounds, translate, cache, webhook, poll_interval, on_job) wyzie.transcribe("talk.mp3", format="json").json returns a TranscribeResult; long jobs are polled
transcribe_url(url, ..., dry_run=False, idempotency_key=None) job = wyzie.transcribe_url("https://example.com/ep.mp3") returns the 202 body
get_transcribe(id, format="srt") wyzie.get_transcribe(job["jobId"]) returns a result, or None while running
fix(media, subtitle, url, id, season, episode, language, format, retime, cache, webhook, on_job) wyzie.fix("movie.mkv", subtitle=srt_text, language="en") returns a FixResult
cancel_transcribe(id) / cancel_fix(id) DELETE /transcribe/{id}, DELETE /fix/{id}: wyzie.cancel_transcribe(job["jobId"]) returns a CancelResult (see below)
extract(media, list_tracks, track, language, all_tracks, **download_options) wyzie.extract("subs.mks", list_tracks=True) gives a dict, one track a str, all_tracks=True zip bytes
usage(days=30) wyzie.usage()["balance"]
set_usage_webhook(url) wyzie.set_usage_webhook("https://example.com/balance")
clear_usage_webhook() wyzie.clear_usage_webhook()
censor(media, language, mode, sound, lists, words, pad_ms, cache, webhook, wait=True, level, allow, music, profile, review, audio_track, ranges_file, imdb, tmdb, idempotency_key) wyzie.censor("ep.mp4", mode="bleep")["media"] waits for the job, returns a CensorJob
censor_url(url, ..., dry_run=False) wyzie.censor_url("https://example.com/v.mp4", dry_run=True)["estimateRequests"]
get_censor_job(id) / wait_censor(id) wyzie.wait_censor(job["id"]) polls until done, never posts again
censor_mask(words or cues, duration, mode, sound, lists, add, pad_ms, level, allow, format, profile, language, sdh_cues, imdb, tmdb) Censored Live: wyzie.censor_mask(cues=[{"start": 0, "end": 2, "text": "..."}])["ranges"]; format="edl" or "skp" returns a filter file
censor_filter(id, format) / censor_subtitle(id, format, marks, style) Free with the job's key: wyzie.censor_filter(job["id"], format="edl"), wyzie.censor_subtitle(job["id"], marks=True) (text)
censor_edit_hits(id, keep, drop, add) / censor_render(id) A review=True job's hit list: wyzie.censor_edit_hits(job["id"], drop=["h2"]), then wyzie.censor_render(job["id"]) (free)
censor_transcript(id) A review=True job's words {i, w, s, e, hit?} for a transcript editor: wyzie.censor_transcript(job["id"]); bleep by place with add=[{"word": i}] (free)
censor_batch(items, webhook, dry_run=False, **options) / get_censor_batch(id) Up to 20 links: wyzie.censor_batch([{"url": "https://example.com/1.mp4"}], mode="bleep")["id"], then wyzie.get_censor_batch(b["id"])["items"] (free)
censor_settings() wyzie.censor_settings()["level"] (a level or "custom"), ["available"]["levels"]
download_media(link) wyzie.download_media(job["media"]) returns the file as bytes; an expired link is asked again once, then LinkExpiredError

media is bytes, a path, or a binary file object. Cloudflare caps a request body near 100 MB: for a big film send only the subtitle tracks (ffmpeg -i movie.mkv -map 0:s -c copy subs.mks).

Censored

# Bleep strong profanity and slurs (Pro: 95 requests a started minute, charged up front)
job = wyzie.censor("episode.mp4", mode="bleep", lists=["profanity_strong", "slurs"], words=["darn"])
print(job["count"], job["ranges"][:1])          # times, category and the word masked ("f***")
open("clean.mp4", "wb").write(wyzie.download_media(job["media"]))  # link valid 15 minutes, 20 downloads

# A link: price it first (free), start it, poll later
est = wyzie.censor_url("https://example.com/talk.mp4", dry_run=True)
started = wyzie.censor_url("https://example.com/talk.mp4", mode="mute", wait=False)
done = wyzie.wait_censor(started["id"])

# Free with the job's key: a filter file a player mutes from (the original file untouched), and a clean subtitle.
# edl is Kodi, MPlayer and mpv (save it as <video name>.edl), skp is VideoSkip, json (default) is {count, ranges}.
# The subtitle masks the words ("f***"); marks=True adds a [bleep] caption over each range. 409 while the job
# runs; censor_subtitle is a 404 for jobs from before transcripts were kept.
open("episode.edl", "w").write(wyzie.censor_filter(done["id"], format="edl"))
open("episode.clean.srt", "w").write(wyzie.censor_subtitle(done["id"], marks=True))

# Strictness instead of lists: lenient, moderate (default), strict (also damn, hell, crap) or super_strict
# (also gosh, darn, heck and insults). "rape" also catches raped, raping, rapes and rapist; "=word" is that
# word only. allow adds to the account's Never Censor list. level and lists together raise ValueError.
strict = wyzie.censor("episode.mp4", level="strict", words=["rape", "=ass"], allow=["hell"])

from wyzie_subs import CENSOR_LEVELS, level_of
level_of(["profanity_severe", "slurs"])  # "lenient"; any other set is "custom"

# Audience presets: kids (= super_strict), teen (damn, hell, crap and "oh my god" stay), family (damn, hell
# and "oh my god" stay). Half lists: mild_damn_hell, mild_crude (of profanity_mild), blasphemy_exclamations,
# blasphemy_curses (of blasphemy); a half reports its parent's category.
teen = wyzie.censor("episode.mp4", level="teen")

# Loud music mode: also listen to the voices with the music taken out, for words music hides (160 more a
# minute), and split two voices talking at once to hear the quieter one (125 more a minute): 380 a minute in
# all, up front. The 160 comes back when the gaps between words are quiet or the pass fails (75 back when the
# separation is cached, 85 when its recognition is): job["music"] is used, not_needed or failed. Of the 125,
# 85 comes back for each minute with no overlap sent to recognition, all 125 when the pass fails:
# job["overlap"] is used, not_needed or failed. None keeps the account's setting. A blocked word also blocks
# the forms AI finds for it (English, free). A word a recogniser often mishears ("pitch meeting" heard as
# a swear) is left alone when the words around it give the real word away; your blocked words always count.
loud = wyzie.censor("episode.mp4", music=True)

# Censored review: stop at the hit list, change it, then render it (free)
r = wyzie.censor("episode.mp4", review=True, profile="Kids")
print(r["status"], r["hits"])  # review [{id, word: "f***", start, end, category, confidence, keep}]
wyzie.censor_edit_hits(r["id"], drop=["h2"], add=[{"start": 12.5, "end": 13}])
wyzie.censor_render(r["id"])
rendered = wyzie.wait_censor(r["id"])

# Censored batch: up to 20 links, shared options, each item its own job
items = [{"url": "https://example.com/ep1.mp4"}, {"url": "https://example.com/ep2.mp4", "mode": "mute"}]
quote = wyzie.censor_batch(items, mode="bleep", dry_run=True)  # free
batch = wyzie.censor_batch(items, mode="bleep", webhook="https://example.com/hook")
progress = wyzie.get_censor_batch(batch["id"])  # status running | done | stopped; items[i] status, id, media

Censored jobs are Pro and charged up front for the whole job, refunded if it fails on our side. Jobs are polled every poll_interval seconds (default 5), 1.5x longer each time up to max_poll_interval (default 30). A file up to 100 MB is read into memory and sent in one request, as with transcribe; a larger one goes in chunks from disk (below), or send a link to censor_url.

review=True (review=1) is charged as any job but stops once the words are matched: the job answers status "review" with hits (word masked; confidence 1 heard in the mix, 0.6 only in the music=True voices stem), kept until expiresAt (24 hours; the rendered file an hour); the wait stops there. censor_edit_hits(id, keep, drop, add) changes the list (at most 500 added ranges; 409 outside review) and censor_render(id) renders it once, free (a failed render goes back to review with error). profile="Kids" uses a named profile from dash.wyzie.io Censored (any case): its lists replace the account's, its words and allow add to them; an unknown name is a 400, nothing charged. censor_settings()["profiles"] lists them (word counts, never the words). 23 languages have their own preset lists (censor_settings()["available"]["languages"]; pt-BR uses pt, zh-TW uses zh; others use the English lists): jobs pick them from language or the detected language, and censor_mask(..., language="es") from the language you send. Download links from search already carry lang=, so censor=1 on them masks with that language's lists. download(..., censor=True, censor_level="strict") (censor=1, level=) masks matched words in any download, first letter kept (f***), free; the answer's X-Censor header is on, off or ignored.

censor_batch(items, webhook, dry_run, **options) posts to /censor/batch: 1 to 20 links (uploads can't be batched), each item its own POST /censor/url job at the same price, charged when it starts, two at a time a key; an item's own options win over the shared ones. The first refused charge (402) stops the batch (stopped: "no_balance"): that item and the rest end skipped_no_balance, uncharged. A failed item is refunded by its own job; an unsupported link fails uncharged. webhook gets one batch.done call. dry_run=True prices each item (media over 4 hours: supported: False). get_censor_batch(id) is free, only for the key that started it, kept 24 hours.

from wyzie_subs import LinkExpiredError, WyzieError

# Censor the French track (a number works too: 0 is the first, the default); every other track is kept
try:
    job = wyzie.censor_url("https://example.com/film.mkv", audio_track="fr")
except WyzieError as e:
    print(e.reason, e.charged)  # "audio_track_not_found", False (also drm, no_audio, silent, music_only, too_long...)
print(job["audio_track"], job.get("dropped"), job.get("warnings"))  # 1, ["audio 2 (dts, fre)"], ["surround: 5.1 mixed down"]

try:
    data = wyzie.download_media(job["media"])  # a stale link is asked again once with the key
except LinkExpiredError:
    data = wyzie.download_media(wyzie.get_censor_job(job["id"])["media"])  # file kept an hour

audio_track (on censor, censor_url and censor_batch items or options) picks the audio track to censor: its number (0 is the first and the default) or its language code ("fr", "fre"). The output keeps every audio and subtitle track and the chapters; only the chosen track is censored. An mp4 leaves out codecs it can't hold, listed in the result's dropped ("audio 2 (dts, fre)"); audio_track on the result is the track censored. An unknown track on censor is a 400 with reason "audio_track_not_found", nothing charged; on censor_url it is found when the file is fetched and the job fails with the charge given back.

Files are checked before any charge. A refusal is a 400, 413 or 422 WyzieError with reason (PROBE_REFUSALS: unreadable, drm, no_audio, unsupported_audio_codec, bad_duration, too_long, bad_audio, too_many_streams, silent, music_only, audio_track_not_found) and charged False. The 202 and the result may carry warnings, each "name: text" (JOB_WARNINGS: multiple_audio_tracks, surround, variable_frame_rate, quiet_audio, dropped_tracks).

Result links (media) last 15 minutes and 20 full downloads; the file is kept an hour. Past that a link answers 403 with error "link_expired" or 429 with error "link_exhausted" (also the header X-Wyzie-Link: expired|exhausted), and refresh / X-Wyzie-Refresh: the job URL that gives a fresh link. The client matches on those, never on the message text. download_media then asks the job (the refresh URL when it is on the client's own API host, since the key goes there; else the link's own GET /censor/{id}) for a fresh link and tries once more; still refused (or no key on the client) raises LinkExpiredError, a WyzieError with link_state ("expired" or "exhausted") and refresh. A failed refresh (the job gone after its hour, the key refused) raises that refresh's WyzieError. Download soon after the job is done.

Every Censored and upload call, and every poll and cancel of a Transcribe or Fix job, sends the key as Authorization: Bearer <key>, never in the URL or body. Other routes (search, download, the transcribe start...) still take ?key=.

Censored: transcript editing, caption sound cues, subtitle styles

# A review=True job's words: bleep any word by its place, or a run of words
rv = wyzie.censor_url("https://example.com/talk.mp4", review=True)
t = wyzie.censor_transcript(rv["id"])  # {id, state, count, words: [{i, w, s, e, hit?}]}
wyzie.censor_edit_hits(rv["id"], add=[{"word": 12}, {"from": 40, "to": 42}])
wyzie.censor_render(rv["id"])

# Censored Live: also mute what the captions announce ("[screaming]", "[gunfire]")
live = wyzie.censor_mask(cues=[{"start": 3, "end": 5, "text": "[screaming]"}], sdh_cues=["screaming"])  # or True for all

# The clean transcript: [bleep] in place of the word, as plain text
txt = wyzie.censor_subtitle(job["id"], format="txt", style="bleep")

censor_transcript(id) answers a review job's words: i (its place), w, s and e (seconds) and hit (the hit id) on a word a hit covers, which comes masked. Only the key that started the job, only while it is in review; free. A review is kept 24 hours (the rendered file an hour). censor_edit_hits add takes {start, end} seconds, {word: i} or {from: i, to: j} (word places, inclusive); a bad place is a 400.

censor_mask(..., sdh_cues=True) (or a list of SDH_CUE_KINDS: gunfire, screaming, moaning, explicit_music) also answers the spans the captions themselves announce in brackets as ranges of category "sdh_cues": word is the masked annotation, mask places it. Off by default; a bad kind is a 400, nothing charged.

censor_subtitle(id, format, style, marks): format srt (default), vtt or txt (plain text, one cue a line); style stars (default, "f***") or bleep ("[bleep]" / "[muted]" in place of the word).

Censored: your own ranges, per-title words, safe retries, the ledger

from pathlib import Path

# Silence the ranges of an EDL, a VideoSkip .skp or a censor_filter JSON: no speech recognition, render price only
job = wyzie.censor_url("https://example.com/film.mp4", ranges_file=Path("film.edl"))

# Name the title: the words you never want muted for it (dash.wyzie.io, Censored, per title) are added to allow
job = wyzie.censor_url("https://example.com/film.mp4", imdb="tt0111161")  # or tmdb=603

# Safe to retry: the same idempotency_key gives back the first answer, never a second job or charge
job = wyzie.censor_url("https://example.com/ep1.mp4", idempotency_key="ep1-strict", wait=False)
print(wyzie.last_replayed)  # True when the API answered from the key

print(wyzie.get_censor_job(job["id"])["ledger"])  # {"charged": 95, "refunded": 0, "net": 95, "reason": None}

ranges_file on censor (sent as a multipart field next to the file) and censor_url takes an EDL, a VideoSkip .skp or the JSON censor_filter answers (the same files it exports; up to 2 MB and 20000 ranges): text, bytes or a pathlib.Path. Its ranges are silenced with no speech recognition, priced as a render only (10 a started minute). It can't be combined with music or review: a 400 "Invalid ranges_file", as is a broken line (the error names it); nothing charged.

imdb ("tt0111161") or tmdb (603) on censor, censor_url and censor_mask names the title. The account keeps per-title Never Censor words (up to 100 titles, 50 words each), set in dash.wyzie.io under Censored or through the account's media prefs (censor.titles). A request that names the title adds that title's words to its allow. A bad id is a 400 "imdb is an IMDb id like tt0111161, tmdb is a TMDB number like 603".

censor and censor_url send an Idempotency-Key header on every call: your idempotency_key (1 to 100 letters, digits and _ . : -), else a random one made for that call. The same key from the same API key again replays the first answer (last_replayed is True) with no second job and no second charge; a repeat while the first still runs is a 409 (retry after 5 s). Answers are kept 24 hours, and an error frees the key. The API also takes these POSTs without a key, but the client always sends one, dry runs too, always a fresh one (a quote never shares a key with the real call). The client retries these POSTs by itself (network errors, 5xx, a 429 with a short Retry-After, a 409 after its Retry-After; up to retries more times, 2 by default) with the same key and the same bytes, so a retry never starts a second job. A key sent again with a different request is a 422 WyzieError with is_idempotency_key_reused True (reason idempotency_key_reused), nothing charged: use a new key.

get_censor_job carries ledger: {charged, refunded, net, reason}, where reason is why the job failed, "refund pending: ..." while a refund is retried, or None.

Censored: files over 100 MB (resumable upload)

One request carries at most 100 MB. censor, transcribe, fix and extract send a larger file (a path, or a seekable binary file) in chunks by themselves (POST /upload, 8 MB chunks, SHA-256 checked) and start the job with its upload_id; the price is the same. The file is read a chunk at a time, never whole into memory. Use upload_large yourself to resume after a restart:

job = wyzie.censor("movie.mkv", level="strict")  # over 100 MB: chunked upload, then the job

# Resume after a crash: save the id, pass it back; only the missing bytes are sent.
uid = wyzie.upload_large("movie.mkv", upload_id=saved, on_upload_id=save, on_progress=lambda got, size: print(got, size))

A wrong offset, a cut-off chunk or a dropped connection carries on from what the server has. A file that changed while it was sent is a 422 WyzieError with is_hash_mismatch (the upload is deleted: send it again); one that got shorter, or an upload whose received does not move for 3 rounds, stops with a WyzieError at once. delete_upload(id) drops an unused one; an upload is used up once a job starts with it and deleted after 6 idle hours. Paid keys; at most 3 unfinished uploads a key. Wyzie(key, large_upload_bytes=...) moves the switch point. A file object that can't seek has no known size, so it always goes in one request. With chunks, ranges_file (censor) goes as JSON text with the job start (5 MB); transcribe, fix and extract send every option in the query, and fix then takes the subtitle as url or id only (a subtitle file raises ValueError). transcribe and fix also send an Idempotency-Key (idempotency_key=, else random per call) and are retried with it, as censor. sync_own_subtitle sends speech segments, not a media file, so /sync's upload_id is not used here.

Errors

Any non-2xx answer raises WyzieError with status, message, details, body (the full JSON error, including extras like topup or reset_at) and retry_after. Use err.is_rate_limited (429) and err.is_auth_error (401/403). Censored adds err.is_product_off (403 PRODUCT_OFF: the product is off for the account, turn it on in dash.wyzie.io), err.is_payment_required (402) and err.is_blocked_site (422: the site blocks server fetching, use the browser extension there); nothing is charged in any of these.

A part of the API that is not open yet answers 404 {"error": "feature_unavailable", ...} and raises FeatureUnavailableError (a WyzieError), nothing charged. A plain 404 stays a WyzieError.

from wyzie_subs import WyzieError

try:
    wyzie.search("tt0111161")
except WyzieError as err:
    if err.is_rate_limited:
        print("retry in", err.retry_after)

"No subtitles found" and "No matching release found" are not errors: search gives [], search_best gives None.

Every scraped result carries rank ({"score": 0-100, "reasons": [...]}: 100 minus penalties such as image_format, extra_file (a song, trailer or sign-language part filed under the title), sdh, machine_translated, language_variant, unreliable_source) and results come in rank order. sort="quality" keeps rank order with video / hash too (they otherwise put the best release match first); sort="downloads" lists the most downloaded first.

Every result has machine: True for a machine-made file (a source's machine translation, or one of our AI rows, which also have ai: True). machine="exclude" leaves those out before paging (search_batch takes it per item or as a default); when only machine-made files matched, search gives []. Default "include", no extra cost.

human = wyzie.search("tt0816692", language="fr", machine="exclude")

Transcribe costs 85 a started minute; speakers=True is 88 a minute plus 3 a file in any language (no language needed; a 503 before any charge when speaker labels are unavailable). A recognition cache hit costs 1 a minute of recognition (4 with speakers), the rest refunded.

GETs, and cancel_transcribe / cancel_fix (a repeat cancel answers the same), are retried on network errors, 5xx and short 429s (Retry-After of 10 s or less) with backoff. POSTs (batch, extract and the other billed calls) are never retried, because they are billed, except censor, censor_url, transcribe, transcribe_url and fix: their Idempotency-Key makes a retry safe.

Cancel a running job

transcribe and fix pass the job id to on_job when the work runs as a job; transcribe_url returns it as jobId. Pass it to cancel_transcribe or cancel_fix:

job = wyzie.transcribe_url("https://example.com/ep.mp3", idempotency_key="order-42")
res = wyzie.cancel_transcribe(job["jobId"])  # {"id", "status": "cancelled", "refunded", "charged", "refundPending"?}

Before recognition starts everything is refunded. During recognition the started minutes already recognised stay charged (85 each, plus a finished fallback proxy fetch) and the rest is refunded. Cancelling again answers the same; refundPending means the refund hasn't landed yet, so cancel again later. Polling a cancelled job raises WyzieError 410 with is_cancelled True. A job that already ended, or whose recognition finished, raises a 409 with is_nothing_to_cancel True and cancel_status "done", "failed" or "finishing" (for "finishing", keep polling: the result is on its way). Another key's job is a 404. Batch jobs can't be cancelled. transcribe_url sends an Idempotency-Key (yours, or a random one), so a retry after a lost answer gets the first 202 back with no second charge.

Repeat downloads

A repeat download of the same subtitle (same link path, season and episode) by the same key within 6 hours of its paid download, with options it hasn't been served with yet in that window (sdh, clean, plain, to, shift, encoding, format), is free: last_cost is 0. Options already served in the window cost 1 again, and at most 20 repeats per subtitle are free in a window. Other network failures raise the underlying httpx exception.

Key safety

Use your API key on a server only. Do not ship it in a browser, mobile app or public repo; use a browser-safe wyzie-pub- key for front-end code. The client never logs or prints the key (it is redacted from httpx request logs, with share= and link t= tokens, and from repr; Censored and upload calls send it in the Authorization header), but a URL you build yourself with the key in it is yours to protect.

More

Client guide: https://docs.wyzie.io/subs/usage/clients

Docs · Support · Status · News · Terms · Privacy

API help: support@wyzie.io. Business: hello@wyzie.io.

Metadata

Release files for wyzie-subs 0.12.1

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for wyzie-subs 0.12.1
File Size Uploaded Provenance Actions
wyzie_subs-0.12.1.tar.gz 52.3 kB Without provenance Details for wyzie_subs-0.12.1.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for wyzie-subs 0.12.1
File Interpreter ABI Platform Actions
wyzie_subs-0.12.1-py3-none-any.whl Python 3 none any Details for wyzie_subs-0.12.1-py3-none-any.whl

Total release size: 92.1 kB

Release files / wyzie_subs-0.12.1.tar.gz

Download URL wyzie_subs-0.12.1.tar.gz
Size 52.3 kB
Tags Source
SHA-256 checksum
How to use checksums
5f2673461984dcaa0a4eda60ce90f50f3c98a3e98f7ae79714c4a361534e5600
BLAKE2b-256 checksum
How to use checksums
0d340f3271d57da27f516f88bc0b981a6beef4b8dec29e146c2bf3c67d43b81a
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.0

Release files / wyzie_subs-0.12.1-py3-none-any.whl

Download URL wyzie_subs-0.12.1-py3-none-any.whl
Size 39.7 kB
Tags Python 3
SHA-256 checksum
How to use checksums
8bfb66d4b9303ae8cf940afcb8e4672fe5de4e623cc7f1103a77b16caf80f4c0
BLAKE2b-256 checksum
How to use checksums
4a2b58454920adc38a98e068d6e312bfa74b5708a711b3cfb7a7e5ecef462902
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via twine/7.0.0 CPython/3.13.0

Security for wyzie-subs 0.12.1

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page