File size: 21,392 Bytes
e9ffb4e
5703e10
e9ffb4e
 
 
 
 
 
0544508
 
 
ecabae2
0544508
e9ffb4e
 
3eeb685
 
e9ffb4e
 
 
 
 
 
 
 
 
 
5703e10
e9ffb4e
1a0be2e
bc89ec6
 
 
 
436e716
 
 
3eeb685
0544508
 
 
 
5d412c9
5fac31f
0544508
5703e10
1da3b38
 
0544508
 
d5f8cc9
3eeb685
6d76796
0544508
5fac31f
5703e10
 
 
5fac31f
5703e10
ab4480a
5703e10
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ab4480a
 
38a2965
5703e10
 
5fac31f
5703e10
5fac31f
 
 
 
5703e10
5fac31f
 
 
 
 
 
 
 
 
 
 
 
 
5703e10
5fac31f
 
 
5703e10
5fac31f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5703e10
5fac31f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5703e10
ecabae2
5fac31f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
38a2965
5fac31f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5703e10
ecabae2
 
730d6d7
ecabae2
 
730d6d7
436e716
66c9a07
ecabae2
 
 
 
 
ab4480a
 
ecabae2
 
 
 
 
 
 
 
 
 
 
 
 
5b92515
730d6d7
5b92515
ecabae2
730d6d7
 
ecabae2
 
 
 
 
0544508
ecabae2
 
730d6d7
 
ecabae2
 
 
 
 
 
 
 
 
 
 
 
5b92515
ecabae2
 
 
 
5b92515
5d412c9
730d6d7
ecabae2
 
 
 
ab4480a
 
 
 
38a2965
ab4480a
ecabae2
 
 
 
 
 
 
 
 
 
 
 
66c9a07
ecabae2
 
436e716
ecabae2
 
 
730d6d7
5fac31f
730d6d7
ecabae2
 
 
730d6d7
 
 
 
 
5d412c9
730d6d7
 
 
 
 
ecabae2
 
 
 
 
 
ab4480a
5703e10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
# ==============================================================================
# Wymuszona instalacja bibliotek
# ==============================================================================
import os
import subprocess
import sys

def install_packages():
    packages = [
        "gradio>=4.0.0", "transformers>=4.38.1", "torch>=2.2.0", 
        "accelerate>=0.27.2", "diffusers>=0.26.3", "fpdf2", "Pillow", 
        "datasets", "gradio_client", "speechbrain", "soundfile", "moviepy==1.0.3"
    ]
    for package in packages:
        try:
            module_name = package.split('>')[0].split('=')[0].split('<')[0]
            __import__(module_name)
            print(f"{package} jest już zainstalowany.")
        except ImportError:
            print(f"Instalowanie {package}...")
            subprocess.check_call([sys.executable, "-m", "pip", "install", package])

if 'PACKAGES_INSTALLED' not in os.environ:
    install_packages()
    os.environ['PACKAGES_INSTALLED'] = 'TRUE'

# ==============================================================================
# Główny kod aplikacji
# ==============================================================================
import gradio as gr
from transformers import pipeline as text_pipeline
from diffusers import DiffusionPipeline
import torch
import re
from fpdf import FPDF
from PIL import Image
import time
from datasets import Dataset, Features, Value, Sequence, Image as HFImage
from gradio_client import Client
from transformers import SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan
import soundfile as sf
import numpy as np
from moviepy.editor import ImageClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
from speechbrain.pretrained import EncoderClassifier

# --- Konfiguracja ---
LLM_MODEL = "HuggingFaceH4/zephyr-7b-beta"
IMAGE_MODEL = "stabilityai/stable-diffusion-2-1-base"
TTS_MODEL = "microsoft/speecht5_tts"
VOCODER_MODEL = "microsoft/speecht5_hifigan"
SPEAKER_EMBEDDING_MODEL = "speechbrain/spkrec-xvect-voxceleb"
DATASET_PATH = "saved_courses"
TEXT_TO_3D_MODEL_SPACE = "stabilityai/TripoSR"
device = "cuda" if torch.cuda.is_available() else "cpu"

