toDus-API 1.3.3__py3-none-any.whl

todus/client/file.py

@@ -0,0 +1,190 @@
+import os
+import re
+import time
+import logging
+from typing import Callable
+import requests
+from .. import util, stanza
+from ..types import FileType
+from ..errors import ConnectionLostError, TokenExpiredError, UploadError
+
+logger = logging.getLogger("todus")
+
+
+class _ProgressReader:
+    def __init__(self, data: bytes, progress_callback: Callable[[int, int], None]) -> None:
+        self.data = data
+        self.total = len(data)
+        self.offset = 0
+        self.progress_callback = progress_callback
+
+    def read(self, size: int = -1) -> bytes:
+        if self.offset >= self.total:
+            return b""
+
+        if size is None or size < 0:
+            chunk = self.data[self.offset:]
+            self.offset = self.total
+        else:
+            end = min(self.offset + size, self.total)
+            chunk = self.data[self.offset:end]
+            self.offset = end
+
+        if chunk and self.progress_callback:
+            self.progress_callback(self.offset, self.total)
+
+        return chunk
+
+
+class ToDusFileMixin:
+    """Mixin que contiene los métodos de subida y descarga de archivos de ToDus."""
+
+    # --- Archivos ---
+
+    def reserve_upload_url(self, token: str, size: int, file_type: FileType, file_name: str = "") -> tuple[str, str]:
+        phone, authstr = self._authstr_from_token(token)
+        sid = util.generate_token(5)
+        up_url = down_url = ""
+
+        # Sanitizar nombre del archivo
+        sanitized_name = util.sanitize_filename(file_name, int(file_type))
+
+        with self._xmpp_session(token) as sock:
+            sock.send(stanza.upload_query(sid, size, int(file_type), file_name=sanitized_name).encode())
+            while True:
+                response = self._recv_all(sock)
+                if response is None:
+                    raise ConnectionLostError()
+                if response == "":
+                    continue
+                if "i='" + sid + "-3'" in response and "put='" in response:
+                    put_match = re.search(r"put=['\"]([^'\"]+)['\"]", response)
+                    get_match = re.search(r"get=['\"]([^'\"]+)['\"]", response)
+                    if put_match and get_match:
+                        up_url = put_match.group(1).replace("amp;", "")
+                        down_url = get_match.group(1)
+                    break
+                if "<not-authorized/>" in response:
+                    raise TokenExpiredError()
+
+        return up_url, down_url
+
+    def get_real_download_url(self, token: str, url: str) -> str:
+        _, authstr = self._authstr_from_token(token)
+        sid = util.generate_token(5)
+
+        with self._xmpp_session(token) as sock:
+            sock.send(stanza.download_query(sid, url).encode())
+            while True:
+                response = self._recv_all(sock)
+                if response is None:
+                    raise ConnectionLostError()
+                if response == "":
+                    continue
+                if "i='" + sid + "-2'" in response and "du='" in response:
+                    match = re.match(".*du='(.*)' stat.*", response)
+                    if match:
+                        return match.group(1).replace("amp;", "")
+                    break
+                if "<not-authorized/>" in response:
+                    raise TokenExpiredError()
+
+        return ""
+
+    def upload_file(self, token: str, data: bytes, file_type: FileType = FileType.FILE, progress_callback: Callable[[int, int], None] = None, file_name: str = "") -> str:
+        up_url, down_url = self.reserve_upload_url(token, len(data), file_type, file_name=file_name)
+        upload_data = _ProgressReader(data, progress_callback) if progress_callback else data
+        resp = requests.put(
+            up_url,
+            data=upload_data,
+            headers={"Content-Length": str(len(data))},
+            timeout=60,
+        )
+        resp.raise_for_status()
+        if progress_callback:
+            progress_callback(len(data), len(data))
+        return down_url
+
+    def download_file(self, token: str, url: str, path: str) -> int:
+        real_url = self.get_real_download_url(token, url)
+        headers = {
+            "User-Agent": "ToDus " + self.version_name + " HTTP-Download",
+            "Authorization": "Bearer " + token,
+        }
+        temp_path = path + ".part"
+        size = -1
+        with open(temp_path, "ab") as f:
+            pos = f.tell()
+            while pos < size or size == -1:
+                if pos:
+                    headers["Range"] = "bytes=" + str(pos) + "-"
+                try:
+                    with self.session.get(real_url, headers=headers, stream=True, timeout=60) as resp:
+                        resp.raise_for_status()
+                        size = pos + int(resp.headers.get("Content-Length", 0))
+                        for chunk in resp.iter_content(chunk_size=8192):
+                            f.write(chunk)
+                except Exception:
+                    time.sleep(5)
+                pos = f.tell()
+        os.rename(temp_path, path)
+        return size
+
+    def download_file_to_folder(self, token: str, url: str, folder: str, filename: str = "") -> tuple[int, str]:
+        headers = {
+            "User-Agent": "ToDus " + self.version_name + " HTTP-Download",
+            "Authorization": "Bearer " + token,
+        }
+
+        os.makedirs(folder, exist_ok=True)
+
+        if not filename:
+            filename = os.path.basename(url.split("?")[0]) or "download"
+
+        final_path = os.path.join(folder, filename)
+        temp_path = final_path + ".part"
+
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+        try:
+            test_resp = self.session.head(url, headers=headers, timeout=15, allow_redirects=True)
+            if test_resp.status_code in (200, 206, 401, 403, 302, 301):
+                real_url = url
+            else:
+                real_url = self.get_real_download_url(token, url)
+                if not real_url:
+                    raise UploadError("No se pudo resolver URL de descarga")
+        except Exception:
+            real_url = self.get_real_download_url(token, url)
+            if not real_url:
+                raise UploadError("No se pudo obtener URL de descarga")
+
+        size = -1
+        downloaded = 0
+        start_time = time.time()
+        last_progress = 0
+
+        with open(temp_path, "wb") as f:
+            with self.session.get(real_url, headers=headers, stream=True, timeout=300) as resp:
+                if resp.status_code not in (200, 206):
+                    raise UploadError(f"HTTP {resp.status_code}: {resp.text[:100]}")
+
+                size = int(resp.headers.get("Content-Length", 0))
+
+                for chunk in resp.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        if downloaded - last_progress >= (500 * 1024):
+                            elapsed = time.time() - start_time
+                            speed = downloaded / elapsed if elapsed > 0 else 0
+                            logger.info("Descargando %s / %s @ %s/s",
+                                        util.format_size(downloaded),
+                                        util.format_size(size),
+                                        util.format_size(int(speed)))
+                            last_progress = downloaded
+
+        os.rename(temp_path, final_path)
+        logger.info("Descarga completa: %s", util.format_size(downloaded))
+        return downloaded, final_path

