totelegram 0.9.10__py3-none-any.whl

totelegram/__init__.py

@@ -0,0 +1,13 @@
+"""
+totelegram nació como un gestor de archivos para administrar la memoria digital en Telegram, construido sobre una premisa central:
+
+    La propiedad no es un registro, es una posibilidad.
+
+No funciona solo como un uploader, sino como un índice de disponibilidad.
+En este modelo, los registros son globales, porque la propiedad no se define por la cuenta que realiza la acción, sino por el acceso efectivo a la información.
+
+Ver: docs/VISION.md
+"""
+
+__version__ = "0.9.10"
+CURRENT_DB_VERSION = 1

totelegram/cli/__main__.py

@@ -0,0 +1,108 @@
+import logging
+import re
+import sys
+from datetime import datetime
+from typing import Optional
+
+import typer
+
+from totelegram.cli.commands import backup, config, profile
+from totelegram.schemas import CLIState
+from totelegram.utils import APP_NAME, get_user_config_dir
+
+logging.getLogger("dotenv").setLevel(logging.CRITICAL)
+
+
+from totelegram import __version__
+from totelegram.cli.commands import send
+from totelegram.cli.ui import console
+from totelegram.identity import SettingsManager
+from totelegram.logging_config import setup_logging
+
+logger = logging.getLogger(__name__)
+COMMANDS_IGNORING_USE = ["profile", "version"]
+
+app = typer.Typer(
+    help="Herramienta para subir archivos a Telegram sin límite de tamaño.",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+app.add_typer(config.app, name="config")
+app.add_typer(profile.app, name="profile")
+app.command(name="send")(send.send_files)
+app.command(name="backup")(backup.backup_folders)
+
+
+def version_callback(value: bool):
+    if value:
+        console.print(f"toTelegram [bold cyan]v{__version__}[/bold cyan]")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    use: Optional[str] = typer.Option(
+        None,
+        "--use",
+        "-u",
+        help="Perfil a utilizar para esta operación (ignora el perfil activo).",
+        is_eager=True,
+    ),
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-V",
+        callback=version_callback,
+        is_eager=True,
+        help="Muestra la versión de la aplicación.",
+    ),
+    debug: bool = typer.Option(
+        False,
+        "--debug",
+        help="Activa el modo debug (DB independiente y logs detallados).",
+    ),
+):
+    """
+    Se ejecuta antes que cualquier comando.
+    """
+    worktable = get_user_config_dir(APP_NAME)
+    config_manager = SettingsManager(worktable)
+
+    cmd_name = ctx.invoked_subcommand or "sys"
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    log_dir = worktable / "logs"
+    log_path = log_dir / f"{timestamp}_{cmd_name}.log"
+
+    setup_logging(log_path, debug)
+
+    # main resuelve la intencion del nombre del perfil a usar; las validaciones dependen del contexto del comando.
+    profile_name = use or config_manager.get_active_profile_name()
+    ctx.obj = CLIState(
+        manager=config_manager, profile_name=profile_name, is_debug=debug
+    )
+    logger.debug(f"--- Nueva Ejecución: {sys.argv} ---")
+
+
+def run_script():
+    # Buscamos argumentos que sean exactamente números negativos (IDs de Telegram)
+    # "-1001309586477" -> "ID:-1001309586477"
+    regex = re.compile(r"^-\d+$")
+    if len(sys.argv) > 1:
+        sys.argv = [f"ID:{arg}" if regex.match(arg) else arg for arg in sys.argv]
+
+    try:
+        from totelegram.cli.__main__ import app
+
+        app()
+    except Exception as e:
+        from totelegram.cli.ui import UI
+
+        UI.error(str(e))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    app()

totelegram/cli/commands/backup.py

