Proyecto: buscador de texto

buscar "TODO" tienda/src/tienda.py
buscar -rn "ERROR" tienda
cat registro.log | buscar "^2026-09-18.*ERROR"
buscar -rc "TODO" tienda

if buscar -r "contraseña" src/ > /dev/null; then
  echo "hay una contraseña en el código"
fi

import re

texto = "El pedido 8812 salió el 2026-09-18 y el 8813 el 2026-09-19."

print(re.search(r"\d+", texto))
print(re.search(r"\d+", texto).group())
print(re.findall(r"\d{4}-\d{2}-\d{2}", texto))
print(re.search(r"bizum", texto))

print(r"\d+")
print(len(r"\d+"), len("\n"))

import re

texto = "El pedido 8812 salió el 2026-09-18 y el 8813 el 2026-09-19."

for encaje in re.finditer(r"pedido (\d+)", texto):
        print(encaje.span(), encaje.group(), encaje.group(1))

print(re.search(r"PEDIDO", texto, re.IGNORECASE))

buscador/
    pyproject.toml
    src/
        buscador/
            __init__.py
            busqueda.py   Compilar, buscar, recorrer ficheros, detectar binarios
            cli.py        Argumentos, color, entrada estándar y códigos de salida
            __main__.py

import re
from collections.abc import Iterable, Iterator
from dataclasses import dataclass
from pathlib import Path

TAMANO_MUESTRA = 1024


@dataclass
class Coincidencia:
        """Una línea que cumple lo que se buscaba."""

    origen: str
    numero: int
    linea: str
    tramos: list[tuple[int, int]]


def compilar(patron: str, ignorar_mayusculas: bool = False) -> re.Pattern:
        """Compila el patrón una sola vez y traduce re.error a ValueError."""
    banderas = re.IGNORECASE if ignorar_mayusculas else 0
    try:
                return re.compile(patron, banderas)
    except re.error as error:
                raise ValueError(f"patrón no válido: {error}") from None

def buscar_en_lineas(
    expresion: re.Pattern,
    lineas: Iterable[str],
    origen: str,
    invertir: bool = False,
) -> Iterator[Coincidencia]:
        """Recorre las líneas y va entregando las que cumplen el patrón."""
    for numero, linea in enumerate(lineas, start=1):
                linea = linea.rstrip("\n")
        tramos = [encaje.span() for encaje in expresion.finditer(linea)]
        if invertir:
                        if not tramos:
                                yield Coincidencia(origen, numero, linea, [])
        elif tramos:
                        yield Coincidencia(origen, numero, linea, tramos)

from buscador.busqueda import buscar_en_lineas, compilar

lineas = [
    "2026-09-18 10:03:41 WARNING stock negativo en el producto 44\n",
    "2026-09-18 10:04:02 ERROR  no se ha podido conectar\n",
    "2026-09-18 10:05:00 INFO  pedido 8812 confirmado\n",
]

expresion = compilar(r"\d{4}")
for coincidencia in buscar_en_lineas(expresion, lineas, "registro.log"):
        print(coincidencia.numero, coincidencia.tramos, coincidencia.linea[:30])

expresion = compilar("error", ignorar_mayusculas=True)
print([c.numero for c in buscar_en_lineas(expresion, lineas, "x")])
print([c.numero for c in buscar_en_lineas(expresion, lineas, "x", invertir=True)])

def es_binario(ruta: Path) -> bool:
        """Un fichero con un byte cero en su primer kilobyte no es texto."""
    with open(ruta, "rb") as fichero:
                return b"\x00" in fichero.read(TAMANO_MUESTRA)


def leer_lineas(ruta: Path) -> Iterator[str]:
        """Lee el fichero línea a línea sin cargarlo entero en memoria."""
    with open(ruta, encoding="utf-8", errors="replace") as fichero:
                yield from fichero


def expandir(rutas: list[Path], recursivo: bool = False) -> tuple[list[Path], list[str]]:
        """Convierte lo que se pidió en una lista de ficheros, y avisa de lo que descarta."""
    ficheros: list[Path] = []
    avisos: list[str] = []

    for ruta in rutas:
                if not ruta.exists():
                        avisos.append(f"{ruta}: no existe")
        elif ruta.is_file():
                        ficheros.append(ruta)
        elif ruta.is_dir() and recursivo:
                        ficheros.extend(
                hijo for hijo in sorted(ruta.rglob("*"))
                if hijo.is_file() and not any(parte.startswith(".") for parte in hijo.parts)
            )
        elif ruta.is_dir():
                        avisos.append(f"{ruta}: es una carpeta (usa -r)")
        else:
                        avisos.append(f"{ruta}: no es un fichero normal")

    return ficheros, avisos