todus/client/message.py

@@ -0,0 +1,202 @@
+import logging
+import threading
+import time
+import socket
+import hashlib
+from typing import Callable
+from .. import util, stanza, constants
+from ..errors import TokenExpiredError, ConnectionLostError
+from ..types import FileType
+
+logger = logging.getLogger("todus")
+
+
+class ToDusMessageMixin:
+    """Mixin que contiene la lógica de mensajería (envío y recepción) de ToDus."""
+
+    # --- Mensajeria Privada ---
+
+    def send_message(self, token: str, to_jid: str, body: str) -> str:
+        """Envía mensaje de texto privado. Retorna el msg_id generado."""
+        mid = util.generate_token(8)
+        msg = stanza.message(to_jid, body, msg_id=mid)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return mid
+
+    def edit_message(self, token: str, to_jid: str, new_body: str, original_msg_id: str) -> str:
+        """Edita un mensaje privado."""
+        edit_id = util.generate_token(8)
+        msg = stanza.edit_message(to_jid, new_body, original_msg_id, edit_id=edit_id)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return edit_id
+
+    def send_file_message(self, token: str, to_jid: str, url: str, file_type: FileType, caption: str = "", file_name: str = "", file_size: int = 0) -> str:
+        mid = util.generate_token(8)
+        msg = stanza.file_message(to_jid, url, int(file_type), caption, msg_id=mid, file_name=file_name, file_size=file_size)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return mid
+
+    def send_image_message(self, token: str, to_jid: str, url: str, file_name: str, file_size: int, width: int = 0, height: int = 0, thumbnail: str = "", caption: str = "") -> str:
+        """Envía mensaje privado con imagen adjunta."""
+        mid = util.generate_token(8)
+        msg = stanza.image_message(to_jid, url, file_name, file_size, width, height, thumbnail, caption, msg_id=mid)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return mid
+
+    def send_image_message_simple(self, token: str, to_jid: str, url: str, file_name: str, file_size: int, msg_id: str = "") -> str:
+        """Envía mensaje privado con imagen SIN metadata."""
+        mid = msg_id or util.generate_token(8)
+        msg = stanza.image_message_simple(to_jid, url, file_name, file_size, msg_id=mid)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return mid
+
+    def send_button_message(self, token: str, to_jid: str, text: str, buttons: list[dict]) -> str:
+        """Envía mensaje con botones interactivos."""
+        mid = util.generate_token(8)
+        msg = stanza.button_message(to_jid, text, buttons, msg_id=mid)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return mid
+
+    def send_contact_message(self, token: str, to_jid: str, contact_id: str, contact_name: str, contact_phone: str) -> str:
+        mid = util.generate_token(8)
+        msg = stanza.contact_message(to_jid, contact_id, contact_name, contact_phone, msg_id=mid)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return mid
+
+    def send_sticker_message(self, token: str, to_jid: str, sticker_id: str, sticker_name: str, sticker_pack: str, sticker_hash: str) -> str:
+        mid = util.generate_token(8)
+        msg = stanza.sticker_message(to_jid, sticker_id, sticker_name, sticker_pack, sticker_hash, msg_id=mid)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return mid
+
+    def send_video_message(self, token: str, to_jid: str, url: str, video_id: str, file_name: str, file_size: int, duration: int, width: int, height: int, thumbnail: str, info_text: str = "") -> str:
+        mid = hashlib.md5(util.generate_token(16).encode()).hexdigest()
+        msg = stanza.video_message(to_jid, url, video_id, file_name, file_size, duration, width, height, thumbnail, msg_id=mid, info_text=info_text)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return mid
+
+    def send_location_message(self, token: str, to_jid: str, lat: float, lon: float, zoom: float = 11.0, text: str = "") -> str:
+        """Envía un mensaje con ubicación adjunta."""
+        mid = util.generate_token(8)
+        msg = stanza.location_message(to_jid, lat, lon, zoom, text, msg_id=mid)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return mid
+
+    def send_event_message(self, token: str, to_jid: str, title: str, start: int, end: int, all_day: bool, ics_data: str, event_id: str = "") -> str:
+        """Envía un mensaje con evento/calendario adjunto."""
+        mid = util.generate_token(8)
+        msg = stanza.event_message(to_jid, event_id, title, start, end, all_day, ics_data, msg_id=mid)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return mid
+
+    def send_chat_state(self, token: str, to_jid: str, state: str) -> None:
+        st = stanza.chat_state(to_jid, state)
+        with self._xmpp_session(token) as sock:
+            sock.send(st.encode())
+
+    def delete_message(self, token: str, to_jid: str, message_id: str, msg_type: str = "c", body: str = "", media_xml: str = "") -> str:
+        """Elimina un mensaje propio."""
+        msg = stanza.delete_message(to_jid, message_id, msg_id=message_id, msg_type=msg_type, body=body, media_xml=media_xml)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return message_id
+
+    def send_read_receipt(self, token: str, to_jid: str, msg_id: str, msg_type: str = "c") -> str:
+        """Envía una confirmación de lectura (read receipt)."""
+        rid = util.generate_token(8)
+        msg = stanza.read_receipt(to_jid, msg_id, receipt_id=rid, msg_type=msg_type)
+        with self._xmpp_session(token) as sock:
+            sock.send(msg.encode())
+        return rid
+
+    # --- Recepción de mensajes ---
+
+    def listen_messages(self, token: str, callback: Callable[[dict], None]) -> None:
+        while True:
+            try:
+                with self._xmpp_session(token) as sock:
+                    self._listen_loop(sock, callback)
+            except TokenExpiredError:
+                raise
+            except (ConnectionLostError, OSError, socket.error):
+                time.sleep(15)
+
+    def _listen_loop(self, sock, callback: Callable[[dict], None]) -> None:
+        stop_event = threading.Event()
+        ping_id = util.generate_token(5)
+        ka = threading.Thread(
+            target=self._keepalive_worker,
+            args=(sock, stop_event, ping_id),
+            daemon=True,
+        )
+        ka.start()
+        self._xml_parser.reset()
+
+        try:
+            while True:
+                try:
+                    response = self._recv_all(sock)
+                except OSError as e:
+                    raise ConnectionLostError(e)
+
+                if response is None:
+                    raise ConnectionLostError("Servidor cerro conexion")
+
+                if response == "":
+                    continue
+
+                stanzas = self._xml_parser.feed(response)
+
+                for msg in stanzas:
+                    is_content = (
+                        msg.get("body")
+                        or msg.get("url")
+                        or msg.get("contact_id")
+                        or msg.get("sticker_id")
+                        or msg.get("video_url")
+                        or msg.get("buttons")
+                        or msg.get("location_id")
+                    )
+                    
+                    if is_content and not msg.get("deleted"):
+                        msg_id = msg.get("id", "")
+                        msg_from = msg.get("from", "")
+                        if msg_id and msg_from:
+                            try:
+                                receipt = stanza.receipt(msg_from, msg_id)
+                                sock.send(receipt.encode())
+                            except Exception:
+                                pass
+                    
+                    if (
+                        is_content
+                        or msg.get("chat_state")
+                        or msg.get("receipt")
+                        or msg.get("deleted")
+                    ):
+                        callback(msg)
+
+        finally:
+            stop_event.set()
+            self._xml_parser.reset()
+
+    def _keepalive_worker(self, sock, stop: threading.Event, ping_id: str) -> None:
+        while not stop.is_set():
+            time.sleep(constants.KEEPALIVE_INTERVAL)
+            if stop.is_set():
+                break
+            try:
+                sock.send(stanza.ping(ping_id).encode())
+            except OSError:
+                break

