Update app.py

app.py

@@ -26,54 +26,59 @@ import os
 import sys
 from datetime import datetime
 
-# Configuration
+# 설정
 PEER_ID = f"peer-{os.getenv('COMPUTERNAME', 'unknown')}-{datetime.now().strftime('%Y%m%d%H%M%S')}"
-SERVER_URL = "https://your-username-your-space.hf.space"  # Replace with actual Space URL
+SERVER_URL = "https://your-username-your-space.hf.space"  # 실제 Space URL로 변경하세요
 
 def check_gpu():
-    """Check GPU availability"""
+    """GPU 사용 가능 여부 확인"""
     try:
         result = subprocess.run(['nvidia-smi', '--query-gpu=utilization.gpu', '--format=csv,noheader,nounits'], 
                               capture_output=True, text=True)
         if result.returncode == 0:
             gpu_usage = int(result.stdout.strip())
-            return gpu_usage < 20  # GPU is idle if usage < 20%
+            return gpu_usage < 20  # GPU 사용률 20% 미만이면 idle
     except:
-        print("GPU not found. Running in CPU mode.")
+        print("GPU를 찾을 수 없습니다. CPU 모드로 실행됩니다.")
         return False
 
 def register_peer():
-    """Register peer with server"""
+    """서버에 Peer 등록"""
     try:
         response = requests.post(f"{SERVER_URL}/api/peers/register", params={"peer_id": PEER_ID})
         if response.status_code == 200:
-            print(f"✅ Peer registered: {PEER_ID}")
+            print(f"✅ Peer 등록 성공: {PEER_ID}")
             return True
     except Exception as e:
-        print(f"❌ Server connection failed: {e}")
+        print(f"❌ 서버 연결 실패: {e}")
     return False
 
 def generate_image_cpu(prompt, output_path):
-    """Generate test image using CPU"""
+    """CPU로 테스트 이미지 생성"""
     from PIL import Image, ImageDraw, ImageFont
     
     img = Image.new('RGB', (512, 512), color='white')
     draw = ImageDraw.Draw(img)
     
