totelegram 0.9.10__tar.gz

totelegram-0.9.10/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: totelegram
+Version: 0.9.10
+Summary: toTelegram sube archivos a telegram sin importar el tamaño.
+Home-page: https://github.com/CalumRakk/toTelegram
+Author: Leo
+Requires-Python: >=3.10.0
+Description-Content-Type: text/markdown
+Requires-Dist: filetype==1.2.0
+Requires-Dist: peewee>=3.17.9
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pydantic-settings>=2.10.1
+Requires-Dist: pyrogram==2.0.106
+Requires-Dist: TgCrypto>=1.2.5
+Requires-Dist: typer>=0.21.1
+Requires-Dist: filelock>=3.20.3
+Requires-Dist: tartape>=2.2.0
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+## toTelegram
+
+Este proyecto es una herramienta de CLI en Python diseñada para subir archivos a Telegram sin preocuparse por los límites de tamaño (2GB/4GB). La idea no es solo tener un uploader, sino un gestor de disponibilidad que entiende qué archivos ya están en la "nube" de tus chats para evitar subidas redundantes.
+
+
+### ¿De qué va esto?
+A diferencia de un uploader simple, `toTelegram` usa una base de datos local (SQLite) para trackear los archivos por su MD5. Si intentas subir algo que el sistema ya detectó en otro chat al que tienes acceso, intentará hacer un forward (mirror) o reconstruir el archivo desde piezas sueltas (puzzle) en lugar de gastar ancho de banda volviendo a subir los bytes.
+
+
+---
+
+### Cómo probarlo
+
+Puedes instalar el paquete directamente desde el repositorio sin necesidad de clonarlo manualmente:
+
+
+**1. Instala usando pip desde GitHub:**
+
+```
+pip install totelegram
+```
+
+**2. Crea un perfil:**
+
+Necesitas tu **API_ID** y **API_HASH** de [Telegram](https://my.telegram.org/).
+
+```
+totelegram profile create
+```
+
+**3. Configura un chat de destino**
+
+```
+totelegram config search "Mi Nube Privada" --apply
+```
+
+**4. Envía archivos o carpetas:**
+
+```
+# Enviar archivos individuales
+totelegram send video.mp4
+
+# Archivar una carpeta completa como un backup estructurado
+totelegram backup ./mis_fotos
+```

totelegram-0.9.10/README.md

@@ -0,0 +1,45 @@
+## toTelegram
+
+Este proyecto es una herramienta de CLI en Python diseñada para subir archivos a Telegram sin preocuparse por los límites de tamaño (2GB/4GB). La idea no es solo tener un uploader, sino un gestor de disponibilidad que entiende qué archivos ya están en la "nube" de tus chats para evitar subidas redundantes.
+
+
+### ¿De qué va esto?
+A diferencia de un uploader simple, `toTelegram` usa una base de datos local (SQLite) para trackear los archivos por su MD5. Si intentas subir algo que el sistema ya detectó en otro chat al que tienes acceso, intentará hacer un forward (mirror) o reconstruir el archivo desde piezas sueltas (puzzle) en lugar de gastar ancho de banda volviendo a subir los bytes.
+
+
+---
+
+### Cómo probarlo
+
+Puedes instalar el paquete directamente desde el repositorio sin necesidad de clonarlo manualmente:
+
+
+**1. Instala usando pip desde GitHub:**
+
+```
+pip install totelegram
+```
+
+**2. Crea un perfil:**
+
+Necesitas tu **API_ID** y **API_HASH** de [Telegram](https://my.telegram.org/).
+
+```
+totelegram profile create
+```
+
+**3. Configura un chat de destino**
+
+```
+totelegram config search "Mi Nube Privada" --apply
+```
+
+**4. Envía archivos o carpetas:**
+
+```
+# Enviar archivos individuales
+totelegram send video.mp4
+
+# Archivar una carpeta completa como un backup estructurado
+totelegram backup ./mis_fotos
+```

totelegram-0.9.10/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

totelegram-0.9.10/setup.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+
+from setuptools import find_packages, setup
+
+from totelegram import __version__
+
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="totelegram",
+    version=__version__,
+    description="toTelegram sube archivos a telegram sin importar el tamaño.",
+    author="Leo",
+    url="https://github.com/CalumRakk/toTelegram",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    install_requires=[
+        "filetype==1.2.0",
+        "peewee>=3.17.9",
+        "pydantic>=2.11.7",
+        "pydantic-settings>=2.10.1",
+        "pyrogram==2.0.106",
+        "TgCrypto>=1.2.5",
+        "typer>=0.21.1",
+        "filelock>=3.20.3",
+        "tartape>=2.2.0",
+    ],
+    packages=find_packages(),
+    entry_points={
+        "console_scripts": ["totelegram=totelegram.cli.__main__:run_script"],
+    },
+    python_requires=">=3.10.0",
+)

totelegram-0.9.10/tests/test_adr.py

@@ -0,0 +1,42 @@
+import unittest
+
+from totelegram.identity import Settings
+from totelegram.schemas import AccessLevel
+
+
+class TestArchitectureRules(unittest.TestCase):
+    def test_adr_001_immutable_profile_credentials(self):
+        """
+        ADR-001: Perfil Inmutable.
+
+        Las credenciales base (API_ID, API_HASH) y el nombre del perfil
+        DEBEN ser inmutables para garantizar la integridad de la sesión de Pyrogram.
+
+        Si este test falla, lee: docs/adr/001-perfil-inmutable.md
+        """
+        required_internal_fields = {"API_ID", "API_HASH", "PROFILE_NAME"}
+
+        api_id = Settings.get_info("API_ID")
+        api_hash = Settings.get_info("API_HASH")
+        profile_name = Settings.get_info("PROFILE_NAME")
+
+        error_message = (
+            f"\n\n[VIOLACIÓN DE ARQUITECTURA - ADR-001]\n"
+            f"Se intentó hacer editables campos críticos: {required_internal_fields}\n"
+            f"Estos campos deben permanecer en Settings.INTERNAL_FIELDS.\n"
+            f"Consulta 'docs/adr/001-perfil-inmutable.md' para más detalles.\n"
+        )
+
+        self.assertTrue(
+            api_id is not None and api_id.level == AccessLevel.DEBUG_READONLY,
+            error_message,
+        )
+        self.assertTrue(
+            api_hash is not None and api_hash.level == AccessLevel.DEBUG_READONLY,
+            error_message,
+        )
+        self.assertTrue(
+            profile_name is not None
+            and profile_name.level == AccessLevel.DEBUG_READONLY,
+            error_message,
+        )

totelegram-0.9.10/tests/test_chunking.py

@@ -0,0 +1,21 @@
+import unittest
+
+from totelegram.packaging import chunk_ranges
+
+
+class TestChunkingMath(unittest.TestCase):
+    def test_chunk_ranges_exact_division(self):
+        """Caso: 10MB archivo, 5MB chunk -> 2 partes exactas"""
+        file_size = 10 * 1024 * 1024
+        chunk_size = 5 * 1024 * 1024
+        ranges = chunk_ranges(file_size, chunk_size)
+
+        self.assertEqual(len(ranges), 2)
+        self.assertEqual(ranges[0], (0, 5242880))
+        self.assertEqual(ranges[1], (5242880, 10485760))
+
+    def test_chunk_ranges_remainder(self):
+        """Caso: 10 bytes archivo, 3 bytes chunk -> 4 partes (3, 3, 3, 1)"""
+        ranges = chunk_ranges(10, 3)
+        expected = [(0, 3), (3, 6), (6, 9), (9, 10)]
+        self.assertEqual(ranges, expected)

totelegram-0.9.10/tests/test_command_config.py

@@ -0,0 +1,116 @@
+import unittest
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from typer.testing import CliRunner
+
+from totelegram.cli.commands.config import app
+from totelegram.identity import SettingsManager
+from totelegram.schemas import CLIState
+
+runner = CliRunner()
+
+
+class TestCliConfig(unittest.TestCase):
+    def setUp(self):
+        self.tmp_dir = TemporaryDirectory()
+        self.config_path = Path(self.tmp_dir.name)
+
+        self.profile_name = "test_user"
+        manager = SettingsManager(self.config_path)
+        manager._write_all_settings(
+            "test_user",
+            {
+                "profile_name": self.profile_name,
+                "chat_id": "123456789",
+                "upload_limit_rate_kbps": "1000",
+                "api_id": "123456789",
+                "api_hash": "123456789",
+            },
+        )
+
+        self.state = CLIState(manager=manager, profile_name=self.profile_name)
+        self.manager = manager
+
+    def tearDown(self):
+        try:
+            self.tmp_dir.cleanup()
+        except Exception:
+            pass
+
+    def test_config_display_table(self):
+        """Verificar que el comando base muestra la tabla de configuración."""
+        result = runner.invoke(app, obj=self.state)
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Configuración", result.stdout)
+        self.assertIn("test_user", result.stdout)
+        self.assertIn("chat_id", result.stdout)
+
+    def test_set_valid_value(self):
+        """Probar que un cambio válido se persiste correctamente."""
+
+        result = runner.invoke(
+            app,
+            ["set", "upload_limit_rate_kbps", "500"],
+            obj=self.state,
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        settings = self.manager.get_settings(self.profile_name)
+        current_value = getattr(settings, "upload_limit_rate_kbps", None)
+        self.assertEqual(current_value, 500)
+
+    def test_set_invalid_type_safety(self):
+        """
+        Si meto basura en un campo numérico,
+        Pydantic debe saltar y el comando debe fallar.
+        """
+
+        result = runner.invoke(
+            app, ["set", "MAX_FILESIZE_BYTES", "no_soy_un_numero"], obj=self.state
+        )
+
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("debe ser de tipo", result.stdout)
+
+        # El valor original no debería haber cambiado
+        settings = self.manager.get_settings(self.profile_name)
+        current_value = getattr(settings, "MAX_FILESIZE_BYTES", None)
+        self.assertNotEqual(current_value, "no_soy_un_numero")
+
+    def test_set_internal_field_protection(self):
+        """
+        ADR-001: API_ID y otros campos internos son inmutables tras la creación.
+        """
+        result = runner.invoke(app, ["set", "api_id", "99999"], obj=self.state)
+
+        self.assertIn("Solo Lectura", result.stdout.replace("\n", ""))
+
+    def test_list_add(self):
+        """Proba añadir elementos de una lista."""
+        # Añadir (confirmando con 'y')
+        runner.invoke(app, ["add", "exclude_files", "*.tmp", "*.bak"], obj=self.state)
+
+        settings = self.manager.get_settings(self.profile_name)
+        self.assertIn("*.tmp", settings.exclude_files)
+        self.assertIn("*.bak", settings.exclude_files)
+
+    def test_list_add_remove_flow(self):
+        """Probar el flujo de añadir y quitar elementos de una lista (exclude_files)."""
+        # Añadir (confirmando con 'y')
+        runner.invoke(
+            app, ["add", "exclude_files", "*.tmp", "*.bak"], input="y\n", obj=self.state
+        )
+
+        settings = self.manager.get_settings(self.profile_name)
+        self.assertIn("*.tmp", settings.exclude_files)  # type: ignore
+        self.assertIn("*.bak", settings.exclude_files)  # type: ignore
+
+        # Quitar uno
+        runner.invoke(
+            app, ["remove", "exclude_files", "*.tmp"], input="y\n", obj=self.state
+        )
+
+        settings = self.manager.get_settings(self.profile_name)
+        self.assertNotIn("*.tmp", settings.exclude_files)  # type: ignore
+        self.assertIn("*.bak", settings.exclude_files)  # type: ignore

totelegram-0.9.10/tests/test_command_profile.py

@@ -0,0 +1,134 @@
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+from totelegram.cli.commands.profile import app
+from totelegram.identity import SettingsManager
+from totelegram.schemas import AccessReport, AccessStatus, ChatMatch, CLIState
+
+
+class TestCliProfile(unittest.TestCase):
+    def setUp(self):
+        """Configuración inicial antes de cada test."""
+        self.runner = CliRunner()
+        self.test_dir = tempfile.mkdtemp()
+        self.workdir = Path(self.test_dir)
+
+        self.manager = SettingsManager(self.workdir)
+        self.manager.profiles_dir.mkdir(parents=True, exist_ok=True)
+        self.manager.inventories_dir.mkdir(parents=True, exist_ok=True)
+
+        self.state = CLIState(manager=self.manager, profile_name=None, is_debug=False)
+
+    def tearDown(self):
+        """Limpieza después de cada test."""
+        shutil.rmtree(self.test_dir)
+
+    def test_list_profiles_empty(self):
+        """Debe informar que no hay perfiles si la carpeta está vacía."""
+        result = self.runner.invoke(app, ["list"], obj=self.state)
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("No se encontraron perfiles", result.stdout)
+
+    @patch("totelegram.telegram.auth.AuthLogic.initialize_profile")
+    @patch("totelegram.telegram.client.TelegramSession.from_profile")
+    @patch("totelegram.telegram.access.ChatAccessService.verify_access")
+    def test_create_profile_success_with_chat_id(
+        self, mock_verify, mock_session, mock_auth
+    ):
+        """Prueba la creación de un perfil con chat_id directo (sin wizard)."""
+
+        profile_name = "test_profile"
+
+        # Simulamos que el acceso al chat es válido
+        mock_verify.return_value = AccessReport(
+            status=AccessStatus.READY,
+            chat=ChatMatch(id=-100123456, title="Destino Test", type="channel"),
+            reason="Acceso verificado",
+        )
+
+        # Ejecutamos el comando pasando argumentos para evitar prompts interactivos
+        result = self.runner.invoke(
+            app,
+            [
+                "create",
+                "--profile-name",
+                profile_name,
+                "--api-id",
+                "123456",
+                "--api-hash",
+                "abcdef",
+                "--chat-id",
+                "-100123456",
+            ],
+            obj=self.state,
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn(f"Creando perfil", result.stdout)
+
+        # Verificamos que se guardó la configuración en el .env
+        settings = self.manager._load_and_sanitize(profile_name)
+        self.assertEqual(settings["chat_id"], -100123456)
+
+    def test_switch_profile_fails_if_incomplete(self):
+        """No debe permitir cambiar a un perfil que no sea 'trinity' (incompleto)."""
+        profile_name = "orphan"
+
+        # Creamos solo el .env, pero no el archivo .session
+        env_path = self.manager.get_settings_path(profile_name)
+        env_path.parent.mkdir(parents=True, exist_ok=True)
+        env_path.write_text("profile_name=orphan")
+
+        result = self.runner.invoke(app, ["switch", profile_name], obj=self.state)
+
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("está incompleto", result.stdout)
+
+    def test_switch_profile_success(self):
+        """Cambio exitoso de perfil cuando existen .env y .session."""
+        profile_name = "active_user"
+
+        # 1. Crear .env
+        env_path = self.manager.get_settings_path(profile_name)
+        env_path.parent.mkdir(parents=True, exist_ok=True)
+        env_path.write_text("profile_name=active_user\nchat_id=12345")
+
+        # 2. Crear .session (archivo vacío para simular existencia)
+        session_path = self.manager.get_session_path(profile_name)
+        session_path.write_text("fake session data")
+
+        result = self.runner.invoke(app, ["switch", profile_name], obj=self.state)
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Perfil cambiado exitosamente", result.stdout)
+        self.assertEqual(self.manager.get_active_profile_name(), profile_name)
+
+    def test_delete_profile_full(self):
+        """Eliminación física de un perfil."""
+        profile_name = "target_delete"
+
+        # Crear rastro
+        env_path = self.manager.get_settings_path(profile_name)
+        env_path.parent.mkdir(parents=True, exist_ok=True)
+        env_path.write_text("data")
+        session_path = self.manager.get_session_path(profile_name)
+        session_path.write_text("data")
+
+        # Usamos --yes para saltar la confirmación interactiva
+        result = self.runner.invoke(
+            app, ["delete", profile_name, "--yes"], obj=self.state
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertFalse(env_path.exists())
+        self.assertFalse(session_path.exists())
+        self.assertIn(f"eliminado correctamente", result.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()

totelegram-0.9.10/tests/test_models.py

@@ -0,0 +1,141 @@
+import unittest
+
+import peewee
+
+from totelegram.database import DatabaseSession  # type: ignore
+from totelegram.models import (
+    Job,
+    Source,
+    TelegramChat,
+)
+from totelegram.schemas import Strategy
+
+
+class TestModelsArchitecture(unittest.TestCase):
+    def setUp(self):
+        self.db_manager = DatabaseSession(":memory:")
+        self.db_manager.start()
+        self.chat = TelegramChat.create(
+            id=-100123456, title="Test Chat", type="channel"
+        )
+        self.chat_alternate = TelegramChat.create(
+            id=-100123801, title="Test Chat", type="channel"
+        )
+
+    def tearDown(self):
+        self.db_manager.close()
+
+    def test_source_file_uniqueness_by_md5(self):
+        """Prueba la unicidad de Source por MD5."""
+        Source.create(
+            path_str="video.mp4",
+            md5sum="abc123",
+            size=500,
+            mtime=1.0,
+            mimetype="video/mp4",
+        )
+        with self.assertRaises(peewee.IntegrityError):
+            Source.create(
+                path_str="otra_ruta/video.mp4",
+                md5sum="abc123",
+                size=500,
+                mtime=1.0,
+                mimetype="video/mp4",
+            )
+
+    def test_job_contract_strategy_assignment(self):
+        """
+        Prueba la lógica de ADR-002:
+        El Job determina la estrategia al nacer basado en el límite de bytes.
+        """
+        source = Source.create(
+            path_str="data.bin",
+            md5sum="hash1",
+            size=150,
+            mtime=1.0,
+            mimetype="application/octet-stream",
+        )
+
+        # CASO : El archivo (150b) es mayor que el limite (100b) -> CHUNKED
+
+        job_chunked = Job.formalize_intent(
+            source, self.chat, is_premium=False, tg_limit=100
+        )
+        self.assertEqual(job_chunked.strategy, Strategy.CHUNKED)
+        self.assertEqual(job_chunked.config.tg_max_size, 100)
+
+        # CASO : El archivo (150b) es menor que el limite (200b) -> SINGLE
+        job_single = Job.formalize_intent(
+            source, self.chat_alternate, is_premium=True, tg_limit=200
+        )
+        self.assertEqual(job_single.strategy, Strategy.SINGLE)
+        self.assertEqual(job_single.config.tg_max_size, 200)
+
+    def test_job_immutability_integrity(self):
+        """
+        Verifica que una vez creado el Job, su config queda persistida en JSON
+        y no cambia aunque cambien los parámetros externos (ADR-002).
+        """
+        source = Source.create(
+            path_str="test.zip",
+            md5sum="hash_imm",
+            size=150,
+            mtime=1.0,
+            mimetype="app/zip",
+        )
+
+        job = Job.formalize_intent(source, self.chat, is_premium=False, tg_limit=100)
+
+        # Recuperamos de la DB para asegurar que el JSONField funcionó
+        job_from_db = Job.get_by_id(job.id)
+        self.assertEqual(job_from_db.config.tg_max_size, 100)
+
+    # def test_payload_relation_and_status(self):
+    #     """Valida que los payloads se vinculen correctamente y el Job cambie de estado."""
+    #     source = Source.create(
+    #         path_str="doc.pdf", md5sum="h_pdf", size=10, mtime=1.0, mimetype="app/pdf"
+    #     )
+
+    #     job = Job.formalize_intent(source, self.chat, is_premium=False, tg_limit=100)
+
+    #     self.assertEqual(job.status, JobStatus.PENDING)
+
+    #     # Simular creación de un payload (SINGLE)
+    #     Payload.create_payloads(job, [Path("doc.pdf")])
+    #     self.assertEqual(job.payloads.count(), 1)
+
+    #     job.set_uploaded()
+    #     self.assertEqual(job.status, JobStatus.UPLOADED)
+
+    # def test_remote_payload_register_upload(self):
+    #     """Valida el registro del 'Vínculo de Acceso' (RemotePayload)."""
+    #     source = Source.create(
+    #         path_str="a.txt", md5sum="h1", size=10, mtime=1, mimetype="t"
+    #     )
+
+    #     job = Job.formalize_intent(source, self.chat, False, 100)
+    #     payload = Payload.create(job=job, sequence_index=0, md5sum="hp1", size=10)
+
+    #     user = TelegramUser.create(id=123, first_name="Tester")
+
+    #     # Mock de objeto Message de Pyrogram que cumpla con json.loads(str(msg))
+    #     class MockTgMessage:
+    #         def __init__(self):
+    #             self.id = 999
+    #             self.chat = type("obj", (object,), {"id": -100123456})
+
+    #         def __str__(self):
+    #             return json.dumps(
+    #                 {
+    #                     "message_id": self.id,
+    #                     "chat": {"id": self.chat.id, "type": "channel"},  # type: ignore
+    #                 }
+    #             )
+
+    #     remote = RemotePayload.register_upload(
+    #         payload=payload, tg_message=MockTgMessage(), owner=user
+    #     )
+
+    #     self.assertEqual(remote.message_id, 999)
+    #     self.assertEqual(remote.chat_id, -100123456)
+    #     self.assertEqual(remote.owner.id, 123)