Spaces:

francozanardi
/

pycaps

Paused

App Files Files Community

Franco Zanardi commited on Jun 28, 2025

Commit

6774799

1 Parent(s): d083627

feature: allow edit templates

Browse files

Files changed (14) hide show

.gitignore +1 -0
src/app.py +3 -0
src/config.py +2 -1
src/file_manager.py +62 -0
src/{editor → subtitle_editor}/__init__.py +1 -1
src/{editor → subtitle_editor}/index.html +0 -0
src/template_editor/__init__.py +15 -0
src/template_editor/index.html +217 -0
src/ui/step1_upload.py +2 -1
src/ui/step2_configure.py +142 -41
src/ui/step3_edit.py +1 -1
src/ui/step4_render.py +2 -2
src/ui/step5_view.py +2 -4
src/utils.py +84 -11

.gitignore CHANGED Viewed

	@@ -1 +1,2 @@
1	.vscode


1	.vscode
2	+ __pycache__

src/app.py CHANGED Viewed

@@ -9,11 +9,14 @@ from ui.step2_configure import render_step2
 from ui.step3_edit import render_step3
 from ui.step4_render import render_step4
 from ui.step5_view import render_step5
 st.set_page_config(layout="wide", page_title="Pycaps Demo")
 logger.set_logging_level(logging.DEBUG)
 initialize_session_state()
 st.title("🎬 Pycaps Demo")
 st.markdown("""
 <style>

 from ui.step3_edit import render_step3
 from ui.step4_render import render_step4
 from ui.step5_view import render_step5
+from file_manager import init_file_manager
 st.set_page_config(layout="wide", page_title="Pycaps Demo")
 logger.set_logging_level(logging.DEBUG)
 initialize_session_state()
+init_file_manager()
+# --- Renderizado de la UI ---
 st.title("🎬 Pycaps Demo")
 st.markdown("""
 <style>

src/config.py CHANGED Viewed

@@ -1,11 +1,12 @@
 import os
 import tempfile
-MAX_CONCURRENT_JOBS = 3
 LOCK_DIR = os.path.join(tempfile.gettempdir(), "pycaps_locks")
 os.makedirs(LOCK_DIR, exist_ok=True)
 MAX_VIDEO_SIZE = 50 * 1024 * 1024
 LOCK_TTL_SECONDS = 20 * 60
 TEMPLATES_INFO = [
     {"name": "classic", "ai_features": []},

 import os
 import tempfile
+MAX_CONCURRENT_JOBS = 5
 LOCK_DIR = os.path.join(tempfile.gettempdir(), "pycaps_locks")
 os.makedirs(LOCK_DIR, exist_ok=True)
 MAX_VIDEO_SIZE = 50 * 1024 * 1024
 LOCK_TTL_SECONDS = 20 * 60
+SESSION_TTL_SECONDS = 60 * 60
 TEMPLATES_INFO = [
     {"name": "classic", "ai_features": []},

src/file_manager.py ADDED Viewed

	@@ -0,0 +1,62 @@

+import os
+import shutil
+import tempfile
+import time
+import uuid
+import streamlit as st
+from config import SESSION_TTL_SECONDS
+def init_file_manager():
+    base_dir = get_base_sessions_dir()
+    os.makedirs(base_dir, exist_ok=True)
+    session_dir = get_session_dir()
+    os.makedirs(session_dir, exist_ok=True)
+    touch()
+    cleanup_expired_sessions()
+def get_base_sessions_dir():
+    return os.path.join(tempfile.gettempdir(), "pycaps-sessions")
+def get_session_dir():
+    return os.path.join(get_base_sessions_dir(), st.session_state.session_id)
+def get_path(*relative_path):
+    return os.path.join(get_session_dir(), *relative_path)
+def get_random_file_name(ext):
+    return get_path(f"{uuid.uuid4()}.{ext}")
+def create_temp_file(suffix="", prefix="tmp", text=False):
+    fd, path = tempfile.mkstemp(suffix=suffix, prefix=prefix, dir=get_session_dir(), text=text)
+    # Abre y devuelve el archivo como objeto file abierto (similar a NamedTemporaryFile)
+    mode = "w+" if text else "w+b"
+    file_obj = os.fdopen(fd, mode)
+    return file_obj
+def create_temp_dir(suffix="", prefix="tmp"):
+    return tempfile.mkdtemp(suffix=suffix, prefix=prefix, dir=get_session_dir())
+def touch():
+    keepalive_path = os.path.join(get_session_dir(), ".keepalive")
+    with open(keepalive_path, "w") as f:
+        f.write(str(time.time()))
+def cleanup_expired_sessions():
+    now = time.time()
+    for name in os.listdir(get_base_sessions_dir()):
+        path = os.path.join(get_base_sessions_dir(), name)
+        if not os.path.isdir(path):
+            continue
+        try:
+            keepalive_file = os.path.join(path, ".keepalive")
+            if os.path.exists(keepalive_file):
+                last_touched = os.path.getmtime(keepalive_file)
+            else:
+                last_touched = os.path.getmtime(path)
+            if now - last_touched > SESSION_TTL_SECONDS:
+                shutil.rmtree(path)
+        except Exception as e:
+            pass
+def delete_current_session_dir():
+    shutil.rmtree(get_session_dir(), ignore_errors=True)

src/{editor → subtitle_editor}/__init__.py RENAMED Viewed

@@ -2,7 +2,7 @@ import streamlit.components.v1 as components
 import os
 _component_func = components.declare_component(
-    "editor",
     path=os.path.join(os.path.dirname(os.path.abspath(__file__)))
 )

 import os
 _component_func = components.declare_component(
+    "subtitle_editor",
     path=os.path.join(os.path.dirname(os.path.abspath(__file__)))
 )

src/{editor → subtitle_editor}/index.html RENAMED Viewed

File without changes

src/template_editor/__init__.py ADDED Viewed

	@@ -0,0 +1,15 @@

+import streamlit.components.v1 as components
+import os
+_component_func = components.declare_component(
+    "template_editor",
+    path=os.path.join(os.path.dirname(os.path.abspath(__file__)))
+)
+def template_editor(json, css, key=None):
+    component_value = _component_func(
+        json=json,
+        css=css,
+        key=key,
+    )
+    return component_value

src/template_editor/index.html ADDED Viewed

	@@ -0,0 +1,217 @@

+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Template Editor</title>
+    <!-- CodeMirror CSS -->
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.15/codemirror.min.css">
+    <link rel="stylesheet"
+        href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.15/theme/material-darker.min.css">
+    <!-- CodeMirror JS y modos de lenguaje -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.15/codemirror.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.15/mode/javascript/javascript.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.65.15/mode/css/css.min.js"></script>
+    <!-- Streamlit Component Lib -->
+    <script
+        src="https://cdn.jsdelivr.net/gh/streamlit/streamlit@master/frontend/src/streamlit-component-lib.js"></script>
+    <style>
+        body {
+            font-family: sans-serif;
+            margin: 0;
+            padding: 0;
+        }
+        .container {
+            display: flex;
+            flex-direction: column;
+            height: 100vh;
+        }
+        .editors {
+            overflow: hidden;
+        }
+        .editor-pane {
+            overflow: hidden;
+            padding: 5px;
+        }
+        .editor-pane h3 {
+            margin: 5px 0;
+            font-size: 14px;
+            color: #FAFAFA;
+        }
+        .CodeMirror {
+            flex: 1;
+            border: 1px solid #444;
+            border-radius: 4px;
+            height: 390px
+        }
+        .buttons {
+            margin-top: 10px;
+            display: flex;
+            justify-content: flex-end;
+        }
+        .buttons button {
+            padding: 8px 16px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-weight: bold;
+            margin-left: 10px;
+            width: 100px;
+        }
+        .save-btn {
+            background-color: #007bff;
+            color: white;
+        }
+        .editor-help {
+            font-size: 12px;
+            color: #a0a0a0;
+            margin-top: 8px;
+            padding: 0 5px;
+            text-align: center;
+        }
+        .editor-help a {
+            color: #4dabf7;
+            text-decoration: none;
+            font-weight: bold;
+        }
+        .editor-help a:hover {
+            text-decoration: underline;
+        }
+        .editor-help code {
+            background-color: #333;
+            padding: 2px 4px;
+            border-radius: 3px;
+            font-size: 11px;
+            color: #d0d0d0;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="editors">
+            <div class="editor-pane">
+                <h3>styles.css</h3>
+                <textarea id="css-editor"></textarea>
+            </div>
+            <p class="editor-help">
+                Remember, any tag can be used as a CSS class (e.g., <code>.word.highlight</code>).
+                See all available tags in the
+                <a href="https://github.com/francozanardi/pycaps/blob/main/docs/TAGS.md" target="_blank" rel="noopener noreferrer">
+                    Tagging System docs
+                </a>.
+            </p>
+            <div class="editor-pane">
+                <h3>pycaps.template.json</h3>
+                <textarea id="json-editor"></textarea>
+            </div>
+            <p class="editor-help">
+                Need help with the configuration? Check the
+                <a href="https://github.com/francozanardi/pycaps/blob/main/docs/CONFIG_REFERENCE.md"
+                    target="_blank" rel="noopener noreferrer">
+                    full JSON reference
+                </a>
+                in our documentation.
+            </p>
+        </div>
+        <div class="buttons">
+            <button class="save-btn">Save</button>
+        </div>
+    </div>
+    <script>
+        // Source: https://discuss.streamlit.io/t/code-snippet-create-components-without-any-frontend-tooling-no-react-babel-webpack-etc/13064
+        function sendMessageToStreamlitClient(type, data) {
+            const outData = Object.assign({
+                isStreamlitMessage: true,
+                type: type,
+            }, data);
+            window.parent.postMessage(outData, "*");
+        }
+        function init() {
+            sendMessageToStreamlitClient("streamlit:componentReady", { apiVersion: 1 });
+        }
+        function setFrameHeight(height) {
+            sendMessageToStreamlitClient("streamlit:setFrameHeight", { height: height });
+        }
+        // `data` puede ser cualquier valor serializable en JSON.
+        function sendDataToPython(data) {
+            sendMessageToStreamlitClient("streamlit:setComponentValue", { value: data, dataType: "json" });
+        }
+        function onDataFromPython(event) {
+            if (event.data.type !== "streamlit:render") return;
+            if (event.data.args) {
+                if (!window.wereEditorsInitialized) {
+                    window.wereEditorsInitialized = true;
+                    initializeEditors(event.data.args.json, event.data.args.css);
+                }
+            } else {
+                sendDataToPython({ action: "error", message: 'Unexpected error: missing JSON and CSS' });
+                document.querySelector('.container').innerHTML = '';
+                setFrameHeight(1);
+            }
+        }
+        let jsonEditor, cssEditor;
+        function initializeEditors(jsonData, cssData) {
+            jsonEditor = CodeMirror.fromTextArea(document.getElementById('json-editor'), {
+                mode: { name: "javascript", json: true },
+                theme: 'material-darker',
+                lineNumbers: true,
+            });
+            jsonEditor.setValue(JSON.stringify(jsonData, null, 2));
+            cssEditor = CodeMirror.fromTextArea(document.getElementById('css-editor'), {
+                mode: 'css',
+                theme: 'material-darker',
+                lineNumbers: true,
+            });
+            cssEditor.setValue(cssData);
+        }
+        function sendValue() {
+            try {
+                const jsonContent = JSON.parse(jsonEditor.getValue());
+                const cssContent = cssEditor.getValue();
+                sendDataToPython({
+                    action: "save",
+                    json_content: jsonContent,
+                    css_content: cssContent
+                });
+            } catch (e) {
+                console.error("Invalid JSON format:", e);
+                sendDataToPython({ action: "error", message: "Invalid JSON format. Please correct it before saving." });
+            }
+        }
+        // Listeners
+        document.querySelector(".save-btn").addEventListener("click", sendValue);
+        window.addEventListener("message", onDataFromPython);
+        init();
+        setFrameHeight(1000);
+    </script>
+</body>
+</html>

src/ui/step1_upload.py CHANGED Viewed

@@ -3,6 +3,7 @@ import os
 import tempfile
 import shutil
 from pathlib import Path
 import pycaps.video.render.audio_utils as audio_utils
 from pycaps import WhisperAudioTranscriber
 from utils import go_to_step, acquire_lock_slot, handle_unexpected_exception
@@ -52,7 +53,7 @@ def render_step1():
                     document = transcriber.transcribe(audio_path)
                     st.session_state.transcribed_doc = document.to_dict()
-                    persisted_path = os.path.join(tempfile.gettempdir(), f"session_{st.session_state.session_id}.mp4")
                     shutil.copy(video_path, persisted_path)
                     st.session_state.video_path = persisted_path

 import tempfile
 import shutil
 from pathlib import Path
+from file_manager import get_path
 import pycaps.video.render.audio_utils as audio_utils
 from pycaps import WhisperAudioTranscriber
 from utils import go_to_step, acquire_lock_slot, handle_unexpected_exception
                     document = transcriber.transcribe(audio_path)
                     st.session_state.transcribed_doc = document.to_dict()
+                    persisted_path = get_path(f"input.mp4")
                     shutil.copy(video_path, persisted_path)
                     st.session_state.video_path = persisted_path

src/ui/step2_configure.py CHANGED Viewed

@@ -1,89 +1,193 @@
 import streamlit as st
 import os
-from pycaps import Document, TemplateLoader
-from utils import go_to_step, reset_all, build_pipeline_from_state, setup_api_keys, cleanup_api_keys, handle_unexpected_exception
 from config import TEMPLATE_NAMES, TEMPLATES_INFO
 def render_step2():
     st.header("Configure & Process")
-    api_key = st.session_state.get('api_key_input')
-    api_key_type = st.session_state.get('api_key_type')
     col1, col2 = st.columns([1, 1])
     with col1:
-        render_configuration_column(api_key, api_key_type)
     with col2:
         render_preview_column()
-def render_configuration_column(api_key, api_key_type):
     st.subheader("Configuration")
-    template_name = st.selectbox("Choose a Style", TEMPLATE_NAMES)
     st.session_state.selected_template = template_name
     selected_template_info = next((t for t in TEMPLATES_INFO if t["name"] == template_name), None)
     if selected_template_info and selected_template_info["ai_features"]:
         ai_features_str = ", ".join(selected_template_info["ai_features"])
-        if not api_key:
             st.warning(f"⚠️ This template uses AI features ({ai_features_str}). "
                        "Please provide an API key in the sidebar to enable them. "
                        "Otherwise, they will be ignored during processing.")
         else:
             st.info(f"✨ This template uses AI features: {ai_features_str}.")
     st.session_state.edit_requested = st.checkbox(
-        "I want to review and edit the processed subtitles before rendering.",
         value=st.session_state.get('edit_requested', False)
     )
-    st.write("")
     b_next_col, b_back_col = st.columns(2)
     with b_next_col:
         if st.button("Render Video ➡️", type="primary", use_container_width=True):
-            with st.spinner("Applying template, effects, and tags... ⚙️"):
-                try:
-                    pipeline = build_pipeline_from_state()
-                    if not pipeline:
-                        raise RuntimeError("Could not build pipeline. Missing video or template selection.")
-                    setup_api_keys(api_key_type, api_key)
-                    # NOTE: Assuming your pipeline has methods `prepare` and `process_document`
-                    pipeline.prepare()
-                    document = Document.from_dict(st.session_state.transcribed_doc)
-                    processed_document = pipeline.process_document(document)
-                    pipeline.close()
-                    st.session_state.processed_doc = processed_document.to_dict()
-                    go_to_step(3)
-                    st.rerun()
-                except Exception as e:
-                    handle_unexpected_exception(e)
-                finally:
-                    cleanup_api_keys()
     with b_back_col:
         if st.button("⬅️ Start Over", use_container_width=True):
             reset_all()
             st.rerun()
 def render_preview_column():
     st.subheader("Live Preview")
     st.markdown("Generate a short, low-quality video preview with the selected style. This takes a few seconds.")
     st.warning("AI features (auto-emojis, ai tagger) are ignored in the preview.")
     preview_container = st.container()
-    template_name = st.session_state.get('selected_template') # Use a local var for clarity
     has_preview_for_template = template_name in st.session_state.previews
-    is_button_disabled = has_preview_for_template or st.session_state.preview_generating
-    if st.button("Generate Preview ⚡", use_container_width=True, disabled=is_button_disabled):
         st.session_state.preview_generating = True
         st.rerun()
     if st.session_state.preview_generating:
         try:
             with st.spinner("Generating preview video... ⚡"):
-                builder = TemplateLoader(template_name).with_input_video(st.session_state.video_path).load(False)
                 pipeline = builder.build(preview_time=(0, 5))
                 document = Document.from_dict(st.session_state.transcribed_doc)
@@ -94,15 +198,12 @@ def render_preview_column():
                 preview_output_path = pipeline._output_video_path
                 if preview_output_path and os.path.exists(preview_output_path):
-                    preview_container.video(preview_output_path)
                     st.session_state.previews[template_name] = preview_output_path
                 else:
-                    preview_container.error("Could not generate preview.")
         except Exception as e:
             handle_unexpected_exception(e)
         finally:
             st.session_state.preview_generating = False
             st.rerun()
-    if has_preview_for_template:
-        preview_container.video(st.session_state.previews[template_name])

 import streamlit as st
 import os
+from pycaps import Document
+from utils import (go_to_step, reset_all, setup_api_keys, cleanup_api_keys,
+                   handle_unexpected_exception, load_template_files, create_pipeline_builder)
+from file_manager import get_random_file_name
 from config import TEMPLATE_NAMES, TEMPLATES_INFO
+from template_editor import template_editor
 def render_step2():
     st.header("Configure & Process")
+    if 'editing_mode' not in st.session_state: st.session_state.editing_mode = False
+    if 'edited_templates' not in st.session_state: st.session_state.edited_templates = {}
     col1, col2 = st.columns([1, 1])
     with col1:
+        render_configuration_column()
     with col2:
         render_preview_column()
+def render_configuration_column():
     st.subheader("Configuration")
+    if st.session_state.preview_generating:
+        return
+    if st.session_state.editing_mode:
+        handle_editing_mode()
+    else:
+        handle_preset_selection_mode()
+def handle_preset_selection_mode():
+    display_names = [
+        f"{name} [EDITED]" if (name in st.session_state.edited_templates and st.session_state.edited_templates[name]["modified"]) else name
+        for name in TEMPLATE_NAMES
+    ]
+    current_selection_name = st.session_state.get('selected_template', TEMPLATE_NAMES[0])
+    try:
+        current_index = TEMPLATE_NAMES.index(current_selection_name)
+    except ValueError:
+        current_index = 0
+    selected_display_name = st.selectbox(
+        "Choose a Style", display_names, index=current_index
+    )
+    # Extraer el nombre real de la template
+    template_name = selected_display_name.replace(" [EDITED]", "")
     st.session_state.selected_template = template_name
     selected_template_info = next((t for t in TEMPLATES_INFO if t["name"] == template_name), None)
     if selected_template_info and selected_template_info["ai_features"]:
         ai_features_str = ", ".join(selected_template_info["ai_features"])
+        if not st.session_state.get('api_key_input'):
             st.warning(f"⚠️ This template uses AI features ({ai_features_str}). "
                        "Please provide an API key in the sidebar to enable them. "
                        "Otherwise, they will be ignored during processing.")
         else:
             st.info(f"✨ This template uses AI features: {ai_features_str}.")
+    st.write("")
+    if st.button("✍️ Customize template", use_container_width=True):
+        st.session_state.editing_mode = True
+        # Si la template no ha sido editada antes, la cargamos desde los archivos originales
+        if template_name not in st.session_state.edited_templates:
+            initial_data = load_template_files(template_name)
+            st.session_state.edited_templates[template_name] = {
+                "json": initial_data["json"],
+                "css": initial_data["css"],
+                "resources_zip": None,
+                "modified": False
+            }
+        st.rerun()
+    st.divider()
     st.session_state.edit_requested = st.checkbox(
+        "I want to review and edit the processed subtitles before rendering",
         value=st.session_state.get('edit_requested', False)
     )
     b_next_col, b_back_col = st.columns(2)
     with b_next_col:
         if st.button("Render Video ➡️", type="primary", use_container_width=True):
+            process_and_advance()
     with b_back_col:
         if st.button("⬅️ Start Over", use_container_width=True):
             reset_all()
             st.rerun()
+def handle_editing_mode():
+    template_name = st.session_state.selected_template
+    st.info(f"You are customizing the **'{template_name}'** template.")
+    current_edit_data = st.session_state.edited_templates[template_name]
+    editor_result = template_editor(
+        json=current_edit_data["json"],
+        css=current_edit_data["css"],
+        key=f"editor_{template_name}"
+    )
+    if editor_result:
+        if editor_result.get("action") == "save":
+            old_json = st.session_state.edited_templates[template_name].get("json", None)
+            old_css = st.session_state.edited_templates[template_name].get("css", None)
+            new_json = editor_result["json_content"]
+            new_css = editor_result["css_content"]
+            # This is a little bit tricky, but this logic can be executed multiple times for the same preview (because of using st.rerun)
+            # So, if `was_content_modified` is not used, we are going to remove the preview when this is re-rendered but the code was not changed
+            # On the other hand, modified must be always "True", since if we use `was_content_modified` here, it will be "False" when this is re-rendered for the same saving
+            was_content_modified = old_json != new_json or old_css != new_css
+            st.session_state.edited_templates[template_name]["json"] = new_json
+            st.session_state.edited_templates[template_name]["css"] = new_css
+            st.session_state.edited_templates[template_name]["modified"] = True
+            if template_name in st.session_state.previews and was_content_modified:
+                del st.session_state.previews[template_name]
+            st.toast("✅ Template saved!")
+            st.success("✅ Template saved!")
+        elif editor_result.get("action") == "error":
+            st.error(editor_result.get("message", "An error occurred in the editor."))
+    st.session_state.edited_templates[template_name]["resources_zip"] = st.file_uploader(
+        "(Optional) Upload a `.zip` to add or overwrite resources", type=["zip"],
+        key=f"uploader_{template_name}"
+    )
+    edit_buttons_col1, edit_buttons_col2 = st.columns(2)
+    with edit_buttons_col1:
+        if st.button("Back to Templates", use_container_width=True):
+            st.session_state.editing_mode = False
+            st.rerun()
+    with edit_buttons_col2:
+        if st.button("Reset to Original", help="Discards all edits for this template.", use_container_width=True):
+            if template_name in st.session_state.edited_templates:
+                del st.session_state.edited_templates[template_name]
+            if template_name in st.session_state.previews:
+                del st.session_state.previews[template_name]
+            st.toast(f"Template '{template_name}' has been reset to its original state.")
+            st.success(f"Template '{template_name}' has been reset to its original state.")
+            st.session_state.editing_mode = False
+            st.rerun()
+def process_and_advance():
+    with st.spinner("Applying configuration..."):
+        try:
+            builder = create_pipeline_builder()
+            builder.with_input_video(st.session_state.video_path)
+            setup_api_keys(st.session_state.api_key_type, st.session_state.api_key_input)
+            pipeline = builder.build()
+            pipeline.prepare()
+            document = Document.from_dict(st.session_state.transcribed_doc)
+            processed_document = pipeline.process_document(document)
+            pipeline.close()
+            st.session_state.processed_doc = processed_document.to_dict()
+            go_to_step(3)
+            st.rerun()
+        except Exception as e:
+            handle_unexpected_exception(e)
+        finally:
+            cleanup_api_keys()
 def render_preview_column():
     st.subheader("Live Preview")
     st.markdown("Generate a short, low-quality video preview with the selected style. This takes a few seconds.")
     st.warning("AI features (auto-emojis, ai tagger) are ignored in the preview.")
     preview_container = st.container()
+    template_name = st.session_state.get('selected_template')
     has_preview_for_template = template_name in st.session_state.previews
+    should_disable_button = has_preview_for_template or st.session_state.preview_generating
+    if has_preview_for_template:
+        preview_container.video(st.session_state.previews[template_name])
+    if st.button("Generate Preview ⚡", use_container_width=True, disabled=should_disable_button):
         st.session_state.preview_generating = True
         st.rerun()
     if st.session_state.preview_generating:
         try:
             with st.spinner("Generating preview video... ⚡"):
+                builder = create_pipeline_builder()
+                builder.with_input_video(st.session_state.video_path)
                 pipeline = builder.build(preview_time=(0, 5))
                 document = Document.from_dict(st.session_state.transcribed_doc)
                 preview_output_path = pipeline._output_video_path
                 if preview_output_path and os.path.exists(preview_output_path):
                     st.session_state.previews[template_name] = preview_output_path
                 else:
+                    raise RuntimeError("Could not generate preview.")
         except Exception as e:
             handle_unexpected_exception(e)
         finally:
             st.session_state.preview_generating = False
             st.rerun()

src/ui/step3_edit.py CHANGED Viewed

@@ -1,5 +1,5 @@
 import streamlit as st
-from editor import subtitle_editor
 from utils import go_to_step, handle_unexpected_exception
 def render_step3():

 import streamlit as st
+from subtitle_editor import subtitle_editor
 from utils import go_to_step, handle_unexpected_exception
 def render_step3():

src/ui/step4_render.py CHANGED Viewed

@@ -1,7 +1,7 @@
 import streamlit as st
 import os
 from pycaps import Document
-from utils import go_to_step, build_pipeline_from_state, setup_api_keys, handle_unexpected_exception
 def render_step4():
     st.header("Final Render")
@@ -10,7 +10,7 @@ def render_step4():
     try:
         with st.spinner("Rendering final video... This is the last step! 🎬"):
-            pipeline = build_pipeline_from_state()
             if not pipeline:
                 raise RuntimeError("Could not build pipeline for rendering.")

 import streamlit as st
 import os
 from pycaps import Document
+from utils import go_to_step, create_pipeline_builder, setup_api_keys, handle_unexpected_exception
 def render_step4():
     st.header("Final Render")
     try:
         with st.spinner("Rendering final video... This is the last step! 🎬"):
+            pipeline = create_pipeline_builder().with_input_video(st.session_state.video_path).build()
             if not pipeline:
                 raise RuntimeError("Could not build pipeline for rendering.")

src/ui/step5_view.py CHANGED Viewed

@@ -1,12 +1,10 @@
 import streamlit as st
-from utils import go_to_step, reset_all, release_lock_slot, acquire_lock_slot, display_video
 def render_step5():
     st.header("Your Video is Ready!")
-    if st.session_state.lock_file_path:
-        release_lock_slot(st.session_state.lock_file_path)
-        st.session_state.lock_file_path = None
     if 'final_video_path' in st.session_state and st.session_state.final_video_path:
         display_video(st.session_state.final_video_path)

 import streamlit as st
+from utils import go_to_step, reset_all, release_lock_slot_if_needed, acquire_lock_slot, display_video
 def render_step5():
     st.header("Your Video is Ready!")
+    release_lock_slot_if_needed()
     if 'final_video_path' in st.session_state and st.session_state.final_video_path:
         display_video(st.session_state.final_video_path)

src/utils.py CHANGED Viewed

@@ -4,9 +4,16 @@ import time
 import glob
 import uuid
 from pathlib import Path
 from pycaps.api import ApiKeyService
-from pycaps import TemplateLoader
 from config import LOCK_DIR, LOCK_TTL_SECONDS, MAX_CONCURRENT_JOBS
 # --- Lock Management ---
@@ -65,14 +72,14 @@ def cleanup_api_keys():
 def go_to_step(step):
     st.session_state.current_step = step
-def reset_all():
-    if 'lock_file_path' in st.session_state and st.session_state.lock_file_path:
         release_lock_slot(st.session_state.lock_file_path)
-    persisted_keys = ['api_key_type', 'api_key_input']
-    if 'video_path' in st.session_state and st.session_state.video_path and os.path.exists(st.session_state.video_path):
-        os.remove(st.session_state.video_path)
     for key in list(st.session_state.keys()):
         if key not in persisted_keys:
             del st.session_state[key]
@@ -100,10 +107,49 @@ def initialize_session_state():
 # --- Pipeline & Display ---
-def build_pipeline_from_state():
-    if not st.session_state.video_path or not st.session_state.selected_template:
-        return None
-    return TemplateLoader(st.session_state.selected_template).with_input_video(st.session_state.video_path).load()
 def handle_unexpected_exception(e):
     st.session_state.error_message = f"Unexpected error: {e}"
@@ -123,3 +169,30 @@ def display_video(video_path):
             "⬇️ Download Video", video_bytes,
             f"pycaps_{Path(video_path).stem}.mp4", "video/mp4"
         )

 import glob
 import uuid
 from pathlib import Path
+import importlib.resources as resources
+from importlib.abc import Traversable
+import zipfile
+import json
+import shutil
+from pathlib import Path
+from file_manager import create_temp_dir, get_random_file_name
 from pycaps.api import ApiKeyService
+from pycaps import TemplateLoader, JsonConfigLoader
 from config import LOCK_DIR, LOCK_TTL_SECONDS, MAX_CONCURRENT_JOBS
 # --- Lock Management ---
 def go_to_step(step):
     st.session_state.current_step = step
+def release_lock_slot_if_needed():
+    if st.session_state.lock_file_path:
         release_lock_slot(st.session_state.lock_file_path)
+        st.session_state.lock_file_path = None
+def reset_all():
+    release_lock_slot_if_needed()
+    persisted_keys = ['api_key_type', 'api_key_input']
     for key in list(st.session_state.keys()):
         if key not in persisted_keys:
             del st.session_state[key]
 # --- Pipeline & Display ---
+def create_pipeline_builder():
+    template_name = st.session_state.selected_template
+    if template_name not in st.session_state.edited_templates:
+        return (
+            TemplateLoader(template_name)
+            .load(False)
+            .should_save_subtitle_data(False)
+            .with_output_video(get_random_file_name("mp4"))
+        )
+    edited_data = st.session_state.edited_templates[template_name]
+    temp_dir = create_temp_dir()
+    original_template_path = get_template_path(template_name)
+    resources_dir = Path(temp_dir) / "resources"
+    os.makedirs(resources_dir, exist_ok=True)
+    # Primero, copiar recursos originales si existen
+    if original_template_path and (original_template_path / "resources").is_dir():
+        edited_data["json"]["resources"] = "resources"
+        shutil.copytree(str(original_template_path / "resources"), str(resources_dir), dirs_exist_ok=True)
+    # Luego, descomprimir y sobrescribir con los recursos subidos por el usuario
+    if edited_data.get('resources_zip'):
+        edited_data["json"]["resources"] = "resources"
+        with zipfile.ZipFile(edited_data['resources_zip'], 'r') as zip_ref:
+            zip_ref.extractall(resources_dir)
+    # Crear los archivos de configuración en el directorio temporal
+    config_path = Path(temp_dir) / "pycaps.json"
+    with open(config_path, "w") as f:
+        edited_data["json"]["css"] = "styles.css"
+        json.dump(edited_data["json"], f, indent=2)
+    css_path = Path(temp_dir) / "styles.css"
+    with open(css_path, "w") as f:
+        f.write(edited_data["css"])
+    return (
+        JsonConfigLoader(str(config_path))
+        .load(False)
+        .should_save_subtitle_data(False)
+        .with_output_video(get_random_file_name("mp4"))
+    )
 def handle_unexpected_exception(e):
     st.session_state.error_message = f"Unexpected error: {e}"
             "⬇️ Download Video", video_bytes,
             f"pycaps_{Path(video_path).stem}.mp4", "video/mp4"
         )
+def get_template_path(template_name: str) -> Traversable:
+    """Obtiene la ruta a la carpeta de una template predefinida."""
+    try:
+        return resources.files(f"pycaps.template.preset.{template_name}")
+    except ModuleNotFoundError:
+        return None
+def load_template_files(template_name: str) -> dict:
+    """Carga el contenido de los archivos de una template predefinida."""
+    template_path = get_template_path(template_name)
+    if not template_path:
+        return {"json": {}, "css": ""}
+    try:
+        with (template_path / "pycaps.template.json").open("r", encoding="utf-8") as f:
+            json_content = json.load(f)
+    except FileNotFoundError:
+        json_content = {}
+    try:
+        with (template_path / "styles.css").open("r", encoding="utf-8") as f:
+            css_content = f.read()
+    except FileNotFoundError:
+        css_content = ""
+    return {"json": json_content, "css": css_content}