devcopilot 0.2.0__py3-none-any.whl

messaging/platforms/voice_flow.py

@@ -0,0 +1,295 @@
+"""Shared voice-note flow for messaging platform adapters."""
+
+from __future__ import annotations
+
+import contextlib
+import tempfile
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from loguru import logger
+
+from core.anthropic import format_user_error_preview
+
+from ..models import IncomingMessage
+from ..voice import PendingVoiceRegistry, VoiceTranscriptionService
+
+AUDIO_EXTENSIONS = (".ogg", ".mp4", ".mp3", ".wav", ".m4a")
+VOICE_DISABLED_MESSAGE = "Voice notes are disabled."
+VOICE_TRANSCRIPTION_ERROR_MESSAGE = (
+    "Could not transcribe voice note. Please try again or send text."
+)
+
+MessageHandler = Callable[[IncomingMessage], Awaitable[None]]
+QueueSend = Callable[..., Awaitable[str | None]]
+QueueDelete = Callable[..., Awaitable[None]]
+
+
+@dataclass(frozen=True)
+class VoiceNoteRequest:
+    """Platform-normalized voice-note input."""
+
+    platform: str
+    chat_id: str
+    user_id: str
+    message_id: str
+    raw_event: Any
+    content_type: str
+    temp_suffix: str
+    status_text: str
+    download_to: Callable[[Path], Awaitable[None]]
+    reply_text: Callable[[str], Awaitable[None]]
+    reply_to_message_id: str | None = None
+    status_parse_mode: str | None = None
+    message_thread_id: str | None = None
+    username: str | None = None
+
+
+def is_audio_metadata(filename: str | None, content_type: str | None) -> bool:
+    """Return whether attachment metadata describes an audio file."""
+    normalized_content_type = (content_type or "").lower()
+    normalized_filename = (filename or "").lower()
+    return normalized_content_type.startswith("audio/") or any(
+        normalized_filename.endswith(extension) for extension in AUDIO_EXTENSIONS
+    )
+
+
+def audio_suffix_from_metadata(
+    *,
+    filename: str | None = None,
+    content_type: str | None = None,
+    default: str = ".ogg",
+) -> str:
+    """Choose a temp-file suffix from platform attachment metadata."""
+    normalized_filename = (filename or "").lower()
+    normalized_content_type = (content_type or "").lower()
+
+    if "m4a" in normalized_content_type:
+        return ".m4a"
+    if "mp4" in normalized_content_type:
+        if normalized_filename.endswith(".m4a"):
+            return ".m4a"
+        return ".mp4"
+    if "mpeg" in normalized_content_type or "mp3" in normalized_content_type:
+        return ".mp3"
+    if "wav" in normalized_content_type:
+        return ".wav"
+
+    for extension in AUDIO_EXTENSIONS:
+        if normalized_filename.endswith(extension):
+            return extension
+    return default
+
+
+class VoiceNoteFlow:
+    """Own common voice transcription state and control flow."""
+
+    def __init__(
+        self,
+        *,
+        voice_note_enabled: bool,
+        whisper_model: str,
+        whisper_device: str,
+        hf_token: str,
+        nvidia_nim_api_key: str,
+        log_raw_messaging_content: bool,
+        log_api_error_tracebacks: bool,
+    ) -> None:
+        self._voice_note_enabled = voice_note_enabled
+        self._whisper_model = whisper_model
+        self._whisper_device = whisper_device
+        self._log_raw_messaging_content = log_raw_messaging_content
+        self._log_api_error_tracebacks = log_api_error_tracebacks
+        self._pending_voice = PendingVoiceRegistry()
+        self._voice_transcription = VoiceTranscriptionService(
+            hf_token=hf_token,
+            nvidia_nim_api_key=nvidia_nim_api_key,
+        )
+
+    @property
+    def is_enabled(self) -> bool:
+        """Return whether voice-note handling is enabled."""
+        return self._voice_note_enabled
+
+    async def reply_if_disabled(
+        self, reply_text: Callable[[str], Awaitable[None]]
+    ) -> bool:
+        """Reply with the disabled message when voice-note handling is disabled."""
+        if self._voice_note_enabled:
+            return False
+        await reply_text(VOICE_DISABLED_MESSAGE)
+        return True
+
+    async def register_pending_voice(
+        self, chat_id: str, voice_msg_id: str, status_msg_id: str
+    ) -> None:
+        """Register a voice note as pending transcription."""
+        await self._pending_voice.register(chat_id, voice_msg_id, status_msg_id)
+
+    async def cancel_pending_voice(
+        self, chat_id: str, reply_id: str
+    ) -> tuple[str, str] | None:
+        """Cancel a pending voice transcription."""
+        return await self._pending_voice.cancel(chat_id, reply_id)
+
+    async def is_voice_still_pending(self, chat_id: str, voice_msg_id: str) -> bool:
+        """Return whether a voice note is still pending."""
+        return await self._pending_voice.is_pending(chat_id, voice_msg_id)
+
+    async def complete_pending_voice(
+        self, chat_id: str, voice_msg_id: str, status_msg_id: str
+    ) -> None:
+        """Mark a voice note as no longer pending."""
+        await self._pending_voice.complete(chat_id, voice_msg_id, status_msg_id)
+
+    async def handle(
+        self,
+        request: VoiceNoteRequest,
+        *,
+        message_handler: MessageHandler | None,
+        queue_send_message: QueueSend,
+        queue_delete_message: QueueDelete,
+    ) -> bool:
+        """Transcribe a voice note and hand the resulting turn to messaging."""
+        if await self.reply_if_disabled(request.reply_text):
+            return True
+
+        if message_handler is None:
+            return False
+
+        status_msg_id = await queue_send_message(
+            request.chat_id,
+            request.status_text,
+            reply_to=request.message_id,
+            parse_mode=request.status_parse_mode,
+            fire_and_forget=False,
+            message_thread_id=request.message_thread_id,
+        )
+        status_msg_id_text = str(status_msg_id)
+        await self.register_pending_voice(
+            request.chat_id,
+            request.message_id,
+            status_msg_id_text,
+        )
+        handed_off = False
+
+        with tempfile.NamedTemporaryFile(
+            suffix=request.temp_suffix, delete=False
+        ) as tmp:
+            tmp_path = Path(tmp.name)
+
+        try:
+            await request.download_to(tmp_path)
+
+            transcribed = await self._voice_transcription.transcribe(
+                tmp_path,
+                request.content_type,
+                whisper_model=self._whisper_model,
+                whisper_device=self._whisper_device,
+            )
+
+            if not await self.is_voice_still_pending(
+                request.chat_id,
+                request.message_id,
+            ):
+                await queue_delete_message(request.chat_id, status_msg_id_text)
+                return True
+
+            await self.complete_pending_voice(
+                request.chat_id,
+                request.message_id,
+                status_msg_id_text,
+            )
+            handed_off = True
+
+            incoming = IncomingMessage(
+                text=transcribed,
+                chat_id=request.chat_id,
+                user_id=request.user_id,
+                message_id=request.message_id,
+                platform=request.platform,
+                reply_to_message_id=request.reply_to_message_id,
+                message_thread_id=request.message_thread_id,
+                username=request.username,
+                raw_event=request.raw_event,
+                status_message_id=status_msg_id,
+            )
+
+            self._log_transcription(request, transcribed)
+            await message_handler(incoming)
+            return True
+        except ValueError as e:
+            await self._clear_failed_pending_voice(
+                request,
+                status_msg_id_text,
+                queue_delete_message,
+                handed_off=handed_off,
+            )
+            await request.reply_text(format_user_error_preview(e))
+            return True
+        except ImportError as e:
+            await self._clear_failed_pending_voice(
+                request,
+                status_msg_id_text,
+                queue_delete_message,
+                handed_off=handed_off,
+            )
+            await request.reply_text(format_user_error_preview(e))
+            return True
+        except Exception as e:
+            await self._clear_failed_pending_voice(
+                request,
+                status_msg_id_text,
+                queue_delete_message,
+                handed_off=handed_off,
+            )
+            if self._log_api_error_tracebacks:
+                logger.error("Voice transcription failed: {}", e)
+            else:
+                logger.error(
+                    "Voice transcription failed: exc_type={}",
+                    type(e).__name__,
+                )
+            await request.reply_text(VOICE_TRANSCRIPTION_ERROR_MESSAGE)
+            return True
+        finally:
+            with contextlib.suppress(OSError):
+                tmp_path.unlink(missing_ok=True)
+
+    async def _clear_failed_pending_voice(
+        self,
+        request: VoiceNoteRequest,
+        status_msg_id: str,
+        queue_delete_message: QueueDelete,
+        *,
+        handed_off: bool,
+    ) -> None:
+        await self.complete_pending_voice(
+            request.chat_id,
+            request.message_id,
+            status_msg_id,
+        )
+        if not handed_off:
+            with contextlib.suppress(Exception):
+                await queue_delete_message(request.chat_id, status_msg_id)
+
+    def _log_transcription(self, request: VoiceNoteRequest, transcribed: str) -> None:
+        label = request.platform.upper()
+        if self._log_raw_messaging_content:
+            logger.info(
+                "{}_VOICE: chat_id={} message_id={} transcribed={!r}",
+                label,
+                request.chat_id,
+                request.message_id,
+                (transcribed[:80] + "..." if len(transcribed) > 80 else transcribed),
+            )
+        else:
+            logger.info(
+                "{}_VOICE: chat_id={} message_id={} transcribed_len={}",
+                label,
+                request.chat_id,
+                request.message_id,
+                len(transcribed),
+            )

