""" HLS/DASH Converter EXTREME — App nativa Windows Convierte a HLS/DASH y sube a GitHub. Sin Gradio. Auto-elevación a administrador. """ import sys import os import ctypes import subprocess import threading import tempfile import shutil import re import json import time import uuid import tkinter as tk from tkinter import ttk, filedialog, messagebox, scrolledtext from pathlib import Path from concurrent.futures import ThreadPoolExecutor, as_completed # ─── AUTO-ELEVACIÓN ADMINISTRADOR ─────────────────────────── def is_admin(): try: return ctypes.windll.shell32.IsUserAnAdmin() except: return False def elevate(): if not is_admin(): ctypes.windll.shell32.ShellExecuteW( None, "runas", sys.executable, " ".join(sys.argv), None, 1 ) sys.exit() elevate() try: import requests except ImportError: requests = None # ─── COLORES ──────────────────────────────────────────────── BG = "#080d18" BG2 = "#0f1629" BG3 = "#17213a" ACCENT = "#6366f1" ACCENT2 = "#8b5cf6" GREEN = "#22c55e" RED = "#ef4444" YELLOW = "#f59e0b" CYAN = "#22d3ee" FG = "#e2e8f0" FG2 = "#94a3b8" FG3 = "#3a5070" BORDER = "#1a2a40" FM = ("Consolas", 10) FB = ("Consolas", 11, "bold") FS = ("Consolas", 9) # ─── UTILS ────────────────────────────────────────────────── def get_threads(): try: return max(len(os.sched_getaffinity(0)) - 1, 1) except: return max((os.cpu_count() or 4) - 1, 1) N_THREADS = get_threads() def clean_folder(n): return re.sub(r'[<>:"/\\|?*]', '_', n).strip()[:200] def clean_repo(n): n = re.sub(r'[^a-zA-Z0-9_-]', '-', n) return re.sub(r'-+', '-', n).strip('-')[:100] def build_name(ctype, mname, sname, season, ep_start, idx): if ctype == "Película": b = mname.strip() or "Pelicula" return clean_folder(b), clean_repo(b) name = sname.strip() or "Serie" try: t = int(season) except: t = 1 try: e = int(ep_start) + idx except: e = idx + 1 lbl = f"{name}_T{t}_Ep{e}" return clean_folder(lbl), clean_repo(lbl) def is_live(url): if not url.startswith(("http://", "https://")): return False lo = url.lower() if any(lo.endswith(x) for x in ['.mp4','.mkv','.avi','.mov','.ts']): return False return any(p in lo for p in ['/live/','/stream/','.m3u8','.mpd','/hls/','/dash/']) def input_args(src): ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" if src.startswith(("http://", "https://")): if is_live(src): return ['-user_agent', ua, '-timeout', '60000000', '-reconnect','1','-reconnect_streamed','1', '-fflags','+genpts+igndts','-probesize','100M','-analyzeduration','50M'] return ['-user_agent', ua, '-timeout', '120000000', '-reconnect','1','-reconnect_streamed','1','-reconnect_delay_max','10', '-analyzeduration','500000000','-probesize','500000000', '-fflags','+genpts+igndts','-err_detect','ignore_err', '-max_delay','10000000','-rw_timeout','120000000'] return ['-analyzeduration','100000000','-probesize','100000000','-fflags','+genpts+igndts'] def render_args(): return ['-threads', str(N_THREADS), '-thread_type', 'slice+frame', '-slices', str(N_THREADS), '-max_muxing_queue_size', '9999', '-thread_queue_size', '4096'] def detect_duration(src, iargs): try: cmd = ['ffprobe','-v','error'] + iargs + ['-show_entries','format=duration','-of','json','-i',src] r = subprocess.run(cmd, capture_output=True, text=True, timeout=120) d = json.loads(r.stdout).get('format',{}).get('duration') return float(d) if d and d != 'N/A' else None except: return None def detect_audio(src, iargs): try: cmd = ['ffprobe','-v','error'] + iargs + [ '-select_streams','a', '-show_entries','stream=index,codec_name:stream_tags=language,title', '-of','json','-i',src] r = subprocess.run(cmd, capture_output=True, text=True, timeout=120) tracks = [] for s in json.loads(r.stdout).get('streams',[]): tags = s.get('tags',{}) tracks.append({'index': s.get('index',0), 'language': tags.get('language','und').lower(), 'title': tags.get('title', f"Audio {s.get('index',0)}"), 'codec': s.get('codec_name','unknown')}) return tracks except: return [] def prioritize_audio(tracks): prio = ['spa','es','spanish','español','latino','lat','es-mx','es-419'] def key(t): l, ti = t['language'], t['title'].lower() for p in prio: if p in l or p in ti: return 0 return 1 if l == 'und' else 2 return sorted(tracks, key=key) def make_master_m3u8(out_dir, video_streams, audio_playlists): c = "#EXTM3U\n#EXT-X-VERSION:7\n\n" for a in audio_playlists: d = "YES" if a['is_default'] else "NO" c += f'#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="{a["title"]}",LANGUAGE="{a["language"]}",DEFAULT={d},AUTOSELECT={d},URI="{a["file"]}"\n' c += "\n" for v in video_streams: c += f'#EXT-X-STREAM-INF:BANDWIDTH={v["bandwidth"]},RESOLUTION={v["resolution"]},CODECS="{v["codecs"]}",AUDIO="audio"\n{v["file"]}\n' (out_dir / "master.m3u8").write_text(c) RAMDISK_PATH = None def setup_ramdisk(): global RAMDISK_PATH for p in [r"C:\Temp\hls_tmp", tempfile.gettempdir() + r"\hls_tmp"]: try: Path(p).mkdir(parents=True, exist_ok=True) RAMDISK_PATH = Path(p) return Path(p) except: continue RAMDISK_PATH = Path(tempfile.gettempdir()) return RAMDISK_PATH RAMDISK = setup_ramdisk() def process_audio_track(args): track, i, total, src, out_dir, iargs = args tmp = RAMDISK / f"aud_{os.getpid()}_{i}_{int(time.time())}" tmp.mkdir(exist_ok=True) try: af = tmp / f"audio_{i}.m3u8" sf = tmp / f"audio_{i}_%03d.ts" wav_tmp = tmp / f"audio_{i}_raw.wav" r_dec = subprocess.run( ['ffmpeg','-hide_banner','-threads',str(N_THREADS)] + iargs + [ '-i',src,'-map',f"0:{track['index']}",'-vn', '-c:a','pcm_s16le','-ar','48000','-ac','2','-f','wav', str(wav_tmp),'-y','-loglevel','error'], capture_output=True, text=True, timeout=7200) if r_dec.returncode != 0 or not wav_tmp.exists(): raise Exception(f"Decode PCM falló: {r_dec.stderr[-300:]}") r_enc = subprocess.run( ['ffmpeg','-hide_banner','-threads',str(N_THREADS), '-i',str(wav_tmp),'-c:a','libmp3lame','-b:a','192k', '-ar','48000','-ac','2','-compression_level','0', '-max_muxing_queue_size','9999','-thread_queue_size','4096', '-hls_time','5','-hls_list_size','0', '-hls_segment_filename',str(sf), '-hls_flags','independent_segments+append_list+temp_file', '-hls_playlist_type','vod','-hls_segment_type','mpegts', str(af),'-y','-loglevel','error'], capture_output=True, text=True, timeout=7200) wav_tmp.unlink(missing_ok=True) if r_enc.returncode != 0 or not af.exists(): raise Exception(f"Encode MP3 falló: {r_enc.stderr[-300:]}") ts_files = list(tmp.glob(f"audio_{i}_*.ts")) if not ts_files: raise Exception("Sin segmentos TS") shutil.move(str(af), str(out_dir / f"audio_{i}.m3u8")) for ts in ts_files: shutil.move(str(ts), str(out_dir / ts.name)) return {'success': True, 'index': i, 'track': track, 'segments_count': len(ts_files), 'playlist': {'file': f"audio_{i}.m3u8", 'language': track['language'], 'title': track['title'], 'is_default': i == 0}} except Exception as e: return {'success': False, 'index': i, 'error': str(e), 'track': track} finally: shutil.rmtree(tmp, ignore_errors=True) def process_video_copy(src, iargs, out_dir, tmp_v, vf, sf, log_cb): hls = ['-hls_time','5','-hls_list_size','0','-hls_segment_filename',str(sf), '-hls_flags','independent_segments+append_list+temp_file+split_by_time', '-hls_playlist_type','vod','-hls_segment_type','mpegts',str(vf),'-y','-loglevel','error'] base = ['ffmpeg','-hide_banner','-threads',str(N_THREADS)] + iargs + [ '-i',src,'-map','0:v:0','-an', '-max_muxing_queue_size','9999','-avoid_negative_ts','make_zero', '-fflags','+genpts+igndts+flush_packets+discardcorrupt', '-err_detect','ignore_err','-copytb','1','-start_at_zero','-thread_queue_size','4096'] r1 = subprocess.run(base + ['-c:v','copy','-bsf:v','h264_mp4toannexb,dump_extra'] + hls, capture_output=True, text=True, timeout=7200) if r1.returncode == 0 and vf.exists() and list(tmp_v.glob("video_1080p_*.ts")): log_cb(" ✓ Video COPY OK (h264_mp4toannexb)"); return True vf.unlink(missing_ok=True) for f in tmp_v.glob("video_1080p_*.ts"): f.unlink(missing_ok=True) log_cb(" ⚠ Copy con bsf falló, reintentando sin bsf…") r2 = subprocess.run(base + ['-c:v','copy'] + hls, capture_output=True, text=True, timeout=7200) if r2.returncode == 0 and vf.exists() and list(tmp_v.glob("video_1080p_*.ts")): log_cb(" ✓ Video COPY OK (sin bsf)"); return True vf.unlink(missing_ok=True) for f in tmp_v.glob("video_1080p_*.ts"): f.unlink(missing_ok=True) log_cb(" ⚠ Copy falló, re-encode H.264 ultrafast…") hls2 = ['-hls_time','5','-hls_list_size','0','-hls_segment_filename',str(sf), '-hls_flags','independent_segments+append_list+temp_file', '-hls_playlist_type','vod','-hls_segment_type','mpegts',str(vf),'-y','-loglevel','error'] r3 = subprocess.run( ['ffmpeg','-hide_banner','-threads',str(N_THREADS)] + iargs + [ '-i',src,'-map','0:v:0','-an','-c:v','libx264','-preset','ultrafast','-crf','23', '-pix_fmt','yuv420p','-threads',str(N_THREADS), '-max_muxing_queue_size','9999','-thread_queue_size','4096'] + hls2, capture_output=True, text=True, timeout=14400) if r3.returncode == 0 and vf.exists() and list(tmp_v.glob("video_1080p_*.ts")): log_cb(" ✓ Video re-encode H.264 OK"); return True raise Exception(f"Video falló en todos los modos: {r3.stderr[-400:]}") def git_push_retry(gd, args, retries=3, timeout=600): for attempt in range(retries): try: subprocess.run(['git','push'] + args, cwd=gd, check=True, capture_output=True, timeout=timeout) return True except: if attempt == retries-1: return False time.sleep(3) return False def run_conversion(job, log_cb, progress_cb, done_cb): """Hilo principal de conversión""" token = job['token'] sources = job['sources'] conv_opt = job['conv_opt'] stream_fmt = job['stream_fmt'] batch_size = job['batch_size'] delete_local = job['delete_local'] max_workers = job['max_workers'] ctype = job['ctype'] mname = job['mname'] sname = job['sname'] season = job['season'] ep_start = job['ep_start'] final_links = [] try: log_cb(f"🚀 EXTREME v5.1 | Threads: {N_THREADS} | Temp: {RAMDISK}") for idx, source in enumerate(sources): src = source['value'] folder_name, repo_name = build_name(ctype, mname, sname, season, ep_start, idx) log_cb(f"\n📦 [{idx+1}/{len(sources)}] {folder_name}") progress_cb(int(idx/len(sources)*100), f"[{idx+1}/{len(sources)}] {folder_name}") out_dir = RAMDISK / "outputs" / folder_name out_dir.mkdir(parents=True, exist_ok=True) iargs = input_args(src) dur = detect_duration(src, iargs) if dur: h, m, s2 = int(dur//3600), int((dur%3600)//60), int(dur%60) log_cb(f" ⏱ Duración: {h:02d}:{m:02d}:{s2:02d}") audio_tracks = detect_audio(src, iargs) or [{'index':0,'language':'und','title':'Audio','codec':'unk'}] audio_tracks = prioritize_audio(audio_tracks) log_cb(f" 🎵 {len(audio_tracks)} pista(s)") manifest_file = "" if stream_fmt == "HLS (M3U8)": log_cb(f" 🎵 Procesando {len(audio_tracks)} audio(s) → PCM → MP3") aargs_list = [(t, i, len(audio_tracks), src, out_dir, iargs) for i, t in enumerate(audio_tracks)] audio_playlists = [] with ThreadPoolExecutor(max_workers=max_workers) as ex: futures = {ex.submit(process_audio_track, a): a for a in aargs_list} for fut in as_completed(futures): res = fut.result() if res['success']: audio_playlists.append(res['playlist']) log_cb(f" ✓ Audio {res['index']+1}: {res['track']['title']} ({res['segments_count']} segs)") else: log_cb(f" ✗ Audio {res['index']+1}: {res.get('error','')[:120]}") audio_playlists.sort(key=lambda x: int(x['file'].split('_')[1].split('.')[0])) if not audio_playlists: raise Exception("Sin audio procesado") video_streams = [] if "Copy" in conv_opt: log_cb(" ⚡ Video COPY → HLS") tmp_v = RAMDISK / f"vid_{idx}" tmp_v.mkdir(exist_ok=True) vf = tmp_v / "video_1080p.m3u8" sf = tmp_v / "video_1080p_%03d.ts" process_video_copy(src, iargs, out_dir, tmp_v, vf, sf, log_cb) final_1080 = out_dir / "video_1080p.m3u8" shutil.move(str(vf), str(final_1080)) for ts in tmp_v.glob("video_1080p_*.ts"): shutil.move(str(ts), str(out_dir / ts.name)) shutil.rmtree(tmp_v, ignore_errors=True) (out_dir / "video_720p.m3u8").write_text(final_1080.read_text()) video_streams = [ {'file':'video_1080p.m3u8','resolution':'1920x1080','bandwidth':5000000,'codecs':'avc1.640028'}, {'file':'video_720p.m3u8', 'resolution':'1280x720', 'bandwidth':3000000,'codecs':'avc1.640028'}, ] else: rlist = ([{'label':'4K','scale':'scale=-2:2160','br':'15000k','bufsize':'30000k','res':'3840x2160'}, {'label':'1080p','scale':'scale=-2:1080','br':'5000k','bufsize':'10000k','res':'1920x1080'}, {'label':'720p','scale':'scale=-2:720','br':'2800k','bufsize':'5600k','res':'1280x720'}] if "4K" in conv_opt else [{'label':'1080p','scale':'scale=-2:1080','br':'5000k','bufsize':'10000k','res':'1920x1080'}, {'label':'720p','scale':'scale=-2:720','br':'2800k','bufsize':'5600k','res':'1280x720'}]) for rc in rlist: log_cb(f" 🔄 Renderizando {rc['label']}…") tmp_r = RAMDISK / f"render_{rc['label']}" tmp_r.mkdir(exist_ok=True) vf = tmp_r / f"video_{rc['label']}.m3u8" sf = tmp_r / f"video_{rc['label']}_%03d.ts" r = subprocess.run( ['ffmpeg','-hide_banner','-threads',str(N_THREADS)] + iargs + [ '-i',src,'-map','0:v:0','-an','-c:v','libx264', '-preset','ultrafast','-crf','23','-vf',rc['scale'], '-b:v',rc['br'],'-maxrate',rc['br'],'-bufsize',rc['bufsize'], '-pix_fmt','yuv420p'] + render_args() + [ '-hls_time','5','-hls_list_size','0', '-hls_segment_filename',str(sf), '-hls_flags','independent_segments+append_list+temp_file', '-hls_playlist_type','vod','-hls_segment_type','mpegts', str(vf),'-y','-loglevel','error'], capture_output=True, text=True, timeout=14400) if r.returncode != 0: shutil.rmtree(tmp_r, ignore_errors=True) log_cb(f" ⚠ Error {rc['label']}") continue shutil.move(str(vf), str(out_dir / f"video_{rc['label']}.m3u8")) for ts in tmp_r.glob(f"video_{rc['label']}_*.ts"): shutil.move(str(ts), str(out_dir / ts.name)) shutil.rmtree(tmp_r, ignore_errors=True) video_streams.append({'file':f"video_{rc['label']}.m3u8", 'resolution':rc['res'], 'bandwidth':int(rc['br'].replace('k','000'))+192000, 'codecs':'avc1.640028'}) log_cb(f" ✓ {rc['label']} OK") if not video_streams: raise Exception("Sin video generado") make_master_m3u8(out_dir, video_streams, audio_playlists) manifest_file = "master.m3u8" elif stream_fmt == "DASH (MPD)": log_cb(" 🎬 Generando DASH…") tmp_d = RAMDISK / f"dash_{idx}" tmp_d.mkdir(exist_ok=True) cmd = ['ffmpeg','-hide_banner','-threads',str(N_THREADS)] + iargs + ['-i',src] vc = "copy" if "Copy" in conv_opt else "libx264" cmd += ['-map','0:v:0','-c:v:0',vc] if vc != "copy": cmd += ['-preset','ultrafast','-crf','23'] for i2, t2 in enumerate(audio_tracks): cmd += ['-map',f"0:{t2['index']}",f'-c:a:{i2}','aac',f'-b:a:{i2}','192k', f'-ar:a:{i2}','48000',f'-ac:a:{i2}','2'] mpd_out = tmp_d / "manifest.mpd" cmd += (render_args() if vc != "copy" else ['-max_muxing_queue_size','9999','-copytb','1','-start_at_zero','-thread_queue_size','4096']) cmd += ['-f','dash','-seg_duration','5','-use_template','1','-use_timeline','0', '-init_seg_name','init-$RepresentationID$.m4s', '-media_seg_name','chunk-$RepresentationID$-$Number%05d$.m4s', str(mpd_out),'-y','-loglevel','error'] r = subprocess.run(cmd, capture_output=True, text=True, timeout=14400) if r.returncode != 0: shutil.rmtree(tmp_d, ignore_errors=True) raise Exception(f"DASH falló: {r.stderr[-400:]}") shutil.move(str(mpd_out), str(out_dir / "manifest.mpd")) for m4s in tmp_d.glob("*.m4s"): shutil.move(str(m4s), str(out_dir / m4s.name)) shutil.rmtree(tmp_d, ignore_errors=True) manifest_file = "manifest.mpd" log_cb(" ✓ DASH OK") # ── GITHUB ── log_cb(f" ☁ Subiendo a GitHub: {repo_name}") if not requests: raise Exception("requests no instalado — pip install requests") headers = {"Authorization": f"token {token}"} rr = requests.post("https://api.github.com/user/repos", headers=headers, json={"name": repo_name, "private": True}, timeout=30) if rr.status_code == 422: u = requests.get("https://api.github.com/user", headers=headers, timeout=30) html_url = f"https://github.com/{u.json()['login']}/{repo_name}" elif rr.status_code in [200, 201]: html_url = rr.json()['html_url'] else: raise Exception(f"GitHub API {rr.status_code}: {rr.text[:200]}") git_url = html_url.replace('https://', f'https://{token}@') + '.git' gd = str(out_dir) for gc in [['git','init'],['git','checkout','-b','main'], ['git','remote','add','origin',git_url], ['git','config','http.postBuffer','524288000'], ['git','config','core.compression','0']]: subprocess.run(gc, cwd=gd, check=True, capture_output=True) all_files = os.listdir(gd) ext_s = '.m4s' if stream_fmt == "DASH (MPD)" else '.ts' ext_m = '.mpd' if stream_fmt == "DASH (MPD)" else '.m3u8' segs = [f for f in all_files if f.endswith(ext_s)] mans = [f for f in all_files if f.endswith(ext_m)] subprocess.run(['git','add'] + mans, cwd=gd, check=True, capture_output=True) subprocess.run(['git','commit','-m',f'init {folder_name}'], cwd=gd, check=True, capture_output=True) git_push_retry(gd, ['-u','origin','main']) log_cb(f" 📦 {len(segs)} segmentos → batch {batch_size}") for i3 in range(0, len(segs), batch_size): batch = segs[i3:i3+batch_size] subprocess.run(['git','add']+batch, cwd=gd, check=True, capture_output=True) subprocess.run(['git','commit','-m',f'segs {i3}-{i3+len(batch)}'], cwd=gd, check=True, capture_output=True) ok = git_push_retry(gd, ['origin','main']) if ok: log_cb(f" 📤 {min(i3+batch_size,len(segs))}/{len(segs)}") else: log_cb(f" ⚠ Batch {i3} error") gp = f"https://gooplay.xyz/gp/stream.php?repo={repo_name}&branch=main&file={manifest_file}" gh = f"{html_url}/blob/main/{manifest_file}" final_links.append(f"{folder_name}\nGooplay: {gp}\nGitHub: {gh}") log_cb(f" ✓ Completado: {folder_name}") if delete_local: shutil.rmtree(out_dir, ignore_errors=True) log_cb(" ✓ Archivos locales borrados") else: log_cb(f" ℹ Archivos en: {out_dir}") result = "\n\n".join(final_links) log_cb("\n🎉 TODOS COMPLETADOS\n" + "="*40 + "\n" + result) done_cb(True, result) except Exception as e: import traceback log_cb(f"\n✗ ERROR: {e}\n{traceback.format_exc()}") done_cb(False, str(e)) # ════════════════════════════════════════════════════════════ # GUI # ════════════════════════════════════════════════════════════ class AppHLS(tk.Tk): def __init__(self): super().__init__() self.title("HLS/DASH Converter EXTREME") self.geometry("1100x750") self.minsize(900, 620) self.configure(bg=BG) self.resizable(True, True) self._build() self._center() def _center(self): self.update_idletasks() w, h = self.winfo_width(), self.winfo_height() sw, sh = self.winfo_screenwidth(), self.winfo_screenheight() self.geometry(f"{w}x{h}+{(sw-w)//2}+{(sh-h)//2}") def _style(self): s = ttk.Style(self) s.theme_use("clam") s.configure(".", background=BG, foreground=FG, font=FM, fieldbackground=BG2, borderwidth=0) s.configure("TFrame", background=BG) s.configure("TLabel", background=BG, foreground=FG) s.configure("TEntry", fieldbackground=BG2, foreground=FG, insertcolor=FG, borderwidth=1) s.configure("TCombobox", fieldbackground=BG2, background=BG3, foreground=FG, arrowcolor=FG2) s.map("TCombobox", fieldbackground=[("readonly", BG2)], foreground=[("readonly", FG)]) s.configure("TCheckbutton", background=BG, foreground=FG2) s.map("TCheckbutton", background=[("active", BG)]) s.configure("TRadiobutton", background=BG, foreground=FG2) s.map("TRadiobutton", background=[("active", BG)]) s.configure("Horizontal.TProgressbar", troughcolor=BG3, background=ACCENT, borderwidth=0, thickness=6) def _build(self): self._style() # HEADER hdr = tk.Frame(self, bg=BG, pady=8) hdr.pack(fill="x", padx=20) tk.Label(hdr, text="HLS/DASH CONVERTER EXTREME", bg=BG, fg=ACCENT, font=("Consolas", 15, "bold")).pack(side="left") tk.Label(hdr, text=f" · {N_THREADS} threads · {RAMDISK}", bg=BG, fg=FG3, font=FS).pack(side="left") self._lbl_status = tk.Label(hdr, text="● Listo", bg=BG, fg=GREEN, font=FS) self._lbl_status.pack(side="right") tk.Frame(self, bg=BORDER, height=1).pack(fill="x", padx=20) body = tk.Frame(self, bg=BG) body.pack(fill="both", expand=True, padx=20, pady=8) # ─ LEFT ─ left = tk.Frame(body, bg=BG, width=340) left.pack(side="left", fill="y", padx=(0, 10)) left.pack_propagate(False) self._section(left, "GITHUB TOKEN") self._gh_token = self._entry_var(left, "ghp_…", show="*") self._section(left, "FUENTES") # Files f_files = tk.Frame(left, bg=BG) f_files.pack(fill="x", pady=(0, 4)) self._file_lbl = tk.Label(f_files, text="Sin archivos", bg=BG3, fg=FG3, font=FS, anchor="w", padx=6, pady=3) self._file_lbl.pack(side="left", fill="x", expand=True) tk.Button(f_files, text="📁 Archivos", bg=BG3, fg=FG2, bd=0, font=FS, cursor="hand2", command=self._browse_files, padx=6, pady=3).pack(side="right") self._files_list = [] # URLs tk.Label(left, text="URLs (una por línea):", bg=BG, fg=FG2, font=FS).pack(anchor="w") self._urls_txt = tk.Text(left, bg=BG2, fg=FG, insertbackground=FG, font=FS, bd=0, relief="flat", height=5, wrap="none") self._urls_txt.pack(fill="x", pady=(0, 6)) self._section(left, "CONVERSIÓN") self._conv_opt = ttk.Combobox(left, state="readonly", font=FS, height=6, values=["Opción 1: Copy Video", "Opción 2: Copy Video MP3", "Opción 3: 1080p+720p H.264", "Opción 4: 4K+1080p+720p H.264"]) self._conv_opt.set("Opción 1: Copy Video") self._conv_opt.pack(fill="x", pady=(0, 4)) self._stream_fmt = ttk.Combobox(left, state="readonly", font=FS, values=["HLS (M3U8)", "DASH (MPD)"]) self._stream_fmt.set("HLS (M3U8)") self._stream_fmt.pack(fill="x", pady=(0, 6)) f_nums = tk.Frame(left, bg=BG) f_nums.pack(fill="x", pady=(0, 4)) tk.Label(f_nums, text="Batch git:", bg=BG, fg=FG2, font=FS).pack(side="left") self._batch_var = tk.StringVar(value="30") tk.Entry(f_nums, textvariable=self._batch_var, bg=BG2, fg=FG, insertbackground=FG, font=FS, bd=0, width=5, relief="flat").pack(side="left", padx=4) tk.Label(f_nums, text="Workers:", bg=BG, fg=FG2, font=FS).pack(side="left") self._workers_var = tk.StringVar(value="4") tk.Entry(f_nums, textvariable=self._workers_var, bg=BG2, fg=FG, insertbackground=FG, font=FS, bd=0, width=4, relief="flat").pack(side="left", padx=4) self._del_local = tk.BooleanVar(value=True) ttk.Checkbutton(left, text="Borrar archivos locales al terminar", variable=self._del_local).pack(anchor="w") self._section(left, "CONTENIDO") self._ctype = tk.StringVar(value="Serie") f_ct = tk.Frame(left, bg=BG) f_ct.pack(fill="x") for ct in ["Película", "Serie"]: ttk.Radiobutton(f_ct, text=ct, variable=self._ctype, value=ct, command=self._toggle_ctype).pack(side="left", padx=4) self._movie_frame = tk.Frame(left, bg=BG) tk.Label(self._movie_frame, text="Nombre:", bg=BG, fg=FG2, font=FS).pack(anchor="w") self._mname = self._entry_var(self._movie_frame, "El Padrino") self._serie_frame = tk.Frame(left, bg=BG) tk.Label(self._serie_frame, text="Serie:", bg=BG, fg=FG2, font=FS).pack(anchor="w") self._sname = self._entry_var(self._serie_frame, "Breaking Bad") f_ss = tk.Frame(self._serie_frame, bg=BG) f_ss.pack(fill="x") tk.Label(f_ss, text="Temp:", bg=BG, fg=FG2, font=FS).pack(side="left") self._season = tk.StringVar(value="1") tk.Entry(f_ss, textvariable=self._season, bg=BG2, fg=FG, insertbackground=FG, font=FS, bd=0, width=4, relief="flat").pack(side="left", padx=4) tk.Label(f_ss, text="Ep inicial:", bg=BG, fg=FG2, font=FS).pack(side="left") self._ep_start = tk.StringVar(value="1") tk.Entry(f_ss, textvariable=self._ep_start, bg=BG2, fg=FG, insertbackground=FG, font=FS, bd=0, width=4, relief="flat").pack(side="left", padx=4) self._serie_frame.pack(fill="x", pady=(4, 0)) # ─ RIGHT ─ right = tk.Frame(body, bg=BG) right.pack(side="right", fill="both", expand=True) # Progress self._lbl_prog = tk.Label(right, text="", bg=BG, fg=FG2, font=FS, anchor="w") self._lbl_prog.pack(fill="x") self._pbar = ttk.Progressbar(right, mode="determinate", style="Horizontal.TProgressbar") self._pbar.pack(fill="x", pady=(2, 6)) # Log tk.Label(right, text="LOG DE PROCESAMIENTO", bg=BG, fg=FG3, font=("Consolas", 8, "bold")).pack(anchor="w") log_f = tk.Frame(right, bg=BORDER) log_f.pack(fill="both", expand=True, pady=(2, 6)) self._log_txt = tk.Text( log_f, bg="#030810", fg=CYAN, font=("Consolas", 9), bd=0, relief="flat", state="disabled", wrap="word", insertbackground=FG, selectbackground=ACCENT2 ) sb = ttk.Scrollbar(log_f, command=self._log_txt.yview) self._log_txt.configure(yscrollcommand=sb.set) sb.pack(side="right", fill="y") self._log_txt.pack(fill="both", expand=True, padx=1, pady=1) # Links output tk.Label(right, text="LINKS GENERADOS", bg=BG, fg=FG3, font=("Consolas", 8, "bold")).pack(anchor="w") lnk_f = tk.Frame(right, bg=BORDER) lnk_f.pack(fill="x", pady=(2, 6)) self._links_txt = tk.Text( lnk_f, bg="#020c08", fg=GREEN, font=("Consolas", 9), bd=0, relief="flat", state="disabled", height=6, insertbackground=FG ) lsb = ttk.Scrollbar(lnk_f, command=self._links_txt.yview) self._links_txt.configure(yscrollcommand=lsb.set) lsb.pack(side="right", fill="y") self._links_txt.pack(fill="x", padx=1, pady=1) # Buttons bf = tk.Frame(right, bg=BG) bf.pack(fill="x") self._btn_start = tk.Button( bf, text="🚀 INICIAR CONVERSIÓN", bg=ACCENT, fg="white", bd=0, padx=16, pady=10, font=("Consolas", 12, "bold"), cursor="hand2", command=self._do_start ) self._btn_start.pack(side="left", fill="x", expand=True) tk.Button( bf, text="✕", bg=BG3, fg=RED, bd=0, padx=14, pady=10, font=FB, cursor="hand2", command=self._do_cancel ).pack(side="right", padx=(6, 0)) self._cancelled = False # ── HELPERS ────────────────────────────────────────── def _section(self, parent, text): f = tk.Frame(parent, bg=BG) f.pack(fill="x", pady=(10, 2)) tk.Label(f, text=text, bg=BG, fg=FG3, font=("Consolas", 8, "bold")).pack(side="left") tk.Frame(f, bg=BORDER, height=1).pack(side="right", fill="x", expand=True, padx=(6, 0), pady=4) def _entry_var(self, parent, placeholder, show=None): v = tk.StringVar() kw = {"show": show} if show else {} tk.Entry(parent, textvariable=v, bg=BG2, fg=FG2, insertbackground=FG, font=FS, bd=0, relief="flat", **kw).pack(fill="x", ipady=5, pady=(0, 4)) return v def _toggle_ctype(self): if self._ctype.get() == "Película": self._serie_frame.pack_forget() self._movie_frame.pack(fill="x", pady=(4, 0)) else: self._movie_frame.pack_forget() self._serie_frame.pack(fill="x", pady=(4, 0)) def _browse_files(self): files = filedialog.askopenfilenames( filetypes=[("Video", "*.mp4 *.mkv *.avi *.mov *.ts *.m2ts *.webm"), ("Todos", "*.*")] ) if files: self._files_list = list(files) names = ", ".join(Path(f).name for f in files) self._file_lbl.configure( text=names[:60] + ("…" if len(names) > 60 else ""), fg=FG2 ) def _log(self, msg): self._log_txt.configure(state="normal") self._log_txt.insert("end", msg + "\n") self._log_txt.see("end") self._log_txt.configure(state="disabled") def _set_progress(self, pct, label=""): self._pbar["value"] = pct self._lbl_prog.configure(text=label) self.update_idletasks() def _set_links(self, text): self._links_txt.configure(state="normal") self._links_txt.delete("1.0", "end") self._links_txt.insert("1.0", text) self._links_txt.configure(state="disabled") # ── START ──────────────────────────────────────────── def _do_start(self): token = self._gh_token.get().strip() if not token: messagebox.showwarning("Token", "Ingresá tu token de GitHub") return sources = [] for f in self._files_list: sources.append({"type": "file", "value": f}) for line in self._urls_txt.get("1.0", "end").strip().split("\n"): u = line.strip() if u: sources.append({"type": "url", "value": u}) if not sources: messagebox.showwarning("Fuente", "Agregá archivos o URLs") return self._btn_start.configure(state="disabled", bg=FG3) self._lbl_status.configure(text="● Procesando…", fg=YELLOW) self._log_txt.configure(state="normal") self._log_txt.delete("1.0", "end") self._log_txt.configure(state="disabled") self._pbar["value"] = 0 self._cancelled = False try: batch_size = int(self._batch_var.get() or 30) max_workers = int(self._workers_var.get() or 4) season = int(self._season.get() or 1) ep_start = int(self._ep_start.get() or 1) except: batch_size, max_workers, season, ep_start = 30, 4, 1, 1 job = { 'token': token, 'sources': sources, 'conv_opt': self._conv_opt.get(), 'stream_fmt': self._stream_fmt.get(), 'batch_size': batch_size, 'delete_local': self._del_local.get(), 'max_workers': max_workers, 'ctype': self._ctype.get(), 'mname': self._mname.get().strip(), 'sname': self._sname.get().strip(), 'season': season, 'ep_start': ep_start, } def _done(ok, result): self.after(0, self._btn_start.configure, {"state": "normal", "bg": ACCENT}) if ok: self.after(0, self._lbl_status.configure, {"text": "● Completado", "fg": GREEN}) self.after(0, self._set_links, result) self.after(0, self._set_progress, 100, "Completado") else: self.after(0, self._lbl_status.configure, {"text": "● Error", "fg": RED}) threading.Thread( target=run_conversion, args=(job, lambda m: self.after(0, self._log, m), lambda p, l: self.after(0, self._set_progress, p, l), _done), daemon=True ).start() def _do_cancel(self): self._cancelled = True self._lbl_status.configure(text="● Cancelado", fg=RED) self._log("⛔ Cancelado por usuario") self._btn_start.configure(state="normal", bg=ACCENT) if __name__ == "__main__": app = AppHLS() app.mainloop()