-    # Draw prompt text
+    # 텍스트 그리기
     text = f"Prompt: {prompt[:50]}..."
     draw.text((10, 10), text, fill='black')
     draw.text((10, 40), f"Generated by: {PEER_ID}", fill='gray')
     draw.text((10, 70), f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", fill='gray')
     
+    # 테스트 패턴 그리기
+    for i in range(0, 512, 32):
+        draw.line([(i, 0), (i, 512)], fill='lightgray')
+        draw.line([(0, i), (512, i)], fill='lightgray')
+    
     img.save(output_path)
-    print(f"📝 Test image generated: {output_path}")
+    print(f"📝 테스트 이미지 생성 완료: {output_path}")
 
 def main():
-    print("🚀 Starting P2P GPU Client...")
+    print("🚀 P2P GPU 클라이언트 시작...")
     
     if not register_peer():
-        print("Server registration failed. Exiting.")
+        print("서버 등록 실패. 프로그램을 종료합니다.")
         return
     
     while True:
@@ -81,7 +86,7 @@ def main():
             # Heartbeat
             requests.post(f"{SERVER_URL}/api/peers/heartbeat", params={"peer_id": PEER_ID})
             
-            # Request job
+            # 작업 요청
             response = requests.get(f"{SERVER_URL}/api/jobs/request", params={"peer_id": PEER_ID})
             if response.status_code == 200:
                 job_data = response.json()
@@ -91,20 +96,20 @@ def main():
                     job_id = job["id"]
                     prompt = job["prompt"]
                     
-                    print(f"\\n📋 New job received: {prompt}")
+                    print(f"\\n📋 새 작업 수신: {prompt}")
                     
-                    # Generate image
+                    # 이미지 생성
                     output_path = f"{job_id}.png"
                     
                     if check_gpu():
-                        print("🎮 Generating with GPU...")
-                        # Actual GPU generation code would go here
+                        print("🎮 GPU 모드로 생성 중...")
+                        # 실제 GPU 생성 코드가 여기 들어갑니다
                         generate_image_cpu(prompt, output_path)
                     else:
-                        print("💻 Generating with CPU...")
+                        print("💻 CPU 모드로 생성 중...")
                         generate_image_cpu(prompt, output_path)
                     
-                    # Upload result
+                    # 결과 업로드
                     with open(output_path, 'rb') as f:
                         files = {'file': (output_path, f, 'image/png')}
                         response = requests.post(
@@ -114,26 +119,26 @@ def main():
                         )
                     
                     if response.status_code == 200:
-                        print("✅ Result uploaded successfully")
+                        print("✅ 결과 업로드 성공")
                     
-                    # Clean up
+                    # 임시 파일 삭제
                     os.remove(output_path)
             
-            time.sleep(10)  # Check every 10 seconds
+            time.sleep(10)  # 10초마다 확인
             
         except KeyboardInterrupt:
-            print("\\n👋 Shutting down")
+            print("\\n👋 프로그램 종료")
             break
         except Exception as e:
-            print(f"⚠️ Error: {e}")
+            print(f"⚠️ 오류 발생: {e}")
             time.sleep(30)
 
 if __name__ == "__main__":
-    # Check required packages
+    # 필요한 패키지 확인
     try:
         import PIL
     except ImportError:
-        print("Installing required packages...")
+        print("필요한 패키지를 설치합니다...")
         subprocess.run([sys.executable, "-m", "pip", "install", "pillow", "requests"])
     
     main()
@@ -147,34 +152,34 @@ with open("client/requirements.txt", "w") as f:
     f.write("requests\npillow\n")
 
 with open("client/README.md", "w", encoding="utf-8") as f:
-    f.write("""# P2P GPU Client for Windows
+    f.write("""# P2P GPU 클라이언트 (Windows)
 
-## Installation
-1. Install Python 3.8+
-2. Run `pip install -r requirements.txt`
-3. Update SERVER_URL in `peer_agent.py` with actual Hugging Face Space URL
-4. Run `python peer_agent.py`
+## 설치 방법
+1. Python 3.8 이상 설치
+2. `pip install -r requirements.txt` 실행
+3. `peer_agent.py` 파일의 SERVER_URL을 실제 Hugging Face Space URL로 수정
+4. `python peer_agent.py` 실행
 
-## GPU Support
-- Automatically detects NVIDIA GPU if available
-- Falls back to CPU mode for testing
+## GPU 지원
+- NVIDIA GPU가 있으면 자동으로 감지
+- GPU가 없으면 CPU 모드로 테스트 이미지 생성
 """)
 
 # FastAPI app with lifespan
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     # Startup
-    print("Starting P2P GPU Hub...")
+    print("P2P GPU Hub 시작...")
     yield
     # Shutdown
-    print("Shutting down P2P GPU Hub...")
+    print("P2P GPU Hub 종료...")
 
 app = FastAPI(lifespan=lifespan)
 
 # API endpoints
 @app.get("/api/status")
 async def get_status():
-    """Get system status"""
+    """시스템 상태 조회"""
     active_peers = sum(1 for p in peers.values() 
                       if (datetime.now() - p['last_seen']).seconds < 60)
     pending_jobs = sum(1 for j in jobs if j['status'] == 'pending')
@@ -194,7 +199,7 @@ async def get_status():
 
 @app.post("/api/peers/register")
 async def register_peer(peer_id: str):
-    """Register a peer"""
+    """Peer 등록"""
     peers[peer_id] = {
         "status": "idle",
         "last_seen": datetime.now(),
@@ -204,7 +209,7 @@ async def register_peer(peer_id: str):
 
 @app.post("/api/peers/heartbeat")
 async def heartbeat(peer_id: str):
-    """Update peer status"""
+    """Peer 상태 업데이트"""
     if peer_id in peers:
         peers[peer_id]["last_seen"] = datetime.now()
         return {"status": "alive"}
@@ -212,7 +217,7 @@ async def heartbeat(peer_id: str):
 
 @app.post("/api/jobs/submit")
 async def submit_job(request: Request):
-    """Submit a job"""
+    """작업 제출"""
     data = await request.json()
     job_id = str(uuid.uuid4())
     job = {
@@ -226,7 +231,7 @@ async def submit_job(request: Request):
 
 @app.get("/api/jobs/request")
 async def request_job(peer_id: str):
-    """Request a job for processing"""
+    """작업 요청"""
     for job in jobs:
         if job["status"] == "pending":
             job["status"] = "assigned"
@@ -238,7 +243,7 @@ async def request_job(peer_id: str):
 
 @app.post("/api/jobs/result")
 async def submit_result(job_id: str, file: UploadFile = File(...)):
-    """Submit job result"""
+    """작업 결과 제출"""
     filename = f"{job_id}.png"
     file_path = f"results/{filename}"
     
@@ -259,7 +264,7 @@ async def submit_result(job_id: str, file: UploadFile = File(...)):
 
 @app.get("/api/results/{filename}")
 async def get_result(filename: str):
-    """Get generated image"""
+    """생성된 이미지 조회"""
     file_path = f"results/{filename}"
     if os.path.exists(file_path):
         return FileResponse(file_path)
@@ -267,7 +272,7 @@ async def get_result(filename: str):
 
 @app.get("/api/client/{filename}")
 async def get_client_file(filename: str):
-    """Download client file"""
+    """클라이언트 파일 다운로드"""
     file_path = f"client/{filename}"
     if os.path.exists(file_path):
         return FileResponse(file_path, filename=filename)
@@ -275,9 +280,9 @@ async def get_client_file(filename: str):
 
 # Gradio interface functions
 def gradio_submit_job(prompt):
-    """Submit job through Gradio"""
+    """Gradio를 통한 작업 제출"""
     if not prompt:
-        return "Please enter a prompt"
+        return "프롬프트를 입력해주세요."
     
     job_id = str(uuid.uuid4())
     job = {
@@ -287,34 +292,40 @@ def gradio_submit_job(prompt):
         "created_at": datetime.now()
     }
     jobs.append(job)
-    return f"Job submitted successfully! Job ID: {job_id}"
+    return f"✅ 작업이 제출되었습니다!\n작업 ID: {job_id[:8]}..."
 
 def gradio_get_status():
-    """Get status through Gradio"""
+    """Gradio를 통한 상태 조회"""
     active_peers = sum(1 for p in peers.values() 
                       if (datetime.now() - p['last_seen']).seconds < 60)
     pending = sum(1 for j in jobs if j['status'] == 'pending')
     completed = sum(1 for j in jobs if j['status'] == 'completed')
     
-    status_text = f"""### System Status
-- Active Peers: {active_peers}
-- Pending Jobs: {pending}
-- Completed Jobs: {completed}
+    status_text = f"""## 📊 시스템 상태
+
+### 현재 상황
+- **활성 Peer**: {active_peers}개
+- **대기중 작업**: {pending}개
+- **완료된 작업**: {completed}개
 
-### Recent Jobs
+### 최근 작업 목록
 """
     
     # Add recent jobs
     recent_jobs = jobs[-5:][::-1]  # Last 5 jobs, reversed
-    for job in recent_jobs:
-        status_text += f"\n- **{job['id'][:8]}...**: {job['prompt'][:50]}... ({job['status']})"
+    if recent_jobs:
+        for job in recent_jobs:
+            status_emoji = "✅" if job['status'] == 'completed' else "⏳" if job['status'] == 'pending' else "🔄"
+            status_text += f"\n{status_emoji} **{job['id'][:8]}**: {job['prompt'][:50]}... ({job['status']})"
+    else:
+        status_text += "\n아직 작업이 없습니다."
     
     return status_text
 
 def gradio_get_gallery():
-    """Get completed images for gallery"""
+    """갤러리용 이미지 가져오기"""
     image_files = []
-    for job in jobs[-20:]:  # Last 20 jobs
+    for job in jobs[-20:][::-1]:  # Last 20 jobs, newest first
         if job['status'] == 'completed' and 'filename' in job:
             file_path = f"results/{job['filename']}"
             if os.path.exists(file_path):
@@ -322,89 +333,152 @@ def gradio_get_gallery():
     
     return image_files
 
+# Custom CSS
+custom_css = """
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+}
+#gallery {
+    min-height: 400px;
+}
+.gradio-container {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+}
+"""
+
 # Create Gradio interface
-with gr.Blocks(title="P2P GPU Image Generation Hub") as demo:
-    gr.Markdown("# 🤖 P2P GPU Image Generation Hub")
-    gr.Markdown("Distributed image generation using idle GPUs from peer nodes")
+with gr.Blocks(title="P2P GPU 이미지 생성 허브", css=custom_css, theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🤖 P2P GPU 이미지 생성 허브")
+    gr.Markdown("유휴 GPU를 활용한 분산 이미지 생성 시스템")
     
     with gr.Tabs():
-        with gr.Tab("Submit Job"):
+        with gr.Tab("🎨 작업 제출"):
             with gr.Row():
-                with gr.Column():
+                with gr.Column(scale=2):
                     prompt_input = gr.Textbox(
-                        label="Image Prompt", 
-                        placeholder="Describe the image you want to generate...",
-                        lines=3
+                        label="이미지 프롬프트", 
+                        placeholder="생성하고 싶은 이미지를 설명해주세요...\n예: 푸른 하늘 아래 벚꽃이 만개한 공원",
+                        lines=4
                     )
-                    submit_btn = gr.Button("Submit Job", variant="primary")
-                    result_text = gr.Textbox(label="Result", interactive=False)
+                    with gr.Row():
+                        submit_btn = gr.Button("작업 제출", variant="primary", scale=2)
+                        clear_btn = gr.Button("지우기", scale=1)
                     
-                    submit_btn.click(
-                        fn=gradio_submit_job, 
-                        inputs=prompt_input, 
-                        outputs=result_text
+                    result_text = gr.Textbox(
+                        label="제출 결과", 
+                        interactive=False,
+                        lines=2
                     )
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    ### 💡 사용 방법
+                    1. 원하는 이미지를 설명하세요
+                    2. '작업 제출' 버튼을 클릭
+                    3. Peer가 작업을 처리합니다
+                    4. 갤러리에서 결과 확인
+                    
+                    ### 🎯 좋은 프롬프트 예시
+                    - 구체적인 설명 포함
+                    - 스타일이나 분위기 명시
+                    - 색상, 조명 등 세부사항
+                    """)
+            
+            submit_btn.click(
+                fn=gradio_submit_job, 
+                inputs=prompt_input, 
+                outputs=result_text
+            )
+            clear_btn.click(
+                fn=lambda: ("", ""),
+                outputs=[prompt_input, result_text]
+            )
         
-        with gr.Tab("System Status"):
+        with gr.Tab("📊 시스템 상태"):
             status_display = gr.Markdown()
-            refresh_btn = gr.Button("Refresh Status")
+            with gr.Row():
+                refresh_btn = gr.Button("🔄 새로고침", variant="secondary")
+                auto_refresh = gr.Checkbox(label="자동 새로고침 (10초)", value=True)
             
             refresh_btn.click(
                 fn=gradio_get_status, 
                 outputs=status_display
             )
             
-            # Auto-refresh status on load
+            # Auto-refresh status
             demo.load(fn=gradio_get_status, outputs=status_display)
         
-        with gr.Tab("Gallery"):
+        with gr.Tab("🖼️ 갤러리"):
+            gr.Markdown("### 최근 생성된 이미지들")
             gallery = gr.Gallery(
-                label="Generated Images",
-                show_label=True,
+                label="생성된 이미지",
+                show_label=False,
                 elem_id="gallery",
-                columns=3,
-                rows=2,
-                height="auto"
+                columns=4,
+                rows=3,
+                height="auto",
+                object_fit="contain",
+                preview=True
             )
-            refresh_gallery_btn = gr.Button("Refresh Gallery")
+            refresh_gallery_btn = gr.Button("🔄 갤러리 새로고침", variant="secondary")
             
             refresh_gallery_btn.click(
                 fn=gradio_get_gallery,
                 outputs=gallery
             )
             
-            # Auto-load gallery on tab load
+            # Auto-load gallery
             demo.load(fn=gradio_get_gallery, outputs=gallery)
         
-        with gr.Tab("Download Client"):
+        with gr.Tab("💻 클라이언트 다운로드"):
             gr.Markdown("""
-            ## Windows Client Setup
+            ## Windows 클라이언트 설정 가이드
             
-            1. Download the client files:
-               - [peer_agent.py](/api/client/peer_agent.py)
-               - [requirements.txt](/api/client/requirements.txt)
-               - [README.md](/api/client/README.md)
+            ### 📥 1단계: 파일 다운로드
+            다음 파일들을 다운로드하세요:
+            - [peer_agent.py](/api/client/peer_agent.py) - 메인 클라이언트
+            - [requirements.txt](/api/client/requirements.txt) - 필요한 패키지 목록
+            - [README.md](/api/client/README.md) - 설명서
             
-            2. Install Python 3.8 or higher
+            ### 🐍 2단계: Python 설치
+            - Python 3.8 이상 버전 필요
+            - [python.org](https://python.org)에서 다운로드
             
-            3. Install requirements:
-               ```bash
-               pip install -r requirements.txt
-               ```
+            ### 📦 3단계: 패키지 설치
+            ```bash
+            pip install -r requirements.txt
+            ```
             
-            4. Update the SERVER_URL in peer_agent.py with this Space's URL
+            ### ⚙️ 4단계: 설정
+            `peer_agent.py` 파일을 열고 SERVER_URL을 이 Space의 URL로 변경:
+            ```python
+            SERVER_URL = "https://당신의-space-url.hf.space"
+            ```
             
-            5. Run the client:
-               ```bash
-               python peer_agent.py
-               ```
+            ### 🚀 5단계: 실행
+            ```bash
+            python peer_agent.py
+            ```
             
-            The client will automatically detect GPU availability and start processing jobs.
+            ### ✨ 특징
+            - GPU 자동 감지
+            - CPU 폴백 지원
+            - 자동 작업 처리
+            - 10초마다 새 작업 확인
             """)
+            
+            with gr.Row():
+                gr.Markdown("""
+                ### 🎮 GPU 지원
+                - NVIDIA GPU가 있으면 자동으로 활용
+                - GPU가 없어도 CPU로 테스트 가능
+                - GPU 사용률 20% 미만일 때만 작업 수행
+                """)
 
 # Mount Gradio app to FastAPI
 app = gr.mount_gradio_app(app, demo, path="/")
 
-# For Hugging Face Spaces
+# For local testing
 if __name__ == "__main__":
     demo.launch()