teams-transcripts 0.5.0__py3-none-any.whl

teams_transcripts/adapters/vertex.py

@@ -0,0 +1,274 @@
+"""Vertex AI agent adapter -- AnthropicVertex client and query functions.
+
+Extracted from ``transcript_download.py`` lines 656-664
+(``create_agent_client``), 667-698 (``agent_vision_query``), and
+701-716 (``agent_text_query``).
+
+Provides both standalone functions (used by helpers like
+``find_iframe_target``) and a ``VertexAgentAdapter`` class that
+implements the ``AgentPort`` protocol for service-layer injection.
+
+Schema version: 1.0.0
+Created: 2026-04-25
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import typing
+
+if typing.TYPE_CHECKING:
+    from teams_transcripts.domain.models import MeetingConfig
+    from teams_transcripts.infrastructure.logging import Logger
+
+
+# ---------------------------------------------------------------------------
+# JSON extraction helper
+# ---------------------------------------------------------------------------
+
+
+def extract_json_from_response(text: str) -> dict | None:
+    """Extract first JSON object from response text.
+
+    Handles plain JSON, markdown-fenced JSON, or JSON embedded in prose.
+
+    Args:
+        text: Raw response text from the LLM.
+
+    Returns:
+        Parsed JSON dict, or ``None`` if no valid JSON found.
+    """
+    if not text:
+        return None
+    json_match = re.search(r"\{[^}]+\}", text)
+    if json_match:
+        try:
+            return json.loads(json_match.group())
+        except json.JSONDecodeError:
+            return None
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Standalone query functions (used by helpers.find_iframe_target etc.)
+# ---------------------------------------------------------------------------
+
+
+def agent_text_query(
+    client: typing.Any,
+    model: str,
+    prompt: str,
+    *,
+    logger: Logger | None = None,
+) -> dict | None:
+    """Send a single-turn text query to the agent.
+
+    Args:
+        client: AnthropicVertex client instance.
+        model: Model identifier.
+        prompt: Text prompt.
+        logger: Optional logger for error reporting.
+
+    Returns:
+        Parsed JSON dict, or ``None`` on failure.
+    """
+    try:
+        response = client.messages.create(
+            model=model,
+            max_tokens=512,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        text = response.content[0].text.strip()
+        return extract_json_from_response(text)
+    except Exception as exc:
+        if logger is not None:
+            logger.log("agent", f"Text query failed: {exc}")
+        return None
+
+
+def agent_vision_query(
+    client: typing.Any,
+    model: str,
+    image_b64: str,
+    prompt: str,
+    *,
+    logger: Logger | None = None,
+) -> dict | None:
+    """Send a single-turn vision query to the agent.
+
+    Args:
+        client: AnthropicVertex client instance.
+        model: Model identifier.
+        image_b64: Base64-encoded PNG image data.
+        prompt: Text prompt accompanying the image.
+        logger: Optional logger for error reporting.
+
+    Returns:
+        Parsed JSON dict, or ``None`` on failure.
+    """
+    try:
+        response = client.messages.create(
+            model=model,
+            max_tokens=512,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "image",
+                            "source": {
+                                "type": "base64",
+                                "media_type": "image/png",
+                                "data": image_b64,
+                            },
+                        },
+                        {"type": "text", "text": prompt},
+                    ],
+                }
+            ],
+        )
+        text = response.content[0].text.strip()
+        return extract_json_from_response(text)
+    except Exception as exc:
+        if logger is not None:
+            logger.log("agent", f"Vision query failed: {exc}")
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Client factory
+# ---------------------------------------------------------------------------
+
+
+def create_agent_client(config: MeetingConfig) -> typing.Any:
+    """Create an AnthropicVertex client from resolved config.
+
+    Sets ``GOOGLE_APPLICATION_CREDENTIALS`` in the environment and
+    returns a configured client instance.
+
+    Args:
+        config: Meeting configuration with ``adc``, ``gcp_project``,
+            and ``gcp_region`` fields.
+
+    Returns:
+        An ``AnthropicVertex`` client instance.
+    """
+    os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = config.adc
+    from anthropic.lib.vertex import AnthropicVertex
+
+    return AnthropicVertex(
+        project_id=config.gcp_project,
+        region=config.gcp_region,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Lazy import removed -- AnthropicVertex imported at call site above
+# ---------------------------------------------------------------------------
+
+
+# ---------------------------------------------------------------------------
+# VertexAgentAdapter (implements AgentPort)
+# ---------------------------------------------------------------------------
+
+
+class VertexAgentAdapter:
+    """AgentPort implementation using Anthropic SDK via Vertex AI.
+
+    Wraps an AnthropicVertex client and model identifier, delegating
+    to the standalone query functions.
+
+    Args:
+        client: AnthropicVertex client instance.
+        model: Model identifier (e.g. ``"claude-haiku-4-5"``).
+        logger: Logger instance for error reporting.
+    """
+
+    def __init__(
+        self,
+        *,
+        client: typing.Any,
+        model: str,
+        logger: Logger,
+    ) -> None:
+        self._client = client
+        self._model = model
+        self._logger = logger
+
+    @property
+    def client(self) -> typing.Any:
+        """The underlying AnthropicVertex client instance."""
+        return self._client
+
+    def text_query(
+        self,
+        prompt: str,
+        *,
+        max_tokens: int = 512,
+    ) -> dict | None:
+        """Send a text-only prompt to the agent.
+
+        Args:
+            prompt: Text prompt.
+            max_tokens: Maximum tokens in the response.
+
+        Returns:
+            Parsed JSON dict, or ``None`` on failure.
+        """
+        try:
+            response = self._client.messages.create(
+                model=self._model,
+                max_tokens=max_tokens,
+                messages=[{"role": "user", "content": prompt}],
+            )
+            text = response.content[0].text.strip()
+            return extract_json_from_response(text)
+        except Exception as exc:
+            self._logger.log("agent", f"Text query failed: {exc}")
+            return None
+
+    def vision_query(
+        self,
+        image_b64: str,
+        prompt: str,
+        *,
+        max_tokens: int = 512,
+    ) -> dict | None:
+        """Send an image + text prompt to the agent.
+
+        Args:
+            image_b64: Base64-encoded PNG image data.
+            prompt: Text prompt.
+            max_tokens: Maximum tokens in the response.
+
+        Returns:
+            Parsed JSON dict, or ``None`` on failure.
+        """
+        try:
+            response = self._client.messages.create(
+                model=self._model,
+                max_tokens=max_tokens,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": "image/png",
+                                    "data": image_b64,
+                                },
+                            },
+                            {"type": "text", "text": prompt},
+                        ],
+                    }
+                ],
+            )
+            text = response.content[0].text.strip()
+            return extract_json_from_response(text)
+        except Exception as exc:
+            self._logger.log("agent", f"Vision query failed: {exc}")
+            return None

teams_transcripts/domain/__init__.py

@@ -0,0 +1 @@
+"""Domain layer -- pure business logic with no external dependencies."""

teams_transcripts/domain/chat.py

@@ -0,0 +1,115 @@
+"""Pure chat message formatting functions.
+
+All functions in this module are pure: no I/O, no network, no logging,
+no global state.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+
+
+def build_chat_note_block(messages: list[dict], meeting_start: str) -> str:
+    """Build a VTT NOTE Chat block from chat messages.
+
+    Converts absolute timestamps to meeting-start-relative offsets in
+    ``HH:MM:SS.mmm`` format.  The output is a ``NOTE Chat`` block
+    containing a JSON array.
+
+    Args:
+        messages: Chat messages with absolute ``"timestamp"`` values.
+        meeting_start: Meeting start time as ISO 8601 (e.g.
+            ``"2026-04-22T11:15+01:00"``).
+
+    Returns:
+        The ``NOTE Chat`` block string (without surrounding blank lines).
+        Returns empty string when *messages* is empty.
+    """
+    if not messages:
+        return ""
+
+    try:
+        start_dt = datetime.fromisoformat(meeting_start)
+    except (ValueError, TypeError):
+        start_dt = None
+
+    offset_messages = []
+    for msg in messages:
+        entry = dict(msg)
+        if start_dt is not None:
+            try:
+                msg_dt = datetime.fromisoformat(entry["timestamp"])
+                delta = msg_dt - start_dt
+                total_ms = int(delta.total_seconds() * 1000)
+                if total_ms < 0:
+                    total_ms = 0
+                hours = total_ms // 3_600_000
+                minutes = (total_ms % 3_600_000) // 60_000
+                seconds = (total_ms % 60_000) // 1000
+                millis = total_ms % 1000
+                entry["offset"] = f"{hours:02d}:{minutes:02d}:{seconds:02d}.{millis:03d}"
+            except (ValueError, TypeError):
+                entry["offset"] = entry["timestamp"]
+        else:
+            entry["offset"] = entry["timestamp"]
+        del entry["timestamp"]
+        offset_messages.append(entry)
+
+    chat_json = json.dumps(offset_messages, indent=2, ensure_ascii=False)
+    return f"NOTE Chat\n{chat_json}"
+
+
+def compute_chat_offset(message_timestamp: str, meeting_start: str) -> str:
+    """Compute a single message's offset from meeting start.
+
+    Args:
+        message_timestamp: Message time as ISO 8601.
+        meeting_start: Meeting start time as ISO 8601.
+
+    Returns:
+        Offset as ``HH:MM:SS.mmm``, or the original timestamp on failure.
+    """
+    try:
+        start_dt = datetime.fromisoformat(meeting_start)
+        msg_dt = datetime.fromisoformat(message_timestamp)
+        delta = msg_dt - start_dt
+        total_ms = int(delta.total_seconds() * 1000)
+        if total_ms < 0:
+            total_ms = 0
+        hours = total_ms // 3_600_000
+        minutes = (total_ms % 3_600_000) // 60_000
+        seconds = (total_ms % 60_000) // 1000
+        millis = total_ms % 1000
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}.{millis:03d}"
+    except (ValueError, TypeError):
+        return message_timestamp
+
+
+def insert_chat_block(content: str, chat_block: str) -> str:
+    """Insert a NOTE Chat block into VTT content at the correct position.
+
+    The chat block is placed after the existing NOTE Meeting Metadata
+    block (if present), or after the WEBVTT header.
+
+    Args:
+        content: Raw VTT file content.
+        chat_block: The ``NOTE Chat`` block string.
+
+    Returns:
+        VTT content with the chat block inserted.
+    """
+    if not chat_block:
+        return content
+
+    # Insert after the existing NOTE block (metadata) if present.
+    note_end = content.find("\n\nNOTE")
+    if note_end != -1:
+        after_note = content.find("\n\n", note_end + 2)
+        if after_note != -1:
+            insert_pos = after_note + 2
+            return content[:insert_pos] + chat_block + "\n\n" + content[insert_pos:]
+        return content + "\n\n" + chat_block + "\n"
+    if content.startswith("WEBVTT"):
+        return content.replace("WEBVTT\n\n", f"WEBVTT\n\n{chat_block}\n\n", 1)
+    return f"WEBVTT\n\n{chat_block}\n\n{content}"

