todus-lib 1.3.2__py3-none-any.whl

todus/__init__.py

@@ -0,0 +1,52 @@
+"""ToDus Python Library - Cliente XMPP/HTTP para ToDus."""
+
+from .client import ToDusClient, ToDusClient2
+from .group import GroupClient, GroupRole, GroupEvent
+from .types import FileType, ChatState, MessageType, PresenceShow, ButtonSize, ButtonCommand
+from .errors import (
+    ToDusError,
+    AuthenticationError,
+    TokenExpiredError,
+    ConnectionLostError,
+    MessageError,
+    UploadError,
+    ParseError,
+    RateLimitError,
+    StanzaError,
+    GroupError,
+)
+from .util import normalize_phone, build_jid, generate_token, jwt_decode_payload, timestamp_ms, format_size
+from .parser import IncrementalParser, parse_tdack
+
+__version__ = "1.3.2"
+__all__ = [
+    "ToDusClient",
+    "ToDusClient2",
+    "GroupClient",
+    "GroupRole",
+    "GroupEvent",
+    "FileType",
+    "ChatState",
+    "MessageType",
+    "PresenceShow",
+    "ButtonSize",
+    "ButtonCommand",
+    "ToDusError",
+    "AuthenticationError",
+    "TokenExpiredError",
+    "ConnectionLostError",
+    "MessageError",
+    "UploadError",
+    "ParseError",
+    "RateLimitError",
+    "StanzaError",
+    "GroupError",
+    "normalize_phone",
+    "build_jid",
+    "generate_token",
+    "jwt_decode_payload",
+    "timestamp_ms",
+    "format_size",
+    "IncrementalParser",
+    "parse_tdack",
+]

todus/client/__init__.py