todus/client/profile.py

@@ -0,0 +1,56 @@
+import requests
+from ..types import FileType
+
+
+class ToDusProfileMixin:
+    """Mixin que contiene los métodos de manejo de perfil y avatar de ToDus."""
+
+    # --- Perfil ---
+
+    def update_profile(self, token: str, alias: str = "", bio: str = "", picture_url: str = "", thumbnail_url: str = "") -> bool:
+        headers = {
+            "Authorization": token,
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "alias": alias,
+            "description": bio,
+            "picture_url": picture_url,
+            "picture_thumbnail_url": thumbnail_url,
+        }
+        try:
+            resp = self.session.post(
+                "https://auth.todus.cu/v2/todus/users.me.json",
+                json=payload,
+                headers=headers,
+                timeout=30,
+            )
+            return resp.status_code == 200
+        except Exception:
+            return False
+
+    def upload_avatar(self, token: str, image_data: bytes, thumbnail_data: bytes = None) -> tuple[str, str]:
+        if thumbnail_data is None:
+            thumbnail_data = image_data
+
+        up_url, down_url = self.reserve_upload_url(token, len(image_data), FileType.PROFILE)
+        resp = requests.put(
+            up_url,
+            data=image_data,
+            headers={"Content-Length": str(len(image_data)), "Content-Type": "application/octet-stream"},
+            timeout=60,
+        )
+        resp.raise_for_status()
+        profile_url = down_url
+
+        up_url, down_url = self.reserve_upload_url(token, len(thumbnail_data), FileType.PROFILE_THUMBNAIL)
+        resp = requests.put(
+            up_url,
+            data=thumbnail_data,
+            headers={"Content-Length": str(len(thumbnail_data)), "Content-Type": "application/octet-stream"},
+            timeout=60,
+        )
+        resp.raise_for_status()
+        thumbnail_url = down_url
+
+        return profile_url, thumbnail_url