# --- Globalne zmienne dla modeli ---
text_generator, image_generator, client_3d, tts_processor, tts_model, vocoder, speaker_embeddings = (None,) * 7
LLM_LOADED, IMAGE_MODEL_LOADED, CLIENT_3D_LOADED, TTS_LOADED = (False,) * 4

# --- Funkcje ładowania modeli ---
def load_all_models():
    global text_generator, image_generator, client_3d, tts_processor, tts_model, vocoder, speaker_embeddings
    global LLM_LOADED, IMAGE_MODEL_LOADED, CLIENT_3D_LOADED, TTS_LOADED
    
    try:
        print("Ładowanie modelu językowego..."); text_generator = text_pipeline("text-generation", model=LLM_MODEL, torch_dtype=torch.bfloat16, device_map="auto"); LLM_LOADED = True; print("Model językowy załadowany.")
    except Exception as e: print(f"Błąd ładowania LLM: {e}")
    try:
        print("Ładowanie modelu obrazkowego..."); image_generator = DiffusionPipeline.from_pretrained(IMAGE_MODEL); image_generator.to(device); IMAGE_MODEL_LOADED = True; print("Model obrazkowy załadowany.")
    except Exception as e: print(f"Błąd ładowania Image Model: {e}")
    try:
        print("Inicjalizacja klienta 3D..."); client_3d = Client(TEXT_TO_3D_MODEL_SPACE); CLIENT_3D_LOADED = True; print("Klient 3D gotowy.")
    except Exception as e: print(f"Błąd inicjalizacji klienta 3D: {e}")
    try:
        print("Ładowanie modeli TTS...")
        tts_processor = SpeechT5Processor.from_pretrained(TTS_MODEL)
        tts_model = SpeechT5ForTextToSpeech.from_pretrained(TTS_MODEL).to(device)
        vocoder = SpeechT5HifiGan.from_pretrained(VOCODER_MODEL).to(device)
        speaker_model = EncoderClassifier.from_hparams(source=SPEAKER_EMBEDDING_MODEL, savedir=os.path.join('/tmp', SPEAKER_EMBEDDING_MODEL))
        dummy_waveform = torch.randn(1, 16000).to(device)
        speaker_embeddings = speaker_model.encode_batch(dummy_waveform).squeeze().to(device)
        TTS_LOADED = True
        print("Modele TTS załadowane.")
    except Exception as e: print(f"Błąd ładowania modeli TTS: {e}")
    
    # Zwracamy informację do UI, że modele są gotowe
    return gr.update(interactive=True), gr.update(interactive=True)

# --- Funkcje pomocnicze i główne ---
def list_saved_projects():
    if not os.path.exists(DATASET_PATH): return []
    try:
        dataset = Dataset.load_from_disk(DATASET_PATH)
        return dataset["project_name"]
    except Exception as e:
        print(f"Błąd odczytu projektów: {e}"); return []

def parse_course_to_structure(markdown_text):
    course_data = {'title': "Nowy Kurs", 'steps': []}
    title_match = re.search(r"^#\s*(.*)", markdown_text, re.MULTILINE)
    if title_match: course_data['title'] = title_match.group(1).strip()
    step_pattern = re.compile(r"(\d+\.\s*\*\*(.*?)\*\*)\s*([\s\S]*?)(?=\n\d+\.|\Z)", re.MULTILINE)
    steps_found = step_pattern.findall(markdown_text)
    for _, step_title, step_description in steps_found:
        course_data['steps'].append({'title': step_title.strip(), 'description': step_description.strip()})
    return course_data

