aurclips 0.2.0__tar.gz → 0.2.1__tar.gz

{aurclips-0.2.0 → aurclips-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aurclips
-Version: 0.2.0
+Version: 0.2.1
 Summary: De videos largos a YouTube Shorts verticales con subtítulos, 100% local
 Project-URL: Homepage, https://github.com/feliivk/aurclips
 Author: Felii

{aurclips-0.2.0 → aurclips-0.2.1}/aurclips/__init__.py

@@ -1,3 +1,3 @@
 """Bot de automatización de Shorts: descarga, recorta, edita y publica."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{aurclips-0.2.0 → aurclips-0.2.1}/aurclips/marks.py

@@ -421,33 +421,52 @@ def review_session(video_path: str | Path) -> Path:
     print(f"Repasando: {video.name}")
     if existing:
         print(f"  ({len(existing)} marca(s) preexistentes; se conservan)")
-    print("  Enter  -> marca el momento que está sonando (pausar también vale)")
-    print("  u      -> deshacer la última marca de esta sesión")
+    print("  Enter  -> marca el momento que está sonando — EN EL REPRODUCTOR")
+    print("            (o en este terminal); pausar también vale")
+    print("  u      -> deshacer la última marca (también en el reproductor)")
+    print("  volumen en mpv: 9 baja · 0 sube · m mutea")
     print("  Ctrl+C o cerrar el reproductor -> terminar y guardar\n")
 
     player = MpvPlayer(mpv, video)
     lines = _stdin_queue()
+
+    def do_mark():
+        t = player.playback_time()
+        if t is None:
+            print("  no pude leer la posición (¿mpv sigue abriendo?)")
+        elif session.mark(t) is None:
+            print(f"  ya hay una marca en {_mmss(t)}; no se duplica")
+            player.show_message(f"ya marcado ({_mmss(t)})")
+        else:
+            n = len(session.all_marks())
+            print(f"  marca {n:>2} en {_mmss(t)}")
+            player.show_message(f"marca {n} - {_mmss(t)}")
+
+    def do_undo():
+        undone = session.undo()
+        if undone is None:
+            print("  nada que deshacer en esta sesión")
+            player.show_message("nada que deshacer")
+        else:
+            print(f"  deshecha la marca de {_mmss(undone)}")
+            player.show_message(f"deshecha la marca de {_mmss(undone)}")
+
     try:
         while player.alive():
+            # dos fuentes con las mismas teclas: el reproductor y el terminal
+            event = player.poll_event(timeout=0.15)
+            if event == "mark":
+                do_mark()
+            elif event == "undo":
+                do_undo()
             try:
-                line = lines.get(timeout=0.3)
+                command = lines.get_nowait().strip().lower()
             except queue.Empty:
                 continue
-            command = line.strip().lower()
             if command == "u":
-                undone = session.undo()
-                if undone is None:
-                    print("  nada que deshacer en esta sesión")
-                else:
-                    print(f"  deshecha la marca de {_mmss(undone)}")
+                do_undo()
             elif command == "":
-                t = player.playback_time()
-                if t is None:
-                    print("  no pude leer la posición (¿mpv sigue abriendo?)")
-                elif session.mark(t) is None:
-                    print(f"  ya hay una marca en {_mmss(t)}; no se duplica")
-                else:
-                    print(f"  marca {len(session.all_marks()):>2} en {_mmss(t)}")
+                do_mark()
             # cualquier otra entrada se ignora sin ruido
     except KeyboardInterrupt:
         print()

aurclips-0.2.1/aurclips/player.py

@@ -0,0 +1,190 @@
+"""Transporte con mpv para el repaso: lanzar, preguntar la posición, cerrar.
+
+Delgado a propósito y sin tests automáticos — el mismo trato que ffmpeg: aquí
+no hay lógica, solo el cable. La lógica del repaso vive en marks.MarkingSession
+y se prueba sin nada de esto.
+
+mpv es el único reproductor multiplataforma con un IPC limpio para preguntar
+``playback-time``: un named pipe en Windows, un unix socket en POSIX, JSON por
+línea en ambos. Es dependencia opcional solo de este modo.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import queue
+import shutil
+import subprocess
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+from .config import ROOT, _exe_suffix
+
+# Teclas que marcan DENTRO del reproductor. La primera prueba real lo dejó
+# claro: quien repasa tiene las manos y los ojos en el video, no en el
+# terminal — los Enter iban a la ventana de mpv y se perdían. Se le piden a
+# mpv por IPC (comando keybind -> script-message) y llegan como eventos
+# client-message; las mismas teclas que en el terminal.
+KEY_BINDINGS = (
+    ("ENTER", "aurclips-mark"),
+    ("u", "aurclips-undo"),
+)
+
+
+def find_mpv() -> str:
+    """Ruta de mpv, o un error de una línea con la instalación por SO.
+
+    Como los demás binarios del repo: primero el empaquetado en tools/ (la
+    convención de Windows, donde también viven ffmpeg y deno), luego el PATH.
+    """
+    bundled = ROOT / "tools" / "mpv" / f"mpv{_exe_suffix()}"
+    if bundled.exists():
+        return str(bundled)
+    found = shutil.which("mpv")
+    if found:
+        return found
+    raise FileNotFoundError(
+        "No se encontró mpv (el reproductor del repaso). Instálalo y agrégalo "
+        "al PATH (macOS: brew install mpv · Linux: apt install mpv · "
+        "Windows: winget install mpv), o deja el portable en tools/mpv."
+    )
+
+
+class MpvPlayer:
+    """Una instancia de mpv reproduciendo un video, con su socket de IPC."""
+
+    def __init__(self, mpv_path: str, video_path: str | Path):
+        if os.name == "nt":
+            self._ipc = rf"\\.\pipe\aurclips-mpv-{os.getpid()}"
+        else:
+            self._ipc = str(Path(tempfile.gettempdir()) / f"aurclips-mpv-{os.getpid()}.sock")
+        # stdin=DEVNULL: el terminal es de la sesión de marcado; sin esto mpv
+        # heredaría la consola y competiría con el hilo lector por las teclas
+        self._proc = subprocess.Popen(
+            [mpv_path, f"--input-ipc-server={self._ipc}", "--", str(video_path)],
+            stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        self._events: queue.Queue[str] = queue.Queue()
+        threading.Thread(target=self._event_pump, daemon=True).start()
+
+    def poll_event(self, timeout: float) -> str | None:
+        """'mark' o 'undo' si el usuario pulsó la tecla en el reproductor."""
+        try:
+            return self._events.get(timeout=timeout)
+        except queue.Empty:
+            return None
+
+    def show_message(self, text: str) -> None:
+        """OSD en el reproductor: el eco de la marca, donde están los ojos."""
+        try:
+            self._roundtrip(json.dumps({"command": ["show-text", text, 1500]}) + "\n")
+        except OSError:
+            pass
+
+    def _event_pump(self) -> None:
+        """Hilo de eventos: registra las teclas en mpv y escucha sus pulsaciones.
+
+        Conexión propia y persistente (el resto de peticiones va por conexiones
+        cortas aparte, así no se entrelazan). Muere sola cuando mpv se cierra.
+        """
+        conn = self._connect_for_events()
+        if conn is None:
+            return
+        write, read, close = conn
+        try:
+            for key, message in KEY_BINDINGS:
+                write((json.dumps({"command": ["keybind", key,
+                       f"script-message {message}"]}) + "\n").encode("utf-8"))
+            buffer = b""
+            while True:
+                data = read()
+                if not data:  # mpv cerró la conexión
+                    return
+                buffer += data
+                while b"\n" in buffer:
+                    line, buffer = buffer.split(b"\n", 1)
+                    try:
+                        payload = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if payload.get("event") == "client-message":
+                        args = payload.get("args") or []
+                        if args and str(args[0]).startswith("aurclips-"):
+                            self._events.put(str(args[0]).removeprefix("aurclips-"))
+        except OSError:
+            return
+        finally:
+            try:
+                close()
+            except OSError:
+                pass
+
+    def _connect_for_events(self):
+        """(write, read, close) sobre el IPC, esperando a que mpv lo cree."""
+        for _ in range(40):  # mpv tarda un instante en crear el socket/pipe
+            if not self.alive():
+                return None
+            try:
+                if os.name == "nt":
+                    pipe = open(self._ipc, "r+b", buffering=0)
+                    return pipe.write, (lambda: pipe.read(4096)), pipe.close
+                import socket
+                sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+                sock.connect(self._ipc)
+                return sock.sendall, (lambda: sock.recv(4096)), sock.close
+            except OSError:
+                time.sleep(0.25)
+        return None
+
+    def alive(self) -> bool:
+        return self._proc.poll() is None
+
+    def playback_time(self) -> float | None:
+        """Posición de reproducción en segundos; None si no se pudo leer."""
+        request = json.dumps({"command": ["get_property", "playback-time"]}) + "\n"
+        try:
+            for line in self._roundtrip(request):
+                try:
+                    payload = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if "error" in payload:  # respuesta a la petición (no un evento)
+                    if payload["error"] == "success" and isinstance(
+                            payload.get("data"), (int, float)):
+                        return float(payload["data"])
+                    return None
+        except OSError:
+            return None
+        return None
+
+    def _roundtrip(self, request: str) -> list[str]:
+        """Envía una petición y devuelve las líneas de respuesta."""
+        if os.name == "nt":
+            # el pipe lo crea mpv; abrir/escribir/leer por petición es lo robusto
+            with open(self._ipc, "r+b", buffering=0) as pipe:
+                pipe.write(request.encode("utf-8"))
+                return pipe.read(4096).decode("utf-8", "replace").splitlines()
+        import socket
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
+            sock.settimeout(1.0)
+            sock.connect(self._ipc)
+            sock.sendall(request.encode("utf-8"))
+            chunks = b""
+            while b"\n" not in chunks:
+                data = sock.recv(4096)
+                if not data:
+                    break
+                chunks += data
+            return chunks.decode("utf-8", "replace").splitlines()
+
+    def close(self) -> None:
+        if self.alive():
+            self._proc.terminate()
+            try:
+                self._proc.wait(timeout=3)
+            except subprocess.TimeoutExpired:
+                self._proc.kill()

{aurclips-0.2.0 → aurclips-0.2.1}/docs/grabar-en-beats.md

@@ -91,13 +91,16 @@ material descargado de canales directamente no es tuyo. Para eso está el
 aurclips mark mi-grabacion.mp4
 ```
 
-Se abre el video en el reproductor y el terminal queda en modo sesión:
+Se abre el video en el reproductor y marcas **sin salir de él**:
 
-- **Enter** marca el momento que está sonando. Pausar también vale: la marca
-  cae donde dejaste el cursor, con la precisión que quieras.
+- **Enter** (en el reproductor o en el terminal) marca el momento que está
+  sonando, con confirmación en la propia pantalla del video. Pausar también
+  vale: la marca cae donde dejaste el cursor, con la precisión que quieras.
 - **u** deshace la última marca de esta sesión (las que ya existían no se
   tocan).
 - **Ctrl+C** o cerrar el reproductor termina y guarda.
+- Controles útiles de mpv: espacio pausa, flechas buscan, `[` y `]` cambian la
+  velocidad, `9`/`0` bajan/suben el volumen, `m` mutea.
 
 Las marcas van al mismo `<video>.marks.txt` de siempre, junto al video, y las
 que ya hubiera —de la voz, del hotkey o de un repaso anterior— se conservan:
@@ -116,7 +119,8 @@ aurclips clip partida.mp4    # los momentos marcados son los recortes
 
 El repaso necesita **[mpv](https://mpv.io)** (solo este modo lo usa): `winget
 install mpv` en Windows, `brew install mpv` en macOS, `apt install mpv` en
-Linux.
+Linux. En Windows también vale dejar el [build portable](https://mpv.io/installation/)
+descomprimido en `tools/mpv`, junto a los demás binarios del repo.
 
 ## Qué NO tienes que hacer
 

aurclips-0.2.0/aurclips/player.py

@@ -1,97 +0,0 @@
-"""Transporte con mpv para el repaso: lanzar, preguntar la posición, cerrar.
-
-Delgado a propósito y sin tests automáticos — el mismo trato que ffmpeg: aquí
-no hay lógica, solo el cable. La lógica del repaso vive en marks.MarkingSession
-y se prueba sin nada de esto.
-
-mpv es el único reproductor multiplataforma con un IPC limpio para preguntar
-``playback-time``: un named pipe en Windows, un unix socket en POSIX, JSON por
-línea en ambos. Es dependencia opcional solo de este modo.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import subprocess
-import tempfile
-from pathlib import Path
-
-
-def find_mpv() -> str:
-    """Ruta de mpv, o un error de una línea con la instalación por SO."""
-    found = shutil.which("mpv")
-    if found:
-        return found
-    raise FileNotFoundError(
-        "No se encontró mpv (el reproductor del repaso). Instálalo y agrégalo "
-        "al PATH (macOS: brew install mpv · Linux: apt install mpv · "
-        "Windows: winget install mpv)."
-    )
-
-
-class MpvPlayer:
-    """Una instancia de mpv reproduciendo un video, con su socket de IPC."""
-
-    def __init__(self, mpv_path: str, video_path: str | Path):
-        if os.name == "nt":
-            self._ipc = rf"\\.\pipe\aurclips-mpv-{os.getpid()}"
-        else:
-            self._ipc = str(Path(tempfile.gettempdir()) / f"aurclips-mpv-{os.getpid()}.sock")
-        # stdin=DEVNULL: el terminal es de la sesión de marcado; sin esto mpv
-        # heredaría la consola y competiría con el hilo lector por las teclas
-        self._proc = subprocess.Popen(
-            [mpv_path, f"--input-ipc-server={self._ipc}", "--", str(video_path)],
-            stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-
-    def alive(self) -> bool:
-        return self._proc.poll() is None
-
-    def playback_time(self) -> float | None:
-        """Posición de reproducción en segundos; None si no se pudo leer."""
-        request = json.dumps({"command": ["get_property", "playback-time"]}) + "\n"
-        try:
-            for line in self._roundtrip(request):
-                try:
-                    payload = json.loads(line)
-                except json.JSONDecodeError:
-                    continue
-                if "error" in payload:  # respuesta a la petición (no un evento)
-                    if payload["error"] == "success" and isinstance(
-                            payload.get("data"), (int, float)):
-                        return float(payload["data"])
-                    return None
-        except OSError:
-            return None
-        return None
-
-    def _roundtrip(self, request: str) -> list[str]:
-        """Envía una petición y devuelve las líneas de respuesta."""
-        if os.name == "nt":
-            # el pipe lo crea mpv; abrir/escribir/leer por petición es lo robusto
-            with open(self._ipc, "r+b", buffering=0) as pipe:
-                pipe.write(request.encode("utf-8"))
-                return pipe.read(4096).decode("utf-8", "replace").splitlines()
-        import socket
-        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
-            sock.settimeout(1.0)
-            sock.connect(self._ipc)
-            sock.sendall(request.encode("utf-8"))
-            chunks = b""
-            while b"\n" not in chunks:
-                data = sock.recv(4096)
-                if not data:
-                    break
-                chunks += data
-            return chunks.decode("utf-8", "replace").splitlines()
-
-    def close(self) -> None:
-        if self.alive():
-            self._proc.terminate()
-            try:
-                self._proc.wait(timeout=3)
-            except subprocess.TimeoutExpired:
-                self._proc.kill()