thumbnail-maker 0.1.6__py3-none-any.whl

thumbnail_maker/__init__.py

@@ -0,0 +1,9 @@
+"""
+썸네일 생성기 패키지
+"""
+
+from .renderer import ThumbnailRenderer
+
+__version__ = "0.1.0"
+__all__ = ["ThumbnailRenderer"]
+

thumbnail_maker/__main__.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+thumbnail_maker: 단일 엔트리포인트 (subcommands: gui, generate-thumbnail, genthumb, upload)
+"""
+
+import sys
+import argparse
+import os
+
+from .cli import main as generate_main, main_cli as genthumb_main
+from .upload import upload_file
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog='thumbnail_maker', description='썸네일 메이커')
+    subparsers = parser.add_subparsers(dest='command', required=True)
+
+    # gui
+    subparsers.add_parser('gui', help='GUI 실행')
+
+    # generate-thumbnail (DSL만 사용)
+    gen = subparsers.add_parser('generate-thumbnail', help='DSL로 썸네일 생성')
+    gen.add_argument('dsl', nargs='?', default='thumbnail.json', help='DSL 파일 경로')
+    gen.add_argument('-o', '--output', default='thumbnail.png', help='출력 파일 경로')
+    gen.add_argument('--upload', action='store_true', help='생성 후 자동 업로드')
+
+    # genthumb (간편 CLI: 제목/부제목 덮어쓰기 등)
+    gt = subparsers.add_parser('genthumb', help='간편 CLI로 썸네일 생성')
+    gt.add_argument('dsl', nargs='?', default='thumbnail.json', help='DSL 파일 경로')
+    gt.add_argument('-o', '--output', default='thumbnail.png', help='출력 파일 경로')
+    gt.add_argument('--title', help='제목 덮어쓰기 (\\n 또는 실제 줄바꿈 지원)')
+    gt.add_argument('--subtitle', help='부제목 덮어쓰기 (\\n 또는 실제 줄바꿈 지원)')
+    gt.add_argument('--bgImg', help='배경 이미지 경로')
+    
+    # upload
+    upload_parser = subparsers.add_parser('upload', help='이미지 파일 업로드')
+    upload_parser.add_argument('file', help='업로드할 파일 경로')
+
+    args, unknown = parser.parse_known_args()
+
+    if args.command == 'gui':
+        # GUI 명령어일 때만 PySide6 관련 모듈 import
+        from .gui import main as gui_main
+        gui_main()
+        return
+
+    if args.command == 'generate-thumbnail':
+        # generate_main은 자체 argparse를 사용하므로 여기서 직접 동작 위임이 어려움
+        # 동일 기능을 직접 수행하기보다는 해당 모듈의 메인 로직을 그대로 호출하도록 유지
+        # 간단하게는 모듈 내부가 파일 인자를 읽도록 짜여 있으므로, 여기서 args를 재적용
+        # 하지만 기존 main()은 sys.argv를 파싱하므로, 안전하게 별도 경로로 수행
+        # 대신 renderer를 직접 호출하지 않고, cli.main의 구현을 차용하기 위해 임시 argv 구성
+        sys.argv = ['generate-thumbnail', args.dsl, '-o', args.output]
+        generate_main()
+        
+        # 업로드 옵션이 있으면 업로드 수행
+        if args.upload:
+            output_path = args.output
+            if not os.path.isabs(output_path):
+                output_path = os.path.abspath(output_path)
+            
+            if not os.path.exists(output_path):
+                print(f"오류: 출력 파일을 찾을 수 없습니다: {output_path}")
+                sys.exit(1)
+            
+            print(f"업로드 중: {output_path}")
+            url = upload_file(output_path)
+            if url:
+                print(f"✅ 업로드 완료: {url}")
+            else:
+                print("❌ 업로드 실패")
+                sys.exit(1)
+        return
+
+    if args.command == 'genthumb':
+        # 동일 이유로 간편 CLI도 기존 파서를 활용하기 위해 argv 재구성
+        new_argv = ['genthumb']
+        if args.dsl:
+            new_argv.append(args.dsl)
+        if args.output:
+            new_argv += ['-o', args.output]
+        if args.title:
+            new_argv += ['--title', args.title]
+        if args.subtitle:
+            new_argv += ['--subtitle', args.subtitle]
+        if args.bgImg:
+            new_argv += ['--bgImg', args.bgImg]
+        sys.argv = new_argv
+        genthumb_main()
+        return
+    
+    if args.command == 'upload':
+        file_path = args.file
+        if not os.path.exists(file_path):
+            print(f"오류: 파일을 찾을 수 없습니다: {file_path}")
+            sys.exit(1)
+        
+        print(f"업로드 중: {file_path}")
+        url = upload_file(file_path)
+        if url:
+            print(f"✅ 업로드 완료: {url}")
+        else:
+            print("❌ 업로드 실패")
+            sys.exit(1)
+        return
+
+
+if __name__ == '__main__':
+    main()
+
+

thumbnail_maker/cli.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CLI 스크립트
+"""
+
+import sys
+import os
+import json
+import argparse
+import base64
+from .renderer import ThumbnailRenderer
+import tempfile
+import zipfile
+import shutil
+
+
+def main():
+    """메인 CLI 진입점"""
+    parser = argparse.ArgumentParser(description='썸네일 생성')
+    parser.add_argument('dsl', nargs='?', default='thumbnail.json', help='DSL 파일 경로')
+    parser.add_argument('-o', '--output', default='thumbnail.png', help='출력 파일 경로')
+    
+    args = parser.parse_args()
+    staging = None
+    cwd_backup = os.getcwd()
+    # 출력 경로를 절대경로로 확보 (staging 디렉토리 변경 전)
+    output_path = args.output
+    if not os.path.isabs(output_path):
+        output_path = os.path.abspath(output_path)
+    try:
+        # .thl 패키지 지원: 임시 폴더에 풀어서 작업
+        if args.dsl.lower().endswith('.thl') and os.path.exists(args.dsl):
+            staging = tempfile.mkdtemp(prefix='thl_run_')
+            with zipfile.ZipFile(args.dsl, 'r') as zf:
+                zf.extractall(staging)
+            # 작업 디렉토리를 패키지 루트로 변경 (renderer의 'fonts/' 탐색을 위함)
+            os.chdir(staging)
+            dsl_path = os.path.join(staging, 'thumbnail.json')
+        else:
+            dsl_path = args.dsl
+
+        # DSL 파일 확인
+        if not os.path.exists(dsl_path):
+            print(f"오류: DSL 파일을 찾을 수 없습니다: {dsl_path}")
+            sys.exit(1)
+        
+        # DSL 읽기
+        with open(dsl_path, 'r', encoding='utf-8') as f:
+            dsl = json.load(f)
+        
+        # 썸네일 생성
+        ThumbnailRenderer.render_thumbnail(dsl, output_path)
+    finally:
+        try:
+            os.chdir(cwd_backup)
+        except Exception:
+            pass
+        if staging:
+            shutil.rmtree(staging, ignore_errors=True)
+
+
+def main_cli():
+    """간편 CLI 진입점"""
+    parser = argparse.ArgumentParser(description='썸네일 생성 (간편 CLI)')
+    parser.add_argument('dsl', nargs='?', default='thumbnail.json', help='DSL 파일 경로')
+    parser.add_argument('-o', '--output', default='thumbnail.png', help='출력 파일 경로')
+    parser.add_argument('--title', help='제목 덮어쓰기 (\\n 또는 실제 줄바꿈 지원)')
+    parser.add_argument('--subtitle', help='부제목 덮어쓰기 (\\n 또는 실제 줄바꿈 지원)')
+    parser.add_argument('--bgImg', help='배경 이미지 경로')
+    
+    args = parser.parse_args()
+
+    def normalize_text(s: str) -> str:
+        """CLI에서 전달된 텍스트의 줄바꿈 시퀀스를 실제 줄바꿈으로 변환"""
+        if s is None:
+            return s
+        # 리터럴 \n, \r\n, \r 처리
+        # 먼저 \r\n -> \n 으로 통일, 이후 리터럴 역슬래시-n 치환
+        s = s.replace('\r\n', '\n').replace('\r', '\n')
+        s = s.replace('\\n', '\n')
+        return s
+    
+    staging = None
+    cwd_backup = os.getcwd()
+    # 출력 경로를 절대경로로 확보 (staging 디렉토리 변경 전)
+    output_path = args.output
+    if not os.path.isabs(output_path):
+        output_path = os.path.abspath(output_path)
+    try:
+        # .thl 패키지 지원
+        if args.dsl and args.dsl.lower().endswith('.thl') and os.path.exists(args.dsl):
+            staging = tempfile.mkdtemp(prefix='thl_run_')
+            with zipfile.ZipFile(args.dsl, 'r') as zf:
+                zf.extractall(staging)
+            os.chdir(staging)
+            dsl_path = os.path.join(staging, 'thumbnail.json')
+        else:
+            dsl_path = args.dsl
+
+        # DSL 파일 확인
+        if not os.path.exists(dsl_path):
+            print(f"오류: DSL 파일을 찾을 수 없습니다: {dsl_path}")
+            sys.exit(1)
+
+        # DSL 읽기
+        with open(dsl_path, 'r', encoding='utf-8') as f:
+            dsl = json.load(f)
+        
+        # 배경 이미지 처리
+        if args.bgImg and os.path.exists(args.bgImg):
+            with open(args.bgImg, 'rb') as f:
+                image_data = f.read()
+                base64_str = base64.b64encode(image_data).decode('utf-8')
+                data_url = f"data:image/png;base64,{base64_str}"
+                
+                dsl['Thumbnail']['Background']['type'] = 'image'
+                dsl['Thumbnail']['Background']['imagePath'] = data_url
+        
+        # 제목/부제목 덮어쓰기
+        if 'Texts' in dsl.get('Thumbnail', {}):
+            for txt in dsl['Thumbnail']['Texts']:
+                if args.title and txt.get('type') == 'title':
+                    txt['content'] = normalize_text(args.title)
+                if args.subtitle and txt.get('type') == 'subtitle':
+                    txt['content'] = normalize_text(args.subtitle)
+        
+        # 썸네일 생성
+        ThumbnailRenderer.render_thumbnail(dsl, output_path)
+    finally:
+        try:
+            os.chdir(cwd_backup)
+        except Exception:
+            pass
+        if staging:
+            shutil.rmtree(staging, ignore_errors=True)
+
+
+if __name__ == '__main__':
+    main()

