toDus-API 1.3.3__py3-none-any.whl

todus/parser.py

@@ -0,0 +1,415 @@
+"""Parser de stanzas XMPP/ToDus."""
+
+import re
+from . import util
+
+
+def _attr(stanza: str, name: str) -> str:
+    """Extrae atributo de stanza. Soporta comillas simples y dobles."""
+    for quote in ("'", '"'):
+        pattern = rf"\b{name}={quote}([^{quote}]*){quote}"
+        match = re.search(pattern, stanza)
+        if match:
+            return match.group(1)
+    return ""
+
+
+def parse_todus_message(stanza: str) -> dict:
+    """Parsea stanza <m> de ToDus."""
+    # Extraer tag de apertura <m ...> para leer atributos propios del mensaje
+    m_open_match = re.search(r"<m\b[^>]*>", stanza)
+    m_tag = m_open_match.group(0) if m_open_match else ""
+
+    result = {
+        "from": _attr(m_tag, "f"),
+        "to": _attr(m_tag, "o"),
+        "id": _attr(m_tag, "i"),
+        "type": _attr(m_tag, "t"),
+        "original_id": _attr(m_tag, "mi"),
+        "body": "",
+        "url": "",
+        "file_name": "",
+        "file_size": 0,
+        "file_id": "",
+        "file_hash": "",
+        "message_file_id": "",
+        "contact_id": "",
+        "contact_name": "",
+        "contact_phone": "",
+        "sticker_id": "",
+        "sticker_name": "",
+        "sticker_pack": "",
+        "sticker_hash": "",
+        "video_id": "",
+        "video_url": "",
+        "video_name": "",
+        "video_size": 0,
+        "video_duration": 0,
+        "video_width": 0,
+        "video_height": 0,
+        "video_thumbnail": "",
+        "image_width": 0,
+        "image_height": 0,
+        "image_thumbnail": "",
+        "has_key": "<k" in stanza,
+        "offline_ts": "",
+        "edited": "",
+        "deleted": "",
+        "chat_state": "",
+        "receipt": "",
+        "receipt_type": "",
+        "location_id": "",
+        "location_lat": 0.0,
+        "location_lon": 0.0,
+        "location_zoom": 0.0,
+        "location_text": "",
+        "event_id": "",
+        "event_title": "",
+        "event_start": 0,
+        "event_end": 0,
+        "event_all_day": False,
+        "event_ics": "",
+        "has_format": False,
+        "buttons": [],
+        "raw": stanza,
+        "is_group": False,
+        "group_id": "",
+        "sender_phone": "",
+    }
+
+    # Detectar si es mensaje de grupo
+    msg_type = _attr(m_tag, "t")
+    result["is_group"] = msg_type == "gc"
+
+    if result["is_group"]:
+        # Extraer ID del grupo del JID 'from' o 'to'
+        from_jid = result.get("from", "")
+        if "@muclight.im.todus.cu" in from_jid:
+            parts = from_jid.split("/", 1)
+            result["group_id"] = parts[0].split("@")[0] if parts else ""
+            if len(parts) > 1:
+                result["sender_phone"] = parts[1].split("@")[0]
+
+    # Body
+    match = re.search(r"<b>(.*?)</b>", stanza, re.DOTALL)
+    if match:
+        result["body"] = util.unescape_xml(match.group(1)).strip()
+        if "<linkInfo" in stanza:
+            result["has_format"] = True
+
+    # Botones interactivos
+    button_pattern = r"<button\s+btn_t='([^']*)'\s+btn_cmd='([^']*)'\s+btn_msg_c='([^']*)'\s+btn_size='([^']*)'/?>"
+    for btn_match in re.finditer(button_pattern, stanza):
+        result["buttons"].append({
+            "text": util.unescape_xml(btn_match.group(1)),
+            "command": btn_match.group(2),
+            "data": util.unescape_xml(btn_match.group(3)),
+            "size": btn_match.group(4)
+        })
+
+    # URL de archivo (formato antiguo <u>)
+    match = re.search(r"<u>(.*?)</u>", stanza, re.DOTALL)
+    if match:
+        result["url"] = util.unescape_xml(match.group(1)).strip()
+
+    # Archivo adjunto (formato nuevo <file>)
+    file_match = re.search(r"<file\b[^>]*>", stanza)
+    if file_match:
+        file_tag = file_match.group(0)
+        result["file_id"] = _attr(file_tag, "i")
+        result["message_file_id"] = _attr(file_tag, "mi")
+        result["file_name"] = util.unescape_xml(_attr(file_tag, "n"))
+        result["url"] = _attr(file_tag, "url")
+        try:
+            result["file_size"] = int(_attr(file_tag, "s"))
+        except ValueError:
+            result["file_size"] = 0
+        result["file_hash"] = _attr(file_tag, "h")
+
+    # Imagen adjunta (formato </tr>)
+    image_match = re.search(r"<image\b[^>]*>", stanza)
+    if image_match:
+        image_tag = image_match.group(0)
+        result["file_id"] = _attr(image_tag, "i")
+        result["message_file_id"] = _attr(image_tag, "mi")
+        result["file_name"] = util.unescape_xml(_attr(image_tag, "n")) or "image.jpg"
+        result["url"] = _attr(image_tag, "url")
+        try:
+            result["file_size"] = int(_attr(image_tag, "s"))
+        except ValueError:
+            result["file_size"] = 0
+        result["file_hash"] = _attr(image_tag, "h")
+        try:
+            result["image_width"] = int(_attr(image_tag, "w"))
+        except ValueError:
+            result["image_width"] = 0
+        try:
+            result["image_height"] = int(_attr(image_tag, "he"))
+        except ValueError:
+            result["image_height"] = 0
+        result["image_thumbnail"] = _attr(image_tag, "tnail")
+
+    # Contacto adjunto (formato <contact>)
+    contact_match = re.search(r"<contact\b[^>]*>", stanza)
+    if contact_match:
+        contact_tag = contact_match.group(0)
+        result["contact_id"] = _attr(contact_tag, "i")
+        result["contact_name"] = util.unescape_xml(_attr(contact_tag, "n"))
+        result["contact_phone"] = _attr(contact_tag, "num")
+        result["message_file_id"] = _attr(contact_tag, "mi")
+
+    # Sticker adjunto (formato <sticker>)
+    sticker_match = re.search(r"<sticker\b[^>]*>", stanza)
+    if sticker_match:
+        sticker_tag = sticker_match.group(0)
+        result["sticker_id"] = _attr(sticker_tag, "i")
+        result["sticker_name"] = util.unescape_xml(_attr(sticker_tag, "n"))
+        result["sticker_pack"] = util.unescape_xml(_attr(sticker_tag, "f"))
+        result["sticker_hash"] = _attr(sticker_tag, "h")
+        result["message_file_id"] = _attr(sticker_tag, "mi")
+
+    # Video adjunto (formato <video>)
+    video_match = re.search(r"<video\b[^>]*>", stanza)
+    if video_match:
+        video_tag = video_match.group(0)
+        result["video_id"] = _attr(video_tag, "i")
+        result["message_file_id"] = _attr(video_tag, "mi")
+        result["video_name"] = util.unescape_xml(_attr(video_tag, "n"))
+        result["video_url"] = _attr(video_tag, "url")
+        try:
+            result["video_size"] = int(_attr(video_tag, "s"))
+        except ValueError:
+            result["video_size"] = 0
+        try:
+            result["video_duration"] = int(_attr(video_tag, "d"))
+        except ValueError:
+            result["video_duration"] = 0
+        try:
+            result["video_width"] = int(_attr(video_tag, "w"))
+        except ValueError:
+            result["video_width"] = 0
+        try:
+            result["video_height"] = int(_attr(video_tag, "he"))
+        except ValueError:
+            result["video_height"] = 0
+        result["video_thumbnail"] = _attr(video_tag, "tnail")
+        result["file_hash"] = _attr(video_tag, "h")
+
+    # Offline timestamp
+    match = re.search(r"<todus_offline\s+ts='([^']+)'", stanza)
+    if not match:
+        match = re.search(r'<todus_offline\s+ts="([^"]+)"', stanza)
+    if match:
+        result["offline_ts"] = match.group(1)
+
+    # Edited
+    edited_match = re.search(r"<edited\b[^>]*>", stanza)
+    if edited_match:
+        edited_tag = edited_match.group(0)
+        result["edited"] = _attr(edited_tag, "i")
+
+    # Deleted
+    deleted_match = re.search(r"<deleted\b[^>]*>", stanza)
+    if deleted_match:
+        deleted_tag = deleted_match.group(0)
+        result["deleted"] = _attr(deleted_tag, "mi") or _attr(deleted_tag, "i")
+
+    # Ubicación adjunta (location)
+    location_match = re.search(r"<location\b[^>]*>", stanza)
+    if location_match:
+        loc_tag = location_match.group(0)
+        result["location_id"] = _attr(loc_tag, "i")
+        result["message_file_id"] = _attr(loc_tag, "mi")
+        try:
+            result["location_lat"] = float(_attr(loc_tag, "lat"))
+        except ValueError:
+            result["location_lat"] = 0.0
+        try:
+            result["location_lon"] = float(_attr(loc_tag, "lon"))
+        except ValueError:
+            result["location_lon"] = 0.0
+        try:
+            result["location_zoom"] = float(_attr(loc_tag, "z"))
+        except ValueError:
+            result["location_zoom"] = 0.0
+        result["location_text"] = util.unescape_xml(_attr(loc_tag, "t"))
+
+    # Evento adjunto (event)
+    event_match = re.search(r"<event\b[^>]*>", stanza)
+    if event_match:
+        event_tag = event_match.group(0)
+        result["event_id"] = _attr(event_tag, "i")
+        result["message_file_id"] = _attr(event_tag, "mi")
+        result["event_title"] = util.unescape_xml(_attr(event_tag, "ti"))
+        try:
+            result["event_start"] = int(_attr(event_tag, "s"))
+        except ValueError:
+            result["event_start"] = 0
+        try:
+            result["event_end"] = int(_attr(event_tag, "e"))
+        except ValueError:
+            result["event_end"] = 0
+        result["event_all_day"] = _attr(event_tag, "ad").lower() == "true"
+        
+        ics_match = re.search(r"<ics>(.*?)</ics>", stanza, re.DOTALL)
+        if ics_match:
+            result["event_ics"] = ics_match.group(1).strip()
+
+    # Estado de chat (csp/csc)
+    if "<csp xmlns='uc1'/>" in stanza:
+        result["chat_state"] = "composing"
+    elif "<csc xmlns='uc1'/>" in stanza:
+        result["chat_state"] = "paused"
+
+    # Recibos de entrega (dd) o lectura (rd)
+    receipt_match = re.search(r"<dd\b[^>]*>", stanza)
+    if receipt_match:
+        receipt_tag = receipt_match.group(0)
+        result["receipt"] = _attr(receipt_tag, "i")
+        result["receipt_type"] = "delivered"
+    else:
+        read_match = re.search(r"<rd\b[^>]*>", stanza)
+        if read_match:
+            read_tag = read_match.group(0)
+            result["receipt"] = _attr(read_tag, "i")
+            result["receipt_type"] = "read"
+
+    return result
+
+
+def parse_presence(stanza: str) -> dict:
+    """Parsea stanza <p> de presencia."""
+    result = {
+        "from": _attr(stanza, "f"),
+        "to": _attr(stanza, "o"),
+        "id": _attr(stanza, "i"),
+        "status": "",
+        "show": "",
+        "priority": "",
+        "raw": stanza,
+    }
+
+    match = re.search(r"<status>(.*?)</status>", stanza, re.DOTALL)
+    if match:
+        result["status"] = util.unescape_xml(match.group(1))
+
+    match = re.search(r"<show>(.*?)</show>", stanza, re.DOTALL)
+    if match:
+        result["show"] = match.group(1)
+
+    match = re.search(r"<priority>(\d+)</priority>", stanza)
+    if match:
+        result["priority"] = int(match.group(1))
+
+    return result
+
+
+def parse_iq(stanza: str) -> dict:
+    """Parsea stanza IQ."""
+    result = {
+        "from": _attr(stanza, "f"),
+        "to": _attr(stanza, "o"),
+        "id": _attr(stanza, "i"),
+        "type": _attr(stanza, "t"),
+        "error": "",
+        "raw": stanza,
+    }
+
+    if "<error" in stanza:
+        match = re.search(r"<error[^>]*>(.*?)</error>", stanza, re.DOTALL)
+        if match:
+            result["error"] = match.group(1)
+
+    # Upload URLs
+    if _attr(stanza, "put"):
+        result["upload_url"] = _attr(stanza, "put").replace("amp;", "")
+        result["download_url"] = _attr(stanza, "get").replace("amp;", "")
+
+    # Download URL
+    if _attr(stanza, "du"):
+        result["real_url"] = _attr(stanza, "du").replace("amp;", "")
+
+    return result
+
+
+def parse_tdack(stanza: str) -> dict:
+    """Parsea stanza <tdack> de ToDus (acknowledgment)."""
+    return {
+        "type": "tdack",
+        "message_id": _attr(stanza, "mi"),
+        "raw": stanza,
+    }
+
+
+def extract_all_stanzas(xml: str) -> dict:
+    """Extrae todas las stanzas de un chunk XML."""
+    return {
+        "messages": re.findall(r"<m\b.*?</m>", xml, re.DOTALL),
+        "presences": re.findall(r"<p\b.*?</p>", xml, re.DOTALL),
+        "iqs": re.findall(r"<iq\b.*?</iq>", xml, re.DOTALL),
+        "tdacks": re.findall(r"<tdack\b[^>]*?/>", xml),
+        "streams": re.findall(r"<\?xml[^?]*\?><stream:stream[^>]*/?>", xml),
+        "unknown": [],
+    }
+
+
+class IncrementalParser:
+    """Parser incremental que maneja stanzas fragmentadas por TCP."""
+
+    def __init__(self):
+        self._buffer = ""
+
+    def feed(self, chunk: str) -> list[dict]:
+        """Alimenta con nuevo chunk y retorna stanzas completas parseadas."""
+        if not chunk:
+            return []
+
+        self._buffer += chunk
+        stanzas = []
+        seen_raw = set()
+
+        patterns = [
+            (r"<m\b.*?</m>", parse_todus_message),
+            (r"<p\b.*?</p>", parse_presence),
+            (r"<iq\b.*?</iq>", parse_iq),
+            (r"<tdack\b[^>]*?/>", parse_tdack),
+        ]
+
+        for pattern, parser_fn in patterns:
+            for match in re.finditer(pattern, self._buffer, re.DOTALL):
+                stanza_str = match.group(0)
+                if stanza_str in seen_raw:
+                    continue
+                seen_raw.add(stanza_str)
+                try:
+                    parsed = parser_fn(stanza_str)
+                    stanzas.append(parsed)
+                except Exception:
+                    pass
+
+        # Limpiar buffer hasta el final de la última stanza procesada
+        if stanzas:
+            last_end = 0
+            for s in stanzas:
+                raw = s.get("raw", "")
+                idx = self._buffer.find(raw)
+                if idx >= 0:
+                    end = idx + len(raw)
+                    if end > last_end:
+                        last_end = end
+            self._buffer = self._buffer[last_end:]
+
+        # Evitar crecimiento infinito de basura no-XML
+        if len(self._buffer) > 20000:
+            if "<" not in self._buffer:
+                self._buffer = ""
+            else:
+                last_tag = self._buffer.rfind("<")
+                if last_tag > 0:
+                    self._buffer = self._buffer[last_tag:]
+
+        return stanzas
+
+    def reset(self):
+        """Limpia el buffer."""
+        self._buffer = ""