@@ -0,0 +1,107 @@
+import time
+from pathlib import Path
+from typing import List
+
+import typer
+
+from totelegram.cli.commands.config import _get_config_tools
+from totelegram.cli.logic import (
+    InventoryEngine,
+    get_or_create_job,
+    prepare_upload_context,
+)
+from totelegram.cli.ui import UI, DisplayUpload, console
+from totelegram.schemas import VALUE_NOT_SET, CLIState, Commands
+from totelegram.uploader import UploadService
+
+
+def backup_folders(
+    ctx: typer.Context,
+    paths: List[Path] = typer.Argument(
+        ...,
+        exists=True,
+        help="Lista de carpetas a archivar",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Fuerza ignorando el estado del archivo en el sistema",
+    ),
+):
+    """
+    Convierte una carpeta en una Cinta de Datos (TAR) y la distribuye en volúmenes.
+    """
+    state: CLIState = ctx.obj
+    profile_name, _ = _get_config_tools(ctx)
+
+    settings = state.manager.get_settings(profile_name)
+
+    if settings.chat_id == VALUE_NOT_SET:
+        UI.error("El chat destino no está configurado.")
+        commands = [
+            f"{Commands.CONFIG_SET} chat_id <ID>",
+            f"{Commands.CONFIG_SEARCH} <QUERY>",
+        ]
+        UI.tip("puedes configurarlo usando uno de estos comandos:", commands)
+        raise typer.Exit(1)
+
+    if force:
+        UI.warn("Forzando la subida de carpetas sin comprobar el estado del archivo.")
+
+    # --- Scaneo y Informe ---
+    with console.status("[dim]Escaneando directorios...[/]"):
+        scan_report = InventoryEngine(settings, force).scan_backup_inventory(paths)
+
+    DisplayUpload.show_skip_report(scan_report, "carpeta", force_verbose=False)
+
+    candidates = scan_report.found
+    if not candidates:
+        UI.warn("No se encontraron carpetas válidas para procesar.")
+        UI.print(
+            "[dim]Asegúrate de que las rutas existan y no estén excluidas por tus patrones de configuración.[/]"
+        )
+        raise typer.Exit(0)
+
+    # --- Subida de lo encontrado ---
+
+    UI.separator()
+
+    with state.scope() as (client, db):
+        u_ctx = prepare_upload_context(state, client, db, settings)
+        uploader = UploadService(u_ctx)
+
+        from totelegram.telegram.patches import get_patch_status
+
+        status = get_patch_status()
+        if status["applied"]:
+            UI.success("Core Engine: Pyrogram Runtime Patches [ACTIVE]")
+        else:
+            UI.error("Core Engine: Pyrogram Runtime Patches [FAILED]")
+
+        user = u_ctx.owner.first_name or u_ctx.owner.username
+        chat_n = u_ctx.tg_chat.title or u_ctx.tg_chat.username
+        UI.success(f"Conectado como [bold]{user}[/]")
+        UI.info(f"Destino: [bold cyan]{chat_n}[/] [dim](ID: {u_ctx.tg_chat.id})[/]")
+        UI.print("", indent=False)
+
+        for index, folder in enumerate(candidates, 1):
+            is_last = index == len(candidates)
+            DisplayUpload.show_backup_header(folder.name, index, len(candidates))
+
+            with UI.loading("Analizando contenido..."):
+                report_internal = InventoryEngine(settings).scan_backup_internal(folder)
+                time.sleep(0.3)
+
+            DisplayUpload.show_internal_scan_result(report_internal)
+
+            job = get_or_create_job(folder, u_ctx, force, is_last)
+            if job is None:
+                continue
+
+            if uploader.process_job(job, folder):
+                UI.success(f"Carpeta [bold]{folder.name}[/] procesada exitosamente.")
+
+        if scan_report.skipped_by_integrity:
+            UI.separator()
+            DisplayUpload.show_integrity_advice(scan_report)

totelegram/cli/commands/config.py

