Spaces:
Running
Running
| """Telegram formatting <-> the HTML a caption is stored as. | |
| People format a caption like any message: select words and make them bold, italic, a link... Telegram delivers that | |
| as *entities* (kind, offset, length) next to the plain text. Captions are kept as Telegram HTML (the variables are | |
| filled in and the HTML is sent with ``parse_mode="html"``), so ``from_entities`` turns the entities into that HTML and | |
| nobody has to type a tag, and ``preview`` turns stored HTML back into something that is safe to show in a panel. | |
| Entity offsets count UTF-16 code units, so the text is handled the way Telethon does it: an emoji outside the basic | |
| plane is two "surrogate" characters while the work is going on. | |
| """ | |
| from __future__ import annotations | |
| import html | |
| import re | |
| from typing import Any, Dict, Iterable, List, NamedTuple, Optional, Tuple | |
| from telethon.extensions import html as telegram_html | |
| from telethon.helpers import add_surrogate, del_surrogate | |
| from telethon.tl import types | |
| from .parser import CAPTION_VARS | |
| from .utils import esc | |
| _VARIABLE = re.compile(r"\{(?:%s)\}" % "|".join(map(re.escape, CAPTION_VARS))) | |
| _SIMPLE = { | |
| types.MessageEntityBold: ("<b>", "</b>"), | |
| types.MessageEntityItalic: ("<i>", "</i>"), | |
| types.MessageEntityUnderline: ("<u>", "</u>"), | |
| types.MessageEntityStrike: ("<s>", "</s>"), | |
| types.MessageEntityCode: ("<code>", "</code>"), | |
| } | |
| class Span(NamedTuple): | |
| start: int | |
| end: int | |
| open: str | |
| close: str | |
| def _tags(entity: Any) -> Optional[Tuple[str, str]]: | |
| """The HTML tags for one entity. ``None`` for the ones that are not formatting the bot keeps: what Telegram finds by | |
| itself (links in the text, @mentions, #hashtags, /commands) comes back by itself when the caption is sent. Spoilers and | |
| custom emoji are not kept either: Telethon's HTML has no spoiler, and a bot may not send custom emoji.""" | |
| kind = type(entity) | |
| if kind in _SIMPLE: | |
| return _SIMPLE[kind] | |
| if kind is types.MessageEntityTextUrl: | |
| return f'<a href="{html.escape(entity.url, quote=True)}">', "</a>" | |
| if kind is types.MessageEntityMentionName: | |
| return f'<a href="tg://user?id={entity.user_id}">', "</a>" | |
| if kind is types.MessageEntityPre: | |
| language = html.escape(getattr(entity, "language", "") or "", quote=True) | |
| return (f'<pre><code class="language-{language}">', "</code></pre>") if language else ("<pre>", "</pre>") | |
| if kind is types.MessageEntityBlockquote: | |
| return ("<blockquote expandable>" if getattr(entity, "collapsed", False) else "<blockquote>"), "</blockquote>" | |
| return None | |
| def _whole(body: str, at: int) -> int: | |
| """``at``, moved off the middle of a surrogate pair.""" | |
| if 0 < at < len(body) and "\udc00" <= body[at] <= "\udfff" and "\ud800" <= body[at - 1] <= "\udbff": | |
| return at + 1 | |
| return at | |
| def _tidy(spans: Iterable[Span]) -> List[Span]: | |
| """Spans of one kind never overlap afterwards. The HTML parser can't nest a tag in itself (``<b>a<b>b</b>c</b>`` loses | |
| its outer one), so identical spans that overlap or touch are joined, and of two links (or other tags with different | |
| details) that overlap, the one that starts later only gets what the first leaves.""" | |
| groups: Dict[str, List[Span]] = {} | |
| for s in spans: | |
| groups.setdefault(re.match(r"<(\w+)", s.open).group(1), []).append(s) | |
| out: List[Span] = [] | |
| for group in groups.values(): | |
| kept: List[Span] = [] | |
| for s in sorted(group, key=lambda s: (s.start, -s.end)): | |
| if kept and s.start <= kept[-1].end: | |
| last = kept[-1] | |
| if s.open == last.open: | |
| kept[-1] = last._replace(end=max(last.end, s.end)) | |
| continue | |
| if s.start < last.end: | |
| s = s._replace(start=last.end) | |
| if s.end <= s.start: | |
| continue | |
| kept.append(s) | |
| out += kept | |
| return out | |
| def _render(body: str, spans: Iterable[Span]) -> str: | |
| """``body`` as HTML with the spans' tags in it. Spans that overlap without one containing the other are split, so | |
| that the tags always nest.""" | |
| spans = [s._replace(start=_whole(body, s.start), end=_whole(body, s.end)) for s in spans] | |
| spans = _tidy(s for s in spans if s.end > s.start) | |
| points = sorted({0, len(body)} | {p for s in spans for p in (s.start, s.end)}) | |
| out: List[str] = [] | |
| running: List[Span] = [] # the spans that are open right now, outermost first | |
| for index, at in enumerate(points): | |
| ending = [s for s in running if s.end == at] | |
| if ending: | |
| depth = min(running.index(s) for s in ending) | |
| inner, running = running[depth:], running[:depth] | |
| out += [s.close for s in reversed(inner)] | |
| for s in inner: | |
| if s.end != at: # it goes on past this point: close it around the one that ended and open it again | |
| out.append(s.open) | |
| running.append(s) | |
| for s in sorted((s for s in spans if s.start == at), key=lambda s: -s.end): # on a tie the earlier one stays outside | |
| out.append(s.open) | |
| running.append(s) | |
| if index + 1 < len(points): | |
| out.append(esc(body[at:points[index + 1]])) | |
| return "".join(out) | |
| def from_entities(text: str, entities: Optional[Iterable[Any]], start: int = 0) -> Optional[str]: | |
| """``text[start:]`` as HTML that carries the formatting in ``entities``, or ``None`` when there is none to keep. | |
| ``start`` skips what comes before the caption (a command word, say). A ``{variable}`` is never split: a format that | |
| covers only part of one (double-tapping the word inside the braces does that) is widened to the whole variable, because | |
| the variable is replaced as a whole. | |
| """ | |
| if not text or not entities: | |
| return None | |
| first = len(add_surrogate(text[:start])) | |
| body = add_surrogate(text)[first:] | |
| first += len(body) - len(body.lstrip()) | |
| body = body.strip() | |
| variables = [(m.start(), m.end()) for m in _VARIABLE.finditer(body)] | |
| spans = [] | |
| for entity in entities: | |
| tags = _tags(entity) | |
| if tags is None: | |
| continue | |
| a, b = max(entity.offset - first, 0), min(entity.offset + entity.length - first, len(body)) | |
| if b <= a: | |
| continue | |
| for lo, hi in variables: | |
| if a < hi and b > lo: | |
| a, b = min(a, lo), max(b, hi) | |
| spans.append(Span(a, b, *tags)) | |
| return del_surrogate(_render(body, spans)) if spans else None | |
| def preview(template: str, limit: int) -> str: | |
| """A stored caption template as HTML that is safe to show in a panel: its formatting is shown, its tags are balanced | |
| whatever was typed, and it is cut to ``limit`` characters.""" | |
| text, entities = telegram_html.parse(template or "") | |
| if not text: | |
| return "—" | |
| body = add_surrogate(text) | |
| cut = len(body) if len(body) <= limit else _whole(body, limit - 1) | |
| spans = [] | |
| for entity in entities: | |
| tags = _tags(entity) | |
| if tags is not None: | |
| spans.append(Span(entity.offset, min(entity.offset + entity.length, cut), *tags)) | |
| return del_surrogate(_render(body[:cut], spans)) + ("…" if cut < len(body) else "") | |