def generate_course_structure_and_images(topic, progress=gr.Progress(track_tqdm=True)):
    if not LLM_LOADED or not IMAGE_MODEL_LOADED:
        gr.Error("Kluczowe modele AI nie zostały załadowane. Sprawdź logi.")
        return [None, gr.State([])] + [gr.update(visible=False)]*2 + [gr.update(interactive=False)]*3 + [gr.update()]*11

    progress(0, desc="Generowanie tekstu kursu...")
    prompt = f"<|system|>\nJesteś ekspertem w tworzeniu kursów online...</s>\n<|user|>\nTemat kursu: \"{topic}\"</s>\n<|assistant|>"
    response = text_generator(prompt, max_new_tokens=1024, do_sample=True, temperature=0.7, top_p=0.95)
    course_text = response[0]['generated_text'].split('<|assistant|>')[-1].strip()
    course_data = parse_course_to_structure(course_text)
    
    progress(0.2, desc="Generowanie obrazków...")
    generated_images = []
    if course_data['steps']:
        for i, step in enumerate(course_data['steps']):
            progress(0.2 + (i + 1) / len(course_data['steps']) * 0.8, desc=f"Generowanie obrazka dla: {step['title']}")
            image_prompt = f"cinematic photo of '{step['title']}', professional photography, high detail, 8k"
            image = image_generator(image_prompt, num_inference_steps=25).images[0]
            generated_images.append(image)

    updates = [gr.update(value=course_data['title'])]
    for i in range(5):
        if i < len(course_data['steps']):
            updates.extend([gr.update(value=course_data['steps'][i]['title']), gr.update(value=course_data['steps'][i]['description'])])
        else:
            updates.extend(["", ""])

    return generated_images, gr.State(generated_images), gr.update(visible=True), gr.update(visible=True), gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True), *updates

def load_project(project_name):
    if not project_name:
        gr.Warning("Wybierz projekt do wczytania.")
        return [None, gr.State([])] + [gr.update(visible=False)]*2 + [gr.update(interactive=False)]*3 + [gr.update()]*11

    dataset = Dataset.load_from_disk(DATASET_PATH)
    project_data = dataset.filter(lambda example: example["project_name"] == project_name)[0]
    
    loaded_images = project_data["images"]
    
    updates = [gr.update(value=project_data['course_title'])]
    for i in range(5):
        if i < len(project_data['steps']):
            step = project_data['steps'][i]
            updates.extend([gr.update(value=step['title']), gr.update(value=step['description'])])
        else:
            updates.extend(["", ""])

    return loaded_images, gr.State(loaded_images), gr.update(visible=True), gr.update(visible=True), gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True), *updates

def update_preview(course_title, *args):
    markdown_preview = f"# {course_title}\n\n"
    step_data = list(args)
    for i in range(0, len(step_data), 2):
        step_title, step_description = step_data[i], step_data[i+1]
        if step_title:
            markdown_preview += f"### Krok {i//2 + 1}: {step_title}\n{step_description}\n\n"
    return markdown_preview

def move_step(direction, step_index, images_state, *text_fields):
    if direction == "up":
        if step_index == 0: return [images_state] + [gr.update() for _ in text_fields]
        swap_with_index = step_index - 1
    else:
        if step_index >= 4 or not text_fields[(step_index + 1) * 2]: return [images_state] + [gr.update() for _ in text_fields]
        swap_with_index = step_index + 1

    images_state[step_index], images_state[swap_with_index] = images_state[swap_with_index], images_state[step_index]
    
    current_title, current_desc = text_fields[step_index * 2], text_fields[step_index * 2 + 1]
    swap_title, swap_desc = text_fields[swap_with_index * 2], text_fields[swap_with_index * 2 + 1]

    updates = list(text_fields)
    updates[step_index * 2], updates[step_index * 2 + 1] = swap_title, swap_desc
    updates[swap_with_index * 2], updates[swap_with_index * 2 + 1] = current_title, current_desc
    
    final_updates = [gr.update(value=v) for v in updates]
    return [images_state] + final_updates

def generate_3d_model(prompt_text, progress=gr.Progress(track_tqdm=True)):
    if not CLIENT_3D_LOADED:
        gr.Warning("Klient do generowania modeli 3D nie jest dostępny.")
        return None
    if not prompt_text:
        gr.Info("Wpisz tytuł kroku, aby wygenerować model 3D.")
        return None
    progress(0, desc="Wysyłanie zapytania do modelu 3D... (to może potrwać kilka minut)")
    result_path = client_3d.predict(prompt_text, None, True, 0.5, 1024, 256, api_name="/generate")
    progress(1, desc="Model 3D gotowy!")
    return result_path

