initial commit

README.md

@@ -0,0 +1,36 @@
+---
+title: Nano Banana Studio
+emoji: 🍌
+colorFrom: yellow
+colorTo: red
+sdk: streamlit
+sdk_version: 1.41.0 
+app_file: app.py
+pinned: false
+---
+
+
+# 🍌 Nano Banana Studio Pro
+
+유튜버를 위한 올인원 AI 스튜디오입니다. 구글 Gemini 모델을 활용해 영상 장면을 생성하고, 유튜브 SEO(제목, 태그, 설명)를 기획합니다.
+
+## 📂 파일 구조 설명 (Modular Structure)
+
+이 프로젝트는 기능별로 모듈화되어 있습니다. 수정이 필요할 때 해당 파일을 참고하세요.
+
+* **`app.py`**: 메인 실행 파일입니다. Streamlit UI(화면)와 전체적인 흐름을 담당합니다.
+* **`config_style.py`**: **[수정 권장]** 프롬프트 스타일과 썸네일 전략이 저장된 곳입니다. 로직 건드릴 필요 없이 스타일만 추가할 때 이곳을 엽니다.
+* **`logic_image.py`**: 이미지 생성 로직(Brain & Painter)과 캐릭터 참조 기능이 들어있습니다.
+* **`logic_seo.py`**: 유튜브 기획(SEO) 및 썸네일 기획 로직이 들어있습니다.
+* **`utils.py`**: 파일명 정리, 텍스트 자르기 등 단순 도구 함수들이 모여있습니다.
+
+## 🚀 주요 기능
+1.  **AI 장면 생성 (병렬 처리)**: 한 번에 최대 5장의 이미지를 동시에 생성하여 속도가 빠릅니다.
+2.  **캐릭터 참조 (Character Consistency)**: 캐릭터 이미지를 업로드하면 일관된 캐릭터가 등장하도록 그립니다.
+3.  **유튜브 SEO 기획**: 대본을 분석해 클릭률 높은 제목, 설명란, 태그를 추천합니다.
+
+## 🛠️ 설치 및 실행 (로컬)
+
+```bash
+pip install -r requirements.txt
+streamlit run app.py

app.py

@@ -0,0 +1,481 @@
+import streamlit as st
+import os
+import io
+import concurrent.futures
+from PIL import Image
+from google import genai
+
+# 로직 모듈 임포트
+import logic_image
+import logic_seo
+import logic_tts
+from config_style import STYLE_DEFINITIONS, THUMBNAIL_STRATEGIES
+
+# ==========================================
+# 1. 페이지 설정 및 CSS 디자인
+# ==========================================
+st.set_page_config(
+    page_title="Nano Banana Studio Pro",
+    page_icon="🍌",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# 세션 초기화
+if 'scene_results' not in st.session_state:
+    st.session_state['scene_results'] = []
+if 'final_audio' not in st.session_state:
+    st.session_state['final_audio'] = None
+if 'shared_script' not in st.session_state:
+    st.session_state['shared_script'] = ""
+
+# [CSS] 다크모드 + 오렌지 포인트 디자인
+st.markdown("""
+<style>
+    @import url('https://cdn.jsdelivr.net/gh/orioncactus/pretendard/dist/web/static/pretendard.css');
+    
+    html, body, [class*="css"] {
+        font-family: 'Pretendard', sans-serif;
+    }
+    .stApp {
+        background-color: #121212;
+        color: #E0E0E0;
+    }
+    
+    /* 사이드바 */
+    section[data-testid="stSidebar"] {
+        background-color: #0A0A0A;
+        border-right: 1px solid #333;
+    }
+    
+    /* 입력창 가독성 개선 */
+    .stTextInput input, .stTextArea textarea, .stSelectbox div[data-baseweb="select"] > div {
+        background-color: #252525 !important;
+        color: #FFFFFF !important;
+        border: 1px solid #404040 !important;
+        border-radius: 8px !important;
+    }
+    .stTextArea textarea[disabled] {
+        background-color: #1E1E1E !important;
+        color: #AAAAAA !important;
+        border: 1px solid #333 !important;
+    }
+    ::placeholder {
+        color: #AAAAAA !important;
+        opacity: 1;
+    }
+    
+    /* 탭 디자인 */
+    button[data-baseweb="tab"] {
+        font-size: 16px;
+        font-weight: 700;
+        color: #888;
+    }
+    button[data-baseweb="tab"][aria-selected="true"] {
+        color: #FFC107 !important;
+        background-color: transparent !important;
+        border-bottom: 2px solid #FFC107 !important;
+    }
+    
+    /* 버튼 디자인 */
+    div.stButton > button[kind="primary"] {
+        background: linear-gradient(135deg, #FFC107 0%, #FF9800 100%);
+        color: #000000;
+        border: none;
+        padding: 14px 24px;
+        font-size: 16px;
+        font-weight: 800;
+        border-radius: 8px;
+        transition: all 0.3s ease;
+    }
+    div.stButton > button[kind="primary"]:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 15px rgba(255, 193, 7, 0.4);
+    }
+    div.stButton > button[kind="secondary"] {
+        border-color: #555;
+        color: #ddd;
+    }
+
+    h1, h2, h3, h4, h5 { color: #FFFFFF !important; }
+    .highlight { color: #FFC107; }
+    
+    div[data-testid="stExpander"] {
+        background-color: #1E1E1E;
+        border: 1px solid #333;
+        border-radius: 8px;
+    }
+    div[data-testid="stFileUploader"] section {
+        background-color: #1E1E1E;
+        border: 2px dashed #444;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# ==========================================
+# 2. 사이드바 (통합 설정)
+# ==========================================
+with st.sidebar:
+    st.markdown("## ⚙️ 기본 설정 (Basic)")
+    api_key = st.text_input("Google API Key", type="password", placeholder="API 키를 입력하세요...", label_visibility="collapsed")
+    st.divider()
+
+    st.markdown("### 🎨 Model Engine")
+    model_choice = st.radio("사용할 모델", ["⚡ Fast (Gemini 2.0)", "🚀 Pro (Imagen 3)"], label_visibility="collapsed")
+    
+    if "Fast" in model_choice:
+        image_model_id = "gemini-2.0-flash" 
+        text_model_id = "gemini-2.0-flash"
+    else:
+        # [복구] 사용자님이 원하시던 그 모델 ID!
+        image_model_id = "gemini-3-pro-image-preview" 
+        text_model_id = "gemini-3-pro-preview" 
+
+    st.divider()
+
+    st.markdown("### 📐 Canvas Ratio")
+    ar_radio = st.radio("비율", ["16:9", "9:16"], label_visibility="collapsed", horizontal=True)
+    aspect_ratio = ar_radio
+
+    st.divider()
+    
+    st.markdown("### 🛠️ 고급 설정 (TTS & Split)")
+    
+    st.caption("TTS Model ID")
+    tts_model_id = st.text_input("TTS ID", value="gemini-2.5-pro-preview-tts", label_visibility="collapsed")
+    
+    st.markdown("<br>", unsafe_allow_html=True)
+    
+    st.caption("Image Scene Split (이미지 생성용)")
+    duration_per_scene = st.slider("장면당 시간(초)", 3, 30, 5)
+    split_criteria = duration_per_scene * 8
+    st.info(f"💡 {duration_per_scene}초 (약 {split_criteria}자) 단위로 장면을 나눕니다.")
+    st.caption("※ TTS는 설정과 무관하게 500자 단위로 최적화됩니다.")
+        
+    st.divider()
+    
+    st.markdown("## 🎨 스타일 및 캐릭터 설정")
+    st.caption("영상 전체의 분위기와 캐릭터를 결정합니다.")
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### 🖌️ 화풍(Style) 선택")
+    
+    style_options = list(STYLE_DEFINITIONS.keys()) + ["직접 입력"]
+    selected_style = st.selectbox("스타일 선택", style_options, label_visibility="collapsed")
+    
+    custom_style_input = ""
+    current_prompt = ""
+    
+    if selected_style == "직접 입력":
+        custom_style_input = st.text_input("스타일 프롬프트", placeholder="예: 지브리 스타일, 수채화풍")
+        current_prompt = custom_style_input if custom_style_input else "(프롬프트를 입력해주세요)"
+    else:
+        style_value = STYLE_DEFINITIONS[selected_style]
+        if isinstance(style_value, dict):
+            current_prompt = style_value.get('prompt', str(style_value))
+        else:
+            current_prompt = str(style_value)
+
+    st.markdown("#### 📜 적용될 프롬프트 (미리보기)")
+    st.text_area("프롬프트 미리보기", value=current_prompt, height=150, disabled=True, label_visibility="collapsed")
+    
+    st.divider()
+    
+    st.markdown("#### 👤 캐릭터 참조 (Reference)")
+    uploaded_file = st.file_uploader("이미지 업로드", type=["png", "jpg", "jpeg"], label_visibility="collapsed")
+    reference_image = None
+    if uploaded_file:
+        reference_image = Image.open(uploaded_file)
+        st.image(reference_image, caption="참조 이미지", use_container_width=True)
+
+
+# ==========================================
+# 3. 메인 콘텐츠
+# ==========================================
+
+st.title("Nano Banana <span class='highlight'>Studio Pro</span>", anchor=False)
+st.markdown("<div style='margin-top: -15px; color: #888; margin-bottom: 20px;'>AI Powered All-in-One Workspace</div>", unsafe_allow_html=True)
+
+tab1, tab2, tab3 = st.tabs(["🎬 장면 생성 (Scenes)", "📈 기획/SEO (Analysis)", "🎙️ 성우/TTS (Voice)"])
+
+# ----------------------------------------------------------------
+# [TAB 1] 장면/이미지 생성 (메인 기능)
+# ----------------------------------------------------------------
+with tab1:
+    st.markdown("<br>", unsafe_allow_html=True)
+    
+    st.markdown("#### ❶ 대본 입력 (Script)")
+    script_input = st.text_area(
+        "대본", 
+        height=300,
+        placeholder="대본을 줄글로 붙여넣으세요. 사이드바에서 설정한 시간(초) 단위로 AI가 장면을 자동으로 나눕니다.", 
+        label_visibility="collapsed",
+        key="scene_script_input"
+    )
+
+    if script_input:
+        st.session_state['shared_script'] = script_input
+
+    st.markdown("<br>", unsafe_allow_html=True)
+
+    # 생성 버튼
+    if st.button("🚀 장면 생성 시작 (Generate Scenes)", type="primary", use_container_width=True):
+        if not api_key: st.error("⚠️ 사이드바에 API Key를 입력해주세요.")
+        elif not script_input: st.warning("⚠️ 대본을 입력해주세요.")
+        else:
+            # [핵심] 이미지 생성은 슬라이더 값(split_criteria)을 사용
+            raw_scenes = logic_tts.split_text_smartly(script_input, limit=split_criteria)
+            scenes_text = raw_scenes[:10]
+            
+            st.toast(f"📜 {len(scenes_text)}개 장면으로 분할하여 생성을 시작합니다.")
+            
+            client = genai.Client(api_key=api_key)
+            progress_text = "AI 화가가 그림을 그리는 중입니다..."
+            my_bar = st.progress(0, text=progress_text)
+            
+            temp_results = [None] * len(scenes_text)
+            
+            # 안정성 위해 max_workers=2
+            with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+                future_to_idx = {
+                    executor.submit(logic_image.process_scene_task, i, {'text': text}, selected_style, custom_style_input, client, text_model_id, image_model_id, aspect_ratio, reference_image): i 
+                    for i, text in enumerate(scenes_text)
+                }
+                completed = 0
+                for future in concurrent.futures.as_completed(future_to_idx):
+                    idx, prompt, img = future.result()
+                    temp_results[idx] = (prompt, img, scenes_text[idx])
+                    completed += 1
+                    my_bar.progress(completed / len(scenes_text), text=f"Scene {idx+1} 완료!")
+            
+            st.session_state['scene_results'] = temp_results
+            my_bar.empty()
+            st.rerun()
+
+    # 결과 표시
+    if st.session_state['scene_results']:
+        st.divider()
+        st.subheader("🎬 Scene Results")
+        
+        for i, item in enumerate(st.session_state['scene_results']):
+            if item is None: continue
+            p_text, img_data, s_text = item
+            
+            with st.container():
+                c1, c2 = st.columns([1, 2])
+                with c1:
+                    if img_data:
+                        try:
+                            image = Image.open(io.BytesIO(img_data))
+                            st.image(image, use_container_width=True)
+                            st.download_button(
+                                label="⬇️ 다운로드",
+                                data=img_data,
+                                file_name=f"scene_{i+1}.png",
+                                mime="image/png",
+                                key=f"dl_btn_{i}",
+                                use_container_width=True
+                            )
+                        except: st.error("이미지 오류")
+                    else: st.warning("이미지 없음")
+                with c2:
+                    st.markdown(f"**Scene {i+1}**")
+                    st.info(s_text)
+                    if st.button(f"🔄 재생성", key=f"regen_{i}"):
+                        if not api_key: st.error("API Key 필요")
+                        else:
+                            client = genai.Client(api_key=api_key)
+                            with st.spinner("다시 그리는 중..."):
+                                _, new_p, new_img = logic_image.process_scene_task(i, {'text': s_text}, selected_style, custom_style_input, client, text_model_id, image_model_id, aspect_ratio, reference_image)
+                                st.session_state['scene_results'][i] = (new_p, new_img, s_text)
+                                st.rerun()
+                st.divider()
+
+# ----------------------------------------------------------------
+# [TAB 2] 유튜브 기획 (SEO)
+# ----------------------------------------------------------------
+with tab2:
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### 📈 유튜브 SEO 분석기")
+    st.caption("대본을 기반으로 제목, 태그, 설명란을 자동으로 생성합니다.")
+    
+    default_seo_script = st.session_state.get('shared_script', "")
+    seo_script = st.text_area("분석할 대본 입력", value=default_seo_script, height=150, placeholder="SEO 분석을 원하는 대본을 입력하세요.", key="seo_input")
+    
+    if st.button("✨ SEO 기획서 생성하기", key="seo_btn", type="primary"):
+        if not api_key: st.error("API Key 필요")
+        elif not seo_script: st.warning("대본 필요")
+        else:
+            with st.spinner("Brain 모델이 분석 중입니다..."):
+                client = genai.Client(api_key=api_key)
+                seo_result = logic_seo.generate_seo_content(client, text_model_id, seo_script)
+
+                st.session_state["seo_result"] = seo_result
+                st.success("분석 완료!")
+                
+                c_seo1, c_seo2 = st.columns(2)
+                with c_seo1:
+                    st.markdown("##### 📌 추천 제목")
+                    for t in seo_result['titles']: st.info(f"{t}")
+                with c_seo2:
+                    st.markdown("##### 🏷️ 추천 태그")
+                    st.code(", ".join(seo_result['tags']))
+                
+                st.markdown("##### 📝 설명란 (Description)")
+                st.text_area("설명란 결과", seo_result['description'], height=200)
+                st.divider()
+st.subheader("🖼️ 썸네일 생성")
+
+seo_cached = st.session_state.get("seo_result")
+
+if not seo_cached:
+    st.info("SEO 분석을 먼저 실행하면 썸네일 생성 버튼이 나타납니다.")
+else:
+    strat_keys = list(THUMBNAIL_STRATEGIES.keys())
+    sel_strat = st.selectbox("썸네일 전략 선택", strat_keys, index=0)
+
+    # 썸네일 텍스트(메인 타이틀) 후보: SEO 추천 제목 1개를 기본값으로
+    default_thumb_text = seo_cached["titles"][0] if seo_cached.get("titles") else ""
+    thumb_text = st.text_input("썸네일 메인 문구(원하면 수정)", value=default_thumb_text)
+
+    if st.button("🧠 썸네일 프롬프트 생성", key="thumb_prompt_btn"):
+        if not api_key:
+            st.error("API Key 필요")
+        else:
+            client = genai.Client(api_key=api_key)
+
+            strategy_block = THUMBNAIL_STRATEGIES[sel_strat]
+
+            prompt = f"""
+너는 유튜브 썸네일 기획자다.
+아래 '대본'과 '전략'을 참고해서, 이미지 생성 모델에 넣을 '썸네일 프롬프트'를 만든다.
+
+[대본]
+{seo_script[:8000]}
+
+[전략]
+{strategy_block}
+
+[추가 조건]
+- 썸네일 이미지 안에 텍스트를 직접 그려 넣지 마라(글자 생성 금지).
+- 대신 '텍스트를 넣을 자리'를 구도로 확보해라(상단/하단 여백, 안전영역).
+- 국가/국기/대통령/청와대/국회의사당 등 특정 국가 상징이 자동으로 나오지 않게,
+  정치 상징물은 추상적 은유(실루엣, 조명, 군중, 무대)로 처리해라.
+- 화면비는 {aspect_ratio}.
+- 출력은 "프롬프트 텍스트 1개"만. JSON/마크다운 금지.
+
+[사용자가 넣을 메인 문구(참고만)]
+{thumb_text}
+""".strip()
+
+            res = client.models.generate_content(model=text_model_id, contents=prompt)
+            thumb_prompt = (getattr(res, "text", "") or "").strip()
+            st.session_state["thumb_prompt"] = thumb_prompt
+            st.success("썸네일 프롬프트 생성 완료!")
+            st.text_area("생성된 썸네일 프롬프트", value=thumb_prompt, height=180)
+
+    # 프롬프트가 있을 때만 이미지 생성 버튼 노출
+    thumb_prompt_cached = st.session_state.get("thumb_prompt", "")
+    if thumb_prompt_cached:
+        if st.button("🎨 썸네일 이미지 1장 생성", key="thumb_img_btn", type="primary"):
+            if not api_key:
+                st.error("API Key 필요")
+            else:
+                client = genai.Client(api_key=api_key)
+
+                # 이미지 생성 (generate_images 우선, 없으면 generate_content fallback)
+                img_bytes = None
+                try:
+                    if hasattr(client.models, "generate_images"):
+                        img_res = client.models.generate_images(
+                            model=image_model_id,
+                            prompt=thumb_prompt_cached
+                        )
+                        # logic_image에 있는 안전 추출 함수가 없다면 간단히 parts에서 뽑기
+                        try:
+                            cand = img_res.candidates[0]
+                            part = cand.content.parts[0]
+                            img_bytes = part.inline_data.data if part.inline_data else None
+                        except:
+                            img_bytes = None
+                    else:
+                        img_res = client.models.generate_content(
+                            model=image_model_id,
+                            contents=thumb_prompt_cached
+                        )
+                        try:
+                            cand = img_res.candidates[0]
+                            part = cand.content.parts[0]
+                            img_bytes = part.inline_data.data if part.inline_data else None
+                        except:
+                            img_bytes = None
+                except Exception as e:
+                    st.error(f"이미지 생성 실패: {e}")
+
+                if img_bytes:
+                    st.image(Image.open(io.BytesIO(img_bytes)), use_container_width=True)
+                    st.download_button(
+                        "⬇️ 썸네일 다운로드",
+                        data=img_bytes,
+                        file_name="thumbnail.png",
+                        mime="image/png",
+                        use_container_width=True
+                    )
+                else:
+                    st.error("이미지 바이트를 추출하지 못했습니다. (모델 응답 구조 확인 필요)")
+
+# ----------------------------------------------------------------
+# [TAB 3] AI 성우 (TTS)
+# ----------------------------------------------------------------
+with tab3:
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.markdown("#### 🎙️ AI 성우 스튜디오")
+    st.caption("장면 생성 없이 오디오만 필요할 때 사용하세요.")
+    
+    default_tts_script = st.session_state.get('shared_script', "")
+    tts_script = st.text_area("낭독할 대본 입력", value=default_tts_script, height=150, placeholder="읽고 싶은 텍스트를 입력하세요.", key="tts_input")
+    
+    voice_map = {
+        "Charon (남성/다큐)": "Charon", "Puck (남성/쾌활)": "Puck",
+        "Kore (여성/차분)": "Kore", "Fenrir (남성/강함)": "Fenrir",
+        "Aoede (여성/높음)": "Aoede", "Orus (남성/중후)": "Orus"
+    }
+    
+    c_voice1, c_voice2 = st.columns([2, 1])
+    with c_voice1:
+        v_sel = st.selectbox("성우 선택", list(voice_map.keys()), key="tts_voice_sel")
+        voice_opt = voice_map[v_sel]
+    with c_voice2:
+        if st.button("▶ 미리듣기", key="tts_preview"):
+            if not api_key: st.error("API Key 필요")
+            else:
+                client = genai.Client(api_key=api_key)
+                prev_audio = logic_tts.generate_speech_chunk(client, tts_model_id, "안녕하세요, 제 목소리입니다.", voice_opt)
+                if isinstance(prev_audio, bytes):
+                    if not prev_audio.startswith(b'RIFF') and hasattr(logic_tts, 'raw_pcm_to_wav'):
+                        prev_audio = logic_tts.raw_pcm_to_wav(prev_audio)
+                    st.audio(prev_audio, format="audio/wav", autoplay=True)
+
+    if st.button("🎙️ 전체 녹음 및 병합 시작", key="tts_full_btn", type="primary"):
+        if not api_key: st.error("API Key 필요")
+        elif not tts_script: st.warning("대본 필요")
+        else:
+            client = genai.Client(api_key=api_key)
+            
+            # [핵심] TTS는 슬라이더 값(split_criteria)을 무시하고, 무조건 500자 단위로 고정
+            chunks = logic_tts.split_text_smartly(tts_script, limit=500)
+            
+            audio_res = [None] * len(chunks)
+            with st.status("녹음 진행 중...", expanded=True):
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    f_map = {executor.submit(logic_tts.process_tts_task, i, c, client, tts_model_id, voice_opt): i for i, c in enumerate(chunks)}
+                    for f in concurrent.futures.as_completed(f_map):
+                        idx, dat = f.result()
+                        if isinstance(dat, bytes): 
+                            audio_res[idx] = dat
+                            st.write(f"✅ Part {idx+1} 완료")
+            
+            final_wav = logic_tts.merge_wav_bytes(audio_res)
+            if final_wav:
+                st.success("오디오 생성 완료!")
+                st.audio(final_wav, format="audio/wav")
+                st.download_button("다운로드 (WAV)", final_wav, "full_audio.wav", "audio/wav")

config_style.py

@@ -0,0 +1,70 @@
+# ==============================================================
+# Nano Banana Studio - Style & Prompt Configuration
+# ==============================================================
+
+# 1. 영상/이미지 생성 스타일 정의
+# logic_image.py 에서 이 딕셔너리를 참조하여 프롬프트를 설계합니다.
+STYLE_DEFINITIONS = {
+    "밝은 정보/이슈": "대사에 어울리는 2d 얼굴이 둥근 하얀색 스틱맨 연출로 설명과 이해가 잘되는 느낌으로 그려줘 상황을 잘 나타내게 분활화면으로 말고 하나의 장면으로 너무 어지럽지 않게, 글씨는 핵심 키워드 2~3만 나오게 한다. 글씨가 너무 많지 않게 핵심만. 2D 스틱맨을 활용해 대본을 설명이 잘되게 설명하는 연출을 한다. 자막 스타일 연출은 하지 않는다. 글씨가 나올경우 핵심 키워드 중심으로만 나오게 너무 글이 많지 않도록 한다, 글자는 배경과 사물에 자연스럽게 연출, 전체 배경 연출은 2D로 하고 디테일하게 입체적이고 몰입감 있게 연출해서 그려줘 (16:9). 다양한 장소와 상황 연출로 배경을 디테일하게 한다. 무조건 2D 스틱맨 연출. 2d 스틱맨 교육용 일러스트",
+    
+    "스틱맨 드라마/사실적": "고퀄리티 얼구이 둥근 2D 애니메이션 스타일, 사실적인 배경과 조명 연출. 캐릭터: 얼굴이 둥근 하얀색 2D 스틱맨들. 단순한 낙서가 아니라, 명암과 덩어리감이 느껴지는 '고급 스틱맨' 스타일. 얼굴이 크게 잘보이게 연출. 배경: 단순한 단색 배경 금지. 대본의 장소(사무실, 거리, 방 안, 전장 등)를 '사진'처럼 디테일하고 입체적으로 2d 묘사. 분위기: 정보 전달보다는 '상황극(Drama)'에 집중. 영화적인 조명(Cinematic Lighting)과 심도(Depth) 표현. 연출: 스틱맨 여러 캐릭터들이 대본 속 행동을 리얼하게 연기(Acting). 감정 표현은 표정보다는 역동적인 몸짓(Body Language)으로 극대화. 절대 금지: 화면 분할(Split Screen), 텍스트 나열, 단순 인포그래픽 스타일. 대본의 상황을 잘 나타내게 분활화면으로 말고 하나의 장면으로 연출.",
+    
+    "역사/다큐 (Dark)": "역사적 사실을 기반으로 한 '2D 시네마틱 얼굴이 둥근 하얀색 스틱맨 애니메이션' 스타일. 깊이 있는 색감(Dark & Rich Tone)과 극적인 조명 사용. 캐릭터는 2D 실루엣이나 스틱맨이지만 시대에 맞는 의상과 헤어스타일을 착용. 2D 스틱맨을 활용해 대본을 설명이 잘되게 설명하는 연출을 한다. 자막 스타일 연출은 하지 않는다. 전쟁, 기근 등의 묘사는 상징적이고 은유적으로 표현. 너무 고어틱한 연출은 하지 않는다. 배경 묘사에 디테일을 살려 시대적 분위기를 강조. 무조건 얼굴이 둥근 2D 스틱맨 연출. 대본의 상황을 잘 나타내게 분활화면으로 말고 하나의 장면으로 연출.",
+    
+    "3D 다큐멘터리": "Unreal Engine 5 render style, Realistic 3D game cinematic screenshot. 피사체: 매끈하고 하얀 이목구비 없는 마네킹 머리 (Smooth white featureless mannequin head). 눈코입 없음. 복장: 가디건, 청바지, 정장 등 현실적인 의상을 입혀 기묘한 느낌 강조. 조명: 영화 같은 조명 (Cinematic lighting), 다소 어둡고 분위기 있는(Moody) 연출. 배경: 낡은 소파, 어지러진 방 등 사실적인 텍스처와 디테일(8k resolution), 현실적인 다양한 장소. 대본의 상황을 잘 나타내게 분활화면으로 말고 하나의 장면으로 연출.",
+    
+    "과학/엔지니어링": "3D Technical Animation (Fern, AiTelly Style). 화풍: Blender Cycles / Clean Rendering, 밝은 스튜디오 조명(Clean Studio Lighting). 연출: 기계/건축물의 단면도(Cutaway) 및 작동 원리 시각화. 인물: 엔지니어/과학자/교사/회사원/군인 등등 다양한 3d 캐릭터가 등장하여 기계를 조작하거나 설명하는 기능적 역할 수행. 분위기: 깔끔하고, 교육적이며, 명확함(Clear & Educational). 과도한 그림자 배제. 대본의 상황을 잘 나타내게 분활화면으로 말고 하나의 장면으로 연출.",
+    
+    "심플 그림판/졸라맨": "굵은 선, 단순함의 미학. 한 장면에 하나의 주제만.",
+    
+    "실사 + 코믹 페이스": "Hyper-Realistic Environment with Comic Elements. 배경과 사물, 사람/동물의 몸체: '언리얼 엔진 5' 수준의 8K 실사(Photorealistic). 털, 피부 질감, 조명 완벽 구현. 사람 얼굴: 몸은 실사지만 얼굴만 '릭 앤 모티(Rick and Morty) 애니메이션 스타일'의 2D 카툰으로 합성. (참조: 큰 흰색 눈, 검은 점 눈동자, 굵은 눈썹, 단순한 입). - **표정:** 당황, 공포, 혼란, 술에 취한 듯한 '병맛' 표정 강조. 동물 눈: 털과 몸은 다큐멘터리급 실사지만, 눈만 '흰색 흰자와 검은 점 눈동자'로 된 2D 만화 눈으로 연출. 분위기: 고퀄리티 ���큐멘터리인 척하는 병맛 코미디. 진지한 상황일수록 표정을 더 단순하고 멍청하게(Derp) 연출. 절대 이미지에 글씨 연출 전혀 하지 않는다.",
+    
+    "한국 웹툰 스타일": "한국 인기 웹툰 스타일의 고퀄리티 2D 일러스트레이션 (Korean Webtoon Style). 선명한 펜선과 화려한 채색. 집중선(Speed lines)은 정말 중요한 순간에만 가끔 사용. 캐릭터는 8등신 웹툰 주인공 스타일. 캐릭터 주변의 '상황'과 '배경(장소)'을 아주 구체적이고 밀도 있게 묘사. 단순 인물 컷보다는 주변 사물과 배경이 함께 보이는 구도 선호. 전체적으로 배경 디테일이 살아있는 네이버 웹툰 썸네일 스타일. (16:9)",
+    
+    "지브리 대작 감성": "일본 대작 귀여운 지브리풍 애니메이션 스타일 (High-Budget Anime Style). 서정적인 느낌보다는 '정보량이 많고 치밀한' 고밀도 배경 작화 (High Detail Backgrounds). 지브리 캐릭터의 표정과 행동을 '순간 포착'하듯 역동적으로 묘사. 대본의 지문을 하나도 놓치지 않고 시각화하는 '철저한 디테일' 위주. (16:9) 전체 대본에 어울리는 하나의 장면으로 연출."
+}
+
+
+# 2. 썸네일 생성 전략 정의 (추후 썸네일 생성 기능 확장 시 사용)
+THUMBNAIL_STRATEGIES = {
+    "A. 극적 대비 (Split Screen)": """
+    [Strategy Goal]
+    Create a thumbnail with a 50:50 vertical split.
+    Left Side: Negative/Past/Weak (Dark tone).
+    Right Side: Positive/Future/Strong (Bright tone).
+    
+    [CRITICAL RULES]
+    1. **Text Language:** THE TEXT OVERLAY MUST BE IN KOREAN. Extract key phrases from the script in KOREAN. Do not translate them.
+    2. **Composition:** Split screen vertically. Distinct visual separation.
+    3. **Style:** Realistic, high-definition, YouTube documentary style, dramatic lighting.
+    
+    [Prompt Structure to Generate]
+    "Split screen. Left: [Description of A], dark lighting, text: '[한국어 텍스트]'. Right: [Description of B], bright lighting, text: '[한국어 텍스트]'. Bottom: Big bold text '[한국어 메인 타이틀]'. Realistic style, 8k."
+    """,
+
+    "B. 하이브리드 (Real + 2D)": """
+    [Strategy Goal]
+    Composite image. Realistic photo background + 2D vector stickman foreground.
+    
+    [CRITICAL RULES]
+    1. **Text Language:** THE TEXT OVERLAY MUST BE IN KOREAN.
+    2. **Background:** Realistic photo of key subject/location. Documentary news style.
+    3. **Foreground:** Simple 2D stickman character reacting/pointing.
+    
+    [Prompt Structure to Generate]
+    "Composite image. Background: Realistic photo of [Key Subject], news style. Foreground: 2D stickman [Action/Reaction]. Text at bottom: '[한국어 메인 타이틀]', bold font, yellow/red color."
+    """,
+
+    "C. 나노바나나 (2D Stickman)": """
+    [Strategy Goal]
+    Flat 2D vector art, simple stickman character.
+    
+    [CRITICAL RULES]
+    1. **Text Language:** THE TEXT OVERLAY MUST BE IN KOREAN.
+    2. **Style:** Flat 2D vector art, clean lines. NO speech bubbles.
+    3. **Logic:** If comparing -> Split screen. If explaining -> Single wide shot.
+    
+    [Prompt Structure to Generate]
+    "Flat 2D vector art. Stickman character in [Pose]. Background: [Elements]. Text at bottom: '[한국어 메인 타이틀]'. No speech bubbles."
+    """
+}

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

logic_image.py

@@ -0,0 +1,218 @@
+# logic_image.py
+import re
+
+def _get_style_prompt(selected_style, custom_style_input, style_definitions):
+    if selected_style == "직접 입력":
+        return (custom_style_input or "").strip()
+    v = style_definitions.get(selected_style, "")
+    if isinstance(v, dict):
+        return (v.get("prompt") or "").strip()
+    return str(v).strip()
+
+def _safe_extract_image_bytes(response):
+    """
+    google-genai 응답에서 이미지 bytes를 최대한 안전하게 꺼내는 함수
+    (모델/버전별로 응답 구조가 달라서 방어적으로 처리)
+    """
+    # candidates -> content -> parts -> inline_data.data 패턴
+    try:
+        cands = getattr(response, "candidates", None) or []
+        if not cands:
+            return None
+        content = getattr(cands[0], "content", None)
+        parts = getattr(content, "parts", None) or []
+        for p in parts:
+            inline = getattr(p, "inline_data", None)
+            if inline and getattr(inline, "data", None):
+                return inline.data
+    except:
+        pass
+
+    # 혹시 response.image 같은 형태로 오는 경우
+    for key in ["image", "images", "data"]:
+        try:
+            v = getattr(response, key, None)
+            if isinstance(v, (bytes, bytearray)):
+                return bytes(v)
+        except:
+            pass
+
+    return None
+
+def process_scene_task(
+    index,
+    scene,
+    selected_style,
+    custom_style_input,
+    client,
+    text_model_id,
+    image_model_id,
+    aspect_ratio,
+    reference_image=None,
+):
+    """
+    app.py가 기대하는 시그니처:
+    return (idx, prompt_text, image_bytes)
+
+    - scene: {'text': '...'}
+    - reference_image: PIL.Image (옵션)
+    """
+    scene_text = (scene.get("text") or "").strip()
+
+    # 1) Brain: 장면 텍스트 -> 이미지 프롬프트 생성
+    #    (스타일은 config_style.py의 STYLE_DEFINITIONS 기반으로 주입됨)
+    from config_style import STYLE_DEFINITIONS
+
+    style_prompt = _get_style_prompt(selected_style, custom_style_input, STYLE_DEFINITIONS)
+
+    brain_prompt = f"""
+너는 유튜브 영상용 '장면 이미지 프롬프트'를 만드는 전문가야.
+아래 대본을 보고, 딱 "한 장면"을 그리기 위한 프롬프트를 만들어.
+
+[스타일 지시]
+{style_prompt}
+
+[화면비]
+{aspect_ratio}
+
+[대본]
+{scene_text}
+
+[절대 규칙]
+1) 출력은 무조건 한국어로만 작성. 영어/로마자 단어 사용 금지.
+2) 대본의 의미를 바꾸거나 내용을 추가하지 마라. (과장/각색/추측 금지)
+3) 화면 분할(Split Screen) 금지. 한 장면으로만 구성.
+4) 이미지에 글자/자막 넣지 마라. (텍스트 오버레이 금지)
+5) 최종 출력은 "프롬프트 한 덩어리 텍스트"만. JSON/마크다운/번호/제목 금지.
+
+이제 프롬프트를 출력해.
+""".strip()
+
+
+    brain_res = client.models.generate_content(
+        model=text_model_id,
+        contents=brain_prompt
+    )
+
+    # brain_res.text가 없을 수도 있어 방어
+    final_prompt = getattr(brain_res, "text", None) or scene_text
+    final_prompt = re.sub(r"\s+", " ", final_prompt).strip()
+
+    # 2) Painter: 프롬프트 -> 이미지 생성
+    #    google-genai 버전에 따라 generate_images / generate_content 둘 다 대응
+    img_bytes = None
+
+    # (A) generate_images가 있으면 우선 사용
+    if hasattr(client.models, "generate_images"):
+        try:
+            img_res = client.models.generate_images(
+                model=image_model_id,
+                prompt=final_prompt
+            )
+            # 응답 구조가 버전마다 달라서 최대한 방어적으로 추출
+            img_bytes = _safe_extract_image_bytes(img_res)
+        except:
+            img_bytes = None
+
+    # (B) 없으면 generate_content로 시도
+    if img_bytes is None:
+        try:
+            # reference_image가 있을 경우, 가능한 형태로 같이 전달 시도
+            contents = final_prompt
+            if reference_image is not None:
+                # genai.types.Part 가 있으면 그걸 사용
+                try:
+                    from google.genai import types
+                    import io
+                    buf = io.BytesIO()
+                    reference_image.save(buf, format="PNG")
+                    ref_part = types.Part.from_bytes(data=buf.getvalue(), mime_type="image/png")
+                    contents = [final_prompt, ref_part]
+                except:
+                    # types가 없으면 그냥 텍스트만
+                    contents = final_prompt
+
+            img_res = client.models.generate_content(
+                model=image_model_id,
+                contents=contents
+            )
+            img_bytes = _safe_extract_image_bytes(img_res)
+        except:
+            img_bytes = None
+
+    return index, final_prompt, img_bytes
+    def process_thumbnail_task(
+    index,
+    strategy_key,
+    strategy_text,
+    script_text,
+    title_hint,
+    client,
+    text_model_id,
+    image_model_id,
+    aspect_ratio,
+    reference_image=None
+):
+    """
+    return (idx, final_prompt, image_bytes)
+    Tab1(장면 생성)과 동일한 반환형 유지
+    """
+    # 1) Brain: 전략(A/B/C) + 대본 -> 썸네일용 최종 프롬프트(한글) 생성
+    brain_prompt = f"""
+너는 유튜브 썸네일 프롬프트를 만드는 전문가다.
+아래 대본과 썸네일 전략을 바탕으로, 이미지 생성 모델에 넣을 '한 장의 썸네일 프롬프트'를 작성하라.
+
+[전략 키]
+{strategy_key}
+
+[전략 내용]
+{strategy_text}
+
+[대본]
+{script_text[:8000]}
+
+[참고 제목(그리지 말 것)]
+{title_hint}
+
+[필수 조건]
+- 출력은 무조건 한국어만. 영어/로마자 금지.
+- 이미지 안에 글자/자막/배너/로고 절대 생성 금지.
+- 대신 텍스트를 나중에 넣을 수 있게 상단 또는 하단에 넓은 여백(안전영역)을 확보.
+- 특정 국가 상징 자동생성 금지: 태극기, 청와대, 국회의사당, 대통령, 훈장/휘장, 선거 포스터, 국기류 전부 금지.
+- 정치인을 실존 인물처럼 특정하지 말고, 익명 캐릭터/실루엣/상징적 연출로 처리.
+- 화면 분할은 전략에 포함된 경우에만 허용.
+- 화면비: {aspect_ratio}
+- 최종 출력은 프롬프트 텍스트 1개만. (JSON/마크다운/번호 금지)
+""".strip()
+
+    brain_res = client.models.generate_content(model=text_model_id, contents=brain_prompt)
+    final_prompt = (getattr(brain_res, "text", "") or "").strip()
+
+    # 2) Painter: Tab1과 동일한 방식으로 이미지 생성
+    img_bytes = None
+
+    # (A) generate_images 우선
+    if hasattr(client.models, "generate_images"):
+        try:
+            img_res = client.models.generate_images(
+                model=image_model_id,
+                prompt=final_prompt
+            )
+            img_bytes = _safe_extract_image_bytes(img_res)
+        except:
+            img_bytes = None
+
+    # (B) fallback: generate_content
+    if img_bytes is None:
+        try:
+            contents = final_prompt
+            img_res = client.models.generate_content(
+                model=image_model_id,
+                contents=contents
+            )
+            img_bytes = _safe_extract_image_bytes(img_res)
+        except:
+            img_bytes = None
+
+    return index, final_prompt, img_bytes
+

logic_seo.py

@@ -0,0 +1,80 @@
+import json
+import re
+from google import genai
+
+def generate_seo_content(client, model_id, script_text):
+    """
+    대본을 분석하여 유튜브 제목, 태그, 설명란을 생성하는 함수
+    """
+    try:
+        # 프롬프트 설계: JSON 형식으로 출력을 강제함
+        prompt = f"""
+        You are a YouTube SEO Expert.
+        Analyze the following script and generate optimized metadata for a YouTube video.
+        
+        [Script]
+        {script_text[:10000]}  # 텍스트가 너무 길면 자름
+        
+        [Requirements]
+        1. Titles: Create 5 click-bait, high-performing titles (Korean).
+        2. Tags: Generate 15 relevant tags separated by commas (Korean).
+        3. Description: Write a compelling video description including hashtags (Korean).
+        
+        [Output Format]
+        You MUST output a valid JSON object with the following structure:
+        {{
+            "titles": ["title1", "title2", ...],
+            "tags": ["tag1", "tag2", ...],
+            "description": "description text..."
+        }}
+        
+        OUTPUT JSON ONLY. NO MARKDOWN.
+        """
+        
+        # 텍스트 모델 호출
+        response = client.models.generate_content(
+            model=model_id,
+            contents=prompt
+        )
+        
+        response_text = response.text.strip()
+        
+        # 마크다운 코드 블록 제거 (```json ... ```)
+        if response_text.startswith("```"):
+            response_text = re.sub(r"^```json\s*", "", response_text)
+            response_text = re.sub(r"^```\s*", "", response_text)
+            response_text = re.sub(r"\s*```$", "", response_text)
+            
+        # JSON 파싱
+        try:
+            result = json.loads(response_text)
+            
+            # 태그가 리스트가 아니라 문자열로 왔을 경우 처리
+            if isinstance(result.get("tags"), str):
+                result["tags"] = [t.strip() for t in result["tags"].split(",")]
+                
+            return result
+            
+        except json.JSONDecodeError:
+            # JSON 파싱 실패 시 텍스트 파싱 시도 (비상 대책)
+            print("SEO JSON Parsing Failed. Falling back to text parsing.")
+            return _fallback_text_parsing(response_text)
+
+    except Exception as e:
+        print(f"SEO Generation Error: {e}")
+        # 에러 발생 시 빈 깡통 반환 (앱이 죽지 않게)
+        return {
+            "titles": ["분석 실패 (다시 시도해주세요)"],
+            "tags": [],
+            "description": f"오류가 발생했습니다: {str(e)}"
+        }
+
+def _fallback_text_parsing(text):
+    """
+    JSON 형식이 아닐 경우 억지로 데이터를 추출하는 헬퍼 함수
+    """
+    return {
+        "titles": ["생성된 텍스트에서 제목을 추출하지 못했습니다."],
+        "tags": ["오류"],
+        "description": text
+    }

