Spaces:
Running
Running
| """Saved formats (auto and manual): the pieces shared by the menus, the handlers and the pipeline. | |
| A format is a named bundle of a naming template, a caption, a thumbnail, the six metadata titles and the Keep | |
| Audio / Keep Subtitle lists. Every other setting (mode, file type, remove words, target channel) still comes | |
| from the user's normal settings. The caption never does: a format that was given none sends the new | |
| file name in bold. | |
| There are two kinds, twelve of each. An **auto** format renames every file the user sends (the one in use is chosen from | |
| the /start menu); a **manual** format is chosen with /rename and renames one file. The user's default metadata is a preset: | |
| a format can copy it ("Apply default metadata"), and an auto format that has no metadata of its own uses it while it is On. | |
| """ | |
| from __future__ import annotations | |
| import copy | |
| from typing import Any, Dict, Optional, Tuple | |
| from .db import DEFAULT_CAPTION, DEFAULT_FORMAT, DEFAULT_KIND, DEFAULT_SETTINGS, Database | |
| NAME_MAX = 30 | |
| KIND_LABELS = {"auto": "Auto", "manual": "Manual"} | |
| KIND_ICONS = {"auto": "🤖", "manual": "✋"} | |
| # format field -> the kind settings_ops.apply_setting() understands | |
| FIELD_KINDS: Dict[str, str] = { | |
| "template": "template", "caption": "caption", | |
| "title": "mt_title", "author": "mt_author", "artist": "mt_artist", | |
| "audio": "mt_audio", "subtitle": "mt_subtitle", "video": "mt_video", | |
| "keep_audio": "keep_audio", "keep_subtitle": "keep_subtitle", | |
| } | |
| _EDITABLE = ("template", "caption", "meta", "keep_audio", "keep_subtitle") | |
| def other_kind(kind: str) -> str: | |
| return "manual" if kind == "auto" else "auto" | |
| def validate_name(text: Optional[str]) -> Tuple[bool, str]: | |
| """``(True, cleaned name)`` or ``(False, html error)``.""" | |
| name = " ".join((text or "").split()) | |
| if not name: | |
| return False, "❌ Send a name for the format." | |
| if len(name) > NAME_MAX: | |
| return False, f"❌ That name is too long ({NAME_MAX} characters max)." | |
| return True, name | |
| def has_metadata(fmt: Dict[str, Any]) -> bool: | |
| return any(fmt["meta"].values()) or bool(fmt["keep_audio"] or fmt["keep_subtitle"]) | |
| def has_default_metadata(settings: Dict[str, Any]) -> bool: | |
| """Has the user set any default metadata (a title or the like, or a Keep Audio / Keep Subtitle list)?""" | |
| return any(settings["meta"].values()) or bool(settings["keep_audio"] or settings["keep_subtitle"]) | |
| def default_metadata_changes(settings: Dict[str, Any]) -> Dict[str, Any]: | |
| """What ``Database.update_format`` takes to make a format's metadata the user's default metadata.""" | |
| return dict(meta=dict(settings["meta"]), keep_audio=list(settings["keep_audio"]), keep_subtitle=list(settings["keep_subtitle"])) | |
| def default_auto_format() -> Dict[str, Any]: | |
| """What renames the files of a user who has no auto format: the built-in template and caption, no thumbnail, no metadata.""" | |
| out = copy.deepcopy(DEFAULT_FORMAT) | |
| out.update(kind="auto", id=0, name="", has_thumb=False) | |
| return out | |
| def apply_format(settings: Dict[str, Any], fmt: Optional[Dict[str, Any]]) -> Dict[str, Any]: | |
| """The user's settings with the format's template, caption, metadata and keep lists laid over them. | |
| ``fmt`` is ``None`` for an auto rename of a user who has no auto format: the built-in defaults. | |
| Metadata is on whenever the format sets anything, whatever the Metadata switch says: the format carries its own | |
| metadata. A manual format with none leaves the file alone (no ffmpeg pass). An auto format with none leaves the user's | |
| default metadata in charge: it applies while its switch is On, as it always did for auto renames. | |
| """ | |
| fmt = fmt or default_auto_format() | |
| out = copy.deepcopy(settings) | |
| out["template"] = fmt["template"] | |
| out["caption"] = fmt.get("caption") or DEFAULT_CAPTION # never a caption from anywhere else | |
| if has_metadata(fmt) or fmt.get("kind", DEFAULT_KIND) == "manual": | |
| out["meta"] = dict(fmt["meta"]) | |
| out["keep_audio"] = list(fmt["keep_audio"]) | |
| out["keep_subtitle"] = list(fmt["keep_subtitle"]) | |
| out["metadata_on"] = has_metadata(fmt) | |
| return out | |
| def _as_settings(fmt: Dict[str, Any]) -> Dict[str, Any]: | |
| """A format shaped like the user's settings, which is what ``apply_setting`` reads.""" | |
| out = copy.deepcopy(DEFAULT_SETTINGS) | |
| out.update( | |
| template=fmt["template"], caption=fmt["caption"], keep_audio=list(fmt["keep_audio"]), | |
| keep_subtitle=list(fmt["keep_subtitle"]), metadata_on=True, | |
| ) | |
| out["meta"] = dict(fmt["meta"]) | |
| return out | |
| class FormatSettings: | |
| """Edits one saved format through the two methods ``apply_setting`` uses on ``Database``. | |
| That keeps a single copy of every validation rule and message for the user's settings and the formats. | |
| Metadata is always "on" here, so the "metadata is off" notes never show for a format. | |
| """ | |
| def __init__(self, db: Database, fid: int): | |
| self.db = db | |
| self.fid = fid | |
| async def get_settings(self, uid: int) -> Dict[str, Any]: | |
| fmt = await self.db.get_format(uid, self.fid) | |
| if fmt is None: | |
| raise LookupError("that format no longer exists") | |
| return _as_settings(fmt) | |
| async def update_settings(self, uid: int, **changes: Any) -> Dict[str, Any]: | |
| wanted = {k: v for k, v in changes.items() if k in _EDITABLE} | |
| if wanted and await self.db.update_format(uid, self.fid, **wanted) is None: | |
| raise LookupError("that format no longer exists") | |
| return await self.get_settings(uid) | |