Spaces:

Heartsync
/

HWPower

Running

App Files Files Community

seawolf2357 commited on Jan 15

Commit

1f54339

verified ·

1 Parent(s): e006e27

Create app.py

Browse files

Files changed (1) hide show

app.py +888 -1084

app.py CHANGED Viewed

@@ -1,1103 +1,907 @@
-"""
-HWP 파일 변환기 + LLM 채팅 - Gradio 웹 앱
-- Tab 1: LLM 채팅 (스트리밍, 파일 첨부 지원)
-- Tab 2: HWP 변환기
-"""
-import gradio as gr
-import tempfile
 import os
-import subprocess
-import shutil
-import sys
-import re
 import json
-import uuid
-import sqlite3
-import base64
 import requests
-import zlib
-import zipfile
-from pathlib import Path
-from datetime import datetime
-from typing import Generator, List, Dict, Optional
-from xml.etree import ElementTree as ET
-# ============== 환경 설정 ==============
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-PYHWP_PATH = os.path.join(SCRIPT_DIR, 'pyhwp')
-DB_PATH = os.path.join(SCRIPT_DIR, 'chat_history.db')
-if os.path.exists(PYHWP_PATH):
-    sys.path.insert(0, PYHWP_PATH)
-# ============== 모듈 임포트 ==============
-try:
-    import olefile
-    OLEFILE_AVAILABLE = True
-    print("olefile loaded successfully")
-except ImportError:
-    OLEFILE_AVAILABLE = False
-    print("olefile not available")
-try:
-    from markdownify import markdownify as md
-    MARKDOWNIFY_AVAILABLE = True
-    print("markdownify loaded successfully")
-except ImportError:
-    MARKDOWNIFY_AVAILABLE = False
-try:
-    import html2text
-    HTML2TEXT_AVAILABLE = True
-    print("html2text loaded successfully")
-except ImportError:
-    HTML2TEXT_AVAILABLE = False
-try:
-    from bs4 import BeautifulSoup
-    BS4_AVAILABLE = True
-except ImportError:
-    BS4_AVAILABLE = False
-try:
-    import PyPDF2
-    PYPDF2_AVAILABLE = True
-    print("PyPDF2 loaded successfully")
-except ImportError:
-    PYPDF2_AVAILABLE = False
-try:
-    import pdfplumber
-    PDFPLUMBER_AVAILABLE = True
-    print("pdfplumber loaded successfully")
-except ImportError:
-    PDFPLUMBER_AVAILABLE = False
-# hwp5txt 사용 가능 여부 확인
-HWP5TXT_AVAILABLE = False
 try:
-    result = subprocess.run(['hwp5txt', '--help'], capture_output=True, timeout=5)
-    if result.returncode == 0:
-        HWP5TXT_AVAILABLE = True
-        print("hwp5txt command available")
-except:
-    pass
-if not HWP5TXT_AVAILABLE:
-    try:
-        result = subprocess.run([sys.executable, '-c', 'from hwp5.hwp5txt import main; print("ok")'],
-                              capture_output=True, timeout=5)
-        if b'ok' in result.stdout:
-            HWP5TXT_AVAILABLE = True
-            print("hwp5txt module available")
-    except:
-        pass
-print(f"HWP5TXT_AVAILABLE: {HWP5TXT_AVAILABLE}")
-# ============== API 키 설정 ==============
-GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "")
-FIREWORKS_API_KEY = os.environ.get("FIREWORKS_API_KEY", "")
-# ============== SQLite 데이터베이스 ==============
-def init_database():
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS sessions (
-            session_id TEXT PRIMARY KEY,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-            title TEXT
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS messages (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            session_id TEXT,
-            role TEXT,
-            content TEXT,
-            file_info TEXT,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-            FOREIGN KEY (session_id) REFERENCES sessions(session_id)
-        )
-    ''')
-    conn.commit()
-    conn.close()
-def create_session() -> str:
-    session_id = str(uuid.uuid4())
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("INSERT INTO sessions (session_id, title) VALUES (?, ?)",
-                   (session_id, f"대화 {datetime.now().strftime('%Y-%m-%d %H:%M')}"))
-    conn.commit()
-    conn.close()
-    return session_id
-def save_message(session_id: str, role: str, content: str, file_info: str = None):
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("INSERT INTO messages (session_id, role, content, file_info) VALUES (?, ?, ?, ?)",
-                   (session_id, role, content, file_info))
-    cursor.execute("UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE session_id = ?", (session_id,))
-    conn.commit()
-    conn.close()
-def get_session_messages(session_id: str, limit: int = 20) -> List[Dict]:
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("SELECT role, content, file_info, created_at FROM messages WHERE session_id = ? ORDER BY created_at DESC LIMIT ?",
-                   (session_id, limit))
-    rows = cursor.fetchall()
-    conn.close()
-    return [{"role": r[0], "content": r[1], "file_info": r[2], "created_at": r[3]} for r in reversed(rows)]
-def get_all_sessions() -> List[Dict]:
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("SELECT session_id, title, created_at, updated_at FROM sessions ORDER BY updated_at DESC LIMIT 50")
-    rows = cursor.fetchall()
-    conn.close()
-    return [{"session_id": r[0], "title": r[1], "created_at": r[2], "updated_at": r[3]} for r in rows]
-def update_session_title(session_id: str, title: str):
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    cursor.execute("UPDATE sessions SET title = ? WHERE session_id = ?", (title, session_id))
-    conn.commit()
-    conn.close()
-init_database()
-# ============== 파일 유틸리티 ==============
-def extract_text_from_pdf(file_path: str) -> str:
-    text_parts = []
-    if PDFPLUMBER_AVAILABLE:
-        try:
-            with pdfplumber.open(file_path) as pdf:
-                for page in pdf.pages:
-                    text = page.extract_text()
-                    if text:
-                        text_parts.append(text)
-            if text_parts:
-                return "\n\n".join(text_parts)
-        except Exception as e:
-            print(f"pdfplumber error: {e}")
-    if PYPDF2_AVAILABLE:
-        try:
-            with open(file_path, 'rb') as f:
-                reader = PyPDF2.PdfReader(f)
-                for page in reader.pages:
-                    text = page.extract_text()
-                    if text:
-                        text_parts.append(text)
-            if text_parts:
-                return "\n\n".join(text_parts)
-        except Exception as e:
-            print(f"PyPDF2 error: {e}")
-    return None
-def extract_text_from_txt(file_path: str) -> str:
-    for encoding in ['utf-8', 'euc-kr', 'cp949', 'utf-16', 'latin-1']:
-        try:
-            with open(file_path, 'r', encoding=encoding) as f:
-                return f.read()
-        except:
-            continue
-    return None
-def image_to_base64(file_path: str) -> str:
-    with open(file_path, 'rb') as f:
-        return base64.b64encode(f.read()).decode('utf-8')
-def get_image_mime_type(file_path: str) -> str:
-    ext = Path(file_path).suffix.lower()
-    return {'.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
-            '.gif': 'image/gif', '.webp': 'image/webp', '.bmp': 'image/bmp'}.get(ext, 'image/jpeg')
-def is_image_file(fp: str) -> bool:
-    return Path(fp).suffix.lower() in ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp']
-def is_hwp_file(fp: str) -> bool:
-    return Path(fp).suffix.lower() == '.hwp'
-def is_hwpx_file(fp: str) -> bool:
-    return Path(fp).suffix.lower() == '.hwpx'
-def is_pdf_file(fp: str) -> bool:
-    return Path(fp).suffix.lower() == '.pdf'
-def is_text_file(fp: str) -> bool:
-    return Path(fp).suffix.lower() in ['.txt', '.md', '.json', '.csv', '.xml', '.html', '.css', '.js', '.py']
-# ============== HWPX 텍스트 추출 (ZIP/XML 기반) ==============
-def extract_text_from_hwpx(file_path: str) -> tuple:
-    """HWPX 파일에서 텍스트 추출 (ZIP 내부 XML 파싱)"""
-    try:
-        text_parts = []
-        with zipfile.ZipFile(file_path, 'r') as zf:
-            # HWPX 내부 구조 확인
-            file_list = zf.namelist()
-            print(f"  HWPX 내부 파일: {file_list[:10]}...")
-            # Contents 폴더 내의 section XML 파일들 처리
-            section_files = sorted([f for f in file_list if f.startswith('Contents/section') and f.endswith('.xml')])
-            if not section_files:
-                # 다른 경로 시도
-                section_files = sorted([f for f in file_list if 'section' in f.lower() and f.endswith('.xml')])
-            print(f"  섹션 파일: {section_files}")
-            for section_file in section_files:
-                try:
-                    with zf.open(section_file) as sf:
-                        content = sf.read()
-                        # XML 파싱
-                        try:
-                            # 네임스페이스 제거하고 파싱
-                            content_str = content.decode('utf-8')
-                            # 네임스페이스 제거
-                            content_str = re.sub(r'\sxmlns[^"]*"[^"]*"', '', content_str)
-                            content_str = re.sub(r'<[a-zA-Z]+:', '<', content_str)
-                            content_str = re.sub(r'</[a-zA-Z]+:', '</', content_str)
-                            root = ET.fromstring(content_str)
-                            # 모든 텍스트 추출
-                            texts = []
-                            for elem in root.iter():
-                                # t 태그 (텍스트)
-                                if elem.tag.endswith('t') or elem.tag == 't':
-                                    if elem.text:
-                                        texts.append(elem.text)
-                                # 다른 텍스트 노드
-                                elif elem.text and elem.text.strip():
-                                    # 태그 이름이 텍스트 관련인 경우
-                                    if any(x in elem.tag.lower() for x in ['text', 'run', 'para', 'char']):
-                                        texts.append(elem.text.strip())
-                            if texts:
-                                text_parts.append(' '.join(texts))
-                        except ET.ParseError as e:
-                            print(f"  XML 파싱 오류 {section_file}: {e}")
-                            # 정규식으로 텍스트 추출 시도
-                            text_matches = re.findall(r'>([^<]+)<', content.decode('utf-8', errors='ignore'))
-                            clean_texts = [t.strip() for t in text_matches if t.strip() and len(t.strip()) > 1]
-                            if clean_texts:
-                                text_parts.append(' '.join(clean_texts))
-                except Exception as e:
-                    print(f"  섹션 파일 읽기 오류 {section_file}: {e}")
-                    continue
-            # header.xml에서도 텍스트 추출 시도
-            for header_file in [f for f in file_list if 'header' in f.lower() and f.endswith('.xml')]:
-                try:
-                    with zf.open(header_file) as hf:
-                        content = hf.read().decode('utf-8', errors='ignore')
-                        text_matches = re.findall(r'>([^<]+)<', content)
-                        clean_texts = [t.strip() for t in text_matches if t.strip() and len(t.strip()) > 1]
-                        # 헤더는 짧은 텍스트만 추가
-                        if clean_texts:
-                            text_parts.insert(0, ' '.join(clean_texts[:5]))
-                except:
-                    pass
-        if text_parts:
-            result = '\n\n'.join(text_parts)
-            # 정리
-            result = re.sub(r'\s+', ' ', result)
-            result = re.sub(r'\n{3,}', '\n\n', result)
-            return result.strip(), None
-        return None, "HWPX에서 텍스트를 찾을 수 없습니다"
-    except zipfile.BadZipFile:
-        return None, "유효하지 않은 HWPX 파일"
-    except Exception as e:
-        return None, f"HWPX 처리 오류: {str(e)}"
-# ============== HWP 텍스트 추출 (OLE 기반) ==============
-def extract_text_with_hwp5txt(file_path: str) -> tuple:
-    """hwp5txt로 텍스트 추출"""
-    # 방법 1: hwp5txt 명령어 직접 실행
-    try:
-        result = subprocess.run(['hwp5txt', file_path], capture_output=True, timeout=60)
-        if result.returncode == 0 and result.stdout:
-            for enc in ['utf-8', 'cp949', 'euc-kr']:
-                try:
-                    text = result.stdout.decode(enc)
-                    if text.strip() and len(text.strip()) > 10:
-                        return text.strip(), None
-                except:
-                    continue
-    except FileNotFoundError:
-        pass
-    except Exception as e:
-        print(f"  hwp5txt 명령어 오류: {e}")
-    # 방법 2: Python 모듈로 실행
-    try:
-        from hwp5.hwp5txt import main as hwp5txt_main
-        from hwp5.hwp5txt import extract_text
-        from hwp5.filestructure import Hwp5File
-        hwp5file = Hwp5File(file_path)
-        texts = []
-        for section_idx in hwp5file.bodytext.sections():
-            section = hwp5file.bodytext.section(section_idx)
-            for para in extract_text(section):
-                if para.strip():
-                    texts.append(para.strip())
-        hwp5file.close()
-        if texts:
-            return '\n'.join(texts), None
-    except ImportError:
-        pass
-    except Exception as e:
-        print(f"  hwp5txt 모듈 오류: {e}")
-    # 방법 3: 서브프로세스로 Python 코드 실행
-    try:
-        code = f'''
-import sys
-sys.path.insert(0, "{PYHWP_PATH}")
-from hwp5.filestructure import Hwp5File
-from hwp5.hwp5txt import extract_text
-hwp = Hwp5File("{file_path}")
-for idx in hwp.bodytext.sections():
-    section = hwp.bodytext.section(idx)
-    for para in extract_text(section):
-        if para.strip():
-            print(para.strip())
-hwp.close()
-'''
-        result = subprocess.run([sys.executable, '-c', code], capture_output=True, timeout=60)
-        if result.returncode == 0 and result.stdout:
-            for enc in ['utf-8', 'cp949', 'euc-kr']:
-                try:
-                    text = result.stdout.decode(enc)
-                    if text.strip() and len(text.strip()) > 10:
-                        return text.strip(), None
-                except:
-                    continue
-    except Exception as e:
-        print(f"  hwp5txt 서브프로세스 오류: {e}")
-    return None, "hwp5txt 실패"
-def extract_text_with_olefile(file_path: str) -> tuple:
-    """olefile을 사용한 HWP 텍스트 추출"""
-    if not OLEFILE_AVAILABLE:
-        return None, "olefile 모듈 없음"
-    try:
-        ole = olefile.OleFileIO(file_path)
-        # 파일 헤더 확인
-        if not ole.exists('FileHeader'):
-            ole.close()
-            return None, "HWP 파일 헤더 없음"
-        # 압축 여부 확인
-        header_data = ole.openstream('FileHeader').read()
-        is_compressed = (header_data[36] & 1) == 1 if len(header_data) > 36 else True
-        print(f"  HWP 압축 여부: {is_compressed}")
-        all_texts = []
-        # BodyText 섹션들 처리
-        for entry in ole.listdir():
-            entry_path = '/'.join(entry)
-            if entry_path.startswith('BodyText/Section'):
-                try:
-                    stream_data = ole.openstream(entry).read()
-                    # 압축 해제
-                    if is_compressed:
-                        try:
-                            stream_data = zlib.decompress(stream_data, -15)
-                        except:
-                            try:
-                                stream_data = zlib.decompress(stream_data)
-                            except:
-                                pass
-                    # 레코드에서 텍스트 추출
-                    section_text = extract_hwp_section_text(stream_data)
-                    if section_text:
-                        all_texts.append(section_text)
-                except Exception as e:
-                    print(f"  섹션 처리 오류 {entry_path}: {e}")
-                    continue
-        ole.close()
-        if all_texts:
-            result = '\n\n'.join(all_texts)
-            return result.strip(), None
-        return None, "텍스트를 찾을 수 없습니다"
-    except Exception as e:
-        return None, f"olefile 오류: {str(e)}"
-def extract_hwp_section_text(data: bytes) -> str:
-    """HWP 섹션 데이터에서 텍스트 추출"""
-    texts = []
-    pos = 0
-    while pos < len(data) - 4:
-        try:
-            # 레코드 헤더 읽기
-            header = int.from_bytes(data[pos:pos+4], 'little')
-            tag_id = header & 0x3FF
-            level = (header >> 10) & 0x3FF
-            size = (header >> 20) & 0xFFF
-            pos += 4
-            # 확장 크기
-            if size == 0xFFF:
-                if pos + 4 > len(data):
-                    break
-                size = int.from_bytes(data[pos:pos+4], 'little')
-                pos += 4
-            if pos + size > len(data):
-                break
-            record_data = data[pos:pos+size]
-            pos += size
-            # HWPTAG_PARA_TEXT = 67
-            if tag_id == 67 and size > 0:
-                text = decode_para_text(record_data)
-                if text:
-                    texts.append(text)
-        except:
-            pos += 1
-            continue
-    return '\n'.join(texts) if texts else None
-def decode_para_text(data: bytes) -> str:
-    """PARA_TEXT 레코드 디코딩"""
-    result = []
-    i = 0
-    while i < len(data) - 1:
-        code = int.from_bytes(data[i:i+2], 'little')
-        if code == 0:
-            pass
-        elif code == 1:  # 확장 컨트롤
-            i += 14
-        elif code == 2:  # 섹션 정의
-            i += 14
-        elif code == 3:  # 필드 시작
-            i += 14
-        elif code == 4:  # 필드 끝
-            pass
-        elif code == 9:  # 탭
-            result.append('\t')
-        elif code == 10:  # 줄바꿈
-            result.append('\n')
-        elif code == 13:  # 문단 끝
-            result.append('\n')
-        elif code == 24:  # 하이픈
-            result.append('-')
-        elif code == 30 or code == 31:  # 빈칸
-            result.append(' ')
-        elif code < 32:  # 기타 컨트롤 문자
-            pass
         else:
-            # 일반 문자
-            try:
-                char = chr(code)
-                if char.isprintable() or char in '\n\t ':
-                    result.append(char)
-            except:
-                pass
-        i += 2
-    text = ''.join(result).strip()
-    # 정리
-    text = re.sub(r'[ \t]+', ' ', text)
-    text = re.sub(r'\n{3,}', '\n\n', text)
-    return text if len(text) > 2 else None
-def extract_text_from_hwp(file_path: str) -> tuple:
-    """HWP 파일에서 텍스트 추출 (메인 함수)"""
-    print(f"\n[HWP 추출] 시작: {os.path.basename(file_path)}")
-    # 방법 1: hwp5txt
-    print("  방법 1: hwp5txt...")
-    text, error = extract_text_with_hwp5txt(file_path)
-    if text and len(text.strip()) > 20:
-        print(f"  ✓ hwp5txt 성공: {len(text)} 글자")
-        return text, None
-    print(f"  ✗ hwp5txt 실패: {error}")
-    # 방법 2: olefile
-    print("  방법 2: olefile 파싱...")
-    text, error = extract_text_with_olefile(file_path)
-    if text and len(text.strip()) > 20:
-        print(f"  ✓ olefile 성공: {len(text)} 글자")
-        return text, None
-    print(f"  ✗ olefile 실패: {error}")
-    return None, "모든 추출 방법 실패"
-def extract_text_from_hwp_or_hwpx(file_path: str) -> tuple:
-    """HWP 또는 HWPX 파일에서 텍스트 추출"""
-    if is_hwpx_file(file_path):
-        print(f"\n[HWPX 추출] 시작: {os.path.basename(file_path)}")
-        return extract_text_from_hwpx(file_path)
     else:
-        return extract_text_from_hwp(file_path)
-# ============== HWP 변환 함수들 ==============
-def check_hwp_version(file_path):
-    try:
-        with open(file_path, 'rb') as f:
-            header = f.read(32)
-            if b'HWP Document File' in header:
-                return "HWP v5", True
-            elif header[:4] == b'\xd0\xcf\x11\xe0':
-                return "HWP v5 (OLE)", True
-            elif header[:4] == b'PK\x03\x04':  # ZIP 파일 (HWPX)
-                return "HWPX", True
             else:
-                return "Unknown", False
-    except Exception as e:
-        return f"Error: {e}", False
-def convert_to_html_subprocess(input_path, output_dir):
-    """HTML 변환"""
-    output_path = os.path.join(output_dir, "output.html")
-    try:
-        # hwp5html 시도
-        for cmd in [['hwp5html', '--output', output_path, input_path],
-                    [sys.executable, '-c', f'from hwp5.hwp5html import main; import sys; sys.argv=["hwp5html","--output","{output_path}","{input_path}"]; main()']]:
             try:
-                result = subprocess.run(cmd, capture_output=True, timeout=120)
-                if result.returncode == 0:
-                    if os.path.exists(output_path):
-                        return output_path, None
-                    # 디렉토리 검색
-                    for item in os.listdir(output_dir):
-                        item_path = os.path.join(output_dir, item)
-                        if item.lower().endswith(('.html', '.htm')):
-                            return item_path, None
-                        if os.path.isdir(item_path):
-                            return item_path, None
-            except:
-                continue
-    except Exception as e:
-        print(f"HTML 변환 오류: {e}")
-    return None, "HTML 변환 실패"
-def convert_hwp_to_text(input_path: str) -> tuple:
-    """HWP/HWPX를 텍스트로 변환"""
-    return extract_text_from_hwp_or_hwpx(input_path)
-def html_to_markdown(html_content):
-    """HTML을 Markdown으로 변환"""
-    if MARKDOWNIFY_AVAILABLE:
-        try:
-            return md(html_content, heading_style="ATX", bullets="-"), None
-        except:
-            pass
-    if HTML2TEXT_AVAILABLE:
-        try:
-            h = html2text.HTML2Text()
-            h.body_width = 0
-            return h.handle(html_content), None
-        except:
-            pass
-    if BS4_AVAILABLE:
         try:
-            soup = BeautifulSoup(html_content, 'html.parser')
-            return soup.get_text(separator='\n'), None
-        except:
-            pass
-    return None, "Markdown 변환 실패"
-def convert_hwp_to_markdown(input_path: str) -> tuple:
-    """HWP/HWPX를 Markdown으로 변환"""
-    # 텍스트 추출
-    text, error = extract_text_from_hwp_or_hwpx(input_path)
-    if text:
-        return text, None
-    return None, error
-# ============== LLM API ==============
-def call_groq_api_stream(messages: List[Dict], api_key: str) -> Generator[str, None, None]:
-    if not api_key:
-        yield "❌ Groq API 키가 설정되지 않았습니다."
-        return
-    try:
-        response = requests.post(
-            "https://api.groq.com/openai/v1/chat/completions",
-            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
-            json={
-                "model": "meta-llama/llama-4-scout-17b-16e-instruct",
-                "messages": messages,
-                "temperature": 0.7,
-                "max_tokens": 8192,
-                "stream": True
-            },
-            stream=True
-        )
-        if response.status_code != 200:
-            yield f"❌ Groq API 오류: {response.status_code}"
-            return
-        for line in response.iter_lines():
-            if line:
-                line = line.decode('utf-8')
-                if line.startswith('data: ') and line[6:] != '[DONE]':
-                    try:
-                        data = json.loads(line[6:])
-                        content = data.get('choices', [{}])[0].get('delta', {}).get('content', '')
-                        if content:
-                            yield content
-                    except:
-                        continue
-    except Exception as e:
-        yield f"❌ API 오류: {str(e)}"
-def call_fireworks_api_stream(messages: List[Dict], image_base64: str, mime_type: str, api_key: str) -> Generator[str, None, None]:
-    if not api_key:
-        yield "❌ Fireworks API 키가 설정되지 않았습니다."
-        return
-    try:
-        formatted_messages = [{"role": m["role"], "content": m["content"]} for m in messages[:-1]]
-        formatted_messages.append({
-            "role": messages[-1]["role"],
-            "content": [
-                {"type": "image_url", "image_url": {"url": f"data:{mime_type};base64,{image_base64}"}},
-                {"type": "text", "text": messages[-1]["content"]}
-            ]
-        })
-        response = requests.post(
-            "https://api.fireworks.ai/inference/v1/chat/completions",
-            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
-            json={
-                "model": "accounts/fireworks/models/qwen3-vl-235b-a22b-thinking",
-                "max_tokens": 4096,
-                "temperature": 0.6,
-                "messages": formatted_messages,
-                "stream": True
-            },
-            stream=True
-        )
-        if response.status_code != 200:
-            yield f"❌ Fireworks API 오류: {response.status_code}"
-            return
-        for line in response.iter_lines():
-            if line:
-                line = line.decode('utf-8')
-                if line.startswith('data: ') and line[6:] != '[DONE]':
-                    try:
-                        data = json.loads(line[6:])
-                        content = data.get('choices', [{}])[0].get('delta', {}).get('content', '')
-                        if content:
-                            yield content
-                    except:
-                        continue
-    except Exception as e:
-        yield f"❌ API 오류: {str(e)}"
-# ============== 채팅 처리 ==============
-def process_file(file_path: str) -> tuple:
-    if not file_path:
-        return None, None, None
-    filename = os.path.basename(file_path)
-    if is_image_file(file_path):
-        return "image", image_to_base64(file_path), get_image_mime_type(file_path)
-    if is_hwp_file(file_path) or is_hwpx_file(file_path):
-        text, error = extract_text_from_hwp_or_hwpx(file_path)
-        if text and len(text.strip()) > 20:
-            return "text", f"[한글 문서: {filename}]\n\n{text}", None
-        return "error", f"한글 문서 추출 실패: {error}", None
-    if is_pdf_file(file_path):
-        text = extract_text_from_pdf(file_path)
-        if text:
-            return "text", f"[PDF 문서: {filename}]\n\n{text}", None
-        return "error", "PDF 추출 실패", None
-    if is_text_file(file_path):
-        text = extract_text_from_txt(file_path)
-        if text:
-            return "text", f"[텍스트 파일: {filename}]\n\n{text}", None
-        return "error", "텍스트 읽기 실패", None
-    return "unsupported", f"지원하지 않는 형식: {filename}", None
-def chat_response(message: str, history: List[Dict], file: Optional[str],
-                  session_id: str, groq_key: str, fireworks_key: str) -> Generator[tuple, None, None]:
-    if history is None:
-        history = []
-    if not message.strip() and not file:
-        yield history, session_id
-        return
-    if not session_id:
-        session_id = create_session()
-    # 파일 처리
-    file_type, file_content, file_mime = None, None, None
-    file_info = None
-    if file:
-        file_type, file_content, file_mime = process_file(file)
-        file_info = json.dumps({"type": file_type, "filename": os.path.basename(file)})
-        if file_type == "error":
-            history = history + [
-                {"role": "user", "content": message or "파일 업로드"},
-                {"role": "assistant", "content": f"❌ {file_content}"}
-            ]
-            yield history, session_id
-            return
-        elif file_type == "unsupported":
-            history = history + [
-                {"role": "user", "content": message or "파일 업로드"},
-                {"role": "assistant", "content": f"⚠️ {file_content}"}
-            ]
-            yield history, session_id
-            return
-    # 사용자 메시지
-    user_msg = message
-    if file:
-        filename = os.path.basename(file)
-        user_msg = f"📎 {filename}\n\n{message}" if message else f"📎 {filename}"
-    history = history + [{"role": "user", "content": user_msg}, {"role": "assistant", "content": ""}]
-    yield history, session_id
-    # API 메시지 구성
-    db_messages = get_session_messages(session_id, limit=10)
-    api_messages = [{
-        "role": "system",
-        "content": "당신은 도움이 되는 AI 어시스턴트입니다. 한국어로 자연스럽게 대화하며, 파일이 첨부되면 내용을 상세히 분석하여 답변합니다."
-    }]
-    for m in db_messages:
-        api_messages.append({"role": m["role"], "content": m["content"]})
-    current_content = message or ""
-    if file_type == "text" and file_content:
-        current_content = f"{file_content}\n\n사용자 질문: {message}" if message else f"{file_content}\n\n위 문서 내용을 요약해주세요."
-    api_messages.append({"role": "user", "content": current_content})
-    # 응답 생성
-    full_response = ""
-    if file_type == "image":
-        for chunk in call_fireworks_api_stream(api_messages, file_content, file_mime, fireworks_key):
-            full_response += chunk
-            history[-1] = {"role": "assistant", "content": full_response}
-            yield history, session_id
     else:
-        for chunk in call_groq_api_stream(api_messages, groq_key):
-            full_response += chunk
-            history[-1] = {"role": "assistant", "content": full_response}
-            yield history, session_id
-    # 저장
-    save_message(session_id, "user", current_content, file_info)
-    save_message(session_id, "assistant", full_response)
-    if len(db_messages) == 0 and message:
-        update_session_title(session_id, message[:50])
-def new_chat():
-    return [], create_session(), None
-def load_session(session_id: str) -> tuple:
-    if not session_id:
-        return [], ""
-    messages = get_session_messages(session_id, limit=50)
-    return [{"role": m["role"], "content": m["content"]} for m in messages], session_id
-# ============== HWP 변환기 (Tab 2) ==============
-def convert_to_odt_subprocess(input_path, output_dir):
-    output_path = os.path.join(output_dir, "output.odt")
-    try:
-        for cmd in [['hwp5odt', '--output', output_path, input_path],
-                    [sys.executable, '-c', f'from hwp5.hwp5odt import main; import sys; sys.argv=["hwp5odt","--output","{output_path}","{input_path}"]; main()']]:
-            try:
-                result = subprocess.run(cmd, capture_output=True, timeout=120)
-                if result.returncode == 0 and os.path.exists(output_path):
-                    return output_path, None
-            except:
-                continue
-    except:
-        pass
-    return None, "ODT 변환 실패"
-def convert_to_xml_subprocess(input_path, output_dir):
-    output_path = os.path.join(output_dir, "output.xml")
-    try:
-        for cmd in [['hwp5xml', input_path],
-                    [sys.executable, '-c', f'from hwp5.hwp5xml import main; import sys; sys.argv=["hwp5xml","{input_path}"]; main()']]:
-            try:
-                result = subprocess.run(cmd, capture_output=True, timeout=120)
-                if result.returncode == 0 and result.stdout:
-                    with open(output_path, 'wb') as f:
-                        f.write(result.stdout)
-                    return output_path, None
-            except:
-                continue
-    except:
-        pass
-    return None, "XML 변환 실패"
-def convert_hwp(file, output_format, progress=gr.Progress()):
-    if not file:
-        return None, "❌ 파일을 업로드해주세요.", ""
-    input_file = file.name if hasattr(file, 'name') else str(file)
-    ext_lower = Path(input_file).suffix.lower()
-    if ext_lower not in ['.hwp', '.hwpx']:
-        return None, "❌ HWP 또는 HWPX 파일만 지원됩니다.", ""
-    progress(0.1, desc="파일 분석 중...")
-    version, is_valid = check_hwp_version(input_file)
-    if not is_valid:
-        return None, f"❌ 지원하지 않는 파일: {version}", ""
-    tmp_dir = tempfile.mkdtemp()
-    try:
-        input_filename = os.path.basename(input_file)
-        input_path = os.path.join(tmp_dir, input_filename)
-        shutil.copy(input_file, input_path)
-        progress(0.3, desc=f"{output_format}로 변환 중...")
-        output_path, error, ext = None, None, ""
-        if output_format == "HTML":
-            if ext_lower == '.hwpx':
-                return None, "❌ HWPX는 HTML 변환을 지원하지 않습니다. TXT나 Markdown을 사용하세요.", ""
-            output_path, error = convert_to_html_subprocess(input_path, tmp_dir)
-            ext = ".html"
-            if output_path and os.path.isdir(output_path):
-                zip_path = shutil.make_archive(os.path.join(tmp_dir, "html"), 'zip', output_path)
-                output_path, ext = zip_path, ".zip"
-        elif output_format == "ODT (OpenDocument)":
-            if ext_lower == '.hwpx':
-                return None, "❌ HWPX는 ODT 변환을 지원하지 않습니다. TXT나 Markdown을 사용하세요.", ""
-            output_path, error = convert_to_odt_subprocess(input_path, tmp_dir)
-            ext = ".odt"
-        elif output_format == "TXT (텍스트)":
-            text, error = extract_text_from_hwp_or_hwpx(input_path)
-            if text:
-                output_path = os.path.join(tmp_dir, "output.txt")
-                with open(output_path, 'w', encoding='utf-8') as f:
-                    f.write(text)
-            ext = ".txt"
-        elif output_format == "Markdown":
-            text, error = convert_hwp_to_markdown(input_path)
-            if text:
-                output_path = os.path.join(tmp_dir, "output.md")
-                with open(output_path, 'w', encoding='utf-8') as f:
-                    f.write(text)
-            ext = ".md"
-        elif output_format == "XML":
-            if ext_lower == '.hwpx':
-                # HWPX는 이미 XML 기반이므로 내부 XML 추출
-                try:
-                    with zipfile.ZipFile(input_path, 'r') as zf:
-                        # 모든 XML 파일을 하나로 합침
-                        xml_contents = []
-                        for name in zf.namelist():
-                            if name.endswith('.xml'):
-                                with zf.open(name) as f:
-                                    xml_contents.append(f"<!-- {name} -->\n{f.read().decode('utf-8', errors='ignore')}")
-                        output_path = os.path.join(tmp_dir, "output.xml")
-                        with open(output_path, 'w', encoding='utf-8') as f:
-                            f.write('\n\n'.join(xml_contents))
-                except Exception as e:
-                    error = f"HWPX XML 추출 실패: {e}"
-            else:
-                output_path, error = convert_to_xml_subprocess(input_path, tmp_dir)
-            ext = ".xml"
-        if not output_path:
-            return None, f"❌ {error or '변환 실패'}", ""
-        if not os.path.exists(output_path):
-            return None, "❌ 변환된 파일을 찾을 수 없습니다.", ""
-        progress(0.8, desc="완료...")
-        base_name = Path(input_filename).stem
-        final_output = os.path.join(tmp_dir, f"{base_name}{ext}")
-        if output_path != final_output:
-            shutil.copy2(output_path, final_output)
-        file_size = os.path.getsize(final_output)
-        size_str = f"{file_size/1024:.1f} KB" if file_size > 1024 else f"{file_size} bytes"
-        preview = ""
-        if ext in ['.txt', '.md', '.xml']:
-            try:
-                with open(final_output, 'r', encoding='utf-8', errors='ignore') as f:
-                    preview = f.read(5000)
-                    if len(preview) >= 5000:
-                        preview += "\n\n... (생략)"
-            except:
-                pass
-        elif ext == '.zip':
-            preview = "📦 HTML이 ZIP으로 압���되었습니다."
-        progress(1.0, desc="완료!")
-        return final_output, f"✅ 변환 완료: {base_name}{ext} ({size_str})", preview
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        return None, f"❌ 오류: {str(e)}", ""
-# ============== Gradio UI ==============
-css = """
-.upload-box { border: 2px dashed #6366f1 !important; border-radius: 12px !important; }
-.download-box { border: 2px solid #22c55e !important; border-radius: 12px !important; }
-"""
-with gr.Blocks(title="AI 문서 어시스턴트") as demo:
-    session_state = gr.State("")
-    gr.Markdown("# 🤖 AI 문서 어시스턴트\nLLM 채팅 + HWP/HWPX 문서 변환")
-    with gr.Tabs():
-        with gr.Tab("💬 AI 채팅"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### ⚙️ 설정")
-                    with gr.Accordion("🔑 API 키", open=True):
-                        groq_key = gr.Textbox(label="Groq API Key", type="password", value=GROQ_API_KEY)
-                        fireworks_key = gr.Textbox(label="Fireworks API Key", type="password", value=FIREWORKS_API_KEY)
-                    gr.Markdown("### 📁 지원 파일\n- 이미지: JPG, PNG\n- 문서: PDF, TXT\n- 한글: HWP, HWPX ✨")
-                    new_btn = gr.Button("🆕 새 대화", variant="primary")
-                    with gr.Accordion("📜 기록", open=False):
-                        session_list = gr.Dataframe(headers=["ID", "제목", "시간"], interactive=False)
-                        refresh_btn = gr.Button("🔄 새로고침", size="sm")
-                with gr.Column(scale=3):
-                    chatbot = gr.Chatbot(label="대화", height=500)
-                    with gr.Row():
-                        file_upload = gr.File(label="📎 파일", file_types=[".jpg",".jpeg",".png",".gif",".webp",".pdf",".txt",".md",".hwp",".hwpx"], scale=1)
-                        msg_input = gr.Textbox(placeholder="메시지 입력...", lines=2, show_label=False, scale=4)
-                    with gr.Row():
-                        submit_btn = gr.Button("📤 전송", variant="primary", scale=3)
-                        clear_btn = gr.Button("🗑️ 지우기", scale=1)
-        with gr.Tab("📄 HWP 변환기"):
-            gr.Markdown("### HWP/HWPX 파일 변환기")
             with gr.Row():
-                with gr.Column():
-                    hwp_input = gr.File(label="HWP/HWPX 파일", file_types=[".hwp", ".hwpx"], elem_classes=["upload-box"])
-                    format_select = gr.Radio(["HTML", "ODT (OpenDocument)", "TXT (텍스트)", "Markdown", "XML"], value="TXT (텍스트)", label="형식")
-                    convert_btn = gr.Button("🔄 변환", variant="primary", size="lg")
-                with gr.Column():
-                    status_out = gr.Textbox(label="상태", interactive=False)
-                    file_out = gr.File(label="다운로드", elem_classes=["download-box"])
-            with gr.Accordion("📋 미리보기", open=False):
-                preview_out = gr.Textbox(lines=15, interactive=False)
-            gr.Markdown("""
-            > **참고**: HWPX 파일은 TXT, Markdown, XML 변환만 지원됩니다.
-            """)
-    # 이벤트
-    def on_submit(msg, hist, f, sid, gk, fk):
-        if hist is None: hist = []
-        for r in chat_response(msg, hist, f, sid, gk, fk):
-            yield r[0], r[1], "", None
-    submit_btn.click(on_submit, [msg_input, chatbot, file_upload, session_state, groq_key, fireworks_key],
-                     [chatbot, session_state, msg_input, file_upload])
-    msg_input.submit(on_submit, [msg_input, chatbot, file_upload, session_state, groq_key, fireworks_key],
-                     [chatbot, session_state, msg_input, file_upload])
-    new_btn.click(lambda: ([], create_session(), None, ""), outputs=[chatbot, session_state, file_upload, msg_input])
-    clear_btn.click(lambda: ([], None, ""), outputs=[chatbot, file_upload, msg_input])
-    def refresh():
-        sessions = get_all_sessions()
-        return [[s["session_id"][:8], s["title"] or "제목없음", s["updated_at"][:16] if s["updated_at"] else ""] for s in sessions]
-    refresh_btn.click(refresh, outputs=[session_list])
-    def select_session(evt: gr.SelectData, data):
-        if evt.index[0] < len(data):
-            for s in get_all_sessions():
-                if s["session_id"].startswith(data[evt.index[0]][0]):
-                    return load_session(s["session_id"])
-        return [], ""
-    session_list.select(select_session, [session_list], [chatbot, session_state])
-    convert_btn.click(convert_hwp, [hwp_input, format_select], [file_out, status_out, preview_out])
-    demo.load(refresh, outputs=[session_list])
-if __name__ == "__main__":
-    demo.launch(css=css)

 import os
 import json
+import copy
+import time
 import requests
+import random
+import logging
+import numpy as np
+import spaces
+from typing import Any, Dict, List, Optional, Union
+import torch
+from PIL import Image
+import gradio as gr
+from diffusers import (
+    DiffusionPipeline,
+    AutoencoderKL,
+    ZImagePipeline
+)
+from huggingface_hub import (
+    hf_hub_download,
+    HfFileSystem,
+    ModelCard,
+    snapshot_download)
+from diffusers.utils import load_image
+from typing import Iterable
+# ============================================
+# Comic Style CSS
+# ============================================
+COMIC_CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Bangers&family=Comic+Neue:wght@400;700&display=swap');
+.gradio-container {
+    background-color: #FEF9C3 !important;
+    background-image: radial-gradient(#1F2937 1px, transparent 1px) !important;
+    background-size: 20px 20px !important;
+    min-height: 100vh !important;
+    font-family: 'Comic Neue', cursive, sans-serif !important;
+}
+footer, .footer, .gradio-container footer, .built-with, [class*="footer"], .gradio-footer, a[href*="gradio.app"] {
+    display: none !important;
+    visibility: hidden !important;
+    height: 0 !important;
+}
+/* HOME Button Style */
+.home-button-container {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    gap: 15px;
+    margin-bottom: 15px;
+    padding: 12px 20px;
+    background: linear-gradient(135deg, #10B981 0%, #059669 100%);
+    border: 4px solid #1F2937;
+    border-radius: 12px;
+    box-shadow: 6px 6px 0 #1F2937;
+}
+.home-button {
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    padding: 10px 25px;
+    background: linear-gradient(135deg, #FACC15 0%, #F59E0B 100%);
+    color: #1F2937;
+    font-family: 'Bangers', cursive;
+    font-size: 1.4rem;
+    letter-spacing: 2px;
+    text-decoration: none;
+    border: 3px solid #1F2937;
+    border-radius: 8px;
+    box-shadow: 4px 4px 0 #1F2937;
+    transition: all 0.2s ease;
+}
+.home-button:hover {
+    background: linear-gradient(135deg, #FDE047 0%, #FACC15 100%);
+    transform: translate(-2px, -2px);
+    box-shadow: 6px 6px 0 #1F2937;
+}
+.home-button:active {
+    transform: translate(2px, 2px);
+    box-shadow: 2px 2px 0 #1F2937;
+}
+.url-display {
+    font-family: 'Comic Neue', cursive;
+    font-size: 1.1rem;
+    font-weight: 700;
+    color: #FFF;
+    background: rgba(0,0,0,0.3);
+    padding: 8px 16px;
+    border-radius: 6px;
+    border: 2px solid rgba(255,255,255,0.3);
+}
+.header-container {
+    text-align: center;
+    padding: 25px 20px;
+    background: linear-gradient(135deg, #3B82F6 0%, #8B5CF6 100%);
+    border: 4px solid #1F2937;
+    border-radius: 12px;
+    margin-bottom: 20px;
+    box-shadow: 8px 8px 0 #1F2937;
+    position: relative;
+}
+.header-title {
+    font-family: 'Bangers', cursive !important;
+    color: #FFF !important;
+    font-size: 2.8rem !important;
+    text-shadow: 3px 3px 0 #1F2937 !important;
+    letter-spacing: 3px !important;
+    margin: 0 !important;
+}
+.header-subtitle {
+    font-family: 'Comic Neue', cursive !important;
+    font-size: 1.1rem !important;
+    color: #FEF9C3 !important;
+    margin-top: 8px !important;
+    font-weight: 700 !important;
+}
+.stats-badge {
+    display: inline-block;
+    background: #FACC15;
+    color: #1F2937;
+    padding: 6px 14px;
+    border-radius: 20px;
+    font-size: 0.9rem;
+    margin: 3px;
+    font-weight: 700;
+    border: 2px solid #1F2937;
+    box-shadow: 2px 2px 0 #1F2937;
+}
+.gr-panel, .gr-box, .gr-form, .block, .gr-group {
+    background: #FFF !important;
+    border: 3px solid #1F2937 !important;
+    border-radius: 8px !important;
+    box-shadow: 5px 5px 0 #1F2937 !important;
+}
+.gr-button-primary, button.primary, .gr-button.primary {
+    background: linear-gradient(135deg, #EF4444 0%, #F97316 100%) !important;
+    border: 3px solid #1F2937 !important;
+    border-radius: 8px !important;
+    color: #FFF !important;
+    font-family: 'Bangers', cursive !important;
+    font-size: 1.3rem !important;
+    letter-spacing: 2px !important;
+    padding: 12px 24px !important;
+    box-shadow: 4px 4px 0 #1F2937 !important;
+    text-shadow: 1px 1px 0 #1F2937 !important;
+    transition: all 0.2s ease !important;
+}
+.gr-button-primary:hover, button.primary:hover {
+    background: linear-gradient(135deg, #DC2626 0%, #EA580C 100%) !important;
+    transform: translate(-2px, -2px) !important;
+    box-shadow: 6px 6px 0 #1F2937 !important;
+}
+.gr-button-primary:active, button.primary:active {
+    transform: translate(2px, 2px) !important;
+    box-shadow: 2px 2px 0 #1F2937 !important;
+}
+textarea, input[type="text"], input[type="number"] {
+    background: #FFF !important;
+    border: 3px solid #1F2937 !important;
+    border-radius: 8px !important;
+    color: #1F2937 !important;
+    font-family: 'Comic Neue', cursive !important;
+    font-weight: 700 !important;
+}
+textarea:focus, input[type="text"]:focus {
+    border-color: #3B82F6 !important;
+    box-shadow: 3px 3px 0 #3B82F6 !important;
+}
+.info-box {
+    background: linear-gradient(135deg, #FACC15 0%, #FDE047 100%) !important;
+    border: 3px solid #1F2937 !important;
+    border-radius: 8px !important;
+    padding: 12px 15px !important;
+    margin: 10px 0 !important;
+    box-shadow: 4px 4px 0 #1F2937 !important;
+    font-family: 'Comic Neue', cursive !important;
+    font-weight: 700 !important;
+    color: #1F2937 !important;
+}
+label, .gr-input-label, .gr-block-label {
+    color: #1F2937 !important;
+    font-family: 'Comic Neue', cursive !important;
+    font-weight: 700 !important;
+}
+.gr-accordion {
+    background: #E0F2FE !important;
+    border: 3px solid #1F2937 !important;
+    border-radius: 8px !important;
+    box-shadow: 4px 4px 0 #1F2937 !important;
+}
+.footer-comic {
+    text-align: center;
+    padding: 20px;
+    background: linear-gradient(135deg, #3B82F6 0%, #8B5CF6 100%);
+    border: 4px solid #1F2937;
+    border-radius: 12px;
+    margin-top: 20px;
+    box-shadow: 6px 6px 0 #1F2937;
+}
+.footer-comic p {
+    font-family: 'Comic Neue', cursive !important;
+    color: #FFF !important;
+    margin: 5px 0 !important;
+    font-weight: 700 !important;
+}
+::-webkit-scrollbar {
+    width: 12px;
+    height: 12px;
+}
+::-webkit-scrollbar-track {
+    background: #FEF9C3;
+    border: 2px solid #1F2937;
+}
+::-webkit-scrollbar-thumb {
+    background: #3B82F6;
+    border: 2px solid #1F2937;
+    border-radius: 6px;
+}
+::-webkit-scrollbar-thumb:hover {
+    background: #EF4444;
+}
+::selection {
+    background: #FACC15;
+    color: #1F2937;
+}
+/* Slider Styling */
+input[type="range"] {
+    accent-color: #3B82F6;
+}
+/* Image/Gallery Container */
+.gr-image, .gr-gallery {
+    border: 3px solid #1F2937 !important;
+    border-radius: 8px !important;
+    box-shadow: 4px 4px 0 #1F2937 !important;
+}
+/* Original CSS additions */
+#gen_btn{height: 100%}
+#gen_column{align-self: stretch}
+#title{text-align: center}
+#title h1{font-size: 3em; display:inline-flex; align-items:center}
+#title img{width: 100px; margin-right: 0.5em}
+#gallery .grid-wrap{height: 10vh}
+#lora_list{background: var(--block-background-fill);padding: 0 1em .3em; font-size: 90%}
+.card_internal{display: flex;height: 100px;margin-top: .5em}
+.card_internal img{margin-right: 1em}
+.styler{--form-gap-width: 0px !important}
+#progress{height:30px}
+#progress .generating{display:none}
+.progress-container {width: 100%;height: 30px;background-color: #f0f0f0;border-radius: 15px;overflow: hidden;margin-bottom: 20px}
+.progress-bar {height: 100%;background-color: #4f46e5;width: calc(var(--current) / var(--total) * 100%);transition: width 0.5s ease-in-out}
+"""
+loras = [
+    # 로컬 jimin LoRA (app.py와 같은 디렉토리에 jimin.safetensors 필요)
+    {
+        "image": "https://i.namu.wiki/i/VxF2jh087d4V6f9LWw1jQoLcQ_ymdhyD7XtRnq2KVYmN6DZsL4vCTrd1v-ubr8zfejyCCKvUWaBVf9JM9GqR271X6nh4e6mUbW11LaFr9QtepztFJeDZJ1VISkW5KBbebCpqv-w2Uv7RmMPwB5kacg.webp",
+        "title": "koyoon Style",
+        "repo": "./",  # 로컬 경로
+        "weights": "koyoon.safetensors",
+        "trigger_word": "koyoon"
+    },
+    {
+        "image": "https://i.namu.wiki/i/umL8EZtn0hs-nMRYeFxIrkGrMe-R1u5c9fJE8ufrLjvXz52VcSIbG7TT9QJoL2rR7vsFww1lLrE4bwfn5uOBzfq9a90HGdNdlTLmr_KoqOchTovbVC3RDzhDbp7FI-Wq-esCu7_BYIptqethL4onBg.webp",
+        "title": "jimin Style",
+        "repo": "./",  # 로컬 경로
+        "weights": "jimin.safetensors",
+        "trigger_word": "jimin"
+    },
+    {
+        "image": "https://huggingface.co/strangerzonehf/Flux-Ultimate-LoRA-Collection/resolve/main/images/1111111111.png",
+        "title": "AWPortrait Z",
+        "repo": "Shakker-Labs/AWPortrait-Z", #1
+        "weights": "AWPortrait-Z.safetensors",
+        "trigger_word": "Portrait"
+    },
+    {
+        "image": "https://cdn-uploads.huggingface.co/production/uploads/653cd3049107029eb004f968/DLCGlF9uUnFo5zxR5uyx6.png",
+        "title": "50s Western",
+        "repo": "neph1/50s_western_lora_zit",
+        "weights": "50s_western_z_100.safetensors",
+        "trigger_word": "50s_western"
+    },
+    {
+        "image": "https://huggingface.co/neph1/80s_scifi_lora_zit/resolve/main/images/ComfyUI_10288_.png",
+        "title": "80s Scifi",
+        "repo": "neph1/80s_scifi_lora_zit",
+        "weights": "80s_scifi_z_80.safetensors",
+        "trigger_word": "80s_scifi"
+    },
+ # --------------------------------------------------------------------------------------------------------------------------------------
+    {
+        "image": "https://huggingface.co/Ttio2/Z-Image-Turbo-pencil-sketch/resolve/main/images/z-image_00097_.png",
+        "title": "Turbo Pencil",
+        "repo": "Ttio2/Z-Image-Turbo-pencil-sketch", #0
+        "weights": "Zimage_pencil_sketch.safetensors",
+        "trigger_word": "pencil sketch"
+    },
+    {
+        "image": "https://huggingface.co/neph1/50s_scifi_lora_zit/resolve/main/images/ComfyUI_08067_.png",
+        "title": "50s Scifi",
+        "repo": "neph1/50s_scifi_lora_zit",
+        "weights": "50s_scifi_z_80.safetensors",
+        "trigger_word": "50s_scifi"
+    },
+    {
+        "image": "https://huggingface.co/strangerzonehf/Flux-Ultimate-LoRA-Collection/resolve/main/images/cookie-mons.png",
+        "title": "Yarn Art Style",
+        "repo": "linoyts/yarn-art-style", #28
+        "weights": "yarn-art-style_000001250.safetensors",
+        "trigger_word": "yarn art style"
+    },
+    {
+        "image": "https://huggingface.co/Quorlen/Z-Image-Turbo-Behind-Reeded-Glass-Lora/resolve/main/images/ComfyUI_00391_.png",
+        "title": "Behind Reeded Glass",
+        "repo": "Quorlen/Z-Image-Turbo-Behind-Reeded-Glass-Lora", #26
+        "weights": "Z_Image_Turbo_Behind_Reeded_Glass_Lora_TAV2_000002750.safetensors",
+        "trigger_word": "Act1vate!, Behind reeded glass"
+    },
+    {
+        "image": "https://huggingface.co/ostris/z_image_turbo_childrens_drawings/resolve/main/images/1764433619736__000003000_9.jpg",
+        "title": "Childrens Drawings",
+        "repo": "ostris/z_image_turbo_childrens_drawings", #2
+        "weights": "z_image_turbo_childrens_drawings.safetensors",
+        "trigger_word": "Children Drawings"
+    },
+    {
+        "image": "https://huggingface.co/strangerzonehf/Flux-Ultimate-LoRA-Collection/resolve/main/images/xcxc.png",
+        "title": "Tarot Z",
+        "repo": "multimodalart/tarot-z-image-lora", #22
+        "weights": "tarot-z-image_000001250.safetensors",
+        "trigger_word": "trtcrd"
+    },
+    {
+        "image": "https://huggingface.co/renderartist/Technically-Color-Z-Image-Turbo/resolve/main/images/ComfyUI_00917_.png",
+        "title": "Technically Color Z",
+        "repo": "renderartist/Technically-Color-Z-Image-Turbo", #3
+        "weights": "Technically_Color_Z_Image_Turbo_v1_renderartist_2000.safetensors",
+        "trigger_word": "t3chnic4lly"
+    },
+    {
+        "image": "https://huggingface.co/SkyAsl/Tattoo-artist-Z/resolve/main/images/a%20dragon%20with%20flames.png",
+        "title": "Tattoo-artist-Z",
+        "repo": "SkyAsl/Tattoo-artist-Z", #31
+        "weights": "adapter_model.safetensors",
+        "trigger_word": "a tattoo design"
+    },
+    {
+        "image": "https://huggingface.co/strangerzonehf/Flux-Ultimate-LoRA-Collection/resolve/main/images/z-image_00147_.png",
+        "title": "Turbo Ghibli",
+        "repo": "Ttio2/Z-Image-Turbo-Ghibli-Style", #19
+        "weights": "ghibli_zimage_finetune.safetensors",
+        "trigger_word": "Ghibli Style"
+    },
+    {
+        "image": "https://huggingface.co/tarn59/pixel_art_style_lora_z_image_turbo/resolve/main/images/ComfyUI_00273_.png",
+        "title": "Pixel Art",
+        "repo": "tarn59/pixel_art_style_lora_z_image_turbo", #4
+        "weights": "pixel_art_style_z_image_turbo.safetensors",
+        "trigger_word": "Pixel art style."
+    },
+    {
+        "image": "https://huggingface.co/renderartist/Saturday-Morning-Z-Image-Turbo/resolve/main/images/Saturday_Morning_Z_15.png",
+        "title": "Saturday Morning",
+        "repo": "renderartist/Saturday-Morning-Z-Image-Turbo", #5
+        "weights": "Saturday_Morning_Z_Image_Turbo_v1_renderartist_1250.safetensors",
+        "trigger_word": "saturd4ym0rning"
+    },
+    {
+        "image": "https://huggingface.co/AIImageStudio/ReversalFilmGravure_z_Image_turbo/resolve/main/images/2025-12-01_173047-z_image_z_image_turbo_bf16-435125750859057-euler_10_hires.png",
+        "title": "ReversalFilmGravure",
+        "repo": "AIImageStudio/ReversalFilmGravure_z_Image_turbo", #6
+        "weights": "z_image_turbo_ReversalFilmGravure_v1.0.safetensors",
+        "trigger_word": "Reversal Film Gravure, analog film photography"
+    },
+    {
+        "image": "https://huggingface.co/renderartist/Coloring-Book-Z-Image-Turbo-LoRA/resolve/main/images/CBZ_00274_.png",
+        "title": "Coloring Book Z",
+        "repo": "renderartist/Coloring-Book-Z-Image-Turbo-LoRA", #7
+        "weights": "Coloring_Book_Z_Image_Turbo_v1_renderartist_2000.safetensors",
+        "trigger_word": "c0l0ringb00k"
+    },
+    {
+        "image": "https://huggingface.co/damnthatai/1950s_American_Dream/resolve/main/images/ZImage_20251129163459_135x_00001_.jpg",
+        "title": "1950s American Dream",
+        "repo": "damnthatai/1950s_American_Dream", #8
+        "weights": "5os4m3r1c4n4_z.safetensors",
+        "trigger_word": "5os4m3r1c4n4, 1950s, painting, a painting of"
+    },
+    {
+        "image": "https://huggingface.co/wcde/Z-Image-Turbo-DeJPEG-Lora/resolve/main/images/01.png",
+        "title": "DeJPEG",
+        "repo": "wcde/Z-Image-Turbo-DeJPEG-Lora", #9
+        "weights": "dejpeg_v3.safetensors",
+        "trigger_word": ""
+    },
+    {
+        "image": "https://huggingface.co/suayptalha/Z-Image-Turbo-Realism-LoRA/resolve/main/images/n4aSpqa-YFXYo4dtcIg4W.png",
+        "title": "DeJPEG",
+        "repo": "suayptalha/Z-Image-Turbo-Realism-LoRA", #10
+        "weights": "pytorch_lora_weights.safetensors",
+        "trigger_word": "Realism"
+    },
+    {
+        "image": "https://huggingface.co/renderartist/Classic-Painting-Z-Image-Turbo-LoRA/resolve/main/images/Classic_Painting_Z_00247_.png",
+        "title": "Classic Painting Z",
+        "repo": "renderartist/Classic-Painting-Z-Image-Turbo-LoRA", #11
+        "weights": "Classic_Painting_Z_Image_Turbo_v1_renderartist_1750.safetensors",
+        "trigger_word": "class1cpa1nt"
+    },
+    {
+        "image": "https://huggingface.co/DK9/3D_MMORPG_style_z-image-turbo_lora/resolve/main/images/10_with_lora.png",
+        "title": "3D MMORPG",
+        "repo": "DK9/3D_MMORPG_style_z-image-turbo_lora", #12
+        "weights": "lostark_v1.safetensors",
+        "trigger_word": ""
+    },
+    {
+        "image": "https://huggingface.co/Danrisi/Olympus_UltraReal_ZImage/resolve/main/images/Z-Image_01011_.png",
+        "title": "Olympus UltraReal",
+        "repo": "Danrisi/Olympus_UltraReal_ZImage", #13
+        "weights": "Olympus.safetensors",
+        "trigger_word": "digital photography, early 2000s compact camera aesthetic, amateur candid shot, digital photography, early 2000s compact camera aesthetic, amateur candid shot, direct flash lighting, hard flash shadow, specular highlights, overexposed highlights"
+    },
+    {
+        "image": "https://huggingface.co/AiAF/D-ART_Z-Image-Turbo_LoRA/resolve/main/images/example_l3otpwzaz.png",
+        "title": "D ART Z Image",
+        "repo": "AiAF/D-ART_Z-Image-Turbo_LoRA", #14
+        "weights": "D-ART_Z-Image-Turbo.safetensors",
+        "trigger_word": "D-ART"
+    },
+    {
+        "image": "https://huggingface.co/AlekseyCalvin/Marionette_Modernism_Z-image-Turbo_LoRA/resolve/main/bluebirdmandoll.webp",
+        "title": "Marionette Modernism",
+        "repo": "AlekseyCalvin/Marionette_Modernism_Z-image-Turbo_LoRA", #15
+        "weights": "ZImageDadadoll_000003600.safetensors",
+        "trigger_word": "DADADOLL style"
+    },
+    {
+        "image": "https://huggingface.co/AlekseyCalvin/HistoricColor_Z-image-Turbo-LoRA/resolve/main/HSTZgen2.webp",
+        "title": "Historic Color Z",
+        "repo": "AlekseyCalvin/HistoricColor_Z-image-Turbo-LoRA", #16
+        "weights": "ZImage1HST_000004000.safetensors",
+        "trigger_word": "HST style"
+    },
+    {
+        "image": "https://huggingface.co/tarn59/80s_air_brush_style_z_image_turbo/resolve/main/images/ComfyUI_00707_.png",
+        "title": "80s Air Brush",
+        "repo": "tarn59/80s_air_brush_style_z_image_turbo", #17
+        "weights": "80s_air_brush_style_v2_z_image_turbo.safetensors",
+        "trigger_word": "80s Air Brush style."
+    },
+    {
+        "image": "https://huggingface.co/CedarC/Z-Image_360/resolve/main/images/1765505225357__000006750_6.jpg",
+        "title": "360panorama",
+        "repo": "CedarC/Z-Image_360", #18
+        "weights": "Z-Image_360.safetensors",
+        "trigger_word": "360panorama"
+    },
+    {
+        "image": "https://huggingface.co/HAV0X1014/Z-Image-Turbo-KF-Bat-Eared-Fox-LoRA/resolve/main/images/ComfyUI_00132_.png",
+        "title": "KF-Bat-Eared",
+        "repo": "HAV0X1014/Z-Image-Turbo-KF-Bat-Eared-Fox-LoRA", #21
+        "weights": "z-image-turbo-bat_eared_fox.safetensors",
+        "trigger_word": "bat_eared_fox_kemono_friends"
+    },
+    {
+        "image": "https://cdn-uploads.huggingface.co/production/uploads/653cd3049107029eb004f968/IHttgddXu6ZBMo7eyy8p6.png",
+        "title": "80s Horror",
+        "repo": "neph1/80s_horror_movies_lora_zit", #23
+        "weights": "80s_horror_z_80.safetensors",
+        "trigger_word": "80s_horror"
+    },
+    {
+        "image": "https://huggingface.co/Quorlen/z_image_turbo_Sunbleached_Protograph_Style_Lora/resolve/main/images/ComfyUI_00024_.png",
+        "title": "Sunbleached Protograph",
+        "repo": "Quorlen/z_image_turbo_Sunbleached_Protograph_Style_Lora", #24
+        "weights": "zimageturbo_Sunbleach_Photograph_Style_Lora_TAV2_000002750.safetensors",
+        "trigger_word": "Act1vate!"
+    },
+    {
+        "image": "https://huggingface.co/bunnycore/Z-Art-2.1/resolve/main/images/ComfyUI_00069_.png",
+        "title": "Z-Art-2.1",
+        "repo": "bunnycore/Z-Art-2.1", #25
+        "weights": "Z-Image-Art2.1.safetensors",
+        "trigger_word": "anime art"
+    },
+    {
+        "image": "https://huggingface.co/cactusfriend/longfurby-z/resolve/main/images/1764658860954__000003000_1.jpg",
+        "title": "Longfurby",
+        "repo": "cactusfriend/longfurby-z", #27
+        "weights": "longfurbyZ.safetensors",
+        "trigger_word": ""
+    },
+    {
+        "image": "https://huggingface.co/SkyAsl/Pixel-artist-Z/resolve/main/pixel-art-result.png",
+        "title": "Pixel Art",
+        "repo": "SkyAsl/Pixel-artist-Z", #29
+        "weights": "adapter_model.safetensors",
+        "trigger_word": "a pixel art character"
+    },
+]
+dtype = torch.bfloat16
+device = "cuda" if torch.cuda.is_available() else "cpu"
+base_model = "Tongyi-MAI/Z-Image-Turbo"
+print(f"Loading {base_model} pipeline...")
+# Initialize Pipeline
+pipe = ZImagePipeline.from_pretrained(
+    base_model,
+    torch_dtype=dtype,
+    low_cpu_mem_usage=False,
+).to(device)
+# ======== AoTI compilation + FA3 ========
+# As per reference for optimization
 try:
+    print("Applying AoTI compilation and FA3...")
+    pipe.transformer.layers._repeated_blocks = ["ZImageTransformerBlock"]
+    spaces.aoti_blocks_load(pipe.transformer.layers, "zerogpu-aoti/Z-Image", variant="fa3")
+    print("Optimization applied successfully.")
+except Exception as e:
+    print(f"Optimization warning: {e}. Continuing with standard pipeline.")
+MAX_SEED = np.iinfo(np.int32).max
+class calculateDuration:
+    def __init__(self, activity_name=""):
+        self.activity_name = activity_name
+    def __enter__(self):
+        self.start_time = time.time()
+        return self
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.end_time = time.time()
+        self.elapsed_time = self.end_time - self.start_time
+        if self.activity_name:
+            print(f"Elapsed time for {self.activity_name}: {self.elapsed_time:.6f} seconds")
         else:
+            print(f"Elapsed time: {self.elapsed_time:.6f} seconds")
+def update_selection(evt: gr.SelectData, width, height):
+    selected_lora = loras[evt.index]
+    new_placeholder = f"Type a prompt for {selected_lora['title']}"
+    lora_repo = selected_lora["repo"]
+    # 로컬 LoRA 처리
+    if lora_repo == "./":
+        updated_text = f"### Selected: Local LoRA - {selected_lora['title']} ✅"
     else:
+        updated_text = f"### Selected: [{lora_repo}](https://huggingface.co/{lora_repo}) ✅"
+    # Default aspect ratio
+    aspect = "1:1 (Instagram Square)"
+    width = 1024
+    height = 1024
+    if "aspect" in selected_lora:
+        if selected_lora["aspect"] == "portrait":
+            aspect = "9:16 (Instagram Reels/TikTok/Shorts)"
+            width = 768
+            height = 1344
+        elif selected_lora["aspect"] == "landscape":
+            aspect = "16:9 (YouTube/Twitter/X)"
+            width = 1344
+            height = 768
+    return (
+        gr.update(placeholder=new_placeholder),
+        updated_text,
+        evt.index,
+        aspect,
+        width,
+        height,
+    )
+@spaces.GPU
+def run_lora(prompt, image_input, image_strength, cfg_scale, steps, selected_index, randomize_seed, seed, width, height, lora_scale, progress=gr.Progress(track_tqdm=True)):
+    # Clean up previous LoRAs in both cases
+    with calculateDuration("Unloading LoRA"):
+        pipe.unload_lora_weights()
+    # Check if a LoRA is selected
+    if selected_index is not None and selected_index < len(loras):
+        selected_lora = loras[selected_index]
+        lora_path = selected_lora["repo"]
+        trigger_word = selected_lora["trigger_word"]
+        # Prepare Prompt with Trigger Word
+        if(trigger_word):
+            if "trigger_position" in selected_lora:
+                if selected_lora["trigger_position"] == "prepend":
+                    prompt_mash = f"{trigger_word} {prompt}"
+                else:
+                    prompt_mash = f"{prompt} {trigger_word}"
             else:
+                prompt_mash = f"{trigger_word} {prompt}"
+        else:
+            prompt_mash = prompt
+        # Load LoRA
+        with calculateDuration(f"Loading LoRA weights for {selected_lora['title']}"):
+            weight_name = selected_lora.get("weights", None)
             try:
+                pipe.load_lora_weights(
+                    lora_path,
+                    weight_name=weight_name,
+                    adapter_name="default",
+                    low_cpu_mem_usage=True
+                )
+                # Set adapter scale
+                pipe.set_adapters(["default"], adapter_weights=[lora_scale])
+            except Exception as e:
+                print(f"Error loading LoRA: {e}")
+                gr.Warning("Failed to load LoRA weights. Generating with base model.")
+    else:
+        # Base Model Case
+        print("No LoRA selected. Running with Base Model.")
+        prompt_mash = prompt
+    with calculateDuration("Randomizing seed"):
+        if randomize_seed:
+            seed = random.randint(0, MAX_SEED)
+    generator = torch.Generator(device=device).manual_seed(seed)
+    # Note: Z-Image-Turbo is strictly T2I in this reference implementation.
+    # Img2Img via image_input is disabled/ignored for this pipeline update.
+    with calculateDuration("Generating image"):
+        # For Turbo models, guidance_scale is typically 0.0
+        forced_guidance = 0.0 # Turbo mode
+        final_image = pipe(
+            prompt=prompt_mash,
+            height=int(height),
+            width=int(width),
+            num_inference_steps=int(steps),
+            guidance_scale=forced_guidance,
+            generator=generator,
+        ).images[0]
+    yield final_image, seed, gr.update(visible=False)
+def get_huggingface_safetensors(link):
+  split_link = link.split("/")
+  if(len(split_link) == 2):
+            model_card = ModelCard.load(link)
+            base_model = model_card.data.get("base_model")
+            print(base_model)
+            # Relaxed check to allow Z-Image or Flux or others, assuming user knows what they are doing
+            # or specifically check for Z-Image-Turbo
+            if base_model not in ["Tongyi-MAI/Z-Image-Turbo", "black-forest-labs/FLUX.1-dev"]:
+                # Just a warning instead of error to allow experimentation
+                print("Warning: Base model might not match.")
+            image_path = model_card.data.get("widget", [{}])[0].get("output", {}).get("url", None)
+            trigger_word = model_card.data.get("instance_prompt", "")
+            image_url = f"https://huggingface.co/{link}/resolve/main/{image_path}" if image_path else None
+            fs = HfFileSystem()
+            try:
+                list_of_files = fs.ls(link, detail=False)
+                for file in list_of_files:
+                    if(file.endswith(".safetensors")):
+                        safetensors_name = file.split("/")[-1]
+                    if (not image_url and file.lower().endswith((".jpg", ".jpeg", ".png", ".webp"))):
+                      image_elements = file.split("/")
+                      image_url = f"https://huggingface.co/{link}/resolve/main/{image_elements[-1]}"
+            except Exception as e:
+              print(e)
+              gr.Warning(f"You didn't include a link neither a valid Hugging Face repository with a *.safetensors LoRA")
+              raise Exception(f"You didn't include a link neither a valid Hugging Face repository with a *.safetensors LoRA")
+            return split_link[1], link, safetensors_name, trigger_word, image_url
+def check_custom_model(link):
+    if(link.startswith("https://")):
+        if(link.startswith("https://huggingface.co") or link.startswith("https://www.huggingface.co")):
+            link_split = link.split("huggingface.co/")
+            return get_huggingface_safetensors(link_split[1])
+    else:
+        return get_huggingface_safetensors(link)
+def add_custom_lora(custom_lora):
+    global loras
+    if(custom_lora):
         try:
+            title, repo, path, trigger_word, image = check_custom_model(custom_lora)
+            print(f"Loaded custom LoRA: {repo}")
+            card = f'''
+            <div class="custom_lora_card">
+              <span>Loaded custom LoRA:</span>
+              <div class="card_internal">
+                <img src="{image}" />
+                <div>
+                    <h3>{title}</h3>
+                    <small>{"Using: <code><b>"+trigger_word+"</code></b> as the trigger word" if trigger_word else "No trigger word found. If there's a trigger word, include it in your prompt"}<br></small>
+                </div>
+              </div>
+            </div>
+            '''
+            existing_item_index = next((index for (index, item) in enumerate(loras) if item['repo'] == repo), None)
+            if(not existing_item_index):
+                new_item = {
+                    "image": image,
+                    "title": title,
+                    "repo": repo,
+                    "weights": path,
+                    "trigger_word": trigger_word
+                }
+                print(new_item)
+                existing_item_index = len(loras)
+                loras.append(new_item)
+            return gr.update(visible=True, value=card), gr.update(visible=True), gr.Gallery(selected_index=None), f"Custom: {path}", existing_item_index, trigger_word
+        except Exception as e:
+            gr.Warning(f"Invalid LoRA: either you entered an invalid link, or a non-supported LoRA")
+            return gr.update(visible=True, value=f"Invalid LoRA: either you entered an invalid link, a non-supported LoRA"), gr.update(visible=False), gr.update(), "", None, ""
     else:
+        return gr.update(visible=False), gr.update(visible=False), gr.update(), "", None, ""
+def remove_custom_lora():
+    return gr.update(visible=False), gr.update(visible=False), gr.update(), "", None, ""
+run_lora.zerogpu = True
+with gr.Blocks(title="Z-IMAGE GEN/LORA", delete_cache=(60, 60)) as demo:
+    gr.LoginButton(value="Option: HuggingFace 'Login' for extra GPU quota +", size="sm")
+    # HOME Button
+    gr.HTML("""
+    <div class="home-button-container">
+        <a href="https://www.humangen.ai" target="_blank" class="home-button">
+            🏠 HOME
+        </a>
+        <span class="url-display">🌐 www.humangen.ai</span>
+    </div>
+    """)
+    # Header
+    gr.HTML("""
+    <div class="header-container">
+        <div class="header-title">🎨 Z-IMAGE GEN/LORA 🎨</div>
+        <div class="header-subtitle">Generate amazing images with Z-Image Turbo and various LoRA styles!</div>
+        <div style="margin-top:12px">
+            <span class="stats-badge">⚡ Turbo Speed</span>
+            <span class="stats-badge">🎭 30+ LoRAs</span>
+            <span class="stats-badge">🖼️ High Quality</span>
+            <span class="stats-badge">🔧 Custom LoRA</span>
+        </div>
+    </div>
+    """)
+    selected_index = gr.State(None)
+    with gr.Row():
+        with gr.Column(scale=3):
+            prompt = gr.Textbox(label="Enter Prompt", lines=1, placeholder="✦︎ Choose the LoRA and type the prompt (LoRA = None → Base Model = Active)")
+        with gr.Column(scale=1, elem_id="gen_column"):
+            generate_button = gr.Button("🚀 Generate", variant="primary", elem_id="gen_btn")
+    with gr.Row():
+        with gr.Column():
+            selected_info = gr.Markdown("### No LoRA Selected (Base Model)")
+            gallery = gr.Gallery(
+                [(item["image"], item["title"]) for item in loras],
+                label="Z-Image LoRAs",
+                allow_preview=False,
+                columns=3,
+                elem_id="gallery",
+            )
+            with gr.Group():
+                custom_lora = gr.Textbox(label="Enter Custom LoRA", placeholder="Paste the LoRA path and press Enter (e.g., Shakker-Labs/AWPortrait-Z).")
+                gr.Markdown("[Check the list of Z-Image LoRA's](https://huggingface.co/models?other=base_model:adapter:Tongyi-MAI/Z-Image-Turbo)", elem_id="lora_list")
+            custom_lora_info = gr.HTML(visible=False)
+            custom_lora_button = gr.Button("Remove custom LoRA", visible=False)
+        with gr.Column():
+            progress_bar = gr.Markdown(elem_id="progress",visible=False)
+            result = gr.Image(label="Generated Image", format="png", height=630)
+    # SNS Aspect Ratio Presets
+    ASPECT_RATIOS = {
+        "1:1 (Instagram Square)": (1024, 1024),
+        "9:16 (Instagram Reels/TikTok/Shorts)": (768, 1344),
+        "16:9 (YouTube/Twitter/X)": (1344, 768),
+        "4:5 (Instagram Portrait)": (896, 1120),
+        "5:4 (Instagram Landscape)": (1120, 896),
+        "3:4 (Portrait Photo)": (896, 1152),
+        "4:3 (Landscape Photo)": (1152, 896),
+        "2:3 (Pinterest)": (832, 1248),
+        "3:2 (Classic Photo)": (1248, 832),
+        "21:9 (Cinematic Ultra-wide)": (1344, 576),
+        "9:21 (Tall Banner)": (576, 1344),
+    }
+    def update_size(aspect_ratio):
+        width, height = ASPECT_RATIOS.get(aspect_ratio, (1024, 1024))
+        return width, height
+    with gr.Row():
+        with gr.Accordion("⚙️ Advanced Settings", open=True):
+            with gr.Row():
+                input_image = gr.Image(label="Input image (Ignored for Z-Image-Turbo)", type="filepath", visible=False)
+                image_strength = gr.Slider(label="Denoise Strength", info="Ignored for Z-Image-Turbo", minimum=0.1, maximum=1.0, step=0.01, value=0.75, visible=False)
+            gr.HTML('<div class="info-box">📐 <b>Image Size</b> - Select aspect ratio for different platforms</div>')
             with gr.Row():
+                aspect_ratio = gr.Dropdown(
+                    choices=list(ASPECT_RATIOS.keys()),
+                    value="1:1 (Instagram Square)",
+                    label="📱 Aspect Ratio (SNS Presets)",
+                    info="Choose the best ratio for your target platform"
+                )
+            with gr.Row():
+                width = gr.Slider(label="Width", minimum=256, maximum=1536, step=64, value=1536)
+                height = gr.Slider(label="Height", minimum=256, maximum=1536, step=64, value=1536)
+            with gr.Column():
+                with gr.Row():
+                    cfg_scale = gr.Slider(label="CFG Scale", info="Forced to 0.0 for Turbo", minimum=0, maximum=20, step=0.5, value=0.0, interactive=False)
+                    steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=25)
+                with gr.Row():
+                    randomize_seed = gr.Checkbox(True, label="Randomize seed")
+                    seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0, randomize=True)
+                    lora_scale = gr.Slider(label="LoRA Scale", minimum=0, maximum=3, step=0.01, value=0.95)
+    # Connect aspect ratio dropdown to width/height sliders
+    aspect_ratio.change(
+        fn=update_size,
+        inputs=[aspect_ratio],
+        outputs=[width, height]
+    )
+    # Footer
+    gr.HTML("""
+    <div class="footer-comic">
+        <p style="font-family:'Bangers',cursive;font-size:1.5rem;letter-spacing:2px">🎨 Z-IMAGE GEN/LORA 🎨</p>
+        <p>Powered by Z-Image Turbo + LoRA Adapters</p>
+        <p>⚡ Fast Generation • 🎭 Multiple Styles • 🖼️ High Quality</p>
+        <p style="margin-top:10px"><a href="https://www.humangen.ai" target="_blank" style="color:#FACC15;text-decoration:none;font-weight:bold;">🏠 www.humangen.ai</a></p>
+    </div>
+    """)
+    gallery.select(
+        update_selection,
+        inputs=[width, height],
+        outputs=[prompt, selected_info, selected_index, aspect_ratio, width, height]
+    )
+    custom_lora.input(
+        add_custom_lora,
+        inputs=[custom_lora],
+        outputs=[custom_lora_info, custom_lora_button, gallery, selected_info, selected_index, prompt]
+    )
+    custom_lora_button.click(
+        remove_custom_lora,
+        outputs=[custom_lora_info, custom_lora_button, gallery, selected_info, selected_index, custom_lora]
+    )
+    gr.on(
+        triggers=[generate_button.click, prompt.submit],
+        fn=run_lora,
+        inputs=[prompt, input_image, image_strength, cfg_scale, steps, selected_index, randomize_seed, seed, width, height, lora_scale],
+        outputs=[result, seed, progress_bar]
+    )
+demo.queue()
+demo.launch(css=COMIC_CSS, ssr_mode=False, show_error=True)