messaging/rendering/__init__.py

@@ -0,0 +1,3 @@
+"""Markdown rendering utilities for messaging platforms."""
+
+__all__: list[str] = []

messaging/rendering/discord_markdown.py

@@ -0,0 +1,318 @@
+"""Discord markdown utilities.
+
+Discord uses standard markdown: **bold**, *italic*, `code`, ```code block```.
+Used by the message handler and Discord platform adapter.
+"""
+
+from markdown_it import MarkdownIt
+
+from .markdown_tables import normalize_gfm_tables
+
+# Discord escapes: \ * _ ` ~ | >
+DISCORD_SPECIAL = set("\\*_`~|>")
+
+_MD = MarkdownIt("commonmark", {"html": False, "breaks": False})
+_MD.enable("strikethrough")
+_MD.enable("table")
+
+
+def escape_discord(text: str) -> str:
+    """Escape text for Discord markdown (bold, italic, etc.)."""
+    return "".join(f"\\{ch}" if ch in DISCORD_SPECIAL else ch for ch in text)
+
+
+def escape_discord_code(text: str) -> str:
+    """Escape text for Discord code spans/blocks."""
+    return text.replace("\\", "\\\\").replace("`", "\\`")
+
+
+def discord_bold(text: str) -> str:
+    """Format text as bold in Discord (uses **)."""
+    return f"**{escape_discord(text)}**"
+
+
+def discord_code_inline(text: str) -> str:
+    """Format text as inline code in Discord."""
+    return f"`{escape_discord_code(text)}`"
+
+
+def format_status_discord(label: str, suffix: str | None = None) -> str:
+    """Format a status message for Discord (label in bold, optional suffix)."""
+    base = discord_bold(label)
+    if suffix:
+        return f"{base} {escape_discord(suffix)}"
+    return base
+
+
+def format_status(emoji: str, label: str, suffix: str | None = None) -> str:
+    """Format a status message with emoji for Discord (matches Telegram API)."""
+    base = f"{emoji} {discord_bold(label)}"
+    if suffix:
+        return f"{base} {escape_discord(suffix)}"
+    return base
+
+
+def render_markdown_to_discord(text: str) -> str:
+    """Render common Markdown into Discord-compatible format."""
+    if not text:
+        return ""
+
+    text = normalize_gfm_tables(text)
+    tokens = _MD.parse(text)
+
+    def render_inline_table_plain(children) -> str:
+        out: list[str] = []
+        for tok in children:
+            if tok.type == "text" or tok.type == "code_inline":
+                out.append(tok.content)
+            elif tok.type in {"softbreak", "hardbreak"}:
+                out.append(" ")
+            elif tok.type == "image" and tok.content:
+                out.append(tok.content)
+        return "".join(out)
+
+    def render_inline(children) -> str:
+        out: list[str] = []
+        i = 0
+        while i < len(children):
+            tok = children[i]
+            t = tok.type
+            if t == "text":
+                out.append(escape_discord(tok.content))
+            elif t in {"softbreak", "hardbreak"}:
+                out.append("\n")
+            elif t == "em_open" or t == "em_close":
+                out.append("*")
+            elif t == "strong_open" or t == "strong_close":
+                out.append("**")
+            elif t == "s_open" or t == "s_close":
+                out.append("~~")
+            elif t == "code_inline":
+                out.append(f"`{escape_discord_code(tok.content)}`")
+            elif t == "link_open":
+                href = ""
+                if tok.attrs:
+                    if isinstance(tok.attrs, dict):
+                        href = tok.attrs.get("href", "")
+                    else:
+                        for key, val in tok.attrs:
+                            if key == "href":
+                                href = val
+                                break
+                inner_tokens = []
+                i += 1
+                while i < len(children) and children[i].type != "link_close":
+                    inner_tokens.append(children[i])
+                    i += 1
+                link_text = ""
+                for child in inner_tokens:
+                    if child.type == "text" or child.type == "code_inline":
+                        link_text += child.content
+                out.append(f"[{escape_discord(link_text)}]({href})")
+            elif t == "image":
+                href = ""
+                alt = tok.content or ""
+                if tok.attrs:
+                    if isinstance(tok.attrs, dict):
+                        href = tok.attrs.get("src", "")
+                    else:
+                        for key, val in tok.attrs:
+                            if key == "src":
+                                href = val
+                                break
+                if alt:
+                    out.append(f"{escape_discord(alt)} ({href})")
+                else:
+                    out.append(href)
+            else:
+                out.append(escape_discord(tok.content or ""))
+            i += 1
+        return "".join(out)
+
+    out: list[str] = []
+    list_stack: list[dict] = []
+    pending_prefix: str | None = None
+    blockquote_level = 0
+    in_heading = False
+
+    def apply_blockquote(val: str) -> str:
+        if blockquote_level <= 0:
+            return val
+        prefix = "> " * blockquote_level
+        return prefix + val.replace("\n", "\n" + prefix)
+
+    i = 0
+    while i < len(tokens):
+        tok = tokens[i]
+        t = tok.type
+        if t == "paragraph_open":
+            pass
+        elif t == "paragraph_close":
+            out.append("\n")
+        elif t == "heading_open":
+            in_heading = True
+        elif t == "heading_close":
+            in_heading = False
+            out.append("\n")
+        elif t == "bullet_list_open":
+            list_stack.append({"type": "bullet", "index": 1})
+        elif t == "bullet_list_close":
+            if list_stack:
+                list_stack.pop()
+            out.append("\n")
+        elif t == "ordered_list_open":
+            start = 1
+            if tok.attrs:
+                if isinstance(tok.attrs, dict):
+                    val = tok.attrs.get("start")
+                    if val is not None:
+                        try:
+                            start = int(val)
+                        except TypeError, ValueError:
+                            start = 1
+                else:
+                    for key, val in tok.attrs:
+                        if key == "start":
+                            try:
+                                start = int(val)
+                            except TypeError, ValueError:
+                                start = 1
+                            break
+            list_stack.append({"type": "ordered", "index": start})
+        elif t == "ordered_list_close":
+            if list_stack:
+                list_stack.pop()
+            out.append("\n")
+        elif t == "list_item_open":
+            if list_stack:
+                top = list_stack[-1]
+                if top["type"] == "bullet":
+                    pending_prefix = "- "
+                else:
+                    pending_prefix = f"{top['index']}. "
+                    top["index"] += 1
+        elif t == "list_item_close":
+            out.append("\n")
+        elif t == "blockquote_open":
+            blockquote_level += 1
+        elif t == "blockquote_close":
+            blockquote_level = max(0, blockquote_level - 1)
+            out.append("\n")
+        elif t == "table_open":
+            if pending_prefix:
+                out.append(apply_blockquote(pending_prefix.rstrip()))
+                out.append("\n")
+                pending_prefix = None
+
+            rows: list[list[str]] = []
+            row_is_header: list[bool] = []
+
+            j = i + 1
+            in_thead = False
+            in_row = False
+            current_row: list[str] = []
+            current_row_header = False
+
+            in_cell = False
+            cell_parts: list[str] = []
+
+            while j < len(tokens):
+                tt = tokens[j].type
+                if tt == "thead_open":
+                    in_thead = True
+                elif tt == "thead_close":
+                    in_thead = False
+                elif tt == "tr_open":
+                    in_row = True
+                    current_row = []
+                    current_row_header = in_thead
+                elif tt in {"th_open", "td_open"}:
+                    in_cell = True
+                    cell_parts = []
+                elif tt == "inline" and in_cell:
+                    cell_parts.append(
+                        render_inline_table_plain(tokens[j].children or [])
+                    )
+                elif tt in {"th_close", "td_close"} and in_cell:
+                    cell = " ".join(cell_parts).strip()
+                    current_row.append(cell)
+                    in_cell = False
+                    cell_parts = []
+                elif tt == "tr_close" and in_row:
+                    rows.append(current_row)
+                    row_is_header.append(bool(current_row_header))
+                    in_row = False
+                elif tt == "table_close":
+                    break
+                j += 1
+
+            if rows:
+                col_count = max((len(r) for r in rows), default=0)
+                norm_rows: list[list[str]] = []
+                for r in rows:
+                    if len(r) < col_count:
+                        r = r + [""] * (col_count - len(r))
+                    norm_rows.append(r)
+
+                widths: list[int] = []
+                for c in range(col_count):
+                    w = max((len(r[c]) for r in norm_rows), default=0)
+                    widths.append(max(w, 3))
+
+                def fmt_row(
+                    r: list[str], _w: list[int] = widths, _c: int = col_count
+                ) -> str:
+                    cells = [r[c].ljust(_w[c]) for c in range(_c)]
+                    return "| " + " | ".join(cells) + " |"
+
+                def fmt_sep(_w: list[int] = widths, _c: int = col_count) -> str:
+                    cells = ["-" * _w[c] for c in range(_c)]
+                    return "| " + " | ".join(cells) + " |"
+
+                last_header_idx = -1
+                for idx, is_h in enumerate(row_is_header):
+                    if is_h:
+                        last_header_idx = idx
+
+                lines: list[str] = []
+                for idx, r in enumerate(norm_rows):
+                    lines.append(fmt_row(r))
+                    if idx == last_header_idx:
+                        lines.append(fmt_sep())
+
+                table_text = "\n".join(lines).rstrip()
+                out.append(f"```\n{escape_discord_code(table_text)}\n```")
+                out.append("\n")
+
+            i = j + 1
+            continue
+        elif t in {"code_block", "fence"}:
+            code = escape_discord_code(tok.content.rstrip("\n"))
+            out.append(f"```\n{code}\n```")
+            out.append("\n")
+        elif t == "inline":
+            rendered = render_inline(tok.children or [])
+            if in_heading:
+                rendered = f"**{render_inline(tok.children or [])}**"
+            if pending_prefix:
+                rendered = pending_prefix + rendered
+                pending_prefix = None
+            rendered = apply_blockquote(rendered)
+            out.append(rendered)
+        else:
+            if tok.content:
+                out.append(escape_discord(tok.content))
+        i += 1
+
+    return "".join(out).rstrip()
+
+
+__all__ = [
+    "discord_bold",
+    "discord_code_inline",
+    "escape_discord",
+    "escape_discord_code",
+    "format_status",
+    "format_status_discord",
+    "render_markdown_to_discord",
+]

