| from __future__ import annotations |
|
|
| import re |
| from copy import deepcopy |
| from typing import Any |
|
|
|
|
| PLACEHOLDER = re.compile(r"{{\s*([A-Za-z_][A-Za-z0-9_.-]*)\s*}}") |
|
|
| AUTOMATION_TEMPLATES: dict[str, dict[str, Any]] = { |
| "vertical-captioned-clip": { |
| "preset": "tiktok_9_16_fast", |
| "output_name": "{{output_name}}", |
| "scenes": "{{scenes}}", |
| "voiceover": "{{voiceover}}", |
| "background_music": "{{background_music}}", |
| "auto_subtitles": True, |
| "audio_normalize": True, |
| }, |
| "podcast-clip": { |
| "preset": "podcast_square", |
| "output_name": "{{output_name}}", |
| "scenes": "{{scenes}}", |
| "auto_subtitles": True, |
| "audio_normalize": True, |
| }, |
| "product-promo": { |
| "preset": "capcut_product_launch", |
| "output_name": "{{output_name}}", |
| "scenes": "{{scenes}}", |
| "watermark": "{{watermark}}", |
| "background_music": "{{background_music}}", |
| }, |
| } |
|
|
|
|
| def list_automation_templates() -> list[str]: |
| return sorted(AUTOMATION_TEMPLATES) |
|
|
|
|
| def automation_template_catalog() -> dict[str, dict[str, Any]]: |
| return deepcopy(AUTOMATION_TEMPLATES) |
|
|
|
|
| def resolve_render_template( |
| template: str | dict[str, Any], |
| variables: dict[str, Any], |
| overrides: dict[str, Any] | None = None, |
| ) -> dict[str, Any]: |
| if isinstance(template, str): |
| if template not in AUTOMATION_TEMPLATES: |
| raise ValueError(f"Unknown automation template: {template}") |
| source = deepcopy(AUTOMATION_TEMPLATES[template]) |
| elif isinstance(template, dict): |
| source = deepcopy(template) |
| else: |
| raise ValueError("Template must be a registered name or JSON object") |
|
|
| rendered = _substitute(source, variables) |
| if not isinstance(rendered, dict): |
| raise ValueError("Rendered template must produce a JSON object") |
| return _deep_merge(rendered, overrides or {}) |
|
|
|
|
| def _substitute(value: Any, variables: dict[str, Any]) -> Any: |
| if isinstance(value, dict): |
| return {key: _substitute(item, variables) for key, item in value.items()} |
| if isinstance(value, list): |
| return [_substitute(item, variables) for item in value] |
| if not isinstance(value, str): |
| return value |
|
|
| exact = PLACEHOLDER.fullmatch(value) |
| if exact: |
| return deepcopy(_lookup(variables, exact.group(1))) |
|
|
| return PLACEHOLDER.sub(lambda match: str(_lookup(variables, match.group(1))), value) |
|
|
|
|
| def _lookup(variables: dict[str, Any], key: str) -> Any: |
| value: Any = variables |
| for part in key.split("."): |
| if not isinstance(value, dict) or part not in value: |
| raise ValueError(f"Missing template variable: {key}") |
| value = value[part] |
| return value |
|
|
|
|
| def _deep_merge(base: dict[str, Any], overrides: dict[str, Any]) -> dict[str, Any]: |
| output = deepcopy(base) |
| for key, value in overrides.items(): |
| if isinstance(value, dict) and isinstance(output.get(key), dict): |
| output[key] = _deep_merge(output[key], value) |
| else: |
| output[key] = deepcopy(value) |
| return output |
|
|
