django-tgcms 0.1.0__py3-none-any.whl

django_tgcms-0.1.0.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: django-tgcms
+Version: 0.1.0
+Summary: Django reusable app: a Telegram post constructor that outputs Bot API-ready {text, entities} payloads.
+Project-URL: Homepage, https://gitlab.com/ddnsupp/django-tgcms
+Author: ddnsupp
+License: MIT
+License-File: LICENSE
+Keywords: bot-api,cms,django,entities,telegram
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: django>=4.2
+Description-Content-Type: text/markdown
+
+# django-tgcms
+
+A reusable Django app for building Telegram posts. Compose posts from blocks
+(heading, formatted text, photo, video) using a WYSIWYG editor embedded in
+Django admin. `Post.render()` returns a Bot API-ready payload — sending is
+entirely up to you.
+
+**No dependencies beyond Django. No bot logic, no HTTP calls.**
+
+---
+
+## Installation
+
+```bash
+pip install django-tgcms
+# or
+uv add django-tgcms
+```
+
+`settings.py`:
+
+```python
+INSTALLED_APPS = [
+    ...
+    "tgcms",
+]
+
+# Optional — only needed for the send_post test command
+TGCMS = {
+    "BOT_TOKEN": env("YOUR_BOT_TOKEN"),  # map whatever name your project uses
+}
+```
+
+`urls.py` (only if you need the built-in views):
+
+```python
+urlpatterns += [
+    path("tg/", include("tgcms.urls")),
+]
+```
+
+Run migrations:
+
+```bash
+python manage.py migrate
+```
+
+---
+
+## Content — Django admin
+
+Posts are edited in the standard Django admin at `/admin/tgcms/post/`.
+
+**Block types** (drag-and-drop reordering inside each post):
+
+| Type | Stores |
+|---|---|
+| `heading` | Plain text title |
+| `text` | Formatted text — bold, italic, underline, strikethrough, spoiler, code, pre, blockquote, links |
+| `photo` | Media asset + caption |
+| `video` | Media asset + caption |
+
+**MediaAsset** (`/admin/tgcms/mediaasset/`) is a shared media registry. One
+asset can be referenced by any number of blocks across any number of posts.
+After the first Telegram send the `telegram_file_id` is cached on the asset —
+subsequent sends reuse it without re-uploading.
+
+---
+
+## Bot integration
+
+```python
+from tgcms.models import Post
+
+post = Post.objects.prefetch_related("blocks__media").get(pk=post_id)
+payload = post.render()
+# {
+#   "blocks": [
+#     {"type": "heading", "text": "Title"},
+#     {"type": "text", "text": "Hello!", "entities": [{"type": "bold", "offset": 0, "length": 5}]},
+#     {"type": "photo", "media_asset_id": 3, "file": "AgACAgI...", "caption": "..."},
+#   ]
+# }
+```
+
+**aiogram broadcast pattern:**
+
+```python
+from asgiref.sync import sync_to_async
+
+async def send_post(bot, chat_id: int, post_id: int):
+    post = await sync_to_async(
+        Post.objects.prefetch_related("blocks__media").get
+    )(pk=post_id)
+
+    for block in post.blocks.all():
+        data = block.render()
+
+        if data["type"] == "heading":
+            await bot.send_message(chat_id, f"<b>{data['text']}</b>", parse_mode="HTML")
+
+        elif data["type"] == "text":
+            await bot.send_message(chat_id, data["text"])
+
+        elif data["type"] == "photo":
+            msg = await bot.send_photo(
+                chat_id,
+                photo=data["file"],        # telegram_file_id, S3 URL, or local path
+                caption=data.get("caption"),
+            )
+            # Cache file_id after first upload — all future renders return it
+            if block.media and not block.media.telegram_file_id:
+                await sync_to_async(block.media.cache_file_id)(msg.photo[-1].file_id)
+
+        elif data["type"] == "video":
+            msg = await bot.send_video(chat_id, video=data["file"], caption=data.get("caption"))
+            if block.media and not block.media.telegram_file_id:
+                await sync_to_async(block.media.cache_file_id)(msg.video.file_id)
+```
+
+Once `cache_file_id()` is called, `block.media.source` returns the cached
+`telegram_file_id` for every subsequent post that references the same asset.
+
+---
+
+## Testing — management command
+
+```bash
+# Token is read from settings.TGCMS["BOT_TOKEN"] automatically
+python manage.py send_post <post_id> <chat_id>
+
+# Or pass it explicitly
+python manage.py send_post 1 @mychannel --token 123456:ABC...
+
+# Or via env var
+TELEGRAM_BOT_TOKEN=123456:ABC... python manage.py send_post 1 123456789
+```
+
+Token lookup order: `--token` → `settings.TGCMS["BOT_TOKEN"]` → `TELEGRAM_BOT_TOKEN` env var.
+
+---
+
+## Models
+
+```
+MediaAsset
+  file              FileField — upload from disk
+  file_url          URLField  — S3 / CDN link
+  telegram_file_id  Cached after first send (read-only in admin)
+  .source           Property: returns the best available file reference
+  .cache_file_id()  Persists telegram_file_id; call once after the first send
+
+Post
+  title, status     draft / published
+  .render()         Returns {"blocks": [...]}
+  .mark_published() Sets status and published_at
+
+Block               FK → Post, FK → MediaAsset (nullable)
+  type              heading / text / photo / video
+  order             Managed by drag-and-drop in admin
+  text, entities    heading and text blocks
+  media             FK → MediaAsset, photo and video blocks
+  caption, caption_entities
+  .render()         Returns one block in Bot API format
+```
+
+---
+
+## UTF-16 offsets
+
+`MessageEntity.offset` and `length` are counted in UTF-16 code units, not
+Python characters. Non-BMP characters (e.g. 😀 U+1F600) occupy 2 units, not 1.
+All offset arithmetic in `tgcms.formatting` goes through `utf16_len()`.
+
+---
+
+## License
+
+MIT

