121 lines
4.0 KiB
Python
121 lines
4.0 KiB
Python
from __future__ import annotations
|
|
|
|
import re
|
|
from html import escape
|
|
|
|
|
|
ACTOR_PLACEHOLDER_RE = re.compile(r"\{\{\s*actor\s*:\s*([a-z0-9_\-]+)\s*\}\}", re.IGNORECASE)
|
|
PLAIN_LINK_RE = re.compile(r"(?P<label>[^\n<>()]+?) \((?P<url>https?://[^\s)]+)\)")
|
|
|
|
|
|
def build_hidden_link(config: dict) -> str:
|
|
url = config.get("hidden_link_url", "").strip()
|
|
if not url:
|
|
return ""
|
|
invisible = config.get("hidden_link_char", "​")
|
|
return f'<a href="{escape(url, quote=True)}">{invisible}</a>'
|
|
|
|
|
|
def convert_plain_links_to_html(template: str) -> str:
|
|
def repl(match: re.Match[str]) -> str:
|
|
label = match.group("label").rstrip()
|
|
url = match.group("url")
|
|
if "<a " in label:
|
|
return match.group(0)
|
|
return f'<a href="{escape(url, quote=True)}">{escape(label)}</a>'
|
|
|
|
return PLAIN_LINK_RE.sub(repl, template)
|
|
|
|
|
|
def build_actor_phrase(actor: dict, state: dict) -> str:
|
|
actor_state = state.get("actors", {})
|
|
current = actor_state.get(actor["key"], {})
|
|
status = current.get("status", actor.get("default_status", "backstage"))
|
|
return current.get("phrase", actor.get("phrases", {}).get(status, ""))
|
|
|
|
|
|
def build_actor_line(actor: dict, state: dict) -> str:
|
|
phrase = build_actor_phrase(actor, state)
|
|
display_name = actor.get("display_html", escape(actor["display_name"]))
|
|
meta = actor.get("meta_html", escape(actor["pronouns"]))
|
|
emoji = actor.get("emoji_html", escape(actor.get("emoji", "")))
|
|
return (
|
|
f'{emoji} '
|
|
f'<a href="{escape(actor["link"], quote=True)}">{display_name}</a>'
|
|
f"{meta}{escape(phrase)}"
|
|
)
|
|
|
|
|
|
def build_actor_fragment(actor: dict, state: dict) -> str:
|
|
return escape(build_actor_phrase(actor, state))
|
|
|
|
|
|
def build_actor_lines(config: dict, state: dict, skip_keys: set[str] | None = None) -> str:
|
|
actor_lines: list[str] = []
|
|
skip_keys = skip_keys or set()
|
|
|
|
for actor in config["actors"]:
|
|
if actor["key"] in skip_keys:
|
|
continue
|
|
actor_lines.append(build_actor_line(actor, state))
|
|
|
|
actor_lines.extend(config.get("static_actor_lines_html", []))
|
|
return "\n".join(actor_lines)
|
|
|
|
|
|
def replace_actor_placeholders(template: str, config: dict, state: dict) -> tuple[str, set[str]]:
|
|
used_keys: set[str] = set()
|
|
actors_by_key = {actor["key"].lower(): actor for actor in config["actors"]}
|
|
|
|
def repl(match: re.Match[str]) -> str:
|
|
actor_key = match.group(1).lower()
|
|
actor = actors_by_key.get(actor_key)
|
|
if actor is None:
|
|
return match.group(0)
|
|
used_keys.add(actor["key"])
|
|
|
|
line_start = template.rfind("\n", 0, match.start()) + 1
|
|
line_end = template.find("\n", match.end())
|
|
if line_end == -1:
|
|
line_end = len(template)
|
|
line_text = template[line_start:line_end]
|
|
|
|
if line_text.strip().lower() == match.group(0).strip().lower():
|
|
return build_actor_line(actor, state)
|
|
|
|
return build_actor_fragment(actor, state)
|
|
|
|
return ACTOR_PLACEHOLDER_RE.sub(repl, template), used_keys
|
|
|
|
|
|
def build_default_template(config: dict) -> str:
|
|
blocks = []
|
|
for key in ("header_html", "intro_links_html", "projects_block_html", "actors_title_html"):
|
|
value = config.get(key, "").strip()
|
|
if value:
|
|
blocks.append(value)
|
|
|
|
blocks.append("{{actors}}")
|
|
|
|
for key in ("legend_html", "footer_html"):
|
|
value = config.get(key, "").strip()
|
|
if value:
|
|
blocks.append(value)
|
|
|
|
return "\n\n".join(blocks)
|
|
|
|
|
|
def build_channel_text(config: dict, state: dict) -> str:
|
|
template = state.get("template", {}).get("text") or config.get("template_text") or build_default_template(config)
|
|
template = convert_plain_links_to_html(template)
|
|
template, used_keys = replace_actor_placeholders(template, config, state)
|
|
actors_block = build_actor_lines(config, state, skip_keys=used_keys)
|
|
hidden_link = build_hidden_link(config)
|
|
|
|
text = template.replace("{{actors}}", actors_block)
|
|
text = text.replace("{{hidden_link}}", "")
|
|
if hidden_link:
|
|
text = f"{hidden_link}{text}"
|
|
|
|
return text
|