@rlabs-cl/arketum 0.0.0-stage → 1.0.0

package/catalogo-de-ejemplo/stacks/python/e2e-terminal/terminal_prueba.py

@@ -0,0 +1,118 @@
+"""
+TERMINAL DE PRUEBA (fijación del catálogo de Arketum: se copia tal cual y no se
+edita). Prueba un programa de terminal como lo usaría una persona, en una
+pseudo-terminal emulada con pyte (`python3 -m pip install pyte`).
+
+    from terminal_prueba import Terminal
+
+    with Terminal(['sh', 'arrancar.sh'], cwd='.', columnas=80, filas=24) as t:
+        t.esperar(2)                 # deja correr el programa
+        t.tecla('ARRIBA')            # ARRIBA, ABAJO, IZQUIERDA, DERECHA, ENTER, ESC o un carácter
+        t.esperar(0.5)
+        texto = t.pantalla()         # lo que se ve, una cadena con una línea por fila
+        assert t.vivo()              # sigue corriendo
+        assert 'Traceback' not in texto
+
+`t.lineas()` da la lista de filas y `t.codigo` el código de salida cuando termina.
+"""
+
+import fcntl, os, pty, select, signal, struct, termios, time
+
+import pyte
+
+TECLAS = {'ARRIBA': b'\x1b[A', 'ABAJO': b'\x1b[B', 'DERECHA': b'\x1b[C', 'IZQUIERDA': b'\x1b[D', 'ENTER': b'\r', 'ESC': b'\x1b'}
+
+
+class Terminal:
+    def __init__(self, comando, cwd='.', columnas=80, filas=24, env=None):
+        self._pantalla = pyte.Screen(columnas, filas)
+        self._flujo = pyte.ByteStream(self._pantalla)
+        pid, fd = pty.fork()
+        if pid == 0:
+            entorno = dict(os.environ, LANG='en_US.UTF-8', LC_ALL='en_US.UTF-8', TERM='xterm-256color', COLUMNS=str(columnas), LINES=str(filas))
+            entorno.update(env or {})
+            os.chdir(cwd)
+            os.execvpe(comando[0], comando, entorno)
+        fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack('HHHH', filas, columnas, 0, 0))
+        self.pid, self.fd, self._vivo, self.codigo = pid, fd, True, None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.cerrar()
+
+    def esperar(self, segundos):
+        fin = time.time() + segundos
+        while time.time() < fin:
+            r, _, _ = select.select([self.fd], [], [], 0.05)
+            if r:
+                try:
+                    datos = os.read(self.fd, 65536)
+                except OSError:
+                    datos = b''
+                if datos:
+                    self._flujo.feed(datos)
+                else:
+                    time.sleep(0.05)
+            self._comprobar()
+        self._comprobar()
+
+    def tecla(self, nombre):
+        datos = TECLAS.get(nombre, nombre.encode() if isinstance(nombre, str) else nombre)
+        # Como un terminal real: si el programa activó el modo de cursor de aplicación (DECCKM, el modo privado 1, que pyte guarda como 1 << 5; curses
+        # con keypad), las flechas van como ESC O x en vez de ESC [ x.
+        if datos[:2] == b'\x1b[' and len(datos) == 3 and datos[2:] in b'ABCD' and (1 << 5) in self._pantalla.mode:
+            datos = b'\x1bO' + datos[2:]
+        try:
+            os.write(self.fd, datos)
+        except OSError:
+            pass
+
+    def pantalla(self):
+        return '\n'.join(self._pantalla.display)
+
+    def lineas(self):
+        return list(self._pantalla.display)
+
+    def pintadas(self):
+        """Cuántas celdas se ven: con carácter, en vídeo inverso o con un fondo distinto del
+        dominante (al borrar, pyte rellena con el fondo del cursor: ese no cuenta)."""
+        from collections import Counter
+        filas, cols = self._pantalla.lines, self._pantalla.columns
+        celdas = [self._pantalla.buffer[y][x] for y in range(filas) for x in range(cols)]
+        fondo = Counter(c.bg for c in celdas).most_common(1)[0][0]
+        return sum(1 for c in celdas if c.data.strip() or c.reverse or c.bg != fondo)
+
+    def foto(self):
+        """Lo que se ve, con forma: el texto y dónde hay celdas en vídeo inverso o con fondo distinto del dominante."""
+        from collections import Counter
+        filas, cols = self._pantalla.lines, self._pantalla.columns
+        fondo = Counter(self._pantalla.buffer[y][x].bg for y in range(filas) for x in range(cols)).most_common(1)[0][0]
+        marcas = tuple((y, x) for y in range(filas) for x in range(cols) if self._pantalla.buffer[y][x].reverse or self._pantalla.buffer[y][x].bg != fondo)
+        return (self.pantalla(), marcas)
+
+    def vivo(self):
+        self._comprobar()
+        return self._vivo
+
+    def _comprobar(self):
+        if not self._vivo:
+            return
+        p, estado = os.waitpid(self.pid, os.WNOHANG)
+        if p != 0:
+            self._vivo = False
+            self.codigo = os.waitstatus_to_exitcode(estado)
+
+    def cerrar(self):
+        if self._vivo:
+            try:
+                os.kill(self.pid, signal.SIGKILL)
+                os.waitpid(self.pid, 0)
+            except OSError:
+                pass
+            self._vivo = False
+        try:
+            os.close(self.fd)
+        except OSError:
+            pass