django_tgcms-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+tgcms/__init__.py,sha256=uidcTMJ2Hf2gTlLmV-xlhpGK_14enIZ7j4YJF35KCgU,156
+tgcms/admin.py,sha256=Wwd13CO1cTmrmajw3L9IAaOKt588t6hMXQtmNxn47-Y,1897
+tgcms/apps.py,sha256=6PSMngrAbcc2U0vNIgTTJqA_AVva243seEeEVHgM_NM,176
+tgcms/conf.py,sha256=zEnJXUaX2BqJ90bRlWZQHcA8WfsRrNcXsJF1qgxeNio,500
+tgcms/forms.py,sha256=70lctbvBnET6FPl5gWsveF6frWviJ6WaQTnVl64Y4Sc,2076
+tgcms/models.py,sha256=G6Ou7sarjVi8yd7mTcBh7h4Xy3uv0fgSELDM0ZV4UIo,4380
+tgcms/urls.py,sha256=oVGslz6aoplONMANLjv0Ml5vbB_1QzXuaLSdqDjtJNc,397
+tgcms/views.py,sha256=Y2Mv71yrCmd8_dL1fHJnC4K-bzAih0g5OgQpEqMaIUA,1409
+tgcms/widgets.py,sha256=9NrZa2lYVejPkV53YAjbPho4pXFX079ZYLsZB5pl1KU,2155
+tgcms/formatting/__init__.py,sha256=MNOIowE0hzrcVBQNCNLhfTMz5jaiGKYF994zS6goiwU,510
+tgcms/formatting/entities.py,sha256=rl2huXcnI2Z3vLBtaSXNm2KPK9fwzcuhrfcND3KM2DI,602
+tgcms/formatting/html.py,sha256=WVKY83VWMn_16L2GWKQDZEnUlMe2piwLnMMfBggJig4,6003
+tgcms/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgcms/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgcms/management/commands/send_post.py,sha256=IuiyYB6a0tyJzYRTuzm6Qr5fS-3JFOW3Cdrk1ToadK8,5125
+tgcms/migrations/0001_initial.py,sha256=Gka6mAlL_LZUiAb33PpXJ2wuBSKNQ0YDbV3nnCYCMMA,1217
+tgcms/migrations/0002_remove_post_entities_remove_post_text_and_more.py,sha256=UY9qgfWN4Sj5vHUpsChBdm0Fco56LS0rjjb0PguMkQ8,1674
+tgcms/migrations/0003_block_file_url_block_telegram_file_id.py,sha256=XNUG-0wFmbolLgiUSPyhzqmmYt8ZwPZLSxrfBHh2isA,641
+tgcms/migrations/0004_mediaasset_remove_block_file_remove_block_file_url_and_more.py,sha256=YG5HEukPIUUaAD-7GVm2_ISjcoFCRneeDuvYd4JUBII,1585
+tgcms/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tgcms/static/tgcms/block_inline.js,sha256=96Q_w7ro_23cbzpZQdcHfsb73-8eet2Bmcck6aVSjmY,6539
+tgcms/static/tgcms/editor.css,sha256=8S0t_2FkxU1DPCu3RH_JpTHXfhcJ4e16--CyhaZouuE,3266
+tgcms/static/tgcms/editor.js,sha256=lqLhMMmcwsjK_Vk7zIMuPOPxvUATRZoLQPeEPrKbeqE,2609
+tgcms/templates/tgcms/base.html,sha256=9Lubq75QXFacJY2sWZyUb7qXU9b4aqwkhM9g2--GlMU,431
+tgcms/templates/tgcms/post_form.html,sha256=7QnIeJLISklQZBgNAUegtSZLFs02HCshAnXwLx9gjP4,1988
+tgcms/templates/tgcms/post_list.html,sha256=p5O6Facxpw8WK2GYRyrXdyZeKW_fCp4HpLC4s6dyrpA,585
+tgcms/templates/tgcms/post_published.html,sha256=qL8YFUo9bkoVs258OXAI2MK8XUP0wmCK-cF8QUw0Q2U,490
+django_tgcms-0.1.0.dist-info/METADATA,sha256=53AVa9WxqBQUQJnaLfm3gTG9YpaVGSQo-EQyJFnCuYc,5845
+django_tgcms-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+django_tgcms-0.1.0.dist-info/licenses/LICENSE,sha256=a9QcPC5WwLGhHPFm0vuD0qhMHsy4JiRE8XjChhGvAkE,1064
+django_tgcms-0.1.0.dist-info/RECORD,,