logic_tts.py

@@ -0,0 +1,100 @@
+import io
+import wave
+import re
+
+def split_text_smartly(text, limit=500):
+    """
+    텍스트를 문장 부호(.?!) 기준으로 자르되, 
+    limit(글자수)를 넘지 않도록 최대한 꽉 채워서 합치는 똑똑한 함수
+    """
+    # 1. 먼저 문장 부호 기준으로 잘게 쪼갬
+    sentences = re.split(r'(?<=[.?!])\s+', text)
+    chunks = []
+    current_chunk = ""
+
+    for sentence in sentences:
+        # 빈 문장 무시
+        if not sentence.strip():
+            continue
+            
+        # 합쳤을 때 제한을 넘으면 -> 지금까지 모은거 저장하고 새 출발
+        if len(current_chunk) + len(sentence) > limit:
+            if current_chunk:
+                chunks.append(current_chunk.strip())
+            current_chunk = sentence
+        else:
+            # 제한 안 넘으면 -> 계속 이어 붙임
+            current_chunk += " " + sentence
+
+    # 마지막 남은 조각 저장
+    if current_chunk:
+        chunks.append(current_chunk.strip())
+        
+    return chunks
+
+def raw_pcm_to_wav(pcm_data, sample_rate=24000):
+    """
+    [핵심] Gemini가 주는 날것의 PCM 데이터를 
+    브라우저가 들을 수 있는 WAV 포맷으로 변환하는 함수
+    """
+    try:
+        wav_io = io.BytesIO()
+        with wave.open(wav_io, "wb") as wav_file:
+            wav_file.setnchannels(1)       # 모노
+            wav_file.setsampwidth(2)       # 16-bit (2 bytes)
+            wav_file.setframerate(sample_rate)
+            wav_file.writeframes(pcm_data)
+        return wav_io.getvalue()
+    except Exception as e:
+        print(f"PCM to WAV Error: {e}")
+        return None
+
+def generate_speech_chunk(client, model_id, text, voice_name):
+    """
+    짧은 텍스트를 오디오로 바꾸는 함수 (미리듣기용)
+    """
+    try:
+        response = client.models.generate_content(
+            model=model_id,
+            contents=text,
+            config={
+                "response_modalities": ["AUDIO"],
+                "speech_config": {
+                    "voice_config": {
+                        "prebuilt_voice_config": {"voice_name": voice_name}
+                    }
+                }
+            }
+        )
+        
+        # 오디오 데이터 추출
+        if response.candidates and response.candidates[0].content.parts:
+            part = response.candidates[0].content.parts[0]
+            if part.inline_data:
+                return part.inline_data.data
+        return None
+    except Exception as e:
+        print(f"TTS Chunk Error: {e}")
+        return None
+
+def process_tts_task(index, text, client, model_id, voice_name):
+    """
+    병렬 처리를 위한 작업 함수
+    """
+    audio_data = generate_speech_chunk(client, model_id, text, voice_name)
+    if audio_data:
+        # 바로 WAV 헤더를 씌우지 않고, 나중에 합치기 위해 PCM 상태로 반환할 수도 있음
+        # 하지만 여기선 간단하게 PCM 바이너리 자체를 반환
+        return index, audio_data
+    return index, None
+
+def merge_wav_bytes(audio_chunks_pcm, sample_rate=24000):
+    """
+    여러 개의 PCM 조각을 하나의 긴 WAV 파일로 합침
+    """
+    try:
+        full_pcm = b"".join([chunk for chunk in audio_chunks_pcm if chunk])
+        return raw_pcm_to_wav(full_pcm, sample_rate)
+    except Exception as e:
+        print(f"Merge Error: {e}")
+        return None

requirements.txt

@@ -0,0 +1,2 @@
+streamlit
+google-genai

utils.py

@@ -0,0 +1,23 @@
+import re
+import math
+
+def group_sentences(text, target_sec=10):
+    raw_sentences = re.split(r'(?<=[.?!])\s+', text.strip())
+    scenes = []
+    curr_text, curr_time = "", 0
+    for s in raw_sentences:
+        if not s: continue
+        s_time = max(5, math.ceil(len(s)/35)*5)
+        if curr_time + s_time > target_sec and curr_text:
+            scenes.append({"text": curr_text, "time": curr_time})
+            curr_text, curr_time = s, s_time
+        else:
+            curr_text = (curr_text + " " + s).strip()
+            curr_time += s_time
+    if curr_text: scenes.append({"text": curr_text, "time": curr_time})
+    return scenes
+
+def get_smart_filename(index, text):
+    clean_text = re.sub(r'[\\/*?:"<>|]', "", text).strip()
+    name_part = clean_text[:12] if len(clean_text) <= 12 else f"{clean_text[:6]}~{clean_text[-4:]}"
+    return f"{index+1:02d}_{name_part}.png"