thumbnail_maker/gui/__init__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+GUI 모듈 - 썸네일 생성 GUI 애플리케이션
+"""
+
+from .main_window import main
+
+__all__ = ['main']
+

thumbnail_maker/gui/dsl_manager.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+DSL 생성, 로드, 저장 관리 모듈
+"""
+
+import json
+import os
+import base64
+import tempfile
+import zipfile
+import shutil
+from typing import Dict
+
+from ..renderer import ThumbnailRenderer, sanitize
+
+
+class DSLManager:
+    """DSL 관리 클래스"""
+    
+    @staticmethod
+    def generate_dsl(gui) -> Dict:
+        """GUI 위젯에서 DSL 생성"""
+        # 해상도 결정
+        res_mode = gui.res_mode.currentText()
+        if res_mode == 'preset':
+            resolution = {
+                'type': 'preset',
+                'value': gui.aspect_ratio.currentText()
+            }
+        elif res_mode == 'fixedRatio':
+            resolution = {
+                'type': 'fixedRatio',
+                'ratioValue': gui.aspect_ratio.currentText(),
+                'width': gui.width_spin.value()
+            }
+        else:  # custom
+            resolution = {
+                'type': 'custom',
+                'width': gui.width_spin.value(),
+                'height': gui.height_spin.value()
+            }
+        
+        # 배경 결정
+        bg_type = gui.bg_type.currentText()
+        if bg_type == 'image' and gui.bg_image_path.text():
+            # 이미지를 base64로 변환
+            with open(gui.bg_image_path.text(), 'rb') as f:
+                image_data = f.read()
+                base64_str = base64.b64encode(image_data).decode('utf-8')
+                data_url = f"data:image/png;base64,{base64_str}"
+                
+            background = {
+                'type': 'image',
+                'imagePath': data_url,
+                'imageOpacity': gui.bg_opacity.value() / 100.0,
+                'imageBlur': gui.bg_blur.value()
+            }
+        elif bg_type == 'gradient':
+            background = {
+                'type': 'gradient',
+                'colors': [gui.bg_color, '#000000']
+            }
+        else:  # solid
+            background = {
+                'type': 'solid',
+                'color': gui.bg_color
+            }
+        
+        # 텍스트 설정
+        # 제목 폰트 소스 분기
+        title_use_local = gui.title_font_source.currentText() == '로컬 폰트 파일'
+        title_face_url = gui.title_font_file.text() if title_use_local and gui.title_font_file.text() else (gui.title_font_url.text() or 'https://fastly.jsdelivr.net/gh/projectnoonnu/noonfonts_2108@1.1/SBAggroB.woff')
+        # 부제목 폰트 소스 분기
+        subtitle_use_local = gui.subtitle_font_source.currentText() == '로컬 폰트 파일'
+        subtitle_face_url = gui.subtitle_font_file.text() if subtitle_use_local and gui.subtitle_font_file.text() else (gui.subtitle_font_url.text() or 'https://fastly.jsdelivr.net/gh/projectnoonnu/noonfonts_2108@1.1/SBAggroB.woff')
+
+        texts = [
+            {
+                'type': 'title',
+                'content': gui.title_text.toPlainText(),
+                'gridPosition': gui.title_position.currentText(),
+                'font': {
+                    'name': gui.title_font_name.text() or 'SBAggroB',
+                    'faces': [{
+                        'name': gui.title_font_name.text() or 'SBAggroB',
+                        'url': title_face_url,
+                        'weight': gui.title_font_weight.currentText() or 'bold',
+                        'style': gui.title_font_style.currentText() or 'normal'
+                    }]
+                },
+                'fontSize': gui.title_font_size.value(),
+                'color': gui.title_color,
+                'fontWeight': gui.title_font_weight.currentText() or 'bold',
+                'fontStyle': gui.title_font_style.currentText() or 'normal',
+                'lineHeight': 1.1,
+                'wordWrap': gui.title_word_wrap.isChecked(),
+                'outline': {
+                    'thickness': gui.title_outline_thickness.value(),
+                    'color': '#000000'
+                } if gui.title_outline_check.isChecked() else None,
+                'enabled': True
+            }
+        ]
+        
+        # 부제목 추가 (체크 여부와 관계없이 항상 추가하되, enabled 필드로 제어)
+        texts.append({
+            'type': 'subtitle',
+            'content': gui.subtitle_text.toPlainText(),
+            'gridPosition': gui.subtitle_position.currentText(),
+            'font': {
+                'name': gui.subtitle_font_name.text() or 'SBAggroB',
+                'faces': [{
+                    'name': gui.subtitle_font_name.text() or 'SBAggroB',
+                    'url': subtitle_face_url,
+                    'weight': gui.subtitle_font_weight.currentText() or 'normal',
+                    'style': gui.subtitle_font_style.currentText() or 'normal'
+                }]
+            },
+            'fontSize': gui.subtitle_font_size.value(),
+            'color': gui.subtitle_color,
+            'fontWeight': gui.subtitle_font_weight.currentText() or 'normal',
+            'fontStyle': gui.subtitle_font_style.currentText() or 'normal',
+            'lineHeight': 1.1,
+            'wordWrap': gui.subtitle_word_wrap.isChecked(),
+            'outline': None,
+            'enabled': gui.subtitle_visible.isChecked()
+        })
+        
+        dsl = {
+            'Thumbnail': {
+                'Resolution': resolution,
+                'Background': background,
+                'Texts': texts
+            },
+            'TemplateMeta': {
+                'name': '',
+                'shareable': False
+            }
+        }
+        
+        return dsl
+    
+    @staticmethod
+    def load_dsl_to_gui(gui, dsl: Dict):
+        """DSL 데이터를 GUI 위젯에 로드"""
+        thumbnail = dsl.get('Thumbnail', {})
+        
+        # 해상도 설정
+        resolution = thumbnail.get('Resolution', {})
+        res_type = resolution.get('type', 'preset')
+        gui.res_mode.setCurrentText(res_type)
+        
+        if res_type == 'preset':
+            gui.aspect_ratio.setCurrentText(resolution.get('value', '16:9'))
+        elif res_type == 'fixedRatio':
+            gui.aspect_ratio.setCurrentText(resolution.get('ratioValue', '16:9'))
+            gui.width_spin.setValue(resolution.get('width', 480))
+        else:  # custom
+            gui.width_spin.setValue(resolution.get('width', 480))
+            gui.height_spin.setValue(resolution.get('height', 270))
+        
+        # 배경 설정
+        background = thumbnail.get('Background', {})
+        bg_type = background.get('type', 'solid')
+        gui.bg_type.setCurrentText(bg_type)
+        
+        if bg_type == 'solid':
+            gui.bg_color = background.get('color', '#a3e635')
+        elif bg_type == 'gradient':
+            colors = background.get('colors', [])
+            if colors:
+                gui.bg_color = colors[0]
+        elif bg_type == 'image':
+            img_path = background.get('imagePath', '')
+            if img_path.startswith('data:image'):
+                # base64 이미지는 임시 파일로 저장
+                header, encoded = img_path.split(',', 1)
+                image_data = base64.b64decode(encoded)
+                temp_path = os.path.join(tempfile.gettempdir(), 'thl_temp_bg.png')
+                with open(temp_path, 'wb') as f:
+                    f.write(image_data)
+                gui.bg_image_path.setText(temp_path)
+            else:
+                gui.bg_image_path.setText(img_path)
+            gui.bg_opacity.setValue(int(background.get('imageOpacity', 1.0) * 100))
+            gui.bg_blur.setValue(background.get('imageBlur', 0))
+        
+        # 텍스트 설정
+        texts = thumbnail.get('Texts', [])
+        subtitle_found = False
+        for txt in texts:
+            txt_type = txt.get('type')
+            if txt_type == 'title':
+                gui.title_text.setPlainText(txt.get('content', ''))
+                gui.title_position.setCurrentText(txt.get('gridPosition', 'tl'))
+                gui.title_font_size.setValue(txt.get('fontSize', 48))
+                gui.title_color = txt.get('color', '#4ade80')
+                
+                font = txt.get('font', {})
+                font_name = font.get('name', 'SBAggroB')
+                gui.title_font_name.setText(font_name)
+                
+                faces = font.get('faces', [])
+                if faces:
+                    face = faces[0]
+                    url = face.get('url', '')
+                    if url and os.path.exists(url):
+                        # 로컬 파일
+                        gui.title_font_source.setCurrentText('로컬 폰트 파일')
+                        gui.title_font_file.setText(url)
+                    else:
+                        # 웹 URL
+                        gui.title_font_source.setCurrentText('웹 폰트 URL')
+                        gui.title_font_url.setText(url)
+                    
+                    gui.title_font_weight.setCurrentText(face.get('weight', 'bold'))
+                    gui.title_font_style.setCurrentText(face.get('style', 'normal'))
+                
+                outline = txt.get('outline')
+                if outline:
+                    gui.title_outline_check.setChecked(True)
+                    gui.title_outline_thickness.setValue(outline.get('thickness', 7))
+                else:
+                    gui.title_outline_check.setChecked(False)
+                
+                gui.title_word_wrap.setChecked(txt.get('wordWrap', False))
+                
+            elif txt_type == 'subtitle':
+                subtitle_found = True
+                # enabled 필드를 확인하여 체크박스 상태 설정
+                enabled = txt.get('enabled', True)
+                gui.subtitle_visible.setChecked(enabled)
+                gui.subtitle_text.setPlainText(txt.get('content', ''))
+                gui.subtitle_position.setCurrentText(txt.get('gridPosition', 'bl'))
+                gui.subtitle_font_size.setValue(txt.get('fontSize', 24))
+                gui.subtitle_color = txt.get('color', '#ffffff')
+                
+                font = txt.get('font', {})
+                font_name = font.get('name', 'SBAggroB')
+                gui.subtitle_font_name.setText(font_name)
+                
+                faces = font.get('faces', [])
+                if faces:
+                    face = faces[0]
+                    url = face.get('url', '')
+                    if url and os.path.exists(url):
+                        # 로컬 파일
+                        gui.subtitle_font_source.setCurrentText('로컬 폰트 파일')
+                        gui.subtitle_font_file.setText(url)
+                    else:
+                        # 웹 URL
+                        gui.subtitle_font_source.setCurrentText('웹 폰트 URL')
+                        gui.subtitle_font_url.setText(url)
+                    
+                    gui.subtitle_font_weight.setCurrentText(face.get('weight', 'normal'))
+                    gui.subtitle_font_style.setCurrentText(face.get('style', 'normal'))
+                
+                gui.subtitle_word_wrap.setChecked(txt.get('wordWrap', False))
+        
+        # 부제목이 DSL에 없으면 체크 해제
+        if not subtitle_found:
+            gui.subtitle_visible.setChecked(False)
+        
+        # 미리보기 업데이트
+        gui.update_preview()
+    
+    @staticmethod
+    def save_thl_package(gui, file_path: str):
+        """현재 DSL과 사용 폰트를 묶어 .thl 패키지로 저장"""
+        if not hasattr(gui, 'current_dsl'):
+            gui.update_preview()
+        dsl = getattr(gui, 'current_dsl', DSLManager.generate_dsl(gui))
+        
+        staging = None
+        try:
+            # 스테이징 디렉토리 구성
+            staging = tempfile.mkdtemp(prefix='thl_pkg_')
+            fonts_dir = os.path.join(staging, 'fonts')
+            os.makedirs(fonts_dir, exist_ok=True)
+
+            # 폰트 확보 및 복사
+            texts = dsl.get('Thumbnail', {}).get('Texts', [])
+            try:
+                # 프로젝트/fonts에 TTF 생성/보장
+                ThumbnailRenderer.ensure_fonts(texts)
+            except Exception as e:
+                print(f"폰트 확보 경고: {e}")
+
+            # faces를 순회하여 예상 파일명으로 복사
+            faces = ThumbnailRenderer.parse_font_faces(texts)
+            for face in faces:
+                ttf_name = f"{sanitize(face.get('name','Font'))}-{sanitize(str(face.get('weight','normal')))}-{sanitize(str(face.get('style','normal')))}.ttf"
+                src_path = os.path.join(ThumbnailRenderer._fonts_dir(), ttf_name)
+                if os.path.exists(src_path):
+                    shutil.copy2(src_path, os.path.join(fonts_dir, ttf_name))
+
+            # thumbnail.json 저장 (원본 DSL 그대로)
+            with open(os.path.join(staging, 'thumbnail.json'), 'w', encoding='utf-8') as f:
+                json.dump(dsl, f, ensure_ascii=False, indent=2)
+
+            # zip -> .thl
+            with zipfile.ZipFile(file_path, 'w', compression=zipfile.ZIP_DEFLATED) as zf:
+                # 루트에 thumbnail.json
+                zf.write(os.path.join(staging, 'thumbnail.json'), arcname='thumbnail.json')
+                # fonts 폴더
+                if os.path.isdir(fonts_dir):
+                    for name in os.listdir(fonts_dir):
+                        zf.write(os.path.join(fonts_dir, name), arcname=os.path.join('fonts', name))
+        finally:
+            if staging:
+                shutil.rmtree(staging, ignore_errors=True)
+    
+    @staticmethod
+    def load_thl_package(gui, file_path: str) -> Dict:
+        """.thl 패키지를 로드하여 DSL 반환"""
+        staging = None
+        cwd_backup = os.getcwd()
+        try:
+            # .thl 파일을 임시 디렉토리에 압축 해제
+            staging = tempfile.mkdtemp(prefix='thl_load_')
+            with zipfile.ZipFile(file_path, 'r') as zf:
+                zf.extractall(staging)
+            
+            # thumbnail.json 읽기
+            dsl_path = os.path.join(staging, 'thumbnail.json')
+            if not os.path.exists(dsl_path):
+                raise FileNotFoundError('패키지에 thumbnail.json이 없습니다.')
+            
+            with open(dsl_path, 'r', encoding='utf-8') as f:
+                dsl = json.load(f)
+            
+            # 폰트 파일을 프로젝트 fonts 디렉토리로 복사
+            fonts_src_dir = os.path.join(staging, 'fonts')
+            if os.path.isdir(fonts_src_dir):
+                fonts_dst_dir = ThumbnailRenderer._fonts_dir()
+                os.makedirs(fonts_dst_dir, exist_ok=True)
+                for font_file in os.listdir(fonts_src_dir):
+                    src_path = os.path.join(fonts_src_dir, font_file)
+                    dst_path = os.path.join(fonts_dst_dir, font_file)
+                    shutil.copy2(src_path, dst_path)
+            
+            return dsl
+        finally:
+            try:
+                os.chdir(cwd_backup)
+            except Exception:
+                pass
+            if staging:
+                shutil.rmtree(staging, ignore_errors=True)
+

thumbnail_maker/gui/font_utils.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+폰트 관련 유틸리티 함수
+"""
+
+import os
+
+try:
+    from fontTools.ttLib import TTFont
+except Exception:
+    TTFont = None
+
+
+def infer_font_name_from_file(file_path: str) -> str:
+    """파일 경로에서 폰트 이름 추출"""
+    try:
+        ext = os.path.splitext(file_path)[1].lower()
+        if TTFont and ext in ('.ttf', '.otf') and os.path.exists(file_path):
+            tt = TTFont(file_path)
+            # Prefer full font name (nameID=4), fallback to font family (nameID=1)
+            name = None
+            for rec in tt['name'].names:
+                if rec.nameID in (4, 1):
+                    try:
+                        val = rec.toUnicode()
+                    except Exception:
+                        val = rec.string.decode(rec.getEncoding(), errors='ignore')
+                    if val:
+                        name = val
+                        if rec.nameID == 4:
+                            break
+            if name:
+                return name
+    except Exception:
+        pass
+    # Fallback: 파일명(확장자 제외)
+    return os.path.splitext(os.path.basename(file_path))[0]
+