todus/constants.py

@@ -0,0 +1,10 @@
+"""Constantes del protocolo ToDus."""
+
+XMPP_HOST = "im.todus.cu"
+XMPP_PORT = 5222
+MUCLIGHT_HOST = "muclight.im.todus.cu"
+AUTH_VERSION_NAME = "0.40.29"
+AUTH_VERSION_CODE = "21833"
+BUFFER_SIZE = 1024 * 1024
+KEEPALIVE_INTERVAL = 25
+DEFAULT_TIMEOUT = 15

todus/errors.py

@@ -0,0 +1,41 @@
+"""Excepciones de ToDus."""
+
+
+class ToDusError(Exception):
+    """Base para todos los errores de ToDus."""
+
+
+class AuthenticationError(ToDusError):
+    """Credenciales inválidas o sesión expirada."""
+
+
+class TokenExpiredError(ToDusError):
+    """El token JWT ya no es válido."""
+
+
+class ConnectionLostError(ToDusError):
+    """Conexión XMPP perdida inesperadamente."""
+
+
+class MessageError(ToDusError):
+    """Error al enviar o recibir mensaje."""
+
+
+class UploadError(ToDusError):
+    """Error en subida/descarga de archivo."""
+
+
+class ParseError(ToDusError):
+    """Error parseando stanza XMPP."""
+
+
+class RateLimitError(ToDusError):
+    """Demasiadas peticiones en poco tiempo."""
+
+
+class StanzaError(ToDusError):
+    """Stanza malformada o no soportada."""
+
+
+class GroupError(ToDusError):
+    """Error relacionado con grupos MUC Light."""