django_tgcms-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

django_tgcms-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ddnsupp
+
+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.

tgcms/__init__.py

@@ -0,0 +1,6 @@
+"""django-tgcms: a Telegram post constructor for Django.
+
+The import package is ``tgcms``; the distribution is ``django-tgcms``.
+"""
+
+__version__ = "0.1.0"

tgcms/admin.py

@@ -0,0 +1,60 @@
+from django.contrib import admin
+
+from .forms import BlockForm, PostForm
+from .models import Block, MediaAsset, Post
+
+
+@admin.register(MediaAsset)
+class MediaAssetAdmin(admin.ModelAdmin):
+    list_display = ("__str__", "has_file_id", "created_at")
+    search_fields = ("name", "file_url", "telegram_file_id")
+    readonly_fields = ("telegram_file_id", "created_at")
+    fields = ("name", "file", "file_url", "telegram_file_id", "created_at")
+
+    @admin.display(description="Cached", boolean=True)
+    def has_file_id(self, obj):
+        return bool(obj.telegram_file_id)
+
+
+class BlockInline(admin.StackedInline):
+    model = Block
+    form = BlockForm
+    extra = 1
+    fields = ("order", "type", "content_html", "media", "caption_html")
+    autocomplete_fields = ("media",)
+
+    class Media:
+        css = {"all": ("tgcms/editor.css",)}
+        js = ("tgcms/block_inline.js",)
+
+
+@admin.register(Post)
+class PostAdmin(admin.ModelAdmin):
+    form = PostForm
+    inlines = [BlockInline]
+    list_display = ("__str__", "status", "block_count", "updated_at", "published_at")
+    list_filter = ("status",)
+    search_fields = ("title",)
+    actions = ["publish_selected"]
+    fieldsets = [
+        (None, {"fields": ("title", "status")}),
+        (
+            "Timestamps",
+            {
+                "fields": ("created_at", "updated_at", "published_at"),
+                "classes": ("collapse",),
+            },
+        ),
+    ]
+    readonly_fields = ("created_at", "updated_at", "published_at")
+
+    @admin.display(description="Blocks")
+    def block_count(self, obj):
+        return obj.blocks.count()
+
+    @admin.action(description="Mark selected posts as published")
+    def publish_selected(self, request, queryset):
+        count = queryset.count()
+        for post in queryset:
+            post.mark_published()
+        self.message_user(request, f"{count} post(s) marked as published.")