teams_transcripts/domain/html.py

@@ -0,0 +1,126 @@
+"""Pure HTML-to-text conversion for Teams chat messages.
+
+All functions in this module are pure: no I/O, no network, no logging,
+no global state.
+"""
+
+from __future__ import annotations
+
+import html as html_mod
+import re
+
+# ---------------------------------------------------------------------------
+# Reply quote removal
+# ---------------------------------------------------------------------------
+
+_REPLY_OPEN_RE = re.compile(
+    r'<(\w+)\b[^>]*?itemtype\s*=\s*"http://schema\.skype\.com/Reply"[^>]*>',
+    re.IGNORECASE,
+)
+
+
+def _remove_reply_quotes(html: str) -> str:
+    """Remove Teams inline reply/quote blocks from *html*.
+
+    Teams wraps quoted content inside a container element (typically
+    ``<div>`` or ``<blockquote>``) carrying
+    ``itemtype="http://schema.skype.com/Reply"``.  This function strips the
+    entire container and its contents so that only the user's own reply
+    text remains.
+
+    The removal is nesting-aware: if the container tag name (e.g. ``div``)
+    appears nested inside the quote, inner open/close pairs are tracked and
+    the correct outer closing tag is matched.
+    """
+    while True:
+        match = _REPLY_OPEN_RE.search(html)
+        if not match:
+            break
+
+        tag_name = match.group(1)
+        start = match.start()
+        pos = match.end()
+
+        open_re = re.compile(rf"<{tag_name}\b", re.IGNORECASE)
+        close_re = re.compile(rf"</{tag_name}\s*>", re.IGNORECASE)
+
+        depth = 1
+        end = len(html)  # fallback: remove to end of string
+        while depth > 0 and pos < len(html):
+            next_open = open_re.search(html, pos)
+            next_close = close_re.search(html, pos)
+
+            if next_close is None:
+                # No matching close tag — remove rest of string.
+                break
+
+            if next_open and next_open.start() < next_close.start():
+                depth += 1
+                pos = next_open.end()
+            else:
+                depth -= 1
+                if depth == 0:
+                    end = next_close.end()
+                pos = next_close.end()
+
+        html = html[:start] + html[end:]
+
+    return html
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def strip_html_to_text(html: str) -> str:
+    """Convert HTML message content to plain text.
+
+    Handles common Teams message markup: ``<p>``, ``<br>``, ``<div>``,
+    ``<a href="...">``, ``<span>``, and HTML entities.  Reply quote blocks
+    (``itemtype="http://schema.skype.com/Reply"``) are removed entirely so
+    that only the author's own text is returned.
+
+    Returns empty string for blank or whitespace-only content.
+
+    Args:
+        html: Raw HTML string from a Teams chat message.
+
+    Returns:
+        Plain text with reply quotes removed, block elements converted to
+        newlines, links shown as ``text (URL)``, entities decoded, and
+        consecutive newlines collapsed to a single newline.
+    """
+    if not html:
+        return ""
+
+    text = html
+
+    # Strip reply/quote blocks before any tag processing so that quoted
+    # author names and message text are not included in the output.
+    text = _remove_reply_quotes(text)
+
+    # Convert block-level elements to newlines
+    text = re.sub(r"<br\s*/?>", "\n", text, flags=re.IGNORECASE)
+    text = re.sub(r"</p>", "\n", text, flags=re.IGNORECASE)
+    text = re.sub(r"</div>", "\n", text, flags=re.IGNORECASE)
+    text = re.sub(r"</li>", "\n", text, flags=re.IGNORECASE)
+
+    # Extract link text with URL: <a href="URL">text</a> -> text (URL)
+    text = re.sub(
+        r'<a\s[^>]*href="([^"]*)"[^>]*>([^<]*)</a>',
+        r"\2 (\1)",
+        text,
+        flags=re.IGNORECASE,
+    )
+
+    # Remove all remaining HTML tags
+    text = re.sub(r"<[^>]+>", "", text)
+
+    # Decode HTML entities
+    text = html_mod.unescape(text)
+
+    # Collapse consecutive newlines into a single newline.
+    text = re.sub(r"\n{2,}", "\n", text)
+
+    return text.strip()