def generate_audio(text, progress=gr.Progress(track_tqdm=True)):
    if not TTS_LOADED:
        gr.Warning("Modele Text-to-Speech nie są dostępne.")
        return None
    if not text:
        gr.Info("Brak tekstu do wygenerowania audio.")
        return None
    progress(0, desc="Generowanie audio...")
    inputs = tts_processor(text=text, return_tensors="pt")
    speech = tts_model.generate_speech(inputs["input_ids"].to(device), speaker_embeddings.unsqueeze(0), vocoder=vocoder)
    output_path = f"/tmp/audio_{int(time.time())}.wav"
    sf.write(output_path, speech.cpu().numpy(), samplerate=16000)
    progress(1, desc="Audio gotowe!")
    return output_path

def generate_video_from_ui(images_state, course_title, *args, progress=gr.Progress(track_tqdm=True)):
    if not images_state or not course_title:
        gr.Warning("Najpierw wygeneruj kurs, aby stworzyć wideo.")
        return None
    step_data = list(args)
    audio_clips, video_clips, temp_audio_files = [], [], []
    total_steps = len(images_state)
    for i in range(total_steps):
        progress((i + 1) / (total_steps + 1), desc=f"Tworzenie audio dla kroku {i+1}/{total_steps}")
        step_description = step_data[i*2+1]
        if not step_description: continue
        audio_path = generate_audio(step_description)
        if audio_path:
            audio_clip = AudioFileClip(audio_path)
            audio_clips.append(audio_clip)
            temp_audio_files.append(audio_path)
            video_clip = ImageClip(np.array(images_state[i])).set_duration(audio_clip.duration)
            video_clips.append(video_clip)
    if not video_clips:
        gr.Warning("Nie udało się stworzyć żadnych klipów wideo.")
        return None
    progress(0.9, desc="Montowanie finalnego wideo...")
    final_video = concatenate_videoclips(video_clips, method="compose")
    final_video.audio = CompositeAudioClip(audio_clips)
    video_output_path = f"/tmp/final_video_{int(time.time())}.mp4"
    final_video.write_videofile(video_output_path, fps=24, codec="libx24")
    for f in temp_audio_files: os.remove(f)
    progress(1, desc="Wideo gotowe!")
    return video_output_path
    
def save_project(project_name, images_state, course_title, *args):
    if not project_name: return "⚠️ Proszę podać nazwę projektu."
    steps_list = []
    step_data = list(args)
    for i in range(0, len(step_data), 2):
        if step_data[i]: steps_list.append({'title': step_data[i], 'description': step_data[i+1]})
    new_item = {'project_name': project_name, 'course_title': course_title, 'steps': steps_list, 'images': images_state}
    features = Features({'project_name': Value('string'), 'course_title': Value('string'), 'steps': Sequence({'title': Value('string'), 'description': Value('string')}), 'images': Sequence(HFImage())})
    if os.path.exists(DATASET_PATH):
        dataset = Dataset.load_from_disk(DATASET_PATH)
    else:
        dataset = Dataset.from_dict({key: [] for key in features.keys()}, features=features)
    dataset = dataset.add_item(new_item)
    dataset.save_to_disk(DATASET_PATH)
    return f"✅ Projekt '{project_name}' został pomyślnie zapisany!"