package/catalogo-de-ejemplo/stacks/python/suelo-aplicacion-por-capas/requirements.txt

@@ -0,0 +1 @@
+pyte

package/catalogo-de-ejemplo/stacks/python/suelo-aplicacion-por-capas/suelo.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+SUELO FIJO de la forma `aplicacion-por-capas` (fijación del catálogo de Arketum:
+se copia tal cual en `arketum/fijaciones/suelo/` y no se edita; el cierre compara
+su checksum). Las comprobaciones de uso que no escribe quien construye: que la
+aplicación vive, se puede usar y cerrar, y vuelve a arrancar con sus datos; no
+que haga bien lo que pide el encargo.
+
+Arranca el artefacto por su contrato de arranque: `sh arrancar.sh` desde su raíz,
+en una terminal, con `DATOS_DIR` (la carpeta de sus datos), `HOME` y `PUERTO` (un
+puerto libre, por si sirve HTTP) en una carpeta temporal propia.
+
+  arranca    a 80x24, a los 3 s pinta algo y sin traza (vivo, o esperando órdenes)
+  responde   tras Enter y unas flechas sigue sin traza
+  sale       termina limpio (código 0) con `q`, con la orden `salir`/`q`/`exit` + Enter, con la opción de salir del menú, o con fin de entrada
+  rearranca  con los mismos datos (mismo HOME y DATOS_DIR) vuelve a arrancar sin traza
+
+Uso: python3 arketum/fijaciones/suelo/suelo.py <raíz del artefacto>  →  JSON; código 0 si pasa, 1 si no.
+Necesita `pyte` (`python3 -m pip install -r arketum/fijaciones/suelo/requirements.txt`).
+"""
+
+import faulthandler, json, os, re, socket, sys, tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from terminal_prueba import Terminal  # noqa: E402
+
+ARRANQUE = ['sh', 'arrancar.sh']
+SALIDAS = [b'q', b'\r', b'salir\r', b'q\r', b'exit\r']
+# Una opción de menú para salir, la que se vea en pantalla: «5. Salir», «[0] Exit»…
+OPCION_DE_SALIR = re.compile(r'[\[(]?\s*(\w)\s*[\])\.:-]\s*(?:salir|exit|quit|terminar|cerrar)\b', re.I)
+
+
+def libre():
+    with socket.socket() as s:
+        s.bind(('127.0.0.1', 0))
+        return s.getsockname()[1]
+
+
+def pintadas(t):
+    n = 0
+    for _ in range(5):
+        t.esperar(0.15)
+        n = max(n, t.pintadas())
+    return n
+
+
+def evaluar(raiz):
+    if not os.path.isfile(os.path.join(raiz, 'arrancar.sh')):
+        return {'ok': False, 'fallo': 'no hay `arrancar.sh` en la raíz del artefacto: es su contrato de arranque', 'pantalla': ''}
+    r = {'comando': ' '.join(ARRANQUE)}
+    casa = tempfile.mkdtemp(prefix='suelo-')
+    env = {'HOME': casa, 'DATOS_DIR': os.path.join(casa, 'datos'), 'PUERTO': str(libre())}
+    with Terminal(ARRANQUE, cwd=raiz, columnas=80, filas=24, env=env) as t:
+        t.esperar(3)
+        n = pintadas(t)
+        texto = t.pantalla()
+        r['arranca'] = 'Traceback' not in texto and n >= 10 and (t.vivo() or t.codigo == 0)
+        if not r['arranca'] or not t.vivo():
+            return {**r, 'ok': False, 'fallo': 'a 80x24 no arranca: muere, saca una traza o no pinta nada', 'pantalla': texto}
+        t.tecla('ENTER')
+        for k in ('ABAJO', 'ARRIBA'):
+            t.tecla(k)
+            t.esperar(0.3)
+        t.esperar(1)
+        texto = t.pantalla()
+        r['responde'] = 'Traceback' not in texto and (t.vivo() or t.codigo == 0)
+        if not r['responde']:
+            return {**r, 'ok': False, 'fallo': 'tras Enter y unas flechas saca una traza o muere con error', 'pantalla': texto}
+        for b in SALIDAS:
+            if not t.vivo():
+                break
+            t.tecla(b)
+            t.esperar(1.5)
+        for _ in range(2):  # la opción de salir del menú que se vea, y como último recurso, fin de entrada
+            m = OPCION_DE_SALIR.search(t.pantalla())
+            if not t.vivo() or m is None:
+                break
+            t.tecla(f'{m.group(1)}\r')
+            t.esperar(1.5)
+        if t.vivo():
+            t.tecla(b'\x04')
+            t.esperar(1.5)
+        texto = t.pantalla()
+        r['sale'] = not t.vivo() and t.codigo == 0 and 'Traceback' not in texto
+        if not r['sale']:
+            return {**r, 'ok': False, 'fallo': 'no termina limpio con `q`, ni con `salir`/`q`/`exit` + Enter, ni con fin de entrada' if t.vivo() else 'al salir saca una traza o termina con error', 'pantalla': texto}
+    env['PUERTO'] = str(libre())
+    with Terminal(ARRANQUE, cwd=raiz, columnas=80, filas=24, env=env) as t:
+        t.esperar(3)
+        texto = t.pantalla()
+        r['rearranca'] = 'Traceback' not in texto and (t.vivo() or t.codigo == 0)
+        if not r['rearranca']:
+            return {**r, 'ok': False, 'fallo': 'con los datos de la primera vez, al volver a abrir saca una traza o muere', 'pantalla': texto}
+    return {**r, 'ok': True}
+
+
+if __name__ == '__main__':
+    # Un suelo nunca se queda colgado: a los 150 s escribe dónde estaba y termina con error (1).
+    faulthandler.dump_traceback_later(150, exit=True)
+    resultado = evaluar(os.path.abspath(sys.argv[1] if len(sys.argv) > 1 else '.'))
+    print(json.dumps(resultado, ensure_ascii=False, indent=1))
+    sys.exit(0 if resultado['ok'] else 1)

package/catalogo-de-ejemplo/stacks/python/suelo-aplicacion-por-capas/terminal_prueba.py

@@ -0,0 +1,118 @@
+"""
+TERMINAL DE PRUEBA (fijación del catálogo de Arketum: se copia tal cual y no se
+edita). Prueba un programa de terminal como lo usaría una persona, en una
+pseudo-terminal emulada con pyte (`python3 -m pip install pyte`).
+
+    from terminal_prueba import Terminal
+
+    with Terminal(['sh', 'arrancar.sh'], cwd='.', columnas=80, filas=24) as t:
+        t.esperar(2)                 # deja correr el programa
+        t.tecla('ARRIBA')            # ARRIBA, ABAJO, IZQUIERDA, DERECHA, ENTER, ESC o un carácter
+        t.esperar(0.5)
+        texto = t.pantalla()         # lo que se ve, una cadena con una línea por fila
+        assert t.vivo()              # sigue corriendo
+        assert 'Traceback' not in texto
+
+`t.lineas()` da la lista de filas y `t.codigo` el código de salida cuando termina.
+"""
+
+import fcntl, os, pty, select, signal, struct, termios, time
+
+import pyte
+
+TECLAS = {'ARRIBA': b'\x1b[A', 'ABAJO': b'\x1b[B', 'DERECHA': b'\x1b[C', 'IZQUIERDA': b'\x1b[D', 'ENTER': b'\r', 'ESC': b'\x1b'}
+
+
+class Terminal:
+    def __init__(self, comando, cwd='.', columnas=80, filas=24, env=None):
+        self._pantalla = pyte.Screen(columnas, filas)
+        self._flujo = pyte.ByteStream(self._pantalla)
+        pid, fd = pty.fork()
+        if pid == 0:
+            entorno = dict(os.environ, LANG='en_US.UTF-8', LC_ALL='en_US.UTF-8', TERM='xterm-256color', COLUMNS=str(columnas), LINES=str(filas))
+            entorno.update(env or {})
+            os.chdir(cwd)
+            os.execvpe(comando[0], comando, entorno)
+        fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack('HHHH', filas, columnas, 0, 0))
+        self.pid, self.fd, self._vivo, self.codigo = pid, fd, True, None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.cerrar()
+
+    def esperar(self, segundos):
+        fin = time.time() + segundos
+        while time.time() < fin:
+            r, _, _ = select.select([self.fd], [], [], 0.05)
+            if r:
+                try:
+                    datos = os.read(self.fd, 65536)
+                except OSError:
+                    datos = b''
+                if datos:
+                    self._flujo.feed(datos)
+                else:
+                    time.sleep(0.05)
+            self._comprobar()
+        self._comprobar()
+
+    def tecla(self, nombre):
+        datos = TECLAS.get(nombre, nombre.encode() if isinstance(nombre, str) else nombre)
+        # Como un terminal real: si el programa activó el modo de cursor de aplicación (DECCKM, el modo privado 1, que pyte guarda como 1 << 5; curses
+        # con keypad), las flechas van como ESC O x en vez de ESC [ x.
+        if datos[:2] == b'\x1b[' and len(datos) == 3 and datos[2:] in b'ABCD' and (1 << 5) in self._pantalla.mode:
+            datos = b'\x1bO' + datos[2:]
+        try:
+            os.write(self.fd, datos)
+        except OSError:
+            pass
+
+    def pantalla(self):
+        return '\n'.join(self._pantalla.display)
+
+    def lineas(self):
+        return list(self._pantalla.display)
+
+    def pintadas(self):
+        """Cuántas celdas se ven: con carácter, en vídeo inverso o con un fondo distinto del
+        dominante (al borrar, pyte rellena con el fondo del cursor: ese no cuenta)."""
+        from collections import Counter
+        filas, cols = self._pantalla.lines, self._pantalla.columns
+        celdas = [self._pantalla.buffer[y][x] for y in range(filas) for x in range(cols)]
+        fondo = Counter(c.bg for c in celdas).most_common(1)[0][0]
+        return sum(1 for c in celdas if c.data.strip() or c.reverse or c.bg != fondo)
+
+    def foto(self):
+        """Lo que se ve, con forma: el texto y dónde hay celdas en vídeo inverso o con fondo distinto del dominante."""
+        from collections import Counter
+        filas, cols = self._pantalla.lines, self._pantalla.columns
+        fondo = Counter(self._pantalla.buffer[y][x].bg for y in range(filas) for x in range(cols)).most_common(1)[0][0]
+        marcas = tuple((y, x) for y in range(filas) for x in range(cols) if self._pantalla.buffer[y][x].reverse or self._pantalla.buffer[y][x].bg != fondo)
+        return (self.pantalla(), marcas)
+
+    def vivo(self):
+        self._comprobar()
+        return self._vivo
+
+    def _comprobar(self):
+        if not self._vivo:
+            return
+        p, estado = os.waitpid(self.pid, os.WNOHANG)
+        if p != 0:
+            self._vivo = False
+            self.codigo = os.waitstatus_to_exitcode(estado)
+
+    def cerrar(self):
+        if self._vivo:
+            try:
+                os.kill(self.pid, signal.SIGKILL)
+                os.waitpid(self.pid, 0)
+            except OSError:
+                pass
+            self._vivo = False
+        try:
+            os.close(self.fd)
+        except OSError:
+            pass

package/catalogo-de-ejemplo/stacks/python/suelo-juego-terminal/requirements.txt

@@ -0,0 +1 @@
+pyte

package/catalogo-de-ejemplo/stacks/python/suelo-juego-terminal/suelo.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""
+SUELO FIJO de la forma `juego-terminal` (fijación del catálogo de Arketum: se
+copia tal cual en `arketum/fijaciones/suelo/` y no se edita; el cierre compara su
+checksum). Las comprobaciones de uso que no escribe quien construye: que el
+programa vive, no que el juego esté bien.
+
+Arranca el artefacto por su contrato de arranque: `sh arrancar.sh` desde su raíz.
+
+  arranca    a 80x24, a los 3 s sigue vivo, pinta algo y sin traza
+  se_mueve   sin tocar nada, en 2.4 s se ven al menos 5 fotogramas distintos (un juego en tiempo real anima)
+  aguanta    8 s más con flechas pulsadas, vivo y sin traza
+  sale_q     con `q` termina
+  pequena    a 30x10 no saca traza (avisa o sale limpio)
+
+Uso: python3 arketum/fijaciones/suelo/suelo.py <raíz del artefacto>  →  JSON; código 0 si pasa, 1 si no.
+Necesita `pyte` (`python3 -m pip install -r arketum/fijaciones/suelo/requirements.txt`).
+"""
+
+import faulthandler, json, os, sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from terminal_prueba import Terminal  # noqa: E402
+
+ARRANQUE = ['sh', 'arrancar.sh']
+
+
+def pintadas(t):
+    """Lo más pintado en unas cuantas muestras: un juego que borra y redibuja puede pillarse a medias."""
+    n = 0
+    for _ in range(5):
+        t.esperar(0.15)
+        n = max(n, t.pintadas())
+    return n
+
+
+def evaluar(raiz):
+    if not os.path.isfile(os.path.join(raiz, 'arrancar.sh')):
+        return {'ok': False, 'fallo': 'no hay `arrancar.sh` en la raíz del artefacto: es su contrato de arranque', 'pantalla': ''}
+    r = {'comando': ' '.join(ARRANQUE)}
+    with Terminal(ARRANQUE, cwd=raiz, columnas=80, filas=24) as t:
+        t.tecla('ENTER')  # por si hay una pantalla de inicio que espera una tecla
+        t.esperar(3)
+        n = pintadas(t)
+        texto = t.pantalla()
+        r['arranca'] = t.vivo() and 'Traceback' not in texto and n >= 10
+        if not r['arranca']:
+            return {**r, 'ok': False, 'fallo': 'a 80x24 no arranca: muere, saca una traza o no pinta nada', 'pantalla': texto}
+        # Movimiento: muchos fotogramas distintos. Un juego que borra y redibuja parpadea entre dos
+        # estados (completo y vacío), y el parpadeo no es movimiento.
+        fotos = set()
+        for _ in range(12):
+            t.esperar(0.2)
+            fotos.add(t.foto())
+        r['se_mueve'] = len(fotos) >= 5
+        if not r['se_mueve']:
+            return {**r, 'ok': False, 'fallo': 'la pantalla no cambia sola: no hay nada en movimiento', 'pantalla': t.pantalla()}
+        for i in range(32):
+            t.tecla('ARRIBA' if (i // 4) % 2 else 'ABAJO')
+            t.esperar(0.25)
+            if not t.vivo():
+                break
+        texto = t.pantalla()
+        r['aguanta'] = t.vivo() and 'Traceback' not in texto
+        if not r['aguanta']:
+            return {**r, 'ok': False, 'fallo': 'jugando 8 s con flechas, el programa muere o saca una traza', 'pantalla': texto}
+        t.tecla('q')
+        t.esperar(3)
+        r['sale_q'] = not t.vivo()
+        if not r['sale_q']:
+            return {**r, 'ok': False, 'fallo': 'con `q` el programa no termina', 'pantalla': t.pantalla()}
+    with Terminal(ARRANQUE, cwd=raiz, columnas=30, filas=10) as t:
+        t.esperar(2.5)
+        texto = t.pantalla()
+        r['pequena'] = 'Traceback' not in texto and (t.vivo() or t.codigo == 0)
+        if not r['pequena']:
+            return {**r, 'ok': False, 'fallo': 'a 30x10 saca una traza o sale con error en vez de avisar', 'pantalla': texto}
+    return {**r, 'ok': True}
+
+
+if __name__ == '__main__':
+    # Un suelo nunca se queda colgado: a los 150 s escribe dónde estaba y termina con error (1).
+    faulthandler.dump_traceback_later(150, exit=True)
+    resultado = evaluar(os.path.abspath(sys.argv[1] if len(sys.argv) > 1 else '.'))
+    print(json.dumps(resultado, ensure_ascii=False, indent=1))
+    sys.exit(0 if resultado['ok'] else 1)

package/catalogo-de-ejemplo/stacks/python/suelo-juego-terminal/terminal_prueba.py

@@ -0,0 +1,118 @@
+"""
+TERMINAL DE PRUEBA (fijación del catálogo de Arketum: se copia tal cual y no se
+edita). Prueba un programa de terminal como lo usaría una persona, en una
+pseudo-terminal emulada con pyte (`python3 -m pip install pyte`).
+
+    from terminal_prueba import Terminal
+
+    with Terminal(['sh', 'arrancar.sh'], cwd='.', columnas=80, filas=24) as t:
+        t.esperar(2)                 # deja correr el programa
+        t.tecla('ARRIBA')            # ARRIBA, ABAJO, IZQUIERDA, DERECHA, ENTER, ESC o un carácter
+        t.esperar(0.5)
+        texto = t.pantalla()         # lo que se ve, una cadena con una línea por fila
+        assert t.vivo()              # sigue corriendo
+        assert 'Traceback' not in texto
+
+`t.lineas()` da la lista de filas y `t.codigo` el código de salida cuando termina.
+"""
+
+import fcntl, os, pty, select, signal, struct, termios, time
+
+import pyte
+
+TECLAS = {'ARRIBA': b'\x1b[A', 'ABAJO': b'\x1b[B', 'DERECHA': b'\x1b[C', 'IZQUIERDA': b'\x1b[D', 'ENTER': b'\r', 'ESC': b'\x1b'}
+
+
+class Terminal:
+    def __init__(self, comando, cwd='.', columnas=80, filas=24, env=None):
+        self._pantalla = pyte.Screen(columnas, filas)
+        self._flujo = pyte.ByteStream(self._pantalla)
+        pid, fd = pty.fork()
+        if pid == 0:
+            entorno = dict(os.environ, LANG='en_US.UTF-8', LC_ALL='en_US.UTF-8', TERM='xterm-256color', COLUMNS=str(columnas), LINES=str(filas))
+            entorno.update(env or {})
+            os.chdir(cwd)
+            os.execvpe(comando[0], comando, entorno)
+        fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack('HHHH', filas, columnas, 0, 0))
+        self.pid, self.fd, self._vivo, self.codigo = pid, fd, True, None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.cerrar()
+
+    def esperar(self, segundos):
+        fin = time.time() + segundos
+        while time.time() < fin:
+            r, _, _ = select.select([self.fd], [], [], 0.05)
+            if r:
+                try:
+                    datos = os.read(self.fd, 65536)
+                except OSError:
+                    datos = b''
+                if datos:
+                    self._flujo.feed(datos)
+                else:
+                    time.sleep(0.05)
+            self._comprobar()
+        self._comprobar()
+
+    def tecla(self, nombre):
+        datos = TECLAS.get(nombre, nombre.encode() if isinstance(nombre, str) else nombre)
+        # Como un terminal real: si el programa activó el modo de cursor de aplicación (DECCKM, el modo privado 1, que pyte guarda como 1 << 5; curses
+        # con keypad), las flechas van como ESC O x en vez de ESC [ x.
+        if datos[:2] == b'\x1b[' and len(datos) == 3 and datos[2:] in b'ABCD' and (1 << 5) in self._pantalla.mode:
+            datos = b'\x1bO' + datos[2:]
+        try:
+            os.write(self.fd, datos)
+        except OSError:
+            pass
+
+    def pantalla(self):
+        return '\n'.join(self._pantalla.display)
+
+    def lineas(self):
+        return list(self._pantalla.display)
+
+    def pintadas(self):
+        """Cuántas celdas se ven: con carácter, en vídeo inverso o con un fondo distinto del
+        dominante (al borrar, pyte rellena con el fondo del cursor: ese no cuenta)."""
+        from collections import Counter
+        filas, cols = self._pantalla.lines, self._pantalla.columns
+        celdas = [self._pantalla.buffer[y][x] for y in range(filas) for x in range(cols)]
+        fondo = Counter(c.bg for c in celdas).most_common(1)[0][0]
+        return sum(1 for c in celdas if c.data.strip() or c.reverse or c.bg != fondo)
+
+    def foto(self):
+        """Lo que se ve, con forma: el texto y dónde hay celdas en vídeo inverso o con fondo distinto del dominante."""
+        from collections import Counter
+        filas, cols = self._pantalla.lines, self._pantalla.columns
+        fondo = Counter(self._pantalla.buffer[y][x].bg for y in range(filas) for x in range(cols)).most_common(1)[0][0]
+        marcas = tuple((y, x) for y in range(filas) for x in range(cols) if self._pantalla.buffer[y][x].reverse or self._pantalla.buffer[y][x].bg != fondo)
+        return (self.pantalla(), marcas)
+
+    def vivo(self):
+        self._comprobar()
+        return self._vivo
+
+    def _comprobar(self):
+        if not self._vivo:
+            return
+        p, estado = os.waitpid(self.pid, os.WNOHANG)
+        if p != 0:
+            self._vivo = False
+            self.codigo = os.waitstatus_to_exitcode(estado)
+
+    def cerrar(self):
+        if self._vivo:
+            try:
+                os.kill(self.pid, signal.SIGKILL)
+                os.waitpid(self.pid, 0)
+            except OSError:
+                pass
+            self._vivo = False
+        try:
+            os.close(self.fd)
+        except OSError:
+            pass