@@ -0,0 +1,343 @@
+import json
+import time
+from functools import wraps
+from typing import TYPE_CHECKING, List, Literal, Tuple, cast
+
+import typer
+
+from totelegram.cli.ui import UI, DisplayConfig, DisplayGeneric, DisplayProfile
+from totelegram.identity import ConfigService
+from totelegram.schemas import VALUE_NOT_SET, CLIState, Commands
+from totelegram.telegram.access import ChatAccessService
+from totelegram.telegram.client import TelegramSession
+from totelegram.telegram.search import ChatSearchService
+from totelegram.utils import (
+    is_direct_identifier,
+    is_potential_username,
+    is_suspected_glob_expansion,
+    normalize_chat_id,
+    validate_item,
+)
+
+if TYPE_CHECKING:
+    from pyrogram import Client  # type: ignore
+    from pyrogram.types import User
+
+app = typer.Typer(help="Configuración del perfil actual.")
+
+
+def handle_config_errors(func):
+    @wraps(func)
+    def wrapper(ctx: typer.Context, *args, **kwargs):
+        try:
+            return func(ctx, *args, **kwargs)
+        except ValueError as e:
+            UI.error(str(e))
+            raise typer.Exit(1)
+
+    return wrapper
+
+
+def _get_config_tools(ctx: typer.Context) -> Tuple[str, ConfigService]:
+    """Extrae las herramientas necesarias para cualquier comando de configuracion que requieran un perfil."""
+    state: CLIState = ctx.obj
+    settings_name = cast(str, state.manager.resolve_profile_name(state.profile_name))
+    DisplayProfile.announce_profile_used(settings_name)
+    service = ConfigService(state.manager, state.is_debug)
+    return settings_name, service
+
+
+@handle_config_errors
+def _command_modify_list(
+    settings_name: str,
+    service: ConfigService,
+    key: str,
+    values: List[str],
+    action: Literal["add", "remove"],
+):
+    updates = service.prepare_updates([key, values])  # type: ignore
+    verb = "agregar" if action == "add" else "eliminar"
+
+    if is_suspected_glob_expansion(values):
+        if not DisplayConfig.confirm_expanded_pattern(verb, key, values):
+            UI.info("Operacion cancelada.")
+            raise typer.Exit()
+
+    for k, val in updates.items():
+        changed, final_val = service.apply_update(settings_name, k, val, action=action)
+        if changed:
+            UI.success(
+                f"Configuracion [bold]{k}[/] actualizada: {json.dumps(final_val)}"
+            )
+        else:
+            UI.info(f"Configuracion [bold]{k}[/] no sufrio cambios.")
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context):
+    """Muestra la configuración actual si no se pasa un subcomando."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    state: CLIState = ctx.obj
+    manager = state.manager
+    profile_name = manager.resolve_profile_name(state.profile_name, strict=False)
+    if profile_name:
+        settings = manager.get_settings(profile_name)
+        DisplayConfig.show_config_table(profile_name, manager, state.is_debug, settings)
+
+        commands = [
+            f"{Commands.CONFIG_SET} <KEY> <VALUE>",
+            f"{Commands.CONFIG_EDIT_LIST} <KEY> <VALUE1>",
+        ]
+        UI.tip(
+            "Puedes modificar cualquier configuración usando los siguientes comandos:",
+            commands=commands,
+            spacing="top",
+        )
+    else:
+        UI.warn("No hay un perfil activo para mostrar valores de configuracion.")
+
+
+@app.command(name="set")
+@handle_config_errors
+def set_configs(
+    ctx: typer.Context,
+    args: List[str] = typer.Argument(
+        None, help="Pares de CLAVE VALOR (ej: chat_id 12345 upload_limit_rate_kbps 500)"
+    ),
+):
+    """
+    Modifica una o varias configuraciones al mismo tiempo.
+    Uso: totelegram config set chat_id 999999 upload_limit_rate_kbps 1000
+
+    NOTA:
+    Evitar implementar lógica de red o resolución de Telegram (como 'config resolve')
+    dentro de este comando por las siguientes razones:
+
+    1. INDEPENDENCIA: 'config set' debe funcionar 100% offline. Su única responsabilidad
+       es la persistencia en disco (.env). No debe depender de una sesión de Pyrogram.
+    2. ATOMICIDAD: Este comando puede recibir múltiples pares clave-valor.
+       Añadir banderas como '--verify' o '--resolve' crearía ambigüedad sobre qué
+       campo se está verificando o resolviendo.
+    3. PREDICTIBILIDAD: Para automatización, 'set' debe ser instantáneo.
+       Cualquier validación de red debe delegarse al comando 'config check' o
+       'config resolve'.
+    """
+
+    settings_name, service = _get_config_tools(ctx)
+    updates = service.prepare_updates(args)
+    for key, val in updates.items():
+        changed, final_val = service.apply_update(settings_name, key, val, action="set")
+        if changed:
+            UI.success(
+                f"Configuracion [bold]{key}[/] actualizada con [bold]{final_val}[/]."
+            )
+        else:
+            UI.info(f"Configuracion [bold]{key}[/] ya tiene ese valor.")
+
+
+@app.command("unset")
+@handle_config_errors
+def unset_config(
+    ctx: typer.Context,
+    key: str = typer.Argument(..., help="Clave a restaurar a su valor por defecto"),
+):
+    """Quita una configuración personalizada para usar el valor por defecto."""
+
+    settings_name, service = _get_config_tools(ctx)
+    default_val = service.restore_default(settings_name, key)
+    UI.success(f"Restaurado [bold]{key}[/] al valor por defecto: {default_val}")
+
+
+@app.command("add")
+def add_config(
+    ctx: typer.Context,
+    key: str,
+    values: List[str] = typer.Argument(
+        ..., min=1, callback=lambda x: [validate_item(i) for i in x]
+    ),
+):
+    """Agrega valores a una lista (ej. exclude_files)."""
+    settings_name, service = _get_config_tools(ctx)
+    _command_modify_list(settings_name, service, key, values, "add")
+
+
+@app.command("remove")
+def remove_config(
+    ctx: typer.Context,
+    key: str,
+    values: List[str] = typer.Argument(
+        ..., min=1, callback=lambda x: [validate_item(i) for i in x]
+    ),
+):
+    """Quita valores a una lista (ej. exclude_files)."""
+    settings_name, service = _get_config_tools(ctx)
+    _command_modify_list(settings_name, service, key, values, "remove")
+
+
+@app.command("check")
+@handle_config_errors
+def check_config(ctx: typer.Context):
+    """Verifica que el perfil actual esté listo para subir archivos."""
+    state: CLIState = ctx.obj
+    manager = state.manager
+
+    profile_name = manager.resolve_profile_name(state.profile_name, strict=False)
+    if not profile_name:
+        UI.error("No hay un perfil activo o el perfil especificado no existe.")
+        raise typer.Exit(1)
+
+    with UI.loading(
+        f"Comprobando integridad local del perfil: [bold]{profile_name}[/]"
+    ):
+        time.sleep(0.2)
+        profile = manager.get_profile(profile_name)
+
+        if not profile:
+            UI.error(f"Perfil '{profile_name}' no encontrado.")
+            raise typer.Exit(1)
+
+        if not profile.is_trinity:
+            UI.error(f"El perfil '{profile_name}' está incompleto.")
+            if not profile.has_env:
+                UI.info("Falta el archivo de configuración (.env).")
+            if not profile.has_session:
+                UI.info("Falta el archivo de sesión de Telegram (.session).")
+
+            command = f"{Commands.PROFILE_CREATE} --force"
+            UI.tip(
+                f"Créalo de nuevo usando el siguiente comando:",
+                commands=command,
+                spacing="top",
+            )
+            raise typer.Exit(1)
+
+    settings = manager.get_settings(profile_name)
+
+    if settings.chat_id == VALUE_NOT_SET:
+        UI.warn("El destino (chat_id) no está configurado.")
+        UI.tip(
+            "Configura el destino usando uno de estos comandos:",
+            commands=[
+                f"{Commands.CONFIG_SET} chat_id <ID>",
+                f"{Commands.CONFIG_SEARCH} <NOMBRE>",
+            ],
+        )
+        raise typer.Exit(code=1)
+
+    with TelegramSession.from_profile(profile_name, manager) as client:
+        with UI.loading("Verificando conexión y permisos en Telegram..."):
+            validator = ChatAccessService(client)
+            access_report = validator.verify_access(settings.chat_id)
+
+        if not access_report.is_ready:
+            UI.warn("No tienes permisos de escritura en el chat destino.")
+            UI.info(f"Motivo: {access_report.reason}")
+            if access_report.hint:
+                UI.info(access_report.hint)
+            raise typer.Exit(code=1)
+
+        UI.success(f"Perfil '{profile_name}' verificado y listo para operar.")
+        if access_report.chat:
+            UI.info(
+                f"Destino confirmado: [bold]{access_report.chat.title}[/] "
+                f"[dim](ID: {access_report.chat.id})[/dim]"
+            )
+
+
+@app.command("search")
+def search_config(
+    ctx: typer.Context,
+    query: str = typer.Argument(..., help="Nombre, @username o ID."),
+    contains: bool = typer.Option(False, "--contains", "-c"),
+    depth: int = typer.Option(100, "--depth", "-d"),
+    apply: bool = typer.Option(False, "--apply", "-a"),
+):
+    """Busca y establece el chat de destino."""
+    state: CLIState = ctx.obj
+    manager = state.manager
+    profile_name = cast(str, manager.resolve_profile_name(state.profile_name))
+
+    DisplayProfile.announce_profile_used(profile_name)
+
+    # Obtener el ID del chat destino
+    with TelegramSession.from_profile(profile_name, manager) as client:
+        chat_access = ChatAccessService(client)
+        chat_searcher = ChatSearchService(client)
+
+        me = cast("User", client.get_me())
+        UI.info(f"Telegram Session: [bold]{me.username or me.first_name}[/]")
+
+        chat_id = None
+
+        if is_direct_identifier(query):
+            chat_id = normalize_chat_id(query)
+        else:
+            is_exact = not contains
+            search_desc = (
+                f"llamado exactamente '[bold]{query}[/]'"
+                if is_exact
+                else f"que contenga '[bold]{query}[/]' (sin distinción de mayúsculas y minúsculas)"
+            )
+            UI.info(f"Buscando chat {search_desc}")
+            with UI.loading("Explorando los chats recientes..."):
+                result = chat_searcher.search_by_name(query, depth, is_exact)
+
+            if result.is_resolved and result.winner:
+                chat_id = result.winner.id
+
+            elif result.is_ambiguous:
+                conflicts = len(result.conflicts)
+                UI.warn(f"Ambigüedad: Hay {conflicts} chats con ese nombre.")
+                DisplayGeneric.show_chat_table(
+                    result.conflicts, "Conflictos Encontrados"
+                )
+                UI.info("Usa el ID exacto: [bold]config set chat_id <ID>[/]")
+                raise typer.Exit(1)
+
+            elif result.needs_help:
+
+                DisplayGeneric.show_chat_table(
+                    result.suggestions, "Quizás quisiste decir:"
+                )
+                UI.info(
+                    "Tip: Si no encuentras lo que buscas, intenta aumentar la profundidad con --depth."
+                )
+                raise typer.Exit(1)
+            else:
+                UI.error(
+                    f"No se encontró ningún chat relacionado con '{result.query}' en los primeros {result.search_depth} chats recientes."
+                )
+                if is_potential_username(result.query):
+                    UI.tip(
+                        message="Puedes hacer una busqueda más profunda con [bold]--depth[/] o especificar el chat directamente con @username o t.me/username.",
+                        commands=[
+                            f"{Commands.CONFIG_SEARCH} {result.query} --depth 200",
+                            f"{Commands.CONFIG_SEARCH} @{result.query}",
+                        ],
+                    )
+
+                raise typer.Exit(1)
+
+        # Verificación de permisos
+        with UI.loading("Verificando permisos..."):
+            report = chat_access.verify_access(chat_id)
+
+        if not (report.is_ready and report.chat):
+            UI.warn("No tienes permisos de escritura en el chat.")
+            UI.warn("Corrige los permisos antes de intentar cualquier subida.")
+            UI.warn("Configuración 'chat_id' no actualizada.")
+            raise typer.Exit(1)
+
+        # Si llegamos aquí, todo salió bien
+        UI.success(
+            f"¡Encontrado! [bold]{report.chat.title}[/] [dim](ID: {report.chat.id})[/]"
+        )
+        UI.success("Tienes permisos de escritura.")
+
+        if apply:
+            manager.set_setting(profile_name, "chat_id", report.chat.id)
+            UI.success("Configuración 'chat_id' actualizada.")
+
+        raise typer.Exit(0)