todus/stanza.py

@@ -0,0 +1,54 @@
+"""Constructor de stanzas XMPP/ToDus (re-exportación unificada desde subdirectorio)."""
+
+from .stanzas.private import (
+    _generate_msg_id,
+    message,
+    edit_message,
+    file_message,
+    image_message,
+    image_message_simple,
+    button_message,
+    contact_message,
+    sticker_message,
+    video_message,
+    delete_message,
+    location_message,
+    event_message,
+)
+
+from .stanzas.group import (
+    group_message,
+    group_file_message,
+    group_image_message,
+    group_video_message,
+    group_sticker_message,
+    group_contact_message,
+    group_edit_message,
+    group_delete_message,
+    group_location_message,
+    group_event_message,
+)
+
+from .stanzas.presence import (
+    presence,
+    muc_presence,
+    muc_unavailable,
+)
+
+from .stanzas.utils import (
+    iq,
+    ping,
+    chat_state,
+    receipt,
+    read_receipt,
+    ack,
+    keepalive,
+    stream_open,
+    stream_restart,
+    stream_close,
+    sasl_auth,
+    bind,
+    mam_query,
+    upload_query,
+    download_query,
+)

todus/stanzas/__init__.py

@@ -0,0 +1 @@
+# todus stanzas builders package

