discomposer 0.1.0__tar.gz

discomposer-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+.venv/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+

discomposer-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cane
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

discomposer-0.1.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.5
+Name: discomposer
+Version: 0.1.0
+Summary: Validate, fetch and send Discord message templates as Components V2 with discord.py.
+Project-URL: Homepage, https://github.com/caneabi/discomposer
+Project-URL: Editor, https://editor.caneabi.dev
+Project-URL: Documentation, https://github.com/caneabi/discomposer/tree/main/packages/python#readme
+Project-URL: Format, https://github.com/caneabi/discomposer/blob/main/spec/FORMAT.md
+Project-URL: Issues, https://github.com/caneabi/discomposer/issues
+Author: Cane
+License-Expression: MIT
+License-File: LICENSE
+Keywords: components-v2,discord,discord.py,embeds,message-builder,templates,tickets
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications :: Chat
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: aiohttp<4,>=3.9
+Requires-Dist: discord-py<3,>=2.6
+Provides-Extra: test
+Requires-Dist: pytest-asyncio<2,>=0.24; extra == 'test'
+Requires-Dist: pytest<10,>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+<h1 align="center">discomposer for discord.py</h1>
+
+<p align="center">
+  Validate, fetch and send Discord message templates as Components V2.<br>
+  Design the message in the <a href="https://editor.caneabi.dev">visual editor</a>, send it from your bot with a code.
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/discomposer/"><img src="https://img.shields.io/pypi/v/discomposer?color=7b61ff" alt="PyPI"></a>
+  <a href="https://pypi.org/project/discomposer/"><img src="https://img.shields.io/pypi/pyversions/discomposer?color=7b61ff" alt="Python versions"></a>
+  <a href="https://github.com/caneabi/discomposer/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-ff7a59" alt="MIT license"></a>
+</p>
+
+discomposer only builds messages. What a button or selection does (open a ticket, hand out a role) stays in your bot.
+
+## Install
+
+```bash
+pip install discomposer
+```
+
+Requires Python 3.11+ and discord.py 2.6+.
+
+## Fetch a template and send it
+
+```python
+import discord
+from discomposer import EditorClient, MediaStore, render_message, select_rows
+
+editor = EditorClient(media=MediaStore("data/media"))
+
+async def send(channel, code):
+    design = await editor.fetch(code)  # validates and keeps a copy of every image
+    view = discord.ui.LayoutView(timeout=None)
+    for item in render_message(
+        design,
+        guild=channel.guild,
+        buttons={"ticket": lambda b: discord.ui.Button(label=b["label"], custom_id="mybot:ticket")},
+        slots={"online": "12 members online"},
+        selects=lambda menu, guild: select_rows(menu, f"mybot:{menu['id']}"),
+    ):
+        view.add_item(item)
+    await channel.send(view=view, files=editor.media.files_for(design))
+```
+
+`render_message` returns the text outside the box (if any) and the filled container. Use `render` to fill a container you created yourself.
+
+## Offer your bot's features in the editor
+
+```python
+from discomposer import guild_context
+
+link = await editor.open({
+    "title": "Ticket panel",
+    "context": {
+        **guild_context(guild),
+        "buttons": [{"id": "ticket", "label": "Open ticket"}],
+        "selects": [{"purpose": "ticket_categories", "label": "Ticket categories", "roles": "optional"}],
+    },
+    "design": {"blocks": [{"text": "## Support"}]},
+})
+```
+
+The person designs the message at `link` and gives your bot the new code.
+
+## Handle a selection
+
+Values and roles only ever come from the stored template, never from the interaction:
+
+```python
+from discomposer import category_roles, chosen_category, ticket_overwrites
+
+option = chosen_category(saved_design, "tickets", interaction.data["values"][0])
+if option:
+    roles = category_roles(guild, option)
+    channel = await guild.create_text_channel(
+        f"ticket-{interaction.user.name}",
+        overwrites=ticket_overwrites(guild, interaction.user, roles),
+    )
+```
+
+## API overview
+
+| Area | Functions |
+| --- | --- |
+| Format | `validate`, `validate_design`, `find_select`, `selects_for`, `chosen_options` |
+| Sending | `render`, `render_message`, `outside_text`, `select_rows`, `fill_variables`, `VARIABLES` |
+| Editor | `EditorClient` (`open`, `fetch`, `fetch_document`, `upload`, `adopt_images`, `expose_attachments`, `open_message`), `guild_context`, `parse_code` |
+| Images | `MediaStore` (`save`, `files_for`) |
+| Tickets | `ticket_categories`, `chosen_category`, `category_roles`, `missing_roles`, `ticket_overwrites`, `transcript_markdown` |
+
+Errors: `TemplateError` (format), `EditorError` (editor, network), `MediaError` (images). Messages are written for end users.
+
+The template format is specified in [spec/FORMAT.md](https://github.com/caneabi/discomposer/blob/main/spec/FORMAT.md). A JavaScript version for discord.js is available as [`discomposer` on npm](https://www.npmjs.com/package/discomposer).
+
+discomposer is not affiliated with or endorsed by Discord Inc.

discomposer-0.1.0/README.md

@@ -0,0 +1,96 @@
+<h1 align="center">discomposer for discord.py</h1>
+
+<p align="center">
+  Validate, fetch and send Discord message templates as Components V2.<br>
+  Design the message in the <a href="https://editor.caneabi.dev">visual editor</a>, send it from your bot with a code.
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/discomposer/"><img src="https://img.shields.io/pypi/v/discomposer?color=7b61ff" alt="PyPI"></a>
+  <a href="https://pypi.org/project/discomposer/"><img src="https://img.shields.io/pypi/pyversions/discomposer?color=7b61ff" alt="Python versions"></a>
+  <a href="https://github.com/caneabi/discomposer/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-ff7a59" alt="MIT license"></a>
+</p>
+
+discomposer only builds messages. What a button or selection does (open a ticket, hand out a role) stays in your bot.
+
+## Install
+
+```bash
+pip install discomposer
+```
+
+Requires Python 3.11+ and discord.py 2.6+.
+
+## Fetch a template and send it
+
+```python
+import discord
+from discomposer import EditorClient, MediaStore, render_message, select_rows
+
+editor = EditorClient(media=MediaStore("data/media"))
+
+async def send(channel, code):
+    design = await editor.fetch(code)  # validates and keeps a copy of every image
+    view = discord.ui.LayoutView(timeout=None)
+    for item in render_message(
+        design,
+        guild=channel.guild,
+        buttons={"ticket": lambda b: discord.ui.Button(label=b["label"], custom_id="mybot:ticket")},
+        slots={"online": "12 members online"},
+        selects=lambda menu, guild: select_rows(menu, f"mybot:{menu['id']}"),
+    ):
+        view.add_item(item)
+    await channel.send(view=view, files=editor.media.files_for(design))
+```
+
+`render_message` returns the text outside the box (if any) and the filled container. Use `render` to fill a container you created yourself.
+
+## Offer your bot's features in the editor
+
+```python
+from discomposer import guild_context
+
+link = await editor.open({
+    "title": "Ticket panel",
+    "context": {
+        **guild_context(guild),
+        "buttons": [{"id": "ticket", "label": "Open ticket"}],
+        "selects": [{"purpose": "ticket_categories", "label": "Ticket categories", "roles": "optional"}],
+    },
+    "design": {"blocks": [{"text": "## Support"}]},
+})
+```
+
+The person designs the message at `link` and gives your bot the new code.
+
+## Handle a selection
+
+Values and roles only ever come from the stored template, never from the interaction:
+
+```python
+from discomposer import category_roles, chosen_category, ticket_overwrites
+
+option = chosen_category(saved_design, "tickets", interaction.data["values"][0])
+if option:
+    roles = category_roles(guild, option)
+    channel = await guild.create_text_channel(
+        f"ticket-{interaction.user.name}",
+        overwrites=ticket_overwrites(guild, interaction.user, roles),
+    )
+```
+
+## API overview
+
+| Area | Functions |
+| --- | --- |
+| Format | `validate`, `validate_design`, `find_select`, `selects_for`, `chosen_options` |
+| Sending | `render`, `render_message`, `outside_text`, `select_rows`, `fill_variables`, `VARIABLES` |
+| Editor | `EditorClient` (`open`, `fetch`, `fetch_document`, `upload`, `adopt_images`, `expose_attachments`, `open_message`), `guild_context`, `parse_code` |
+| Images | `MediaStore` (`save`, `files_for`) |
+| Tickets | `ticket_categories`, `chosen_category`, `category_roles`, `missing_roles`, `ticket_overwrites`, `transcript_markdown` |
+
+Errors: `TemplateError` (format), `EditorError` (editor, network), `MediaError` (images). Messages are written for end users.
+
+The template format is specified in [spec/FORMAT.md](https://github.com/caneabi/discomposer/blob/main/spec/FORMAT.md). A JavaScript version for discord.js is available as [`discomposer` on npm](https://www.npmjs.com/package/discomposer).
+
+discomposer is not affiliated with or endorsed by Discord Inc.

discomposer-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "discomposer"
+version = "0.1.0"
+description = "Validate, fetch and send Discord message templates as Components V2 with discord.py."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = ["discord.py>=2.6,<3", "aiohttp>=3.9,<4"]
+authors = [{ name = "Cane" }]
+keywords = ["discord", "discord.py", "components-v2", "embeds", "templates", "message-builder", "tickets"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Framework :: AsyncIO",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Communications :: Chat",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/caneabi/discomposer"
+Editor = "https://editor.caneabi.dev"
+Documentation = "https://github.com/caneabi/discomposer/tree/main/packages/python#readme"
+Format = "https://github.com/caneabi/discomposer/blob/main/spec/FORMAT.md"
+Issues = "https://github.com/caneabi/discomposer/issues"
+
+[project.optional-dependencies]
+test = ["pytest>=8,<10", "pytest-asyncio>=0.24,<2"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/discomposer"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+

discomposer-0.1.0/src/discomposer/__init__.py

@@ -0,0 +1,72 @@
+"""discomposer: validate, fetch and send Discord message templates with discord.py."""
+
+from discomposer.editor import (
+    DEFAULT_URL,
+    EditorClient,
+    EditorError,
+    components_to_blocks,
+    emoji_text,
+    guild_context,
+    parse_code,
+)
+from discomposer.format import (
+    TemplateError,
+    chosen_options,
+    clean_emoji,
+    find_select,
+    selects_for,
+    validate,
+    validate_design,
+)
+from discomposer.media import MediaError, MediaStore, image_extension
+from discomposer.render import (
+    button_emoji,
+    button_style,
+    outside_text,
+    render,
+    render_message,
+    select_rows,
+)
+from discomposer.tickets import (
+    category_roles,
+    chosen_category,
+    missing_roles,
+    ticket_categories,
+    ticket_overwrites,
+    transcript_markdown,
+)
+from discomposer.variables import VARIABLES, fill_variables
+
+__all__ = [
+    "DEFAULT_URL",
+    "VARIABLES",
+    "EditorClient",
+    "EditorError",
+    "MediaError",
+    "MediaStore",
+    "TemplateError",
+    "button_emoji",
+    "button_style",
+    "category_roles",
+    "chosen_category",
+    "chosen_options",
+    "clean_emoji",
+    "components_to_blocks",
+    "emoji_text",
+    "fill_variables",
+    "find_select",
+    "guild_context",
+    "image_extension",
+    "missing_roles",
+    "parse_code",
+    "outside_text",
+    "render",
+    "render_message",
+    "select_rows",
+    "selects_for",
+    "ticket_categories",
+    "ticket_overwrites",
+    "transcript_markdown",
+    "validate",
+    "validate_design",
+]

discomposer-0.1.0/src/discomposer/editor.py

@@ -0,0 +1,266 @@
+import copy
+import json
+import re
+from pathlib import PurePosixPath
+from urllib.parse import urlsplit
+
+import aiohttp
+
+from discomposer.format import validate, validate_design
+from discomposer.media import MAX_IMAGE, MediaError
+
+DEFAULT_URL = "https://editor.caneabi.dev"
+# Only the editor and Discord's CDN are fetched, so templates can't reach internal URLs.
+DISCORD_MEDIA = frozenset({"cdn.discordapp.com", "media.discordapp.net"})
+CODE = re.compile(r"[0-9A-HJKMNP-TV-Z]{5}-[0-9A-HJKMNP-TV-Z]{5}")
+MAX_RESPONSE = 70 * 1024
+OFFLINE = "The editor is unavailable right now. Please try again later."
+
+
+class EditorError(Exception):
+    """Talking to the editor failed. The message is meant for end users."""
+
+
+async def read_all(response, limit):
+    # response.content.read(n) returns whatever has arrived so far, which truncates large images.
+    data = bytearray()
+    async for chunk in response.content.iter_chunked(64 * 1024):
+        data.extend(chunk)
+        if len(data) > limit:
+            raise EditorError("The response is too large.")
+    return bytes(data)
+
+
+def parse_code(value):
+    """Return the code from a code or an editor link."""
+    code = str(value).strip().rstrip("/").rsplit("/", 1)[-1].upper()
+    if not CODE.fullmatch(code):
+        raise EditorError("That is not a valid code. It looks like this: K7F3M-9QX2A")
+    return code
+
+
+def components_to_blocks(items, on_row_item=None):
+    """Convert sent Components V2 back into blocks.
+
+    on_row_item(child, blocks) may turn your own buttons or menus into blocks and returns True.
+    Returns (blocks, color, has_actions); has_actions means interactive components were left over.
+    """
+    blocks, color, has_actions = [], None, False
+
+    def walk(parts):
+        nonlocal color, has_actions
+        for part in parts:
+            kind = part.get("type")
+            if kind == 17:
+                color = part.get("accent_color", color)
+                walk(part.get("components", []))
+            elif kind == 9:
+                accessory = part.get("accessory", {})
+                if accessory.get("type") == 11:
+                    blocks.append({"image": accessory.get("media", {}).get("url")})
+                elif accessory.get("type") == 2:
+                    walk([{"type": 1, "components": [accessory]}])
+                walk(part.get("components", []))
+            elif kind == 10:
+                blocks.append({"text": part.get("content", "")})
+            elif kind == 12:
+                blocks.extend(
+                    {"gallery": item.get("media", {}).get("url")} for item in part.get("items", [])
+                )
+            elif kind == 14:
+                blocks.append({"separator": True})
+            elif kind == 1:
+                for child in part.get("components", []):
+                    if on_row_item and on_row_item(child, blocks):
+                        continue
+                    if child.get("type") == 2 and child.get("style") == 5:
+                        link = {"label": child.get("label") or "Link", "url": child.get("url")}
+                        if emoji_text(child.get("emoji")):
+                            link["emoji"] = emoji_text(child.get("emoji"))
+                        blocks.append({"link": link})
+                    else:
+                        has_actions = True
+
+    walk(items)
+    return blocks, color, has_actions
+
+
+def emoji_text(emoji):
+    """Emoji of a component in template notation."""
+    if emoji and emoji.get("id"):
+        prefix = "a" if emoji.get("animated") else ""
+        return f"<{prefix}:{emoji.get('name')}:{emoji['id']}>"
+    return emoji.get("name") if emoji else None
+
+
+def guild_context(guild):
+    """Channels, roles and emojis for the editor. Codes aren't secret, so only public ones."""
+    everyone = guild.default_role
+    channels = [
+        channel for channel in guild.text_channels if channel.permissions_for(everyone).view_channel
+    ]
+    roles = [r for r in guild.roles if not r.is_default() and not r.managed]
+    emojis = [e for e in guild.emojis if e.available]
+    return {
+        "channels": [{"id": str(c.id), "name": c.name} for c in channels[:200]],
+        "roles": [{"id": str(r.id), "name": r.name} for r in reversed(roles[-200:])],
+        "emojis": [{"id": str(e.id), "name": e.name, "animated": e.animated} for e in emojis[:200]],
+    }
+
+
+class EditorClient:
+    """Client for the template editor. Pass a MediaStore to keep copies of images."""
+
+    def __init__(self, base_url=DEFAULT_URL, media=None, *, timeout=30):
+        self.base_url = base_url.rstrip("/")
+        self.media = media
+        self.timeout = timeout
+        self.image_url = re.compile(re.escape(self.base_url) + r"/api/images/[0-9a-f]{64}")
+
+    async def _request(self, method, path, *, limit=MAX_RESPONSE, parse=True, **kwargs):
+        timeout = aiohttp.ClientTimeout(total=self.timeout)
+        try:
+            async with (
+                aiohttp.ClientSession(timeout=timeout) as session,
+                session.request(
+                    method, self.base_url + path, allow_redirects=False, **kwargs
+                ) as response,
+            ):
+                raw = await read_all(response, limit)
+                return response.status, json.loads(raw) if parse else raw
+        except (aiohttp.ClientError, TimeoutError, ValueError):
+            raise EditorError(OFFLINE) from None
+
+    async def open(self, document):
+        """Store a document and return the link to edit it."""
+        document = validate(document)
+        status, body = await self._request("POST", "/api/templates", json=document)
+        if status != 201 or not isinstance(body, dict) or not isinstance(body.get("code"), str):
+            raise EditorError((body or {}).get("error") if isinstance(body, dict) else OFFLINE)
+        return f"{self.base_url}/e/{body['code']}"
+
+    async def upload(self, raw):
+        """Upload an image and return its URL."""
+        status, body = await self._request(
+            "POST", "/api/images", data=raw, headers={"content-type": "application/octet-stream"}
+        )
+        if status != 201 or not isinstance(body, dict) or not isinstance(body.get("path"), str):
+            raise EditorError((body or {}).get("error") if isinstance(body, dict) else OFFLINE)
+        return self.base_url + body["path"]
+
+    async def fetch_document(self, code):
+        """Fetch and validate a document by code or link."""
+        status, body = await self._request("GET", f"/api/templates/{parse_code(code)}")
+        if status == 404:
+            raise EditorError("This code doesn't exist or has expired.")
+        if status != 200 or not isinstance(body, dict):
+            raise EditorError(OFFLINE)
+        return validate(body)
+
+    async def fetch(self, code, *, adopt_images=True):
+        """Fetch the design of a template; images are adopted if a MediaStore is set."""
+        design = (await self.fetch_document(code))["design"]
+        if adopt_images and self.media is not None:
+            design = await self.adopt_images(design)
+        return design
+
+    async def _download(self, url):
+        timeout = aiohttp.ClientTimeout(total=self.timeout)
+        try:
+            async with (
+                aiohttp.ClientSession(timeout=timeout) as session,
+                session.get(url, allow_redirects=False) as response,
+            ):
+                if response.status != 200:
+                    raise EditorError(
+                        "A Discord image has expired. Please upload it again in the editor."
+                    )
+                return await read_all(response, MAX_IMAGE)
+        except (aiohttp.ClientError, TimeoutError):
+            raise EditorError(
+                "An image could not be loaded. Please upload it in the editor."
+            ) from None
+
+    async def adopt_images(self, design):
+        """Store editor and Discord images and point the blocks at attachment:// names.
+
+        The result has attachments: {filename: stored name}. Editor images expire after 30 days.
+        """
+        if self.media is None:
+            raise EditorError("The client needs a MediaStore to adopt images.")
+        design = copy.deepcopy(design)
+        attachments = dict(design.get("attachments", {}))
+        for block in design["blocks"]:
+            for key in ("image", "gallery"):
+                value = block.get(key)
+                if not isinstance(value, str):
+                    continue
+                if self.image_url.fullmatch(value):
+                    status, raw = await self._request(
+                        "GET", urlsplit(value).path, limit=MAX_IMAGE, parse=False
+                    )
+                    if status != 200:
+                        raise EditorError("An uploaded image has expired. Please upload it again.")
+                elif value.startswith("https://") and urlsplit(value).hostname in DISCORD_MEDIA:
+                    raw = await self._download(value)
+                else:
+                    continue
+                try:
+                    stored = self.media.save(raw)
+                except MediaError as error:
+                    raise EditorError(str(error)) from None
+                filename = self.media.attachment_name(stored, raw)
+                attachments[filename] = stored
+                block[key] = f"attachment://{filename}"
+        if attachments:
+            design["attachments"] = attachments
+        return design
+
+    async def expose_attachments(self, design):
+        """Reverse of adopt_images: upload stored attachments so the editor can show them."""
+        design = copy.deepcopy(design)
+        stored = design.pop("attachments", {})
+        for block in design.get("blocks", []):
+            for key in ("image", "gallery"):
+                value = block.get(key)
+                if isinstance(value, str) and value.startswith("attachment://"):
+                    name = stored.get(value.removeprefix("attachment://"))
+                    if name is None or self.media is None:
+                        raise EditorError("An image of this template is missing.")
+                    block[key] = await self.upload(self.media.read(name))
+        return validate_design(design)
+
+    async def open_message(self, message, *, on_row_item=None, **document):
+        """Open a sent message in the editor. Returns None if it has components nobody handles."""
+        items = [component.to_dict() for component in message.components]
+        blocks, color, has_actions = components_to_blocks(items, on_row_item)
+        if has_actions:
+            return None
+        if message.content:
+            blocks.insert(0, {"text": message.content})
+        for embed in message.embeds:
+            parts = [f"## {embed.title}" if embed.title else None, embed.description]
+            text = "\n".join(part for part in parts if part)
+            if text:
+                blocks.append({"text": text})
+            if embed.image and embed.image.url:
+                blocks.append({"gallery": embed.image.url})
+            if color is None and embed.colour:
+                color = embed.colour.value
+        files = {attachment.filename: attachment for attachment in message.attachments}
+        for block in blocks:
+            for key in ("image", "gallery"):
+                value = block.get(key)
+                if not isinstance(value, str):
+                    continue
+                name = (
+                    value.removeprefix("attachment://")
+                    if value.startswith("attachment://")
+                    else PurePosixPath(urlsplit(value).path).name
+                )
+                if name in files:
+                    block[key] = await self.upload(await files[name].read())
+        design = {"blocks": blocks}
+        if color is not None:
+            design["color"] = color
+        return await self.open({**document, "design": design})