from pathlib import Path

from buscador.busqueda import es_binario, expandir

print(es_binario(Path("tienda/datos.bin")), es_binario(Path("tienda/registro.log")))

ficheros, avisos = expandir([Path("tienda")], recursivo=True)
print([str(f) for f in ficheros])
print(expandir([Path("tienda"), Path("no-existe.txt")]))

NORMAL = "\033[0m"
ROJO = "\033[1;31m"
MAGENTA = "\033[35m"
VERDE = "\033[32m"
CIAN = "\033[36m"


def resaltar(coincidencia: Coincidencia, color: bool) -> str:
        """Devuelve la línea con los tramos encontrados envueltos en rojo."""
    if not color or not coincidencia.tramos:
                return coincidencia.linea

    trozos = []
    final_anterior = 0
    for inicio, fin in coincidencia.tramos:
                trozos.append(coincidencia.linea[final_anterior:inicio])
        trozos.append(ROJO + coincidencia.linea[inicio:fin] + NORMAL)
        final_anterior = fin
    trozos.append(coincidencia.linea[final_anterior:])
    return "".join(trozos)


def pintar_coincidencia(coincidencia: Coincidencia, opciones, varios: bool, color: bool) -> None:
        """Imprime una línea al estilo de grep: fichero, número y texto."""
    partes = []
    if varios:
                nombre = coincidencia.origen
        partes.append(f"{MAGENTA}{nombre}{NORMAL}" if color else nombre)
    if opciones.numero_de_linea:
                numero = str(coincidencia.numero)
        partes.append(f"{VERDE}{numero}{NORMAL}" if color else numero)
    partes.append(resaltar(coincidencia, color))
    separador = f"{CIAN}:{NORMAL}" if color else ":"
    print(separador.join(partes))

buscar --color siempre -n "ERROR|WARNING" tienda/registro.log