todus/stanzas/group.py

@@ -0,0 +1,175 @@
+"""Generadores de stanzas XML para chat de grupos en ToDus."""
+
+import hashlib
+from .. import util
+
+
+def _generate_msg_id() -> str:
+    """Genera msg_id en formato hex 32 chars como usa ToDus oficial."""
+    return hashlib.md5(util.generate_token(16).encode()).hexdigest()
+
+
+def group_message(to: str, body: str, msg_id: str = "") -> str:
+    """Mensaje de texto para grupo MUC Light."""
+    mid = msg_id or _generate_msg_id()
+    body_esc = util.escape_xml(body)
+    return (
+        f"<m xml:lang='en' o='{to}' t='gc' i='{mid}' xmlns='jc'>"
+        f"<k xmlns='x8'/>"
+        f"<b>{body_esc}</b>"
+        f"</m>"
+    )
+
+
+def group_file_message(to: str, url: str, file_name: str, file_size: int, 
+                       caption: str = "", msg_id: str = "") -> str:
+    """Archivo para grupo MUC Light."""
+    mid = msg_id or _generate_msg_id()
+    fid = _generate_msg_id()
+    name_esc = util.escape_xml(file_name)
+    url_esc = util.escape_xml(url)
+    
+    return (
+        f"<m xml:lang='en' o='{to}' t='gc' i='{mid}' xmlns='jc'>"
+        f"<file xmlns='file:n' i='{fid}' mi='{mid}' n='{name_esc}' "
+        f"url='{url_esc}' s='{file_size}' h=''/>"
+        f"<k xmlns='x8'/>"
+        f"<b/>"
+        f"</m>"
+    )
+
+
+def group_image_message(to: str, url: str, file_name: str, file_size: int,
+                        width: int, height: int, thumbnail: str = "", 
+                        caption: str = "", msg_id: str = "") -> str:
+    """Imagen para grupo MUC Light."""
+    mid = msg_id or _generate_msg_id()
+    fid = _generate_msg_id()
+    name_esc = util.escape_xml(file_name)
+    url_esc = util.escape_xml(url)
+    tnail = thumbnail if thumbnail else "U6688O?Hr=xu^-w2sp-;,^VZnm-;_3xHMyt5"
+    
+    return (
+        f"<m xml:lang='en' o='{to}' t='gc' i='{mid}' xmlns='jc'>"
+        f"<image xmlns='image:n' i='{fid}' mi='{mid}' url='{url_esc}' "
+        f"n='{name_esc}' s='{file_size}' h='' w='{width}' he='{height}' "
+        f"tnail='{tnail}'/>"
+        f"<k xmlns='x8'/>"
+        f"<b/>"
+        f"</m>"
+    )
+
+
+def group_video_message(to: str, url: str, video_id: str, file_name: str, 
+                        file_size: int, duration: int, width: int, height: int, 
+                        thumbnail: str, caption: str = "", msg_id: str = "") -> str:
+    """Video para grupo MUC Light."""
+    mid = msg_id or _generate_msg_id()
+    name_esc = util.escape_xml(file_name)
+    url_esc = util.escape_xml(url)
+    
+    return (
+        f"<m xml:lang='en' o='{to}' t='gc' i='{mid}' xmlns='jc'>"
+        f"<video xmlns='video:n' i='{video_id}' mi='{mid}' url='{url_esc}' "
+        f"s='{file_size}' h='' d='{duration}' n='{name_esc}' "
+        f"w='{width}' he='{height}' tnail='{thumbnail}'/>"
+        f"<k xmlns='x8'/>"
+        f"<b/>"
+        f"</m>"
+    )
+
+
+def group_sticker_message(to: str, sticker_id: str, sticker_name: str, 
+                          sticker_pack: str, sticker_hash: str, 
+                          msg_id: str = "") -> str:
+    """Sticker para grupo MUC Light."""
+    mid = msg_id or _generate_msg_id()
+    name_esc = util.escape_xml(sticker_name)
+    pack_esc = util.escape_xml(sticker_pack)
+    
+    return (
+        f"<m xml:lang='en' o='{to}' t='gc' i='{mid}' xmlns='jc'>"
+        f"<sticker xmlns='sticker:n' i='{sticker_id}' mi='{mid}' "
+        f"n='{name_esc}' f='{pack_esc}' url='' s='0' h='{sticker_hash}' json=''/>"
+        f"<k xmlns='x8'/>"
+        f"<b/>"
+        f"</m>"
+    )
+
+
+def group_contact_message(to: str, contact_id: str, contact_name: str, 
+                          contact_phone: str, msg_id: str = "") -> str:
+    """Contacto para grupo MUC Light."""
+    mid = msg_id or _generate_msg_id()
+    name_esc = util.escape_xml(contact_name)
+    
+    return (
+        f"<m xml:lang='en' o='{to}' t='gc' i='{mid}' xmlns='jc'>"
+        f"<contact xmlns='contact:n' i='{contact_id}' mi='{mid}' "
+        f"n='{name_esc}' num='{contact_phone}'/>"
+        f"<k xmlns='x8'/>"
+        f"<b/>"
+        f"</m>"
+    )
+
+
+def group_edit_message(to: str, new_body: str, original_msg_id: str, 
+                       edit_id: str = "") -> str:
+    """Editar mensaje en grupo."""
+    eid = edit_id or _generate_msg_id()
+    body_esc = util.escape_xml(new_body)
+    
+    return (
+        f"<m xml:lang='en' o='{to}' t='gc' i='{original_msg_id}' xmlns='jc'>"
+        f"<edited xmlns='edited:n' i='{eid}' mi='{original_msg_id}'/>"
+        f"<k xmlns='x8'/>"
+        f"<b>{body_esc}</b>"
+        f"</m>"
+    )
+
+
+def group_delete_message(to: str, message_id: str, msg_id: str = "", body: str = "", media_xml: str = "") -> str:
+    """Eliminar mensaje en grupo."""
+    mid = msg_id or message_id
+    did = _generate_msg_id()
+    body_xml = f"<b>{util.escape_xml(body)}</b>" if body or not media_xml else "<b/>"
+    return (
+        f"<m xml:lang='en' o='{to}' t='gc' i='{mid}' xmlns='jc'>"
+        f"{media_xml}"
+        f"<deleted xmlns='deleted:n' i='{did}' mi='{message_id}'/>"
+        f"<k xmlns='x8'/>"
+        f"{body_xml}"
+        f"</m>"
+    )
+
+
+def group_location_message(to: str, lat: float, lon: float, zoom: float = 11.0, text: str = "", msg_id: str = "") -> str:
+    """Stanza con ubicación adjunta para grupo MUC Light."""
+    mid = msg_id or _generate_msg_id()
+    lid = _generate_msg_id()
+    text_esc = util.escape_xml(text)
+    return (
+        f"<m xml:lang='en' o='{to}' t='gc' i='{mid}' xmlns='jc'>"
+        f"<location xmlns='location:n' i='{lid}' mi='{mid}' lat='{lat}' lon='{lon}' z='{zoom}' t='{text_esc}'/>"
+        f"<k xmlns='x8'/>"
+        f"<b/>"
+        f"</m>"
+    )
+
+
+def group_event_message(to: str, event_id: str, title: str, start: int, end: int, all_day: bool, ics_data: str, msg_id: str = "") -> str:
+    """Stanza con evento/calendario adjunto para grupo MUC Light."""
+    mid = msg_id or _generate_msg_id()
+    eid = event_id or _generate_msg_id()
+    ad_str = "true" if all_day else "false"
+    title_esc = util.escape_xml(title)
+    ics_esc = util.escape_xml(ics_data)
+    return (
+        f"<m xml:lang='en' o='{to}' t='gc' i='{mid}' xmlns='jc'>"
+        f"<event xmlns='event:n' i='{eid}' mi='{mid}' ti='{title_esc}' s='{start}' e='{end}' ad='{ad_str}'>"
+        f"<ics>{ics_esc}</ics>"
+        f"</event>"
+        f"<k xmlns='x8'/>"
+        f"<b/>"
+        f"</m>"
+    )