def generate_pdf_from_ui(images_state, course_title, *args):
    if not course_title or not images_state: return None
    pdf = FPDF()
    pdf.add_page()
    try:
        pdf.add_font('DejaVu', '', 'DejaVuSans.ttf', uni=True); pdf.set_font('DejaVu', '', 12)
    except RuntimeError:
        print("Brak czcionki DejaVu, używam 'Arial'."); pdf.set_font('Arial', '', 12)
    pdf.set_font_size(24)
    pdf.multi_cell(0, 10, course_title.encode('latin-1', 'replace').decode('latin-1')); pdf.ln(10)
    temp_image_paths = []
    for i, img in enumerate(images_state):
        path = f"/tmp/temp_image_{i}.png"; img.save(path); temp_image_paths.append(path)
    step_data = list(args); image_counter = 0
    for i in range(0, len(step_data), 2):
        step_title, step_description = step_data[i], step_data[i+1]
        if step_title:
            pdf.set_font_size(16)
            pdf.multi_cell(0, 8, f"Krok {i//2 + 1}: {step_title}".encode('latin-1', 'replace').decode('latin-1')); pdf.ln(4)
            if image_counter < len(temp_image_paths):
                pdf.image(temp_image_paths[image_counter], x=None, y=None, w=180); pdf.ln(5); image_counter += 1
            pdf.set_font_size(12)
            pdf.multi_cell(0, 6, step_description.encode('latin-1', 'replace').decode('latin-1')); pdf.ln(10)
    pdf_output_path = f"/tmp/kurs_{int(time.time())}.pdf"; pdf.output(pdf_output_path)
    for path in temp_image_paths: os.remove(path)
    return pdf_output_path

# --- Budowa Interfejsu Gradio ---
custom_css = "body, #root { height: 100vh; margin: 0; padding: 0; } .gradio-container { max-width: 100% !important; } .main, .wrap, .gap { height: 100%; } .app-title { text-align: center; font-size: 2.5em; color: #2c3e50; font-weight: bold; margin-bottom: 0px !important; } .app-subtitle { text-align: center; font-size: 1.1em; color: #576574; margin-top: 5px; margin-bottom: 20px; } .section-title { font-size: 1.5em; font-weight: bold; color: #2980b9; border-bottom: 2px solid #3498db; padding-bottom: 5px; margin-top: 10px; } footer { display: none !important; }"