\033[32m3\033[0m\033[36m:\033[0m2026-09-18 10:03:41 \033[1;31mWARNING\033[0m stock negativo...

def quiere_color(modo: str) -> bool:
        if modo == "nunca":
                return False
    if modo == "siempre":
                return True
    if os.environ.get("NO_COLOR"):
                return False
    return sys.stdout.isatty()

        if not opciones.ficheros:
                fuentes = [(ENTRADA_ESTANDAR, sys.stdin)]
        varios = False
    else:
                fuentes = []
        varios = len(ficheros) > 1
        for fichero in ficheros:
                        try:
                                if es_binario(fichero):
                                        print(f"buscador: {fichero}: fichero binario, me lo salto", file=sys.stderr)
                    continue
                fuentes.append((str(fichero), leer_lineas(fichero)))
            except OSError as error:
                                print(f"buscador: {fichero}: {error.strerror}", file=sys.stderr)
                hubo_errores = True

cat tienda/registro.log | buscar "ERROR"

ls tienda | buscar "\.log$"

        if hubo_errores and not encontrado:
                return 2
    return 0 if encontrado else 1

if buscar -r "IVA" tienda > /dev/null 2>&1; then
  echo "queda IVA por revisar"
else
  echo "nada de IVA"
fi

buscar -n "peticion" grande.log | head -3

def ejecutar() -> int:
        """Envoltorio que aguanta las tuberías cerradas y el Ctrl+C."""
    try:
                codigo = main()
        sys.stdout.flush()
    except KeyboardInterrupt:
                print("\nbuscador: interrumpido", file=sys.stderr)
        return 130
    except BrokenPipeError:
        # Quien leía se ha ido. Se desvía la salida al vacío para que Python
        # no vuelva a intentar vaciarla al cerrar y se queje.
                os.dup2(os.open(os.devnull, os.O_WRONLY), sys.stdout.fileno())
        return 141
    return codigo

                except BrokenPipeError:
            # Es un OSError, así que hay que dejarlo pasar antes del except de abajo.
                        raise
        except OSError as error:
                        print(f"buscador: {origen}: {error.strerror}", file=sys.stderr)

buscar -n "peticion" grande.log | head -3
echo $?

"""La lógica de la búsqueda. No imprime ni lee argumentos."""

import re
from collections.abc import Iterable, Iterator
from dataclasses import dataclass
from pathlib import Path

TAMANO_MUESTRA = 1024


@dataclass
class Coincidencia:
        """Una línea que cumple lo que se buscaba."""

    origen: str
    numero: int
    linea: str
    tramos: list[tuple[int, int]]


def compilar(patron: str, ignorar_mayusculas: bool = False) -> re.Pattern:
        """Compila el patrón una sola vez y traduce re.error a ValueError."""
    banderas = re.IGNORECASE if ignorar_mayusculas else 0
    try:
                return re.compile(patron, banderas)
    except re.error as error:
                raise ValueError(f"patrón no válido: {error}") from None


def buscar_en_lineas(
    expresion: re.Pattern,
    lineas: Iterable[str],
    origen: str,
    invertir: bool = False,
) -> Iterator[Coincidencia]:
        """Recorre las líneas y va entregando las que cumplen el patrón."""
    for numero, linea in enumerate(lineas, start=1):
                linea = linea.rstrip("\n")
        tramos = [encaje.span() for encaje in expresion.finditer(linea)]
        if invertir:
                        if not tramos:
                                yield Coincidencia(origen, numero, linea, [])
        elif tramos:
                        yield Coincidencia(origen, numero, linea, tramos)


def es_binario(ruta: Path) -> bool:
        """Un fichero con un byte cero en su primer kilobyte no es texto."""
    with open(ruta, "rb") as fichero:
                return b"\x00" in fichero.read(TAMANO_MUESTRA)


def leer_lineas(ruta: Path) -> Iterator[str]:
        """Lee el fichero línea a línea sin cargarlo entero en memoria."""
    with open(ruta, encoding="utf-8", errors="replace") as fichero:
                yield from fichero


def expandir(rutas: list[Path], recursivo: bool = False) -> tuple[list[Path], list[str]]:
        """Convierte lo que se pidió en una lista de ficheros, y avisa de lo que descarta."""
    ficheros: list[Path] = []
    avisos: list[str] = []

    for ruta in rutas:
                if not ruta.exists():
                        avisos.append(f"{ruta}: no existe")
        elif ruta.is_file():
                        ficheros.append(ruta)
        elif ruta.is_dir() and recursivo:
                        ficheros.extend(
                hijo for hijo in sorted(ruta.rglob("*"))
                if hijo.is_file() and not any(parte.startswith(".") for parte in hijo.parts)
            )
        elif ruta.is_dir():
                        avisos.append(f"{ruta}: es una carpeta (usa -r)")
        else:
                        avisos.append(f"{ruta}: no es un fichero normal")

    return ficheros, avisos

"""La interfaz: argumentos, color, entrada estándar y códigos de salida."""

import argparse
import os
import sys
from pathlib import Path

from .busqueda import (
    Coincidencia,
    buscar_en_lineas,
    compilar,
    es_binario,
    expandir,
    leer_lineas,
)

NORMAL = "\033[0m"
ROJO = "\033[1;31m"
MAGENTA = "\033[35m"
VERDE = "\033[32m"
CIAN = "\033[36m"

ENTRADA_ESTANDAR = "(entrada estándar)"


def construir_analizador() -> argparse.ArgumentParser:
        analizador = argparse.ArgumentParser(
        prog="buscador",
        description="Busca un patrón en ficheros, o en lo que le llegue por una tubería.",
        epilog="Sin ficheros, lee de la entrada estándar. Devuelve 0 si encuentra algo y 1 si no.",
    )
    analizador.add_argument("patron", help="expresión regular que hay que buscar")
    analizador.add_argument(
        "ficheros",
        nargs="*",
        type=Path,
        help="ficheros o carpetas donde buscar (si no pones ninguno, lee de la entrada estándar)",
    )
    analizador.add_argument("-i", "--ignorar-mayusculas", action="store_true",
                            help="no distinguir mayúsculas de minúsculas")
    analizador.add_argument("-n", "--numero-de-linea", action="store_true",
                            help="mostrar el número de línea")
    analizador.add_argument("-r", "--recursivo", action="store_true",
                            help="bajar por las subcarpetas de las carpetas indicadas")
    analizador.add_argument("-c", "--contar", action="store_true",
                            help="mostrar solo cuántas líneas encajan")
    analizador.add_argument("-v", "--invertir", action="store_true",
                            help="mostrar las líneas que NO encajan")
    analizador.add_argument("--color", choices=["auto", "siempre", "nunca"], default="auto",
                            help="cuándo colorear las coincidencias (por defecto: auto)")
    return analizador


def quiere_color(modo: str) -> bool:
        if modo == "nunca":
                return False
    if modo == "siempre":
                return True
    if os.environ.get("NO_COLOR"):
                return False
    return sys.stdout.isatty()


def resaltar(coincidencia: Coincidencia, color: bool) -> str:
        """Devuelve la línea con los tramos encontrados envueltos en rojo."""
    if not color or not coincidencia.tramos:
                return coincidencia.linea

    trozos = []
    final_anterior = 0
    for inicio, fin in coincidencia.tramos:
                trozos.append(coincidencia.linea[final_anterior:inicio])
        trozos.append(ROJO + coincidencia.linea[inicio:fin] + NORMAL)
        final_anterior = fin
    trozos.append(coincidencia.linea[final_anterior:])
    return "".join(trozos)


def pintar_coincidencia(coincidencia: Coincidencia, opciones, varios: bool, color: bool) -> None:
        """Imprime una línea al estilo de grep: fichero, número y texto."""
    partes = []
    if varios:
                nombre = coincidencia.origen
        partes.append(f"{MAGENTA}{nombre}{NORMAL}" if color else nombre)
    if opciones.numero_de_linea:
                numero = str(coincidencia.numero)
        partes.append(f"{VERDE}{numero}{NORMAL}" if color else numero)
    partes.append(resaltar(coincidencia, color))
    separador = f"{CIAN}:{NORMAL}" if color else ":"
    print(separador.join(partes))


def main(argumentos: list[str] | None = None) -> int:
        opciones = construir_analizador().parse_args(argumentos)
    color = quiere_color(opciones.color)

    try:
                expresion = compilar(opciones.patron, opciones.ignorar_mayusculas)
    except ValueError as error:
                print(f"buscador: {error}", file=sys.stderr)
        return 2

    ficheros, avisos = expandir(opciones.ficheros, opciones.recursivo)
    for aviso in avisos:
                print(f"buscador: {aviso}", file=sys.stderr)

    hubo_errores = bool(avisos)
    encontrado = False

    if not opciones.ficheros:
                fuentes = [(ENTRADA_ESTANDAR, sys.stdin)]
        varios = False
    else:
                fuentes = []
        varios = len(ficheros) > 1
        for fichero in ficheros:
                        try:
                                if es_binario(fichero):
                                        print(f"buscador: {fichero}: fichero binario, me lo salto", file=sys.stderr)
                    continue
                fuentes.append((str(fichero), leer_lineas(fichero)))
            except OSError as error:
                                print(f"buscador: {fichero}: {error.strerror}", file=sys.stderr)
                hubo_errores = True

    for origen, lineas in fuentes:
                cuantas = 0
        try:
                        for coincidencia in buscar_en_lineas(expresion, lineas, origen, opciones.invertir):
                                encontrado = True
                cuantas += 1
                if not opciones.contar:
                                        pintar_coincidencia(coincidencia, opciones, varios, color)
        except BrokenPipeError:
            # Es un OSError, así que hay que dejarlo pasar antes del except de abajo.
                        raise
        except OSError as error:
                        print(f"buscador: {origen}: {error.strerror}", file=sys.stderr)
            hubo_errores = True
            continue
        if opciones.contar:
                        etiqueta = f"{MAGENTA}{origen}{NORMAL}:" if color else f"{origen}:"
            print(f"{etiqueta}{cuantas}" if varios else cuantas)

    if hubo_errores and not encontrado:
                return 2
    return 0 if encontrado else 1


def ejecutar() -> int:
        """Envoltorio que aguanta las tuberías cerradas y el Ctrl+C."""
    try:
                codigo = main()
        sys.stdout.flush()
    except KeyboardInterrupt:
                print("\nbuscador: interrumpido", file=sys.stderr)
        return 130
    except BrokenPipeError:
        # Quien leía se ha ido. Se desvía la salida al vacío para que Python
        # no vuelva a intentar vaciarla al cerrar y se queje.
                os.dup2(os.open(os.devnull, os.O_WRONLY), sys.stdout.fileno())
        return 141
    return codigo


if __name__ == "__main__":
        sys.exit(ejecutar())

[project]
name = "buscador"
version = "1.0.0"
description = "Un buscador de texto en ficheros, al estilo de grep"
requires-python = ">=3.11"

[project.scripts]
buscar = "buscador.cli:ejecutar"

[build-system]
requires = ["setuptools>=68"]
build-backend = "setuptools.build_meta"

tienda/
    datos.bin
    registro.log
    docs/
        leeme.md
    src/
        clientes.py
        tienda.py

buscar --help

buscar "TODO" tienda/src/tienda.py

buscar -rn "TODO" tienda

buscar -rc "TODO" tienda 2> /dev/null

buscar -in "todo" tienda/docs/leeme.md

buscar -vn "INFO" tienda/registro.log

buscar -n "\d{2}:\d{2}:\d{2} ERROR" tienda/registro.log

buscar "TODO" tienda
echo $?

buscar "(abierto" tienda/registro.log
echo $?

buscar -r "Bizum" tienda 2> /dev/null
echo $?

buscar -r "^def |^class " tienda/src -n

buscar "INFO|ERROR|WARNING" tienda/registro.log | cut -d' ' -f3 | sort | uniq -c | sort -rn

ls tienda | buscar "\.log$"

buscar -rn "def " tienda 2> /dev/null | buscar "producto"