@@ -0,0 +1,277 @@
+"""Cliente XMPP/HTTP para ToDus, unificado mediante Mixins."""
+
+import logging
+import socket
+import time
+from base64 import b64encode
+from typing import Callable
+
+from .base import ToDusClientBase
+from .auth import ToDusAuthMixin
+from .message import ToDusMessageMixin
+from .file import ToDusFileMixin
+from .profile import ToDusProfileMixin
+from ..errors import AuthenticationError, TokenExpiredError, ConnectionLostError
+from ..types import FileType
+from .. import util
+
+logger = logging.getLogger("todus")
+
+
+class ToDusClient(
+    ToDusAuthMixin,
+    ToDusMessageMixin,
+    ToDusFileMixin,
+    ToDusProfileMixin,
+    ToDusClientBase,
+):
+    """Cliente stateless para la API de ToDus unificado."""
+    pass
+
+
+class ToDusClient2(ToDusClient):
+    """Cliente stateful con auto-login, auto-reconnect, soporte para grupos y auto-detección de destino."""
+
+    def __init__(self, phone_number: str, password: str = "", proxy: str | None = None, **kwargs) -> None:
+        super().__init__(proxy=proxy, **kwargs)
+        self.phone_number = phone_number
+        self.password = password
+        self._token = ""
+        self._group_client = None
+
+    def _authstr_from_token(self, token: str) -> tuple[str, bytes]:
+        phone, authstr = super()._authstr_from_token(token)
+        if not phone and self.phone_number:
+            phone = util.normalize_phone(self.phone_number)
+            authstr = b64encode((chr(0) + phone + chr(0) + token).encode("utf-8"))
+        return phone, authstr
+
+    def _is_group_target(self, target: str) -> bool:
+        """Detecta si el target es un group_id en lugar de un teléfono."""
+        if not target:
+            return False
+        # Los teléfonos cubanos en ToDus son 10 dígitos empezando por 53
+        return not (target.isdigit() and len(target) == 10 and target.startswith("53"))
+
+    @property
+    def token(self) -> str:
+        return self._token
+
+    @property
+    def registered(self) -> bool:
+        return bool(self.phone_number and self.password)
+
+    @property
+    def logged(self) -> bool:
+        return bool(self._token)
+
+    @property
+    def groups(self):
+        """Acceso al cliente de grupos MUC Light."""
+        if self._group_client is None:
+            from ..group import GroupClient
+            self._group_client = GroupClient(self)
+        return self._group_client
+
+    def login(self) -> None:
+        if not self.password:
+            raise AuthenticationError("No hay password")
+        self._token = super().login(self.phone_number, self.password)
+
+    def request_code(self) -> None:
+        super().request_code(self.phone_number)
+
+    def validate_code(self, code: str) -> None:
+        self.password = super().validate_code(self.phone_number, code)
+
+    # --- Mensajería Privada / Grupo (auto-detección) ---
+
+    def send_message(self, to_phone: str, body: str) -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.send_message(to_phone, body)
+        to_jid = util.build_jid(to_phone)
+        return super().send_message(self._token, to_jid, body)
+
+    def edit_message(self, to_phone: str, new_body: str, original_msg_id: str) -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.edit_message(to_phone, new_body, original_msg_id)
+        to_jid = util.build_jid(to_phone)
+        return super().edit_message(self._token, to_jid, new_body, original_msg_id)
+
+    def send_file_message(self, to_phone: str, url: str, file_type: FileType, caption: str = "", file_name: str = "", file_size: int = 0) -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.send_file(to_phone, url, file_name, file_size, caption)
+        to_jid = util.build_jid(to_phone)
+        return super().send_file_message(self._token, to_jid, url, file_type, caption, file_name=file_name, file_size=file_size)
+
+    def send_image_message(self, to_phone: str, url: str, file_name: str, file_size: int, width: int = 0, height: int = 0, thumbnail: str = "", caption: str = "") -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.send_image(to_phone, url, file_name, file_size, width, height, thumbnail, caption)
+        to_jid = util.build_jid(to_phone)
+        return super().send_image_message(self._token, to_jid, url, file_name, file_size, width, height, thumbnail, caption)
+
+    def send_image_message_simple(self, to_phone: str, url: str, file_name: str, file_size: int) -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.send_image(to_phone, url, file_name, file_size, 0, 0, "", "")
+        to_jid = util.build_jid(to_phone)
+        return super().send_image_message_simple(self._token, to_jid, url, file_name, file_size)
+
+    def send_button_message(self, to_phone: str, text: str, buttons: list[dict]) -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.send_message(to_phone, text)
+        to_jid = util.build_jid(to_phone)
+        return super().send_button_message(self._token, to_jid, text, buttons)
+
+    def send_contact_message(self, to_phone: str, contact_id: str, contact_name: str, contact_phone: str) -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.send_contact(to_phone, contact_id, contact_name, contact_phone)
+        to_jid = util.build_jid(to_phone)
+        return super().send_contact_message(self._token, to_jid, contact_id, contact_name, contact_phone)
+
+    def send_sticker_message(self, to_phone: str, sticker_id: str, sticker_name: str, sticker_pack: str, sticker_hash: str) -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.send_sticker(to_phone, sticker_id, sticker_name, sticker_pack, sticker_hash)
+        to_jid = util.build_jid(to_phone)
+        return super().send_sticker_message(self._token, to_jid, sticker_id, sticker_name, sticker_pack, sticker_hash)
+
+    def send_video_message(self, to_phone: str, url: str, video_id: str, file_name: str, file_size: int, duration: int, width: int, height: int, thumbnail: str, info_text: str = "") -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.send_video(to_phone, url, video_id, file_name, file_size, duration, width, height, thumbnail, info_text)
+        to_jid = util.build_jid(to_phone)
+        return super().send_video_message(self._token, to_jid, url, video_id, file_name, file_size, duration, width, height, thumbnail, info_text=info_text)
+
+    def send_location_message(self, to_phone: str, lat: float, lon: float, zoom: float = 11.0, text: str = "") -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.send_location(to_phone, lat, lon, zoom, text)
+        to_jid = util.build_jid(to_phone)
+        return super().send_location_message(self._token, to_jid, lat, lon, zoom, text)
+
+    def send_event_message(self, to_phone: str, title: str, start: int, end: int, all_day: bool, ics_data: str, event_id: str = "") -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.send_event(to_phone, title, start, end, all_day, ics_data, event_id)
+        to_jid = util.build_jid(to_phone)
+        return super().send_event_message(self._token, to_jid, title, start, end, all_day, ics_data, event_id)
+
+    def send_chat_state(self, to_phone: str, state: str) -> None:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return
+        super().send_chat_state(self._token, util.build_jid(to_phone), state)
+
+    def delete_message(self, to_phone: str, message_id: str, body: str = "", media_xml: str = "") -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return self.groups.delete_message(to_phone, message_id, body=body, media_xml=media_xml)
+        to_jid = util.build_jid(to_phone)
+        return super().delete_message(self._token, to_jid, message_id, body=body, media_xml=media_xml)
+
+    def send_read_receipt(self, to_phone: str, msg_id: str) -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        if self._is_group_target(to_phone):
+            return ""
+        to_jid = util.build_jid(to_phone)
+        return super().send_read_receipt(self._token, to_jid, msg_id)
+
+    # --- Recepción de mensajes (con soporte para grupos) ---
+
+    def listen_messages(self, callback: Callable[[dict], None]) -> None:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+
+        def group_aware_callback(msg: dict):
+            # Procesar mensajes de grupo
+            if msg.get("type") == "gc":
+                msg = self.groups.process_group_message(msg)
+
+                # Notificar callbacks específicos del grupo
+                group_id = msg.get("group_id")
+                if group_id and self._group_client:
+                    if group_id in self._group_client._group_callbacks:
+                        for cb in self._group_client._group_callbacks[group_id]:
+                            try:
+                                cb(msg.copy())
+                            except Exception as e:
+                                logger.error(f"Error en callback de grupo: {e}")
+
+            callback(msg)
+
+        while True:
+            try:
+                super().listen_messages(self._token, group_aware_callback)
+            except TokenExpiredError:
+                self.login()
+            except (ConnectionLostError, OSError, socket.error):
+                time.sleep(15)
+
+    # --- Archivos ---
+
+    def reserve_upload_url(self, size: int, file_type: FileType, file_name: str = "") -> tuple[str, str]:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        return super().reserve_upload_url(self._token, size, file_type, file_name=file_name)
+
+    def get_real_download_url(self, url: str) -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        return super().get_real_download_url(self._token, url)
+
+    def upload_file(self, data: bytes, file_type: FileType = FileType.FILE, progress_callback: Callable[[int, int], None] = None, file_name: str = "") -> str:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        return super().upload_file(self._token, data, file_type, progress_callback, file_name=file_name)
+
+    def download_file(self, url: str, path: str) -> int:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        return super().download_file(self._token, url, path)
+
+    def download_file_to_folder(self, url: str, folder: str, filename: str = "") -> tuple[int, str]:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        return super().download_file_to_folder(self._token, url, folder, filename)
+
+    # --- Perfil ---
+
+    def update_profile(self, alias: str = "", bio: str = "", picture_url: str = "", thumbnail_url: str = "") -> bool:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        return super().update_profile(self._token, alias, bio, picture_url, thumbnail_url)
+
+    def upload_avatar(self, image_data: bytes, thumbnail_data: bytes = None) -> tuple[str, str]:
+        if not self._token:
+            raise AuthenticationError("No autenticado")
+        return super().upload_avatar(self._token, image_data, thumbnail_data)
+
+    def upload_avatar_from_file(self, filepath: str, thumbnail_path: str = None) -> tuple[str, str]:
+        with open(filepath, "rb") as f:
+            image_data = f.read()
+        thumbnail_data = None
+        if thumbnail_path:
+            with open(thumbnail_path, "rb") as f:
+                thumbnail_data = f.read()
+        return self.upload_avatar(image_data, thumbnail_data)