tgcms/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class TgcmsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "tgcms"
+    verbose_name = "Telegram CMS"

tgcms/conf.py

@@ -0,0 +1,21 @@
+from django.conf import settings as django_settings
+
+_DEFAULTS = {
+    "BOT_TOKEN": "",
+}
+
+
+class _AppSettings:
+    @property
+    def _user(self) -> dict:
+        return getattr(django_settings, "TGCMS", {})
+
+    def __getattr__(self, key: str):
+        if key.startswith("_"):
+            raise AttributeError(key)
+        if key not in _DEFAULTS:
+            raise AttributeError(f"Unknown TGCMS setting: {key!r}")
+        return self._user.get(key, _DEFAULTS[key])
+
+
+app_settings = _AppSettings()

tgcms/formatting/__init__.py

@@ -0,0 +1,16 @@
+"""Pure-Python formatting core for tgcms.
+
+This subpackage has no Django dependency. It converts between Telegram-flavoured
+HTML and the canonical ``(text, entities)`` model used by the Bot API, computing
+all ``offset``/``length`` values in UTF-16 code units (as the Bot API requires).
+"""
+
+from .entities import utf16_len, ENTITY_TYPES
+from .html import html_to_text_entities, text_entities_to_html
+
+__all__ = [
+    "utf16_len",
+    "ENTITY_TYPES",
+    "html_to_text_entities",
+    "text_entities_to_html",
+]

tgcms/formatting/entities.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+ENTITY_TYPES = frozenset(
+    {
+        "bold",
+        "italic",
+        "underline",
+        "strikethrough",
+        "spoiler",
+        "code",
+        "pre",
+        "text_link",
+        "blockquote",
+        "expandable_blockquote",
+        "custom_emoji",
+    }
+)
+
+
+def utf16_len(text: str) -> int:
+    return len(text.encode("utf-16-le")) // 2
+
+
+def char_offsets(text: str) -> list[int]:
+    offsets: list[int] = []
+    cu = 0
+    for ch in text:
+        offsets.append(cu)
+        cu += 2 if ord(ch) > 0xFFFF else 1
+    offsets.append(cu)
+    return offsets

