open-yt 0.1.0__tar.gz

open_yt-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 epadev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

open_yt-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: open-yt
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mutagen>=1.47.0
+Requires-Dist: pydantic-settings>=2.14.1
+Requires-Dist: pyfiglet>=1.0.4
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: typer>=0.25.1
+Requires-Dist: yt-dlp>=2026.3.17
+Dynamic: license-file
+
+# OPEN-YT 🟥
+
+> The high-performance, minimalist open-source YouTube engine for audio and video.
+
+[![Python 3.10+](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![Build: PyInstaller](https://img.shields.io/badge/Build-PyInstaller-orange.svg)](https://pyinstaller.org/)
+
+![OPEN-YT Demo](assets/open-yt-demo.gif)
+
+OPEN-YT es una Interfaz de Línea de Comandos (CLI) de grado industrial diseñada para extraer audio y video con la máxima eficiencia. Combina la potencia de `yt-dlp` con una experiencia de usuario (UX) minimalista, elegante y altamente configurable.
+
+## ✨ Características
+
+* **UI/UX Premium:** Interfaz de terminal renderizada con `Rich` y menús interactivos fluidos potenciados por `Questionary`.
+* **Motor Asíncrono:** Descargas ultra rápidas y extracción de metadatos sin bloquear la interfaz.
+* **Persistencia de Estado:** Recuerda tus preferencias de formato (MP3, FLAC, MP4, MKV), resolución y rutas de descarga localmente.
+* **Multiplataforma y Portable:** Distribuido como un binario único. Cero dependencias requeridas para el usuario final.
+
+---
+
+## 🚀 Instalación (Recomendado)
+
+Para usar OPEN-YT en **Linux, Windows o Mac NO es necesario instalar Python ni configurar entornos**.
+
+1. Ve a la sección de [Releases](../../releases) del repositorio.
+2. Descarga el ejecutable nativo correspondiente a tu sistema operativo (ej. `open-yt-linux` o `open-yt-windows.exe`).
+3. Abre tu terminal y ejecútalo directamente.
+
+---
+
+## 💻 Instalación para Desarrolladores
+
+Si deseas explorar el código fuente, modificar la herramienta o compilarla tú mismo:
+
+```bash
+# 1. Clonar el repositorio
+git clone https://github.com/elisbanpaco/open-yt.git
+cd open-yt
+
+# 2. Crear el entorno virtual e instalar dependencias
+uv sync
+
+# 3. Ejecutar
+uv run python src/main.py

open_yt-0.1.0/README.md

@@ -0,0 +1,45 @@
+# OPEN-YT 🟥
+
+> The high-performance, minimalist open-source YouTube engine for audio and video.
+
+[![Python 3.10+](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![Build: PyInstaller](https://img.shields.io/badge/Build-PyInstaller-orange.svg)](https://pyinstaller.org/)
+
+![OPEN-YT Demo](assets/open-yt-demo.gif)
+
+OPEN-YT es una Interfaz de Línea de Comandos (CLI) de grado industrial diseñada para extraer audio y video con la máxima eficiencia. Combina la potencia de `yt-dlp` con una experiencia de usuario (UX) minimalista, elegante y altamente configurable.
+
+## ✨ Características
+
+* **UI/UX Premium:** Interfaz de terminal renderizada con `Rich` y menús interactivos fluidos potenciados por `Questionary`.
+* **Motor Asíncrono:** Descargas ultra rápidas y extracción de metadatos sin bloquear la interfaz.
+* **Persistencia de Estado:** Recuerda tus preferencias de formato (MP3, FLAC, MP4, MKV), resolución y rutas de descarga localmente.
+* **Multiplataforma y Portable:** Distribuido como un binario único. Cero dependencias requeridas para el usuario final.
+
+---
+
+## 🚀 Instalación (Recomendado)
+
+Para usar OPEN-YT en **Linux, Windows o Mac NO es necesario instalar Python ni configurar entornos**.
+
+1. Ve a la sección de [Releases](../../releases) del repositorio.
+2. Descarga el ejecutable nativo correspondiente a tu sistema operativo (ej. `open-yt-linux` o `open-yt-windows.exe`).
+3. Abre tu terminal y ejecútalo directamente.
+
+---
+
+## 💻 Instalación para Desarrolladores
+
+Si deseas explorar el código fuente, modificar la herramienta o compilarla tú mismo:
+
+```bash
+# 1. Clonar el repositorio
+git clone https://github.com/elisbanpaco/open-yt.git
+cd open-yt
+
+# 2. Crear el entorno virtual e instalar dependencias
+uv sync
+
+# 3. Ejecutar
+uv run python src/main.py

open_yt-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "open-yt"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "mutagen>=1.47.0",
+    "pydantic-settings>=2.14.1",
+    "pyfiglet>=1.0.4",
+    "questionary>=2.1.1",
+    "rich>=15.0.0",
+    "tomli-w>=1.2.0",
+    "typer>=0.25.1",
+    "yt-dlp>=2026.3.17",
+]

open_yt-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

open_yt-0.1.0/src/config.py

@@ -0,0 +1,111 @@
+import tomllib
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        config_file="config.toml",
+        config_file_parser=tomllib,
+        extra="ignore",
+    )
+
+    download_path: Path = Field(
+        default=Path.home() / "Downloads",
+        description="Directorio de descargas predeterminado",
+    )
+    default_audio_format: str = Field(
+        default="mp3",
+        description="Formato de audio predeterminado",
+    )
+    default_video_res: str = Field(
+        default="1080",
+        description="Resolución de video predeterminada",
+    )
+    default_audio_quality: str = Field(
+        default="320",
+        description="Calidad de audio predeterminada en kbps",
+    )
+    default_video_format: str = Field(
+        default="mp4",
+        description="Formato de video predeterminado",
+    )
+    embed_thumbnail: bool = Field(
+        default=True,
+        description="Incrustar portada en archivos de audio",
+    )
+
+    @classmethod
+    def get_config_path(cls) -> Path:
+        """Obtiene la ruta del archivo de configuración."""
+        config_dir = Path.home() / ".config" / "music-free"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        return config_dir / "config.toml"
+
+    @classmethod
+    def load(cls) -> "Settings":
+        """Carga la configuración desde el archivo TOML."""
+        config_path = cls.get_config_path()
+        if config_path.exists():
+            with open(config_path, "rb") as f:
+                data = tomllib.load(f)
+            return cls(**data)
+        return cls()
+
+    def save(self) -> None:
+        """Guarda la configuración en el archivo TOML."""
+        config_path = self.get_config_path()
+        config_dict = {
+            "download_path": str(self.download_path),
+            "default_audio_format": self.default_audio_format,
+            "default_video_res": self.default_video_res,
+            "default_audio_quality": self.default_audio_quality,
+            "default_video_format": self.default_video_format,
+            "embed_thumbnail": self.embed_thumbnail,
+        }
+        
+        try:
+            import tomli_w
+            with open(config_path, "wb") as f:
+                tomli_w.dump(config_dict, f)
+        except ImportError:
+            toml_content = f"""# Configuración de music-free
+
+download_path = "{self.download_path}"
+default_audio_format = "{self.default_audio_format}"
+default_video_res = "{self.default_video_res}"
+default_audio_quality = "{self.default_audio_quality}"
+default_video_format = "{self.default_video_format}"
+"""
+            with open(config_path, "w") as f:
+                f.write(toml_content)
+
+    @classmethod
+    def get_default_download_path(cls) -> Path:
+        """Obtiene la carpeta de Descargas del sistema operativo."""
+        if (Path.home() / "Downloads").exists():
+            return Path.home() / "Downloads"
+        if (Path.home() / "downloads").exists():
+            return Path.home() / "downloads"
+        return Path.home()
+
+
+_settings_instance: Optional[Settings] = None
+
+
+def get_settings() -> Settings:
+    """Obtiene la instancia global de configuración."""
+    global _settings_instance
+    if _settings_instance is None:
+        _settings_instance = Settings.load()
+    return _settings_instance
+
+
+def reload_settings() -> Settings:
+    """Recarga la configuración desde el archivo."""
+    global _settings_instance
+    _settings_instance = Settings.load()
+    return _settings_instance

open_yt-0.1.0/src/downloader.py

@@ -0,0 +1,170 @@
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yt_dlp
+
+from config import Settings
+from ui import ProgressHook, console, show_media_info, get_status_spinner
+
+
+class MediaDownloader:
+    """Clase principal para descargas de medios usando yt-dlp."""
+
+    def __init__(self) -> None:
+        """Inicializa el descargador con la configuración."""
+        self.settings = Settings.load()
+        self._ydl_opts: Dict[str, Any] = {}
+
+    _THUMB_FORMATS = {"mp3", "m4a", "flac", "ogg", "opus"}
+
+    def _get_audio_opts(self, quality: str, output_path: Path) -> Dict[str, Any]:
+        """Genera opciones de yt-dlp para descarga de audio."""
+        codec = self.settings.default_audio_format
+        embed = self.settings.embed_thumbnail and codec in self._THUMB_FORMATS
+
+        postprocessors = [
+            {
+                "key": "FFmpegExtractAudio",
+                "preferredcodec": codec,
+                "preferredquality": quality,
+            }
+        ]
+
+        if embed:
+            postprocessors.append({"key": "EmbedThumbnail"})
+
+        return {
+            "format": "bestaudio/best",
+            "outtmpl": str(output_path / "%(title)s.%(ext)s"),
+            "postprocessors": postprocessors,
+            "writethumbnail": embed,
+            "embedthumbnail": embed,
+            "progress_hooks": [ProgressHook()],
+            "quiet": True,
+            "no_warnings": True,
+            "noplaylist": True,
+        }
+
+    def _get_video_opts(self, quality: str, output_path: Path) -> Dict[str, Any]:
+        """Genera opciones de yt-dlp para descarga de video."""
+        format_str = f"bestvideo[height<={quality}]+bestaudio/best" if quality != "best" else "best"
+        return {
+            "format": format_str,
+            "outtmpl": str(output_path / "%(title)s.%(ext)s"),
+            "progress_hooks": [ProgressHook()],
+            "quiet": True,
+            "no_warnings": True,
+            "noplaylist": True,
+        }
+
+    def _extract_info(self, url: str) -> Dict[str, Any]:
+        """Extrae metadatos del video sin descargar."""
+        opts: Dict[str, Any] = {
+            "quiet": True,
+            "no_warnings": True,
+            "extract_flat": False,
+            "noplaylist": True,
+        }
+        with get_status_spinner("Extrayendo metadatos..."):
+            with yt_dlp.YoutubeDL(opts) as ydl:
+                info = ydl.extract_info(url, download=False)
+                if info is None:
+                    raise ValueError("No se pudo obtener información del video")
+                return info
+
+    def _show_info(self, info: Dict[str, Any]) -> None:
+        """Muestra los metadatos del video en una tabla."""
+        display_info: Dict[str, Any] = {
+            "title": info.get("title", "N/A"),
+            "duration": info.get("duration", 0),
+            "uploader": info.get("uploader", info.get("channel", "N/A")),
+            "upload_date": info.get("upload_date", "N/A"),
+            "view_count": info.get("view_count", 0),
+            "like_count": info.get("like_count", 0),
+        }
+        if "resolution" in info:
+            display_info["resolution"] = info["resolution"]
+        if "format" in info:
+            display_info["format"] = info["format"]
+
+        show_media_info(display_info)
+
+    def download_audio(
+        self,
+        url: str,
+        quality: Optional[str] = None,
+        output: Optional[Path] = None,
+    ) -> bool:
+        """Descarga audio de YouTube."""
+        output_path = output or self.settings.download_path
+        audio_quality = quality or self.settings.default_audio_quality
+
+        console.print(f"\n[cyan]🎵 Obteniendo información del audio...[/cyan]\n")
+
+        try:
+            info = self._extract_info(url)
+            self._show_info(info)
+        except Exception as e:
+            console.print(f"[red]Error al obtener información:[/red] {e}")
+            return False
+
+        console.print(f"\n[cyan]⬇️  Descargando audio en formato {self.settings.default_audio_format} ({audio_quality}kbps)...[/cyan]\n")
+
+        opts = self._get_audio_opts(audio_quality, output_path)
+
+        try:
+            with yt_dlp.YoutubeDL(opts) as ydl:
+                ydl.download([url])
+            console.print(f"\n[green]✓[/green] Audio descargado en: {output_path}")
+            return True
+        except yt_dlp.utils.DownloadError as e:
+            console.print(f"\n[red]✗[/red] Error en la descarga: {e}")
+            return False
+        except Exception as e:
+            console.print(f"\n[red]✗[/red] Error inesperado: {e}")
+            return False
+
+    def get_info(self, url: str) -> Optional[Dict[str, Any]]:
+        """Obtiene información del video/audio sin descargar."""
+        try:
+            info = self._extract_info(url)
+            self._show_info(info)
+            return info
+        except Exception as e:
+            console.print(f"[red]Error al obtener información:[/red] {e}")
+            return None
+
+    def download_video(
+        self,
+        url: str,
+        quality: Optional[str] = None,
+        output: Optional[Path] = None,
+    ) -> bool:
+        """Descarga video de YouTube."""
+        output_path = output or self.settings.download_path
+        video_quality = quality or self.settings.default_video_res
+
+        console.print(f"\n[cyan]📺 Obteniendo información del video...[/cyan]\n")
+
+        try:
+            info = self._extract_info(url)
+            self._show_info(info)
+        except Exception as e:
+            console.print(f"[red]Error al obtener información:[/red] {e}")
+            return False
+
+        console.print(f"\n[cyan]⬇️  Descargando video en calidad {video_quality}p...[/cyan]\n")
+
+        opts = self._get_video_opts(video_quality, output_path)
+
+        try:
+            with yt_dlp.YoutubeDL(opts) as ydl:
+                ydl.download([url])
+            console.print(f"\n[green]✓[/green] Video descargado en: {output_path}")
+            return True
+        except yt_dlp.utils.DownloadError as e:
+            console.print(f"\n[red]✗[/red] Error en la descarga: {e}")
+            return False
+        except Exception as e:
+            console.print(f"\n[red]✗[/red] Error inesperado: {e}")
+            return False

open_yt-0.1.0/src/main.py

@@ -0,0 +1,375 @@
+import os
+import sys
+import typer
+from pathlib import Path
+from typing import Any, Optional
+
+import questionary
+from questionary import Style
+from rich.console import Console
+from rich.table import Table
+
+from config import Settings, get_settings, reload_settings
+from downloader import MediaDownloader
+from ui import show_panel, show_welcome_screen, show_current_config
+
+app = typer.Typer(
+    name="wolfcode",
+    help="CLI profesional para descargar contenido de YouTube",
+    add_completion=False,
+)
+console = Console()
+
+video_app = typer.Typer(help="Descargar videos de YouTube")
+audio_app = typer.Typer(help="Descargar audio de YouTube")
+config_app = typer.Typer(help="Gestionar configuración")
+
+app.add_typer(video_app, name="video")
+app.add_typer(audio_app, name="audio")
+app.add_typer(config_app, name="config")
+
+WAVE_STYLE = Style([
+    ("qmark", "fg:cyan bold"),
+    ("pointer", "fg:cyan bold"),
+    ("selected", "fg:cyan bold"),
+    ("separator", "fg:cyan"),
+    ("question", "bold #ffffff"),
+    ("answer", "fg:cyan bold"),
+])
+
+
+def safe_questionary(prompt_func) -> Optional[Any]:
+    """Envuelve questionary para manejo elegante de excepciones."""
+    try:
+        return prompt_func()
+    except (KeyboardInterrupt, EOFError):
+        console.print("\n[dim]Sesion finalizada.[/dim]")
+        sys.exit(0)
+    except Exception:
+        console.print("\n[dim]Sesion finalizada.[/dim]")
+        sys.exit(0)
+
+
+def run_interactive_menu() -> None:
+    """Ejecuta el menú interactivo con questionary."""
+    choice = safe_questionary(lambda: questionary.select(
+        "Que deseas hacer?",
+        choices=[
+            "Descargar Audio",
+            "Descargar Video",
+            "Configuracion",
+            "Salir",
+        ],
+        qmark=">",
+        style=WAVE_STYLE,
+    ).ask())
+
+    if choice == "Salir" or choice is None:
+        console.print("\n[dim]Hasta luego.[/dim]")
+        return
+
+    if choice == "Configuracion":
+        config_menu()
+        run_interactive_menu()
+        return
+
+    url = safe_questionary(lambda: questionary.text(
+        "Ingresa la URL de YouTube:",
+        qmark=">",
+        style=WAVE_STYLE,
+        validate=lambda x: len(x) > 0 or "Por favor ingresa una URL valida",
+    ).ask())
+
+    if not url:
+        console.print("[red]URL requerida[/red]")
+        run_interactive_menu()
+        return
+
+    downloader = MediaDownloader()
+
+    if choice == "Descargar Audio":
+        success = downloader.download_audio(url)
+    else:
+        success = downloader.download_video(url)
+
+    if success:
+        console.print("\n[green]✓[/green] Descarga completada")
+    else:
+        console.print("\n[red]✗[/red] La descarga fallo")
+
+    continue_choice = safe_questionary(lambda: questionary.confirm(
+        "Deseas realizar otra accion?",
+        default=True,
+        style=WAVE_STYLE,
+    ).ask())
+
+    if continue_choice:
+        run_interactive_menu()
+    else:
+        console.print("\n[dim]Hasta luego.[/dim]")
+
+
+@app.callback(invoke_without_command=True)
+def main_callback(
+    ctx: typer.Context,
+) -> None:
+    """Callback principal que detecta si no hay argumentos."""
+    if ctx.invoked_subcommand is None:
+        show_welcome_screen()
+        run_interactive_menu()
+
+
+@video_app.command("download")
+def video_download(
+    url: str = typer.Argument(..., help="URL del video de YouTube"),
+    quality: str = typer.Option("best", "--quality", "-q", help="Calidad del video (best, 1080p, 720p, etc.)"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Directorio de salida"),
+):
+    """Descargar video de YouTube"""
+    output_path = Path(output) if output else None
+    downloader = MediaDownloader()
+
+    success = downloader.download_video(url, quality=quality, output=output_path)
+
+    if not success:
+        raise typer.Exit(1)
+
+
+@video_app.command("info")
+def video_info(
+    url: str = typer.Argument(..., help="URL del video de YouTube"),
+):
+    """Mostrar información del video sin descargar"""
+    downloader = MediaDownloader()
+    success = downloader.get_info(url)
+    if not success:
+        raise typer.Exit(1)
+
+
+@audio_app.command("download")
+def audio_download(
+    url: str = typer.Argument(..., help="URL del video/playlist de YouTube"),
+    format: str = typer.Option("mp3", "--format", "-f", help="Formato de audio (mp3, flac, wav, etc.)"),
+    quality: str = typer.Option("320", "--quality", "-q", help="Calidad del audio (320, 256, 128 kbps)"),
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Directorio de salida"),
+    playlist: bool = typer.Option(False, "--playlist", "-p", help="Descargar playlist completa"),
+):
+    """Descargar audio de YouTube"""
+    output_path = Path(output) if output else None
+    downloader = MediaDownloader()
+
+    success = downloader.download_audio(url, quality=quality, output=output_path)
+
+    if not success:
+        raise typer.Exit(1)
+
+
+@audio_app.command("info")
+def audio_info(
+    url: str = typer.Argument(..., help="URL del video de YouTube"),
+):
+    """Mostrar información del audio sin descargar"""
+    downloader = MediaDownloader()
+    success = downloader.get_info(url)
+    if not success:
+        raise typer.Exit(1)
+
+
+@config_app.command("show")
+def config_show():
+    """Mostrar configuración actual"""
+    settings = get_settings()
+    config_dict = {
+        "download_path": settings.download_path,
+        "default_audio_format": settings.default_audio_format,
+        "default_audio_quality": settings.default_audio_quality,
+        "default_video_format": settings.default_video_format,
+        "default_video_res": settings.default_video_res,
+        "embed_thumbnail": settings.embed_thumbnail,
+    }
+    show_current_config(config_dict)
+
+
+def config_menu() -> None:
+    """Menu interactivo de configuracion."""
+    while True:
+        choice = safe_questionary(lambda: questionary.select(
+            "Configuracion",
+            choices=[
+                "Ver configuracion actual",
+                "Cambiar directorio de descarga",
+                "Cambiar formato de audio",
+                "Cambiar calidad de audio",
+                "Cambiar formato de video",
+                "Cambiar resolucion de video",
+                "Alternar portada incrustada",
+                "Volver al menu principal",
+            ],
+            qmark=">",
+            style=WAVE_STYLE,
+        ).ask())
+
+        if choice == "Volver al menu principal" or choice is None:
+            return
+
+        if choice == "Ver configuracion actual":
+            config_show()
+            continue
+
+        if choice == "Cambiar directorio de descarga":
+            settings = get_settings()
+            current_path = str(settings.download_path)
+            new_path = safe_questionary(lambda: questionary.path(
+                f"Nueva ruta (actual: {current_path}):",
+                default=current_path,
+                only_directories=True,
+                qmark=">",
+                style=WAVE_STYLE,
+            ).ask())
+
+            if new_path and new_path != current_path:
+                path = Path(new_path)
+                if not path.exists():
+                    create = safe_questionary(lambda: questionary.confirm(
+                        f"El directorio '{new_path}' no existe. Desea crearlo?",
+                        default=True,
+                        style=WAVE_STYLE,
+                    ).ask())
+                    if create:
+                        path.mkdir(parents=True, exist_ok=True)
+                    else:
+                        console.print("[red]Directorio no creado. Configuracion sin cambios.[/red]")
+                        continue
+                
+                if path.exists():
+                    settings.download_path = path
+                    settings.save()
+                    reload_settings()
+                    console.print("[green]Configuracion actualizada y guardada.[/green]")
+                else:
+                    console.print("[red]Directorio no valido.[/red]")
+            continue
+
+        if choice == "Cambiar formato de audio":
+            settings = get_settings()
+            new_format = safe_questionary(lambda: questionary.select(
+                f"Selecciona el formato de audio (actual: {settings.default_audio_format}):",
+                choices=["mp3", "m4a", "wav", "flac"],
+                qmark=">",
+                style=WAVE_STYLE,
+            ).ask())
+
+            if new_format:
+                settings.default_audio_format = new_format
+                settings.save()
+                reload_settings()
+                console.print("[green]Configuracion actualizada y guardada.[/green]")
+            continue
+
+        if choice == "Cambiar calidad de audio":
+            settings = get_settings()
+            new_quality = safe_questionary(lambda: questionary.select(
+                f"Selecciona la calidad de audio en kbps (actual: {settings.default_audio_quality}):",
+                choices=["320", "256", "192", "128"],
+                qmark=">",
+                style=WAVE_STYLE,
+            ).ask())
+
+            if new_quality:
+                settings.default_audio_quality = new_quality
+                settings.save()
+                reload_settings()
+                console.print("[green]Configuracion actualizada y guardada.[/green]")
+            continue
+
+        if choice == "Cambiar formato de video":
+            settings = get_settings()
+            new_format = safe_questionary(lambda: questionary.select(
+                f"Selecciona el formato de video (actual: {settings.default_video_format}):",
+                choices=["mp4", "mkv", "webm"],
+                qmark=">",
+                style=WAVE_STYLE,
+            ).ask())
+
+            if new_format:
+                settings.default_video_format = new_format
+                settings.save()
+                reload_settings()
+                console.print("[green]Configuracion actualizada y guardada.[/green]")
+            continue
+
+        if choice == "Cambiar resolucion de video":
+            settings = get_settings()
+            new_res = safe_questionary(lambda: questionary.select(
+                f"Selecciona la resolucion de video (actual: {settings.default_video_res}p):",
+                choices=["2160", "1080", "720", "480", "360"],
+                qmark=">",
+                style=WAVE_STYLE,
+            ).ask())
+
+            if new_res:
+                settings.default_video_res = new_res
+                settings.save()
+                reload_settings()
+                console.print("[green]Configuracion actualizada y guardada.[/green]")
+            continue
+
+        if choice == "Alternar portada incrustada":
+            settings = get_settings()
+            settings.embed_thumbnail = not settings.embed_thumbnail
+            settings.save()
+            reload_settings()
+            status = "activada" if settings.embed_thumbnail else "desactivada"
+            console.print(f"[green]Portada incrustada {status}.[/green]")
+            continue
+
+
+@config_app.command("set")
+def config_set(
+    key: str = typer.Argument(..., help="Clave de configuracion a modificar"),
+    value: str = typer.Argument(..., help="Nuevo valor"),
+):
+    """Modificar configuracion"""
+    settings = Settings.load()
+
+    if key == "download_path":
+        settings.download_path = Path(value)
+    elif key == "default_audio_format":
+        settings.default_audio_format = value
+    elif key == "default_video_res":
+        settings.default_video_res = value
+    elif key == "default_audio_quality":
+        settings.default_audio_quality = value
+    elif key == "default_video_format":
+        settings.default_video_format = value
+    elif key == "embed_thumbnail":
+        settings.embed_thumbnail = value.lower() in ("true", "1", "yes")
+    else:
+        console.print(f"[red]Clave desconocida:[/red] {key}")
+        return
+
+    settings.save()
+    console.print(f"[green]Configuracion actualizada:[/green] {key} = {value}")
+
+
+@config_app.command("reset")
+def config_reset(
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Confirmar reset sin preguntar"),
+):
+    """Restablecer configuración por defecto"""
+    if confirm:
+        settings = Settings()
+        settings.save()
+        console.print("[yellow]✓[/yellow] Configuración restablecida a valores por defecto")
+    else:
+        console.print("[red]Usa --yes para confirmar el reset[/red]")
+
+
+@app.command()
+def version():
+    """Mostrar version de la aplicacion"""
+    console.print("[cyan bold]WOLFCODE v1.0.0[/cyan bold]")
+
+
+if __name__ == "__main__":
+    app()

open_yt-0.1.0/src/open_yt.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: open-yt
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mutagen>=1.47.0
+Requires-Dist: pydantic-settings>=2.14.1
+Requires-Dist: pyfiglet>=1.0.4
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: typer>=0.25.1
+Requires-Dist: yt-dlp>=2026.3.17
+Dynamic: license-file
+
+# OPEN-YT 🟥
+
+> The high-performance, minimalist open-source YouTube engine for audio and video.
+
+[![Python 3.10+](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![Build: PyInstaller](https://img.shields.io/badge/Build-PyInstaller-orange.svg)](https://pyinstaller.org/)
+
+![OPEN-YT Demo](assets/open-yt-demo.gif)
+
+OPEN-YT es una Interfaz de Línea de Comandos (CLI) de grado industrial diseñada para extraer audio y video con la máxima eficiencia. Combina la potencia de `yt-dlp` con una experiencia de usuario (UX) minimalista, elegante y altamente configurable.
+
+## ✨ Características
+
+* **UI/UX Premium:** Interfaz de terminal renderizada con `Rich` y menús interactivos fluidos potenciados por `Questionary`.
+* **Motor Asíncrono:** Descargas ultra rápidas y extracción de metadatos sin bloquear la interfaz.
+* **Persistencia de Estado:** Recuerda tus preferencias de formato (MP3, FLAC, MP4, MKV), resolución y rutas de descarga localmente.
+* **Multiplataforma y Portable:** Distribuido como un binario único. Cero dependencias requeridas para el usuario final.
+
+---
+
+## 🚀 Instalación (Recomendado)
+
+Para usar OPEN-YT en **Linux, Windows o Mac NO es necesario instalar Python ni configurar entornos**.
+
+1. Ve a la sección de [Releases](../../releases) del repositorio.
+2. Descarga el ejecutable nativo correspondiente a tu sistema operativo (ej. `open-yt-linux` o `open-yt-windows.exe`).
+3. Abre tu terminal y ejecútalo directamente.
+
+---
+
+## 💻 Instalación para Desarrolladores
+
+Si deseas explorar el código fuente, modificar la herramienta o compilarla tú mismo:
+
+```bash
+# 1. Clonar el repositorio
+git clone https://github.com/elisbanpaco/open-yt.git
+cd open-yt
+
+# 2. Crear el entorno virtual e instalar dependencias
+uv sync
+
+# 3. Ejecutar
+uv run python src/main.py

open_yt-0.1.0/src/open_yt.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/config.py
+src/downloader.py
+src/main.py
+src/ui.py
+src/open_yt.egg-info/PKG-INFO
+src/open_yt.egg-info/SOURCES.txt
+src/open_yt.egg-info/dependency_links.txt
+src/open_yt.egg-info/requires.txt
+src/open_yt.egg-info/top_level.txt

open_yt-0.1.0/src/open_yt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

open_yt-0.1.0/src/open_yt.egg-info/requires.txt

@@ -0,0 +1,8 @@
+mutagen>=1.47.0
+pydantic-settings>=2.14.1
+pyfiglet>=1.0.4
+questionary>=2.1.1
+rich>=15.0.0
+tomli-w>=1.2.0
+typer>=0.25.1
+yt-dlp>=2026.3.17

open_yt-0.1.0/src/open_yt.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+config
+downloader
+main
+ui

open_yt-0.1.0/src/ui.py

@@ -0,0 +1,272 @@
+from typing import Any, Dict, Optional
+
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import (
+    BarColumn,
+    Progress,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+from rich.rule import Rule
+from rich.table import Table
+from rich.text import Text
+
+
+console = Console()
+
+
+_C1    = "#8B1538"        # rojo oscuro profundo (inicio del gradiente)
+_C2    = "#C4374B"        # rojo medio vibrante
+_C3    = "#E56B6F"        # coral/rosa medio
+_C4    = "#F4A382"        # salmón/naranja claro (fin del gradiente)
+_DIM   = "grey50"         # separadores y texto secundario
+_LABEL = "misty_rose3"    # etiquetas (rosado neutro, no compite con el rojo)
+_OK    = "dark_sea_green3" # éxito (verde apagado, no chilla junto al rojo)
+_ERR   = "bright_red"     # error (único rojo puro, solo para errores reales)
+
+
+_LOGO_ROWS = [
+    (_C1,  "  ██████╗ ██████╗ ███████╗███╗   ██╗",  _C1, "██╗   ██╗████████╗"),
+    (_C1,  " ██╔═══██╗██╔══██╗██╔════╝████╗  ██║",  _C1, "╚██╗ ██╔╝╚══██╔══╝"),
+    (_C2,  " ██║   ██║██████╔╝█████╗  ██╔██╗ ██║",  _C2, "  ╚████╔╝    ██║   "),
+    (_C2,  " ██║   ██║██╔═══╝ ██╔══╝  ██║╚██╗██║",  _C2, "   ╚██╔╝     ██║   "),
+    (_C3,  " ╚██████╔╝██║     ███████╗██║ ╚████║",  _C3, "   ██║      ██║   "),
+    (_C4,  "  ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═══╝",  _C4, "   ╚═╝      ╚═╝   "),
+]
+_SEP_LEFT  = "  █████╗  " 
+_SEP_RIGHT = "  ╚════╝  "
+
+
+def _build_logo() -> Text:
+    """Construye el logo con gradiente usando Rich Text."""
+    logo = Text(justify="center")
+    for i, (lc, left, rc, right) in enumerate(_LOGO_ROWS):
+        # separador central solo en filas 2 y 3 (índice 2 y 3)
+        mid = ""
+        mid_style = _DIM
+        if i == 2:
+            mid = " █████╗  "
+        elif i == 3:
+            mid = " ╚════╝  "
+
+        logo.append(left, style=f"bold {lc}")
+        if mid:
+            logo.append(mid, style=f"dim {mid_style}")
+        else:
+            logo.append("          ")
+        logo.append(right, style=f"bold {rc}")
+        logo.append("\n")
+    return logo
+
+
+def show_welcome_screen() -> None:
+    """Pantalla de bienvenida estilo Claude Code / Gemini CLI."""
+    console.clear()
+
+    # Logo
+    console.print()
+    console.print(_build_logo())
+
+    console.print(Rule(style=_DIM), width=68)
+
+    meta = Text(justify="center")
+    meta.append("v0.0.1", style=f"bold {_C2}")
+    meta.append("  ·  ", style=_DIM)
+    meta.append("Open Source Media Engine", style=_DIM)
+    console.print(meta)
+
+    console.print(Rule(style=_DIM), width=68)
+    console.print()
+
+def format_duration(seconds: int) -> str:
+    hours, remainder = divmod(seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}" if hours else f"{minutes:02d}:{seconds:02d}"
+
+
+def format_number(num: int) -> str:
+    return f"{num:,}"
+
+
+def show_media_card(info_dict: Dict[str, Any]) -> None:
+    """Tarjeta de metadatos con paleta naranja-dorada."""
+    title = info_dict.get("title", "Unknown")
+    duration = format_duration(info_dict.get("duration", 0))
+    channel = info_dict.get("uploader") or info_dict.get("channel", "Unknown")
+    views = format_number(info_dict.get("view_count", 0))
+    likes = format_number(info_dict.get("like_count", 0))
+    upload_date = info_dict.get("upload_date", "Unknown")
+
+    tbl = Table(box=None, show_header=False, padding=(0, 1))
+    tbl.add_column("Label", style=_LABEL, width=14)
+    tbl.add_column("Value", style="white")
+
+    tbl.add_row("Titulo:",     title)
+    tbl.add_row("Canal:",      channel)
+    tbl.add_row("Duracion:",   duration)
+    tbl.add_row("Vistas:",     views)
+    tbl.add_row("Likes:",      likes)
+    tbl.add_row("Fecha:",      upload_date)
+
+    if info_dict.get("resolution") and info_dict.get("resolution") != "N/A":
+        tbl.add_row("Resolucion:", info_dict["resolution"])
+
+    console.print(
+        Panel(
+            tbl,
+            box=box.ROUNDED,
+            border_style=_DIM,
+            padding=(1, 2),
+            width=75,
+            title=f"[{_C2}]Información[/{_C2}]",
+            title_align="left",
+        )
+    )
+
+
+def show_current_config(config_dict: Dict[str, Any]) -> None:
+    """Panel de configuración con secciones y paleta coherente."""
+    download_path  = str(config_dict.get("download_path",         "N/A"))
+    audio_format   = config_dict.get("default_audio_format",      "N/A")
+    audio_quality  = config_dict.get("default_audio_quality",     "N/A")
+    video_format   = config_dict.get("default_video_format",      "N/A")
+    video_res      = config_dict.get("default_video_res",         "N/A")
+
+    content = Text()
+    content.append("Rutas\n",                                  style=f"bold {_C2}")
+    content.append(f"  Directorio: {download_path}\n\n",       style="white")
+    content.append("Audio\n",                                  style=f"bold {_C2}")
+    content.append(
+        f"  Formato: {audio_format}  |  Calidad: {audio_quality} kbps\n\n",
+        style="white",
+    )
+    content.append("Video\n",                                  style=f"bold {_C2}")
+    content.append(
+        f"  Formato: {video_format}  |  Resolución: {video_res}p\n\n",
+        style="white",
+    )
+    content.append("Extras\n",                                 style=f"bold {_C2}")
+    embed_thumb = config_dict.get("embed_thumbnail", True)
+    thumb_status = "Activada" if embed_thumb else "Desactivada"
+    content.append(
+        f"  Portada incrustada: {thumb_status}",
+        style="white",
+    )
+
+    console.print(
+        Panel(
+            content,
+            box=box.ROUNDED,
+            border_style=_DIM,
+            padding=(1, 2),
+            width=75,
+            title=f"[{_C2}]Configuración[/{_C2}]",
+            title_align="left",
+        )
+    )
+
+
+# Alias de compatibilidad
+def show_media_info(info_dict: Dict[str, Any]) -> None:
+    show_media_card(info_dict)
+
+
+class ProgressHook:
+    """Hook de progreso para yt-dlp compatible con Rich."""
+
+    def __init__(
+        self,
+        description: str = "Descargando",
+        bar_style: str = _C2, 
+        text_style: str = "white",
+    ) -> None:
+        self.description = description
+        self.bar_style   = bar_style
+        self.text_style  = text_style
+        self._progress: Optional[Progress] = None
+        self._task_id:  Optional[int]      = None
+
+    def __call__(self, d: Dict[str, Any]) -> None:
+        status = d.get("status")
+        if   status == "starting":     self._handle_starting(d)
+        elif status == "downloading":  self._handle_downloading(d)
+        elif status == "finished":     self._handle_finished(d)
+        elif status == "error":        self._handle_error(d)
+
+    def _init_progress(self, total: float, title: str) -> None:
+        if self._progress is not None:
+            return
+        self._progress = Progress(
+            TextColumn(
+                f"[{self.text_style}]{self.description}: {{task.description}}",
+            ),
+            BarColumn(bar_width=40, style=self.bar_style, complete_style=_C3),
+            TextColumn(
+                f"[{_C4}]{{task.percentage:>3.0f}}%",
+            ),
+            TransferSpeedColumn(),
+            TimeRemainingColumn(),
+            console=console,
+            transient=False,
+        )
+        self._progress.start()
+        self._task_id = self._progress.add_task(title, total=total)
+
+    def _handle_starting(self, d: Dict[str, Any]) -> None:
+        total    = d.get("total_bytes") or d.get("total_bytes_estimate", 0)
+        filename = d.get("filename", "Archivo")
+        self._init_progress(total, filename)
+
+    def _handle_downloading(self, d: Dict[str, Any]) -> None:
+        if self._progress is None or self._task_id is None:
+            total    = d.get("total_bytes") or d.get("total_bytes_estimate", 0)
+            filename = d.get("filename", "Archivo")
+            self._init_progress(total, filename)
+
+        downloaded = d.get("downloaded_bytes", 0)
+        total      = d.get("total_bytes") or d.get("total_bytes_estimate", 1)
+
+        if self._progress and self._task_id is not None:
+            self._progress.update(self._task_id, completed=downloaded, total=total)
+
+    def _handle_finished(self, d: Dict[str, Any]) -> None:
+        if self._progress:
+            self._progress.stop()
+            self._progress = None
+            self._task_id  = None
+        console.print(
+            f"[{_OK}]✓[/{_OK}] [white]Descarga completada:[/white] "
+            f"[{_C2}]{d.get('filename', '')}[/{_C2}]"
+        )
+
+    def _handle_error(self, d: Dict[str, Any]) -> None:
+        if self._progress:
+            self._progress.stop()
+            self._progress = None
+            self._task_id  = None
+        console.print(
+            f"[{_ERR}]✗[/{_ERR}] [white]Error:[/white] "
+            f"[{_ERR}]{d.get('error', 'Error desconocido')}[/{_ERR}]"
+        )
+
+
+def show_panel(
+    title: str,
+    content: str,
+    style: str = _C2,
+    expand: bool = True,
+) -> None:
+    console.print(
+        Panel(content, title=title, border_style=_DIM, expand=expand)
+    )
+
+
+def get_status_spinner(message: str):
+    return console.status(
+        f"[{_C2}]{message}[/{_C2}]",
+        spinner="dots",
+        spinner_style=_C2,
+    )