todus/client/auth.py

@@ -0,0 +1,89 @@
+import string
+import re
+from ..errors import AuthenticationError
+from .. import util
+
+
+class ToDusAuthMixin:
+    """Mixin que contiene los métodos de autenticación HTTP de ToDus."""
+
+    def request_code(self, phone_number: str) -> None:
+        headers = {
+            "Host": "auth.todus.cu",
+            "User-Agent": "ToDus " + self.version_name + " Auth",
+            "Content-Type": "application/x-protobuf",
+        }
+        data = (
+            bytes([0x0A, 0x0A])
+            + phone_number.encode()
+            + bytes([0x12, 0x96, 0x01])
+            + util.generate_token(150).encode()
+        )
+        resp = self.session.post(
+            "https://auth.todus.cu/v2/auth/users.reserve",
+            data=data,
+            headers=headers,
+            timeout=30,
+        )
+        resp.raise_for_status()
+
+    def validate_code(self, phone_number: str, code: str) -> str:
+        headers = {
+            "Host": "auth.todus.cu",
+            "User-Agent": "ToDus " + self.version_name + " Auth",
+            "Content-Type": "application/x-protobuf",
+        }
+        data = (
+            bytes([0x0A, 0x0A])
+            + phone_number.encode()
+            + bytes([0x12, 0x96, 0x01])
+            + util.generate_token(150).encode()
+            + bytes([0x1A, 0x06])
+            + code.encode()
+        )
+        resp = self.session.post(
+            "https://auth.todus.cu/v2/auth/users.register",
+            data=data,
+            headers=headers,
+            timeout=30,
+        )
+        resp.raise_for_status()
+        content = resp.content
+        try:
+            if b"`" in content:
+                idx = content.index(b"`") + 1
+                return content[idx : idx + 96].decode("utf-8")
+            return content[5:166].decode("utf-8")
+        except UnicodeDecodeError:
+            raw = content.decode("latin-1", errors="ignore")
+            match = re.search(r"[a-f0-9]{96}", raw)
+            if match:
+                return match.group(0)
+            return "".join(c for c in raw if c in string.printable and c not in "\r\n")[:96]
+
+    def login(self, phone_number: str, password: str) -> str:
+        headers = {
+            "Host": "auth.todus.cu",
+            "user-agent": "ToDus " + self.version_name + " Auth",
+            "content-type": "application/x-protobuf",
+        }
+        data = (
+            bytes([0x0A, 0x0A])
+            + phone_number.encode()
+            + bytes([0x12, 0x96, 0x01])
+            + util.generate_token(150).encode()
+            + bytes([0x12, 0x60])
+            + password.encode()
+            + bytes([0x1A, 0x05])
+            + self.version_code.encode()
+        )
+        resp = self.session.post(
+            "https://auth.todus.cu/v2/auth/token",
+            data=data,
+            headers=headers,
+            timeout=30,
+        )
+        if resp.status_code == 403:
+            raise AuthenticationError("Credenciales invalidas")
+        resp.raise_for_status()
+        return "".join([c for c in resp.text if c in string.printable])