with gr.Blocks(theme=gr.themes.Soft(primary_hue="sky", secondary_hue="blue"), title="Kreator Kursów AI", css=custom_css) as demo:
    
    gr.HTML("<h1 class='app-title'>🎨 Kreator Kursów AI 🚀</h1>")
    gr.HTML("<p class='app-subtitle'>Twoje centrum dowodzenia do tworzenia multimedialnych kursów DIY</p>")
    
    images_state = gr.State([])

    with gr.Row(equal_height=True):
        with gr.Column(scale=2):
            gr.Markdown("<h2 class='section-title'>⚙️ Panel Sterowania</h2>")
            with gr.Group():
                gr.Markdown("### 1. Wygeneruj lub Wczytaj Projekt")
                topic_input = gr.Textbox(label="Wpisz temat nowego kursu", placeholder="np. Jak zbudować domek dla jeży?", lines=3, interactive=False)
                generate_button = gr.Button("🚀 Wygeneruj Nowy Kurs!", variant="primary", interactive=False)
            with gr.Accordion("📚 Biblioteka Projektów", open=True):
                saved_projects_dropdown = gr.Dropdown(label="Wybierz zapisany projekt", choices=list_saved_projects(), interactive=True)
                load_project_button = gr.Button("📂 Wczytaj Projekt")
            with gr.Group():
                gr.Markdown("### 3. Zapisz Postępy")
                project_name_input = gr.Textbox(label="Nazwa Projektu", placeholder="Mój kurs o jeżach...")
                save_button = gr.Button("💾 Zapisz Projekt", interactive=False)
                save_confirmation_output = gr.Markdown()

        with gr.Column(scale=4):
            gr.Markdown("<h2 class='section-title'>✍️ Główny Edytor</h2>")
            with gr.Group(visible=False) as editor_group:
                course_title_editor = gr.Textbox(label="Tytuł Główny Kursu", interactive=True)
                step_editors = []
                step_text_editors = []
                for i in range(5):
                    with gr.Accordion(f"Krok {i+1}", open=True):
                        with gr.Row():
                            with gr.Column(scale=10):
                                step_title = gr.Textbox(label="Tytuł kroku", interactive=True)
                                step_description = gr.Textbox(label="Opis kroku", lines=5, interactive=True)
                            with gr.Column(scale=1, min_width=80):
                                up_button = gr.Button("🔼")
                                down_button = gr.Button("🔽")
                        with gr.Row():
                            generate_3d_btn = gr.Button("🧊 3D")
                            generate_audio_btn = gr.Button("🎵 Audio")
                        step_editors.extend([step_title, step_description, generate_3d_btn, generate_audio_btn, up_button, down_button])
                        step_text_editors.extend([step_title, step_description])

        with gr.Column(scale=3):
            gr.Markdown("<h2 class='section-title'>👁️ Podgląd i Eksport</h2>")
            with gr.Group(visible=False) as preview_group:
                with gr.Tabs():
                    with gr.TabItem("Tekst"):
                        preview_display = gr.Markdown("Podgląd kursu pojawi się tutaj...")
                    with gr.TabItem("Multimedia"):
                        image_gallery = gr.Gallery(label="Ilustracje", show_label=False, columns=3, height="auto")
                        model_3d_display = gr.Model3D(label="Model 3D", show_label=False)
                        audio_player = gr.Audio(label="Lektor", show_label=False)
                gr.Markdown("### 4. Pobierz Gotowy Kurs")
                with gr.Row():
                    pdf_button = gr.Button("📄 PDF", interactive=False)
                    video_button = gr.Button("🎬 Wideo", interactive=False)
                file_output = gr.File(label="Pobierz PDF")
                video_output = gr.Video(label="Pobierz Wideo", format="mp4")

    # --- Logika Akcji ---
    editor_text_fields = [course_title_editor] + step_text_editors
    all_outputs_for_load_and_generate = [
        image_gallery, images_state, editor_group, preview_group,
        pdf_button, save_button, video_button
    ] + editor_text_fields
    
    demo.load(
        fn=load_all_models,
        inputs=None,
        outputs=[generate_button, topic_input]
    )

    generate_button.click(
        fn=generate_course_structure_and_images,
        inputs=[topic_input],
        outputs=all_outputs_for_load_and_generate
    ).then(fn=update_preview, inputs=editor_text_fields, outputs=preview_display)
    
    load_project_button.click(
        fn=load_project,
        inputs=[saved_projects_dropdown],
        outputs=all_outputs_for_load_and_generate
    ).then(fn=update_preview, inputs=editor_text_fields, outputs=preview_display)
    
    for editor_component in editor_text_fields:
        editor_component.change(fn=update_preview, inputs=editor_text_fields, outputs=preview_display)
    
    pdf_button.click(fn=generate_pdf_from_ui, inputs=[images_state] + editor_text_fields, outputs=file_output)
    save_button.click(fn=save_project, inputs=[project_name_input, images_state] + editor_text_fields, outputs=[save_confirmation_output])

    for i in range(5):
        step_title_comp, step_desc_comp, btn_3d_comp, btn_audio_comp, up_btn, down_btn = step_editors[i*6 : (i+1)*6]
        
        btn_3d_comp.click(fn=generate_3d_model, inputs=[step_title_comp], outputs=[model_3d_display])
        btn_audio_comp.click(fn=generate_audio, inputs=[step_desc_comp], outputs=[audio_player])
        
        up_btn.click(
            fn=move_step,
            inputs=[gr.State("up"), gr.State(i), images_state] + step_text_editors,
            outputs=[images_state] + step_text_editors
        ).then(fn=update_preview, inputs=editor_text_fields, outputs=preview_display)
        
        down_btn.click(
            fn=move_step,
            inputs=[gr.State("down"), gr.State(i), images_state] + step_text_editors,
            outputs=[images_state] + step_text_editors
        ).then(fn=update_preview, inputs=editor_text_fields, outputs=preview_display)
        
    video_button.click(
        fn=generate_video_from_ui,
        inputs=[images_state] + editor_text_fields,
        outputs=[video_output]
    )

demo.queue().launch(show_api=False)