todus/stanzas/presence.py

@@ -0,0 +1,37 @@
+"""Generadores de stanzas XML de presencia para ToDus."""
+
+from .. import util
+
+
+def presence(status: str = "Online", priority: int = 5, show: str = "", caps: bool = True) -> str:
+    """Presencia estándar para chat privado."""
+    cap = ""
+    if caps:
+        cap = (
+            "<c ver='foVtX1ZDcopvf5CM63LcnVayPRs=' "
+            "node='http://www.process-one.net/en/ejabberd/' "
+            "hash='sha-1' xmlns='http://jabber.org/protocol/caps'/>"
+        )
+    show_tag = f"<show>{show}</show>" if show else ""
+    return (
+        f"<presence xmlns='jc'>"
+        f"<status>{util.escape_xml(status)}</status>"
+        f"{show_tag}"
+        f"<priority>{priority}</priority>"
+        f"{cap}"
+        f"</presence>"
+    )
+
+
+def muc_presence(group_jid: str, nickname: str) -> str:
+    """Presencia para unirse a grupo MUC Light."""
+    return (
+        f"<presence xmlns='jc' to='{group_jid}/{nickname}'>"
+        f"<x xmlns='http://jabber.org/protocol/muc'/>"
+        f"</presence>"
+    )
+
+
+def muc_unavailable(group_jid: str) -> str:
+    """Presencia para salir de grupo MUC Light."""
+    return f"<presence xmlns='jc' to='{group_jid}' type='unavailable'/>"