todus/client/base.py

@@ -0,0 +1,183 @@
+import logging
+import re
+import socket
+import ssl
+import string
+from base64 import b64encode
+from contextlib import contextmanager
+import requests
+from .. import constants, parser, stanza, util
+from ..errors import ConnectionLostError, TokenExpiredError
+
+logger = logging.getLogger("todus")
+
+
+class ToDusClientBase:
+    """Clase base para el cliente ToDus que maneja el socket XMPP y HTTP."""
+
+    def __init__(
+        self,
+        version_name: str = constants.AUTH_VERSION_NAME,
+        version_code: str = constants.AUTH_VERSION_CODE,
+        proxy: str | None = None,
+    ) -> None:
+        self.version_name = version_name
+        self.version_code = version_code
+        self.proxy = proxy
+        self.session = requests.Session()
+        self.session.headers.update({"Accept-Encoding": "gzip"})
+        if self.proxy:
+            self.session.proxies = {
+                "http": self.proxy,
+                "https": self.proxy,
+            }
+        self._xml_parser = parser.IncrementalParser()
+
+    def _parse_proxy(self, proxy_url: str):
+        from urllib.parse import urlparse
+        import socks
+
+        parsed = urlparse(proxy_url)
+        scheme = parsed.scheme.lower()
+
+        if "socks5" in scheme:
+            proxy_type = socks.SOCKS5
+        elif "socks4" in scheme:
+            proxy_type = socks.SOCKS4
+        elif "http" in scheme:
+            proxy_type = socks.HTTP
+        else:
+            raise ValueError(f"Tipo de proxy no soportado: {scheme}")
+
+        port = parsed.port
+        if port is None:
+            if proxy_type == socks.HTTP:
+                port = 8080
+            else:
+                port = 1080
+
+        return proxy_type, parsed.hostname, port, parsed.username, parsed.password
+
+    # --- XMPP Socket ---
+
+    def _connect_xmpp(self) -> ssl.SSLSocket:
+        if self.proxy:
+            import socks
+            proxy_type, host, port, username, password = self._parse_proxy(self.proxy)
+            raw_sock = socks.socksocket(socket.AF_INET)
+            raw_sock.set_proxy(proxy_type, host, port, username=username, password=password)
+        else:
+            raw_sock = socket.socket(socket.AF_INET)
+
+        raw_sock.settimeout(constants.DEFAULT_TIMEOUT)
+        raw_sock.connect((constants.XMPP_HOST, constants.XMPP_PORT))
+
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        sock = ctx.wrap_socket(raw_sock, server_hostname=constants.XMPP_HOST)
+        sock.send(stanza.stream_open().encode())
+        return sock
+
+    def _recv_all(self, sock: ssl.SSLSocket) -> str | None:
+        data = b""
+        while True:
+            try:
+                chunk = sock.recv(constants.BUFFER_SIZE)
+                if not chunk:
+                    return None
+                data += chunk
+                if len(chunk) < constants.BUFFER_SIZE:
+                    break
+            except socket.timeout:
+                break
+            except OSError:
+                return None
+        return data.decode("utf-8", errors="replace")
+
+    def _authstr_from_token(self, token: str) -> tuple[str, bytes]:
+        payload = util.jwt_decode_payload(token)
+        phone = payload.get("username", "")
+        if not phone:
+            match = re.search(r"(53\d{8})", token)
+            if match:
+                phone = match.group(1)
+        authstr = b64encode((chr(0) + phone + chr(0) + token).encode("utf-8"))
+        return phone, authstr
+
+    def _process_handshake(self, response: str, sock, authstr: bytes, sid: str, state: dict) -> bool:
+        phase = state.get("phase", "init")
+
+        if phase == "init":
+            if "<stream:features><es xmlns='x2'>" in response:
+                sock.send(stanza.sasl_auth(authstr))
+                state["phase"] = "auth_sent"
+                return True
+            if response.startswith("<?xml version='1.0'?><stream:stream"):
+                if "<stream:features>" in response:
+                    sock.send(stanza.sasl_auth(authstr))
+                    state["phase"] = "auth_sent"
+                return True
+            return True
+
+        if phase == "auth_sent":
+            if "<ok xmlns='x2'/>" in response:
+                sock.send(stanza.stream_restart().encode())
+                state["phase"] = "restream"
+                return True
+            if "<not-authorized/>" in response:
+                raise TokenExpiredError()
+            return True
+
+        if phase == "restream":
+            if "<stream:features><b1 xmlns='x4'/>" in response:
+                sock.send(stanza.bind(sid + "-1").encode())
+                state["phase"] = "bind_sent"
+                return True
+            if response.startswith("<?xml version='1.0'?><stream:stream") and "<stream:features><b1 xmlns='x4'/>" in response:
+                sock.send(stanza.bind(sid + "-1").encode())
+                state["phase"] = "bind_sent"
+                return True
+            return True
+
+        if phase == "bind_sent":
+            if "t='result' i='" + sid + "-1'>" in response:
+                return False
+            if "<not-authorized/>" in response:
+                raise TokenExpiredError()
+            return True
+
+        return True
+
+    def _handshake(self, sock: ssl.SSLSocket, token: str) -> None:
+        _, authstr = self._authstr_from_token(token)
+        sid = util.generate_token(5)
+        state = {"phase": "init"}
+
+        while True:
+            response = self._recv_all(sock)
+            if response is None:
+                raise ConnectionLostError("Servidor cerro conexion durante handshake")
+            if response == "":
+                continue
+
+            if not self._process_handshake(response, sock, authstr, sid, state):
+                return
+
+    # --- Context Manager XMPP ---
+
+    @contextmanager
+    def _xmpp_session(self, token: str):
+        sock = self._connect_xmpp()
+        try:
+            self._handshake(sock, token)
+            sock.send(stanza.presence().encode())
+            yield sock
+        finally:
+            try:
+                sock.send(stanza.stream_close().encode())
+            except Exception:
+                pass
+            try:
+                sock.close()
+            except Exception:
+                pass