bazaar-compute-node 0.2.1rc15__py3-none-any.whl → 0.2.2rc2__py3-none-any.whl

bazaar_compute_node/app/attachments.py

@@ -21,12 +21,10 @@ class AttachmentMaterializer:
         referenced_paths: Callable[[], Awaitable[set[str]]],
         *,
         max_file_bytes: int = 25 * 1024 * 1024,
-        max_workspace_bytes: int = 1024 * 1024 * 1024,
     ) -> None:
         self._workspace = workspace
         self._referenced_paths = referenced_paths
         self._max_file_bytes = max_file_bytes
-        self._max_workspace_bytes = max_workspace_bytes
         self._lock = asyncio.Lock()
 
     async def reconcile(self) -> None:
@@ -66,11 +64,9 @@ class AttachmentMaterializer:
         source: bytes | AsyncIterable[bytes],
         temporary: Path,
         destination: Path,
-        root: Path,
     ) -> int:
         """Write an attachment aside, then move it into place once it is whole."""
 
-        current_size = await asyncio.to_thread(self._stored_size, root)
         descriptor: int | None = None
         try:
             descriptor = await asyncio.to_thread(
@@ -80,7 +76,7 @@ class AttachmentMaterializer:
                 0o600,
             )
             try:
-                size = await self._write(descriptor, source, current_size)
+                size = await self._write(descriptor, source)
                 await asyncio.to_thread(os.fsync, descriptor)
                 stored = await asyncio.to_thread(os.fstat, descriptor)
                 if stored.st_size != size:
@@ -107,12 +103,12 @@ class AttachmentMaterializer:
         self,
         descriptor: int,
         source: bytes | AsyncIterable[bytes],
-        current_size: int,
     ) -> int:
         """Write the source through, refusing it the moment it goes over a limit."""
 
         if isinstance(source, bytes):
-            self._check_room(len(source), current_size)
+            if len(source) > self._max_file_bytes:
+                raise ValueError("attachment exceeds the per-file size limit")
             await asyncio.to_thread(_write_all, descriptor, source)
             return len(source)
         size = 0
@@ -120,16 +116,11 @@ class AttachmentMaterializer:
             if not isinstance(chunk, bytes):
                 raise TypeError("attachment stream must yield bytes")
             size += len(chunk)
-            self._check_room(size, current_size)
+            if size > self._max_file_bytes:
+                raise ValueError("attachment exceeds the per-file size limit")
             await asyncio.to_thread(_write_all, descriptor, chunk)
         return size
 