tgcms/formatting/html.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import html as _html
+from html.parser import HTMLParser
+
+from .entities import char_offsets, utf16_len
+
+_SIMPLE_TAGS = {
+    "b": "bold",
+    "strong": "bold",
+    "i": "italic",
+    "em": "italic",
+    "u": "underline",
+    "ins": "underline",
+    "s": "strikethrough",
+    "strike": "strikethrough",
+    "del": "strikethrough",
+    "code": "code",
+    "tg-spoiler": "spoiler",
+}
+
+_SIMPLE_OUTPUT = {
+    "bold": ("<b>", "</b>"),
+    "italic": ("<i>", "</i>"),
+    "underline": ("<u>", "</u>"),
+    "strikethrough": ("<s>", "</s>"),
+    "spoiler": ('<span class="tg-spoiler">', "</span>"),
+    "code": ("<code>", "</code>"),
+}
+
+
+class _Parser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.text_parts: list[str] = []
+        self._len = 0
+        self._open: list[dict] = []
+        self.entities: list[dict] = []
+        self._code_stack: list[bool] = []
+
+    def _push(self, etype: str, **extra) -> None:
+        self._open.append({"type": etype, "offset": self._len, **extra})
+
+    def _pop(self, etype: str) -> None:
+        for i in range(len(self._open) - 1, -1, -1):
+            if self._open[i]["type"] == etype:
+                ent = self._open.pop(i)
+                ent["length"] = self._len - ent["offset"]
+                if ent["length"] > 0:
+                    self.entities.append(ent)
+                return
+
+    def handle_starttag(self, tag, attrs):
+        attrs = dict(attrs)
+        if tag == "code":
+            lang = attrs.get("class", "")
+            if lang.startswith("language-"):
+                for ent in reversed(self._open):
+                    if ent["type"] == "pre":
+                        ent["language"] = lang[len("language-"):]
+                        break
+                self._code_stack.append(True)
+                return
+            self._code_stack.append(False)
+            self._push("code")
+            return
+        if tag in _SIMPLE_TAGS:
+            self._push(_SIMPLE_TAGS[tag])
+        elif tag == "span" and "tg-spoiler" in (attrs.get("class") or "").split():
+            self._push("spoiler")
+        elif tag == "a":
+            self._push("text_link", url=attrs.get("href", ""))
+        elif tag == "pre":
+            self._push("pre")
+        elif tag == "blockquote":
+            etype = (
+                "expandable_blockquote"
+                if "expandable" in attrs
+                else "blockquote"
+            )
+            self._push(etype)
+        elif tag == "tg-emoji":
+            self._push("custom_emoji", custom_emoji_id=attrs.get("emoji-id", ""))
+
+    def handle_endtag(self, tag):
+        if tag == "code":
+            was_lang = self._code_stack.pop() if self._code_stack else False
+            if not was_lang:
+                self._pop("code")
+            return
+        if tag in _SIMPLE_TAGS:
+            self._pop(_SIMPLE_TAGS[tag])
+        elif tag == "span":
+            self._pop("spoiler")
+        elif tag == "a":
+            self._pop("text_link")
+        elif tag == "pre":
+            self._pop("pre")
+        elif tag == "blockquote":
+            for ent in reversed(self._open):
+                if ent["type"] in ("blockquote", "expandable_blockquote"):
+                    self._pop(ent["type"])
+                    break
+        elif tag == "tg-emoji":
+            self._pop("custom_emoji")
+
+    def handle_data(self, data):
+        self.text_parts.append(data)
+        self._len += utf16_len(data)
+
+    def handle_startendtag(self, tag, attrs):
+        if tag == "br":
+            self.handle_data("\n")
+
+
+def html_to_text_entities(html_text: str) -> tuple[str, list[dict]]:
+    parser = _Parser()
+    parser.feed(html_text or "")
+    parser.close()
+    text = "".join(parser.text_parts)
+    entities = sorted(parser.entities, key=lambda e: (e["offset"], e["length"]))
+    return text, entities
+
+
+def _open_close(entity: dict) -> tuple[str, str]:
+    etype = entity["type"]
+    if etype in _SIMPLE_OUTPUT:
+        return _SIMPLE_OUTPUT[etype]
+    if etype == "text_link":
+        href = _html.escape(entity.get("url", ""), quote=True)
+        return f'<a href="{href}">', "</a>"
+    if etype == "pre":
+        lang = entity.get("language")
+        if lang:
+            cls = _html.escape(lang, quote=True)
+            return f'<pre><code class="language-{cls}">', "</code></pre>"
+        return ("<pre>", "</pre>")
+    if etype == "blockquote":
+        return ("<blockquote>", "</blockquote>")
+    if etype == "expandable_blockquote":
+        return ("<blockquote expandable>", "</blockquote>")
+    if etype == "custom_emoji":
+        eid = _html.escape(str(entity.get("custom_emoji_id", "")), quote=True)
+        return f'<tg-emoji emoji-id="{eid}">', "</tg-emoji>"
+    return ("", "")
+
+
+def text_entities_to_html(text: str, entities: list[dict]) -> str:
+    if not text:
+        return ""
+    offsets = char_offsets(text)
+    u16_to_idx: dict[int, int] = {}
+    for idx, off in enumerate(offsets):
+        u16_to_idx.setdefault(off, idx)
+
+    opens: dict[int, list[dict]] = {}
+    closes: dict[int, list[dict]] = {}
+    for ent in entities or []:
+        start = ent["offset"]
+        end = ent["offset"] + ent["length"]
+        if start not in u16_to_idx or end not in u16_to_idx:
+            continue
+        opens.setdefault(start, []).append(ent)
+        closes.setdefault(end, []).append(ent)
+
+    for lst in opens.values():
+        lst.sort(key=lambda e: e["offset"] + e["length"], reverse=True)
+    for lst in closes.values():
+        lst.sort(key=lambda e: e["offset"], reverse=True)
+
+    out: list[str] = []
+    for idx, ch in enumerate(text):
+        off = offsets[idx]
+        for ent in closes.get(off, []):
+            out.append(_open_close(ent)[1])
+        for ent in opens.get(off, []):
+            out.append(_open_close(ent)[0])
+        out.append(_html.escape(ch, quote=False))
+    for ent in closes.get(offsets[-1], []):
+        out.append(_open_close(ent)[1])
+    return "".join(out)