messaging/rendering/markdown_tables.py

@@ -0,0 +1,49 @@
+"""Shared Markdown table pre-normalization for platform renderers."""
+
+from __future__ import annotations
+
+import re
+
+_TABLE_SEP_RE = re.compile(r"^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$")
+_FENCE_RE = re.compile(r"^\s*```")
+
+
+def _is_gfm_table_header_line(line: str) -> bool:
+    """Return whether a line looks like a GFM table header."""
+    if "|" not in line:
+        return False
+    if _TABLE_SEP_RE.match(line):
+        return False
+    parts = [part.strip() for part in line.strip().strip("|").split("|")]
+    return len([part for part in parts if part]) >= 2
+
+
+def normalize_gfm_tables(text: str) -> str:
+    """Insert blank lines before detected tables outside fenced code blocks."""
+    lines = text.splitlines()
+    if len(lines) < 2:
+        return text
+
+    out_lines: list[str] = []
+    in_fence = False
+
+    for idx, line in enumerate(lines):
+        if _FENCE_RE.match(line):
+            in_fence = not in_fence
+            out_lines.append(line)
+            continue
+
+        if (
+            not in_fence
+            and idx + 1 < len(lines)
+            and _is_gfm_table_header_line(line)
+            and _TABLE_SEP_RE.match(lines[idx + 1])
+            and out_lines
+            and out_lines[-1].strip() != ""
+        ):
+            indent_match = re.match(r"^(\s*)", line)
+            out_lines.append(indent_match.group(1) if indent_match else "")
+
+        out_lines.append(line)
+
+    return "\n".join(out_lines)