substui 0.1.0__py3-none-any.whl

substui/__init__.py

@@ -0,0 +1,4 @@
+"""Substui: encontre legendas sem sair do terminal."""
+
+__version__ = "0.1.0"
+

substui/__main__.py

@@ -0,0 +1,5 @@
+from substui.app import main
+
+if __name__ == "__main__":
+    main()
+

substui/app.py

@@ -0,0 +1,328 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+from typing import ClassVar
+
+from rich.text import Text
+from textual import work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.widgets import (
+    Button,
+    DataTable,
+    DirectoryTree,
+    Footer,
+    Header,
+    Input,
+    Label,
+    Select,
+    Static,
+)
+
+from substui.settings import SettingsStore
+from substui.subtitles import SearchResult, SubtitleCandidate, SubtitleService
+
+VIDEO_EXTENSIONS = {
+    ".3g2", ".3gp", ".avi", ".flv", ".m2ts", ".m4v", ".mkv", ".mov",
+    ".mp4", ".mpeg", ".mpg", ".mts", ".ogm", ".ogv", ".rm", ".rmvb",
+    ".ts", ".vob", ".webm", ".wmv",
+}
+
+LANGUAGES = (
+    ("Português (Brasil)", "pt-BR"),
+    ("Português", "pt"),
+    ("English", "en"),
+    ("Español", "es"),
+    ("Français", "fr"),
+    ("Deutsch", "de"),
+    ("Italiano", "it"),
+)
+
+
+class VideoTree(DirectoryTree):
+    @staticmethod
+    def filter_paths(paths: Iterable[Path]) -> Iterable[Path]:
+        return [path for path in paths if path.is_dir() or path.suffix.lower() in VIDEO_EXTENSIONS]
+
+
+class SubsTui(App[None]):
+    TITLE = "SubsTUI"
+    SUB_TITLE = "Legendas sem sair do terminal"
+    CSS = """
+    Screen { background: #0d0b12; color: #e9e4f5; }
+    Header { background: #16131d; color: #d8b4fe; }
+    Footer { background: #16131d; color: #b9a7e6; }
+    Footer > .footer--key { background: #a78bfa; color: #0d0b12; }
+    #toolbar { height: 5; padding: 1 2; background: #16131d; }
+    #path { width: 1fr; }
+    #language { width: 24; margin-left: 1; }
+    Input { border: tall #6b6577; background: #0d0b12; color: #e9e4f5; }
+    Input:focus { border: tall #a78bfa; }
+    Select { border: tall #6b6577; background: #0d0b12; color: #e9e4f5; }
+    Select:focus { border: tall #a78bfa; }
+    #main { height: 1fr; padding: 1; }
+    #browser-pane {
+        width: 38%; min-width: 36; margin-right: 1;
+        border: round #6b6577; background: #100e16;
+    }
+    #tree { height: 1fr; padding: 0 1; }
+    DirectoryTree > .directory-tree--extension { color: #6b6577; }
+    DirectoryTree > .directory-tree--folder { color: #b9a7e6; }
+    Tree > .tree--cursor { background: #302741; color: #e9e4f5; }
+    .pane-title { height: 3; padding: 1 2; color: #d8b4fe; text-style: bold; }
+    #results-pane { width: 1fr; padding: 0 1; border: round #6b6577; background: #100e16; }
+    #selected { height: 3; padding: 1; color: #d8b4fe; text-style: bold; }
+    #status { height: 3; padding: 1 2; background: #16131d; color: #b9a7e6; }
+    #results { height: 1fr; }
+    DataTable > .datatable--header { background: #241e30; color: #d8b4fe; text-style: bold; }
+    DataTable > .datatable--cursor { background: #3b3150; color: #e9e4f5; }
+    DataTable > .datatable--odd-row { background: #14111b; }
+    #actions { height: 3; align: right middle; padding-right: 1; }
+    Button { margin-left: 1; background: #241e30; color: #e9e4f5; border: none; }
+    Button:hover { background: #3b3150; }
+    Button.-primary { background: #a78bfa; color: #0d0b12; }
+    Button.-success { background: #86d6a2; color: #0d0b12; }
+    .busy { color: #f0c560; }
+    .success { color: #86d6a2; }
+    .error { color: #ee7d92; }
+    """
+
+    BINDINGS: ClassVar[list[Binding]] = [
+        Binding("ctrl+q", "quit", "Sair"),
+        Binding("r", "search", "Buscar"),
+        Binding("b", "best", "Baixar melhor"),
+        Binding("d", "download", "Baixar selecionada"),
+        Binding("f", "toggle_all", "Mostrar todos"),
+        Binding("u", "up", "Pasta acima"),
+        Binding("ctrl+l", "focus_path", "Ir para pasta"),
+    ]
+
+    def __init__(self, settings_store: SettingsStore | None = None) -> None:
+        super().__init__()
+        self.store = settings_store or SettingsStore()
+        self.settings = self.store.load()
+        self.service = SubtitleService()
+        self.video_path: Path | None = None
+        self.search_result: SearchResult | None = None
+        self.candidates: dict[str, SubtitleCandidate] = {}
+        self.show_all_results = False
+
+    def compose(self) -> ComposeResult:
+        start = self._valid_start_path()
+        yield Header()
+        with Horizontal(id="toolbar"):
+            yield Input(str(start), placeholder="Digite uma pasta e pressione Enter", id="path")
+            yield Select(LANGUAGES, value=self.settings.language, allow_blank=False, id="language")
+            yield Button("Abrir", id="open-path", variant="primary")
+        with Horizontal(id="main"):
+            with Vertical(id="browser-pane"):
+                yield Label("▌ ARQUIVOS DE VÍDEO", classes="pane-title")
+                yield VideoTree(start, id="tree")
+            with Vertical(id="results-pane"):
+                yield Static("▌ Selecione um arquivo de vídeo", id="selected")
+                yield DataTable(id="results", cursor_type="row", zebra_stripes=True)
+                with Horizontal(id="actions"):
+                    yield Button("Mostrar todos", id="toggle-all")
+                    yield Button("Buscar", id="search")
+                    yield Button("Baixar melhor", id="best", variant="primary")
+                    yield Button("Baixar selecionada", id="download", variant="success")
+                yield Static("Pronto.", id="status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one("#results", DataTable)
+        table.add_columns("#", "MATCH", "FONTE", "IDIOMA", "RELEASE · SINAIS")
+
+    def _valid_start_path(self) -> Path:
+        path = Path(self.settings.start_path).expanduser()
+        return path if path.is_dir() else Path.home()
+
+    @property
+    def language(self) -> str:
+        value = self.query_one("#language", Select).value
+        return str(value) if value is not Select.BLANK else "pt-BR"
+
+    def on_directory_tree_file_selected(self, event: DirectoryTree.FileSelected) -> None:
+        if event.path.suffix.lower() not in VIDEO_EXTENSIONS:
+            return
+        self.video_path = event.path
+        self.query_one("#selected", Static).update(f"▌ {event.path.name}")
+        self.run_search()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "path":
+            self.open_path(event.value)
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        if event.select.id != "language" or event.value is Select.BLANK:
+            return
+        self.settings.language = str(event.value)
+        self.store.save(self.settings)
+        self.set_status(f"Idioma alterado para {event.value}.", "success")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        actions = {
+            "open-path": lambda: self.open_path(self.query_one("#path", Input).value),
+            "search": self.action_search,
+            "best": self.action_best,
+            "download": self.action_download,
+            "toggle-all": self.action_toggle_all,
+        }
+        action = actions.get(event.button.id or "")
+        if action:
+            action()
+
+    def open_path(self, raw_path: str) -> None:
+        path = Path(raw_path.strip().strip('"')).expanduser().resolve()
+        if not path.is_dir():
+            self.set_status(f"Pasta inexistente: {path}", "error")
+            return
+        tree = self.query_one("#tree", VideoTree)
+        tree.path = path
+        tree.reload()
+        self.query_one("#path", Input).value = str(path)
+        self.settings.start_path = str(path)
+        self.store.save(self.settings)
+        self.set_status(f"Pasta aberta: {path}", "success")
+
+    def action_up(self) -> None:
+        current = Path(self.query_one("#path", Input).value)
+        self.open_path(str(current.parent))
+
+    def action_focus_path(self) -> None:
+        self.query_one("#path", Input).focus()
+
+    def action_search(self) -> None:
+        if self.video_path:
+            self.run_search()
+        else:
+            self.set_status("Selecione um vídeo primeiro.", "error")
+
+    def action_best(self) -> None:
+        if not self.video_path:
+            self.set_status("Selecione um vídeo primeiro.", "error")
+            return
+        self.run_download_best()
+
+    def action_download(self) -> None:
+        table = self.query_one("#results", DataTable)
+        if not self.search_result or table.row_count == 0:
+            self.set_status("Faça uma busca e selecione uma legenda.", "error")
+            return
+        row_key, _ = table.coordinate_to_cell_key(table.cursor_coordinate)
+        candidate = self.candidates.get(str(row_key.value))
+        if candidate:
+            self.run_download(candidate)
+
+    def action_toggle_all(self) -> None:
+        if not self.search_result:
+            self.set_status("Faça uma busca primeiro.", "error")
+            return
+        self.show_all_results = not self.show_all_results
+        self.render_results()
+
+    def set_status(self, message: str, kind: str = "") -> None:
+        status = self.query_one("#status", Static)
+        status.set_classes(kind)
+        status.update(message)
+
+    @work(thread=True, exclusive=True, group="subtitle")
+    def run_search(self) -> None:
+        assert self.video_path is not None
+        video_path = self.video_path
+        language = self.language
+        self.call_from_thread(self.set_status, f"Buscando legendas em {language}…", "busy")
+        try:
+            result = self.service.search(video_path, language)
+        # Falhas de rede e parsing variam entre os plugins dos provedores.
+        except Exception as error:  # noqa: BLE001
+            self.call_from_thread(self.set_status, f"Falha na busca: {error}", "error")
+            return
+        self.call_from_thread(self.show_results, result)
+
+    def show_results(self, result: SearchResult) -> None:
+        self.search_result = result
+        self.candidates = {candidate.key: candidate for candidate in result.candidates}
+        self.show_all_results = False
+        self.render_results()
+
+    def render_results(self) -> None:
+        assert self.search_result is not None
+        table = self.query_one("#results", DataTable)
+        table.clear()
+        all_candidates = self.search_result.candidates
+        compatible = [candidate for candidate in all_candidates if candidate.compatible]
+        visible = all_candidates if self.show_all_results else compatible
+        for rank, candidate in enumerate(visible, start=1):
+            color = (
+                "#86d6a2"
+                if candidate.confidence >= 90
+                else "#f0c560"
+                if candidate.compatible
+                else "#ee7d92"
+            )
+            quality = Text(f"{candidate.confidence:>3}% {candidate.rank_label}", style=f"bold {color}")
+            detail = Text(candidate.release, style="#e9e4f5")
+            if candidate.reasons:
+                detail.append(f"  ·  {' · '.join(candidate.reasons)}", style="#b9a7e6")
+            table.add_row(
+                Text(f"{rank:>2}", style="#6b6577"),
+                quality,
+                Text(candidate.provider, style="#a78bfa"),
+                candidate.language,
+                detail,
+                key=candidate.key,
+            )
+        toggle = self.query_one("#toggle-all", Button)
+        toggle.label = "Ocultar fracos" if self.show_all_results else "Mostrar todos"
+        total = len(all_candidates)
+        good = len(compatible)
+        hidden = total - good
+        if good:
+            suffix = f" · {hidden} resultado(s) fraco(s) ocultado(s)" if hidden else ""
+            self.set_status(
+                f"✓ {good} compatível(is) de {total}{suffix}. Selecione e pressione D.",
+                "success",
+            )
+        elif total:
+            self.set_status(
+                f"⚠ Nenhum match confiável entre {total} resultado(s). Pressione F para revisar.",
+                "error",
+            )
+        else:
+            self.set_status(f"Nenhuma legenda encontrada em {self.language}.", "error")
+
+    @work(thread=True, exclusive=True, group="subtitle")
+    def run_download(self, candidate: SubtitleCandidate) -> None:
+        assert self.search_result is not None
+        self.call_from_thread(self.set_status, f"Baixando de {candidate.provider}…", "busy")
+        try:
+            path = self.service.download(self.search_result, candidate)
+        except Exception as error:  # noqa: BLE001
+            self.call_from_thread(self.set_status, f"Falha no download: {error}", "error")
+            return
+        self.call_from_thread(self.set_status, f"Legenda salva em {path}", "success")
+
+    @work(thread=True, exclusive=True, group="subtitle")
+    def run_download_best(self) -> None:
+        assert self.video_path is not None
+        video_path = self.video_path
+        language = self.language
+        self.call_from_thread(self.set_status, "Buscando e baixando a melhor legenda…", "busy")
+        try:
+            path = self.service.download_best(video_path, language)
+        except Exception as error:  # noqa: BLE001
+            self.call_from_thread(self.set_status, f"Falha no download: {error}", "error")
+            return
+        self.call_from_thread(self.set_status, f"Legenda salva em {path}", "success")
+
+
+def main() -> None:
+    SubsTui().run()
+
+
+if __name__ == "__main__":
+    main()
+

substui/matching.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import re
+import unicodedata
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+from typing import Any
+
+from guessit import guessit
+
+ARTICLES = {
+    "a",
+    "an",
+    "as",
+    "das",
+    "de",
+    "do",
+    "dos",
+    "el",
+    "la",
+    "las",
+    "le",
+    "les",
+    "o",
+    "os",
+    "the",
+    "un",
+    "une",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class MatchQuality:
+    confidence: int
+    label: str
+    compatible: bool
+    reasons: tuple[str, ...]
+
+
+def normalize_title(value: str) -> str:
+    text = unicodedata.normalize("NFKD", value).encode("ascii", "ignore").decode()
+    words = re.findall(r"[a-z0-9]+", text.lower())
+    meaningful = [word for word in words if word not in ARTICLES]
+    return " ".join(meaningful or words)
+
+
+def title_similarity(left: str, right: str) -> float:
+    left_normalized = normalize_title(left)
+    right_normalized = normalize_title(right)
+    if not left_normalized or not right_normalized:
+        return 0.0
+    sequence = SequenceMatcher(None, left_normalized, right_normalized).ratio()
+    left_words = set(left_normalized.split())
+    right_words = set(right_normalized.split())
+    token_f1 = 2 * len(left_words & right_words) / (len(left_words) + len(right_words))
+    return max(sequence, token_f1)
+
+
+def rank_match(video: Any, release: str, matches: tuple[str, ...]) -> MatchQuality:
+    """Turn Subliminal's technical matches into a user-facing confidence rank."""
+    match_set = set(matches)
+    if "hash" in match_set:
+        return MatchQuality(100, "EXATO", True, ("hash do arquivo",))
+
+    is_episode = hasattr(video, "series")
+    kind = "episode" if is_episode else "movie"
+    guessed = dict(guessit(release, {"type": kind})) if not release.isdecimal() else {}
+    reasons: list[str] = []
+    confidence = 0
+    incompatible = False
+
+    identity_key = "series" if is_episode else "title"
+    video_title = str(getattr(video, identity_key, "") or "")
+    guessed_title = str(guessed.get("title", "") or "")
+
+    if identity_key in match_set:
+        confidence += 45
+        reasons.append("título")
+    if {"imdb_id", "tmdb_id"} & match_set:
+        confidence = max(confidence, 70)
+        reasons.append("ID do filme")
+
+    if guessed_title and video_title:
+        similarity = title_similarity(video_title, guessed_title)
+        if similarity >= 0.90:
+            confidence += 15
+            reasons.append("nome exato")
+        elif similarity >= 0.70:
+            confidence += 8
+            reasons.append("nome parecido")
+        elif similarity < 0.62 and not ({"imdb_id", "tmdb_id"} & match_set):
+            confidence -= 35
+            reasons.append("título divergente")
+
+    video_year = getattr(video, "year", None)
+    guessed_year = guessed.get("year")
+    if guessed_year and video_year:
+        if int(guessed_year) == int(video_year):
+            confidence += 20
+            reasons.append(str(video_year))
+        else:
+            confidence -= 60
+            incompatible = True
+            reasons.append(f"ano diferente ({guessed_year})")
+    elif "year" in match_set:
+        confidence += 20
+        reasons.append(str(video_year or "ano"))
+
+    if is_episode:
+        for field, points, label in (
+            ("season", 12, "temporada"),
+            ("episode", 18, "episódio"),
+        ):
+            guessed_value = guessed.get(field)
+            video_value = getattr(video, field, None)
+            if field in match_set:
+                confidence += points
+                reasons.append(label)
+            if guessed_value is not None and video_value is not None and guessed_value != video_value:
+                incompatible = True
+                confidence -= 50
+                reasons.append(f"{label} diferente")
+
+    guessed_technical = {
+        "source": guessed.get("source"),
+        "resolution": guessed.get("screen_size"),
+        "video_codec": guessed.get("video_codec"),
+    }
+    for field, guessed_value in guessed_technical.items():
+        video_value = getattr(video, field, None)
+        if guessed_value and video_value and str(guessed_value).lower() != str(video_value).lower():
+            penalty = 10 if field == "source" else 2
+            confidence -= penalty
+            label = {"source": "fonte", "resolution": "resolução", "video_codec": "vídeo"}[field]
+            reasons.append(f"{label} diferente ({guessed_value})")
+
+    technical = (
+        ("release_group", 6, "grupo"),
+        ("streaming_service", 5, "streaming"),
+        ("source", 5, "fonte"),
+        ("fps", 3, "FPS"),
+        ("audio_codec", 3, "áudio"),
+        ("resolution", 3, "resolução"),
+        ("video_codec", 3, "vídeo"),
+    )
+    for field, points, label in technical:
+        if field in match_set:
+            confidence += points
+            reasons.append(label)
+
+    confidence = max(0, min(100, confidence))
+    compatible = not incompatible and confidence >= 60
+    if confidence >= 90:
+        label = "ÓTIMO"
+    elif confidence >= 75:
+        label = "BOM"
+    elif confidence >= 60:
+        label = "POSSÍVEL"
+    else:
+        label = "BAIXO"
+    return MatchQuality(confidence, label, compatible, tuple(dict.fromkeys(reasons)))
+

substui/settings.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from platformdirs import user_config_path
+
+
+@dataclass(slots=True)
+class Settings:
+    language: str = "pt-BR"
+    start_path: str = str(Path.home())
+
+
+class SettingsStore:
+    def __init__(self, path: Path | None = None) -> None:
+        self.path = path or user_config_path("substui", appauthor=False) / "settings.json"
+
+    def load(self) -> Settings:
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+            return Settings(
+                language=str(data.get("language", "pt-BR")),
+                start_path=str(data.get("start_path", Path.home())),
+            )
+        except (OSError, ValueError, TypeError):
+            return Settings()
+
+    def save(self, settings: Settings) -> bool:
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(
+                json.dumps(asdict(settings), ensure_ascii=False, indent=2),
+                encoding="utf-8",
+            )
+        except OSError:
+            return False
+        return True
+

substui/subtitles.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from substui.matching import rank_match
+
+
+@dataclass(slots=True)
+class SubtitleCandidate:
+    key: str
+    provider: str
+    language: str
+    score: int
+    confidence: int
+    rank_label: str
+    compatible: bool
+    reasons: tuple[str, ...]
+    matches: tuple[str, ...]
+    release: str
+    raw: Any
+
+
+@dataclass(slots=True)
+class SearchResult:
+    video: Any
+    candidates: list[SubtitleCandidate]
+
+
+class SubtitleService:
+    """Pequena fachada sobre o Subliminal para manter a UI desacoplada."""
+
+    def __init__(self) -> None:
+        self._configure_cache()
+
+    @staticmethod
+    def _configure_cache() -> None:
+        from subliminal import region
+
+        if not region.is_configured:
+            region.configure("dogpile.cache.memory")
+
+    @staticmethod
+    def _language(code: str) -> Any:
+        from babelfish import Language
+
+        return Language.fromietf(code)
+
+    def search(self, video_path: Path, language: str) -> SearchResult:
+        from subliminal import compute_score, list_subtitles, scan_video
+
+        video = scan_video(str(video_path))
+        found = list_subtitles([video], {self._language(language)}).get(video, [])
+        candidates: list[SubtitleCandidate] = []
+        for index, subtitle in enumerate(found):
+            matches = tuple(sorted(subtitle.get_matches(video)))
+            release = self._release_name(subtitle)
+            quality = rank_match(video, release, matches)
+            candidates.append(
+                SubtitleCandidate(
+                    key=f"{subtitle.provider_name}:{subtitle.id}:{index}",
+                    provider=subtitle.provider_name,
+                    language=str(subtitle.language),
+                    score=int(compute_score(subtitle, video)),
+                    confidence=quality.confidence,
+                    rank_label=quality.label,
+                    compatible=quality.compatible,
+                    reasons=quality.reasons,
+                    matches=matches,
+                    release=release,
+                    raw=subtitle,
+                )
+            )
+        candidates.sort(
+            key=lambda candidate: (
+                candidate.compatible,
+                candidate.confidence,
+                candidate.score,
+            ),
+            reverse=True,
+        )
+        return SearchResult(video=video, candidates=candidates)
+
+    @staticmethod
+    def _release_name(subtitle: Any) -> str:
+        for attribute in (
+            "release_info",
+            "movie_release_name",
+            "release",
+            "file_name",
+            "filename",
+            "movie_full_name",
+            "movie_name",
+            "movie_title",
+            "title",
+        ):
+            value = getattr(subtitle, attribute, None)
+            if value:
+                return str(value).replace("\n", " ")
+        return str(getattr(subtitle, "id", "—"))
+
+    def download(self, result: SearchResult, candidate: SubtitleCandidate) -> Path:
+        from subliminal import download_subtitles, save_subtitles
+
+        download_subtitles([candidate.raw])
+        target = Path(candidate.raw.get_path(result.video))
+        saved = save_subtitles(result.video, [candidate.raw])
+        if not saved:
+            raise RuntimeError("O provedor não retornou conteúdo para salvar.")
+        return target
+
+    def download_best(self, video_path: Path, language: str) -> Path:
+        result = self.search(video_path, language)
+        candidate = next((item for item in result.candidates if item.compatible), None)
+        if candidate is None:
+            raise LookupError(f"Nenhuma legenda compatível encontrada em {language}.")
+        return self.download(result, candidate)
+
+

substui-0.1.0.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.5
+Name: substui
+Version: 0.1.0
+Summary: Navegador TUI para buscar e baixar legendas
+Project-URL: Homepage, https://github.com/codyzzd/substui
+Project-URL: Repository, https://github.com/codyzzd/substui.git
+Project-URL: Issues, https://github.com/codyzzd/substui/issues
+Project-URL: Changelog, https://github.com/codyzzd/substui/releases
+Author: codyzzd
+License-Expression: MIT
+License-File: LICENSE
+Keywords: opensubtitles,subliminal,subtitles,terminal,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.10
+Requires-Dist: platformdirs>=4.0
+Requires-Dist: subliminal<3,>=2.3
+Requires-Dist: textual<8,>=0.89
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Requires-Dist: twine>=6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# SubsTUI
+
+[![CI](https://github.com/codyzzd/substui/actions/workflows/ci.yml/badge.svg)](https://github.com/codyzzd/substui/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/substui?label=PyPI)](https://pypi.org/project/substui/)
+[![Python](https://img.shields.io/badge/Python-3.10%2B-a78bfa)](https://www.python.org/)
+[![Licença MIT](https://img.shields.io/badge/licen%C3%A7a-MIT-86d6a2)](LICENSE)
+
+Encontre a legenda certa sem sair do terminal.
+
+O SubsTUI é um navegador de arquivos com interface TUI que pesquisa, compara e baixa legendas
+ao lado dos seus vídeos. Ele usa o [Subliminal](https://github.com/Diaoul/subliminal) para consultar
+múltiplos provedores e acrescenta um ranking próprio para separar o release correto de resultados
+com título parecido, ano errado ou outra fonte de vídeo.
+
+> O projeto está em fase alfa. A busca depende da disponibilidade e dos limites dos provedores.
+
+## Comece com um comando
+
+Com o [`uv`](https://docs.astral.sh/uv/) instalado, execute o SubsTUI sem clonar nem instalar o
+projeto:
+
+```bash
+uvx --from git+https://github.com/codyzzd/substui.git substui
+```
+
+Depois da primeira publicação no PyPI, o comando fica ainda menor:
+
+```bash
+uvx substui
+```
+
+O `uvx` baixa o pacote e suas dependências em um ambiente isolado e abre a TUI. Ele funciona no
+Windows, Linux e macOS. Assim como o `npx` requer Node, este método requer apenas o `uv`.
+
+### Instalar o uv
+
+Windows, com Winget:
+
+```powershell
+winget install --id=astral-sh.uv -e
+```
+
+macOS, com Homebrew:
+
+```bash
+brew install uv
+```
+
+Linux e macOS, com o instalador oficial:
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+No Windows também é possível usar o instalador oficial:
+
+```powershell
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+```
+
+## Instalação permanente
+
+Para deixar o comando `substui` disponível de qualquer pasta:
+
+```bash
+uv tool install git+https://github.com/codyzzd/substui.git
+substui
+```
+
+Após a publicação no PyPI:
+
+```bash
+uv tool install substui
+substui
+```
+
+O `pipx` continua disponível como alternativa para quem já usa Python:
+
+```bash
+pipx install substui
+substui
+```
+
+Se o comando não aparecer imediatamente após uma instalação permanente, execute
+`uv tool update-shell` e abra um terminal novo.
+
+## O que ele faz
+
+- Navega pelas pastas exibindo somente diretórios e arquivos de vídeo.
+- Pesquisa em vários provedores, incluindo OpenSubtitles e OpenSubtitles.com.
+- Ranqueia legendas por título, ano, hash, fonte, resolução, codecs e grupo de release.
+- Classifica cada resultado como `EXATO`, `ÓTIMO`, `BOM`, `POSSÍVEL` ou `BAIXO`.
+- Oculta resultados claramente incompatíveis, mas permite revisá-los com `F`.
+- Baixa uma opção escolhida ou seleciona automaticamente o melhor match confiável.
+- Salva idioma e última pasta entre execuções.
+- Grava a legenda ao lado do vídeo, normalmente como `video.pt-BR.srt`.
+
+## Como funciona o ranking
+
+O score técnico do Subliminal é combinado com uma análise do nome real do release:
+
+- Um hash igual recebe prioridade máxima.
+- Título, ano, temporada e episódio definem a identidade do conteúdo.
+- `BluRay`, `WEB-DL`, `TELESYNC`, resolução, codecs e grupo ajudam a identificar o corte correto.
+- Ano, temporada ou episódio divergentes invalidam o resultado.
+- Uma fonte diferente reduz a confiança porque pode indicar tempos e cortes diferentes.
+
+Assim, uma legenda para `The.Odyssey.2026.1080p.BluRay` aparece acima de um making-of, de uma
+versão de 2016 ou de outro filme que apenas contém “Odyssey” no nome.
+
+## Atalhos
+
+| Tecla | Ação |
+|---|---|
+| `↑` / `↓` / `Enter` | Navegar e selecionar |
+| `R` | Buscar legendas novamente |
+| `D` | Baixar a legenda selecionada |
+| `B` | Baixar o melhor match confiável |
+| `F` | Mostrar ou ocultar resultados fracos |
+| `U` | Subir uma pasta |
+| `Ctrl+L` | Digitar outro caminho |
+| `Ctrl+Q` | Sair |
+
+O idioma é escolhido no topo da interface. Português do Brasil (`pt-BR`) é o padrão.
+
+## Provedores
+
+Alguns provedores funcionam sem conta; outros podem exigir credenciais, limitar requisições ou
+ficar temporariamente indisponíveis. O SubsTUI não hospeda legendas: ele consulta os provedores
+configurados pelo Subliminal e salva somente o resultado escolhido pelo usuário.
+
+## Desenvolvimento
+
+```bash
+git clone https://github.com/codyzzd/substui.git
+cd substui
+python -m venv .venv
+python -m pip install -e ".[dev]"
+python -m pytest
+python -m ruff check .
+python -m build
+```
+
+O CI testa o projeto no Windows e Linux com Python 3.10 e 3.13. Consulte
+[RELEASING.md](RELEASING.md) para publicar uma nova versão no PyPI.
+
+## Roadmap
+
+- Tela para configurar provedores e credenciais.
+- Pré-visualização de trechos antes do download.
+- Download em lote para uma temporada ou pasta.
+- Binários independentes para Windows, Linux e macOS.
+- Instalação por gerenciadores como Winget e Homebrew.
+
+## Contribuindo
+
+Issues e pull requests são bem-vindos. Veja [CONTRIBUTING.md](CONTRIBUTING.md) antes de enviar uma
+mudança maior.
+
+## Licença
+
+Distribuído sob a [licença MIT](LICENSE).
+

substui-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+substui/__init__.py,sha256=-VDCM6Cg_m0bx3CT_gv-JvLbtCMjEjhJSeK3a0UTNgo,79
+substui/__main__.py,sha256=peYXu_dAQP1YCbpLDtx1xvzv6p2y_DUzWgqL3OG7L0M,69
+substui/app.py,sha256=OAsgpSpxutAovII9n1sTw0sAXvyuXYbUU6dLubuugUU,13357
+substui/matching.py,sha256=oGYqn14CEFfsgICAUk6bjdMIh6H_Yh1cJHwU6QQAGmE,5238
+substui/settings.py,sha256=yWZv_zTyPsYiyLrFmdOLP7lfOrIj0wLsXknJEaNatgk,1159
+substui/subtitles.py,sha256=pS5rf8eKvdtfkZe_DiyaY2bBhZIQtlZyxGbXL-scddg,3823
+substui-0.1.0.dist-info/METADATA,sha256=284LH5Bgl6eFPZ0fTGyUwMTouNCqi0AYK4QxceRdxDA,6443
+substui-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+substui-0.1.0.dist-info/entry_points.txt,sha256=jI-MWti2amHZh1F5KFRdsMEE6akxaN8dhk7_2S1OjMg,45
+substui-0.1.0.dist-info/licenses/LICENSE,sha256=eE75ud0N00f5Ro_VvJ8BVxqcuR6wEjRYgLiQWb86PUA,1093
+substui-0.1.0.dist-info/RECORD,,

substui-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

substui-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+substui = substui.app:main

substui-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 codyzzd e contribuidores do SubsTUI
+
+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.
+