tgcms/forms.py

@@ -0,0 +1,60 @@
+from django import forms
+
+from .formatting import html_to_text_entities, text_entities_to_html
+from .models import Block, Post
+from .widgets import TelegramEditorWidget
+
+
+class PostForm(forms.ModelForm):
+    class Meta:
+        model = Post
+        fields = ["title", "status"]
+
+
+class BlockForm(forms.ModelForm):
+    content_html = forms.CharField(
+        required=False,
+        widget=TelegramEditorWidget,
+        label="Content",
+        help_text="Used for text and heading blocks.",
+    )
+    caption_html = forms.CharField(
+        required=False,
+        widget=TelegramEditorWidget,
+        label="Caption",
+        help_text="Used for photo and video blocks.",
+    )
+
+    class Meta:
+        model = Block
+        fields = ["order", "type", "media"]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.instance and self.instance.pk:
+            if self.instance.type in (Block.Type.TEXT, Block.Type.HEADING):
+                self.fields["content_html"].initial = text_entities_to_html(
+                    self.instance.text, self.instance.entities
+                )
+            if self.instance.type in (Block.Type.PHOTO, Block.Type.VIDEO):
+                self.fields["caption_html"].initial = text_entities_to_html(
+                    self.instance.caption, self.instance.caption_entities
+                )
+
+    def save(self, commit=True):
+        block = super().save(commit=False)
+        if block.type in (Block.Type.TEXT, Block.Type.HEADING):
+            text, entities = html_to_text_entities(
+                self.cleaned_data.get("content_html", "")
+            )
+            block.text = text
+            block.entities = entities if block.type == Block.Type.TEXT else []
+        if block.type in (Block.Type.PHOTO, Block.Type.VIDEO):
+            text, entities = html_to_text_entities(
+                self.cleaned_data.get("caption_html", "")
+            )
+            block.caption = text
+            block.caption_entities = entities
+        if commit:
+            block.save()
+        return block