-    def _check_room(self, size: int, current_size: int) -> None:
-        if size > self._max_file_bytes:
-            raise ValueError("attachment exceeds the per-file size limit")
-        if current_size + size > self._max_workspace_bytes:
-            raise ValueError("attachment workspace quota exceeded")
-
     async def materialize(
         self,
         source: bytes | AsyncIterable[bytes],
@@ -153,7 +144,7 @@ class AttachmentMaterializer:
             await asyncio.to_thread(
                 staging.mkdir, parents=True, exist_ok=True, mode=0o700
             )
-            size = await self._stage(source, temporary, destination, root)
+            size = await self._stage(source, temporary, destination)
         return InboundAttachment(
             attachment_id=attachment_id,
             name=Path(name).name,
@@ -181,17 +172,6 @@ class AttachmentMaterializer:
             error=error,
         )
 
-    @staticmethod
-    def _stored_size(root: Path) -> int:
-        if not root.exists():
-            return 0
-        return sum(
-            path.stat().st_size
-            for pattern in ("*/content", "*/content.*")
-            for path in root.glob(pattern)
-            if path.is_file() and not path.is_symlink()
-        )
-
 
 def _write_all(descriptor: int, payload: bytes) -> None:
     view = memoryview(payload)

bazaar_compute_node/contrib/wecom/channel.py

@@ -43,7 +43,7 @@ from ...core.timerwheel import TimerWheel
 from ...core.utils.clock import remaining
 from ...core.utils.markdown import split_markdown, utf8_bytes
 from ...i18n import ENGLISH, Translator, create_translator
-from .identity import conversation_thread_id, parse_provider_thread_id
+from .identity import TopicAddress, conversation_thread_id, parse_provider_thread_id
 from .outbound import (
     AttachmentReader,
     PreparedAttachment,
@@ -52,6 +52,7 @@ from .outbound import (
     prepare_attachments,
     visible_message_body,
 )
+from .topic import TopicConversations
 
 _STOP = object()
 _MAX_MEDIA_BYTES = 25 * 1024 * 1024
@@ -198,6 +199,13 @@ class WeComChannel(IChannel):
             self._logger.addHandler(logging.StreamHandler())
         self._logger.setLevel(logging.INFO)
         self._logger.propagate = False
+        self._topics = TopicConversations(
+            context,
+            bot_id=bot_id,
+            secret=secret,
+            emit=self._inbound.put,
+            logger=self._logger,
+        )
 
     @property
     def name(self) -> str:
@@ -241,6 +249,7 @@ class WeComChannel(IChannel):
         self._startup_finished.clear()
         self._startup_error = None
         self._state = "connecting"
+        self._topics.start()
         self._runner = asyncio.create_task(self._run(), name="bcn-wecom-channel")
         try:
             await asyncio.wait_for(self._startup_finished.wait(), timeout=timeout)
@@ -249,46 +258,57 @@ class WeComChannel(IChannel):
             self._runner.cancel()
             await asyncio.gather(self._runner, return_exceptions=True)
             self._runner = None
+            await self._topics.stop(timeout=timeout)
             self._state = "stopped"
             raise
         if self._startup_error is not None:
+            await self._topics.stop(timeout=timeout)
             raise self._startup_error
 
     async def stop(self, *, timeout: float) -> None:
         self._stopping.set()
-        decided_at_ms = time_ns() // 1_000_000
-        for pending in tuple(self._pending_approvals.values()):
-            if not pending.future.done():
-                pending.future.set_result(
-                    ApprovalResult(
-                        request_id=pending.request.approval.request_id,
-                        decision=ApprovalDecision.REJECTED,
-                        decided_at_ms=decided_at_ms,
-                        reason="channel_stopped",
-                    )
-                )
-        self._pending_approvals.clear()
-        self._approval_task_ids_by_request.clear()
-        await self._cancel_approval_card_updates()
+        deadline = asyncio.get_running_loop().time() + timeout
+        shutdown = asyncio.create_task(
+            self._topics.stop(timeout=timeout), name="bcn-wecom-topics-stop"
+        )
         try:
-            await asyncio.wait_for(self._send_lock.acquire(), timeout=timeout)
-        except TimeoutError:
-            pass
-        else:
-            self._send_lock.release()
-        connection = self._connection
-        if connection is not None:
-            await connection.close()
-        runner = self._runner
-        if runner is not None:
+            decided_at_ms = time_ns() // 1_000_000
+            for pending in tuple(self._pending_approvals.values()):
+                if not pending.future.done():
+                    pending.future.set_result(
+                        ApprovalResult(
+                            request_id=pending.request.approval.request_id,
+                            decision=ApprovalDecision.REJECTED,
+                            decided_at_ms=decided_at_ms,
+                            reason="channel_stopped",
+                        )
+                    )
+            self._pending_approvals.clear()
+            self._approval_task_ids_by_request.clear()
+            await self._cancel_approval_card_updates()
             try:
-                await asyncio.wait_for(runner, timeout=timeout)
+                await asyncio.wait_for(
+                    self._send_lock.acquire(), timeout=remaining(deadline)
+                )
             except TimeoutError:
-                runner.cancel()
-                await asyncio.gather(runner, return_exceptions=True)
-        self._runner = None
-        self._state = "stopped"
-        await self._inbound.put(_STOP)
+                pass
+            else:
+                self._send_lock.release()
+            connection = self._connection
+            if connection is not None:
+                await connection.close()
+            runner = self._runner
+            if runner is not None:
+                try:
+                    await asyncio.wait_for(runner, timeout=remaining(deadline))
+                except TimeoutError:
+                    runner.cancel()
+                    await asyncio.gather(runner, return_exceptions=True)
+        finally:
+            self._runner = None
+            await shutdown
+            self._state = "stopped"
+            await self._inbound.put(_STOP)
 
     async def receive(self) -> AsyncIterator[Message]:
         while True:
@@ -510,6 +530,24 @@ class WeComChannel(IChannel):
     async def send(
         self, request: ChannelSendRequest, *, timeout: float
     ) -> ProviderCallResult[ChannelDeliveryReceipt]:
+        try:
+            address = TopicAddress.parse(request.provider_thread_id)
+            if address is not None and address.bot_id != self._bot_id:
+                raise ValueError("WeCom topic belongs to another bot")
+        except ValueError as error:
+            return ProviderCallResult(
+                status=ProviderCallStatus.FAILED,
+                error_kind="invalid_topic_target",
+                error_message=str(error),
+            )
+        if address is not None:
+            if self._stopping.is_set():
+                return ProviderCallResult(
+                    status=ProviderCallStatus.FAILED,
+                    error_kind="channel_stopped",
+                    error_message="WeCom channel is stopping",
+                )
+            return await self._topics.send(request, address, timeout=timeout)
         _, target_id = parse_provider_thread_id(request.provider_thread_id)
         try:
             batches = (
@@ -945,6 +983,13 @@ class WeComChannel(IChannel):
     async def request_approval(
         self, request: ChannelApprovalRequest, *, timeout: float
     ) -> ApprovalResult:
+        if TopicAddress.parse(request.provider_thread_id) is not None:
+            return ApprovalResult(
+                request_id=request.approval.request_id,
+                decision=ApprovalDecision.REJECTED,
+                decided_at_ms=time_ns() // 1_000_000,
+                reason="WeCom native topics do not support approval cards",
+            )
         request_id = request.approval.request_id
         if timeout <= 0:
             raise TimeoutError("WeCom approval card delivery timed out")
@@ -1375,7 +1420,7 @@ class WeComChannel(IChannel):
         return False
 
     async def _receive_event(self, frame: Mapping[str, object]) -> None:
-        """Take in a bot event frame, which is only ever an approval decision."""
+        """Route native topic events and ordinary chat approval decisions."""
 
         body = frame.get("body")
         event = body.get("event") if isinstance(body, dict) else None
@@ -1387,6 +1432,8 @@ class WeComChannel(IChannel):
             "wecom.event.received",
             event_type=self._last_event_type,
         )
+        if isinstance(body, dict) and self._topics.receive(body):
+            return
         if (
             self._last_event_type == "template_card_event"
             and isinstance(event, dict)
@@ -1408,6 +1455,10 @@ class WeComChannel(IChannel):
         if not isinstance(body, dict):
             self._filter_message("invalid_body")
             return
+        compatibility = body.get("compat_info")
+        if isinstance(compatibility, dict) and compatibility.get("source") == "channel":
+            self._filter_message("native_topic_projection")
+            return
         route = self._route(body)
         if route is None:
             return

bazaar_compute_node/contrib/wecom/identity.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
+from urllib.parse import quote, unquote
+
 _PROVIDER_PREFIX = "wecom"
 
 
@@ -20,4 +23,49 @@ def parse_provider_thread_id(value: str) -> tuple[str, str]:
     return parts[1], parts[2]
 
 
-__all__ = ["conversation_thread_id", "parse_provider_thread_id"]
+@dataclass(frozen=True, slots=True)
+class TopicAddress:
+    bot_id: str
+    topic_id: str
+    post_id: str | None = None
+
+    @property
+    def provider_thread_id(self) -> str:
+        value = (
+            f"wecom:{quote(self.bot_id, safe='')}:topic:{quote(self.topic_id, safe='')}"
+        )
+        if self.post_id is not None:
+            value += f":post:{quote(self.post_id, safe='')}"
+        return value
+
+    @classmethod
+    def parse(cls, value: str) -> TopicAddress | None:
+        parts = value.split(":")
+        if len(parts) not in {4, 6} or parts[0] != "wecom" or parts[2] != "topic":
+            return None
+        if not parts[1] or not parts[3]:
+            raise ValueError("WeCom topic address requires a bot and channel")
+        if len(parts) == 6 and (parts[4] != "post" or not parts[5]):
+            raise ValueError("WeCom topic address requires a post id")
+        return cls(
+            unquote(parts[1]),
+            unquote(parts[3]),
+            unquote(parts[5]) if len(parts) == 6 else None,
+        )
+
+
+def post_message_id(post_id: str) -> str:
+    return "post:" + quote(post_id, safe="")
+
+
+def reply_message_id(post_id: str, reply_id: str) -> str:
+    return "reply:" + quote(post_id, safe="") + ":" + quote(reply_id, safe="")
+
+
+__all__ = [
+    "TopicAddress",
+    "conversation_thread_id",
+    "parse_provider_thread_id",
+    "post_message_id",
+    "reply_message_id",
+]