Update app.py

app.py

@@ -1,557 +1,226 @@
 import gradio as gr
-import uuid
-import os
 import json
-from datetime import datetime
-from typing import Dict, List
-import shutil
-import time
-import threading
-
-# Initialize data storage
-peers: Dict[str, Dict] = {}
-jobs: List[Dict] = []
-job_lock = threading.Lock()
-peer_lock = threading.Lock()
-
-# Create directories
-os.makedirs("results", exist_ok=True)
-os.makedirs("client", exist_ok=True)
-
-# Client code
-CLIENT_CODE = '''import requests
-import subprocess
-import time
 import os
-import sys
 from datetime import datetime
-import json
-
-# 설정
-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"  # 실제 Space URL로 변경하세요
-
-def check_gpu():
-    """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 사용률 20% 미만이면 idle
-    except:
-        print("GPU를 찾을 수 없습니다. CPU 모드로 실행됩니다.")
-        return False
+import base64
+from PIL import Image, ImageDraw, ImageFont
+import io
+import random
 
-def register_peer():
-    """서버에 Peer 등록"""
-    try:
-        response = requests.post(
-            f"{SERVER_URL}/run/register_peer",
-            json={"data": [PEER_ID]},
-            headers={"Content-Type": "application/json"}
-        )
-        if response.status_code == 200:
-            result = response.json()
-            if result.get("data") and result["data"][0] == "registered":
-                print(f"✅ Peer 등록 성공: {PEER_ID}")
-                return True
-    except Exception as e:
-        print(f"❌ 서버 연결 실패: {e}")
-    return False
+# 간단한 메모리 저장소
+jobs = []
+results = {}
 
-def send_heartbeat():
-    """서버에 heartbeat 전송"""
-    try:
-        response = requests.post(
-            f"{SERVER_URL}/run/heartbeat",
-            json={"data": [PEER_ID]},
-            headers={"Content-Type": "application/json"}
-        )
-        return response.status_code == 200
-    except:
-        return False
+# 디렉토리 생성
+os.makedirs("temp", exist_ok=True)
 
-def request_job():
-    """작업 요청"""
-    try:
-        response = requests.post(
-            f"{SERVER_URL}/run/request_job",
-            json={"data": [PEER_ID]},
-            headers={"Content-Type": "application/json"}
-        )
-        if response.status_code == 200:
-            result = response.json()
-            if result.get("data") and result["data"][0]:
-                return json.loads(result["data"][0])
-    except Exception as e:
-        print(f"작업 요청 실패: {e}")
-    return None
-
-def generate_image_cpu(prompt, output_path):
-    """CPU로 테스트 이미지 생성"""
-    from PIL import Image, ImageDraw, ImageFont
-    
-    img = Image.new('RGB', (512, 512), color='white')
+def create_test_image(prompt):
+    """테스트 이미지 생성"""
+    img = Image.new('RGB', (512, 512), color=(255, 255, 255))
     draw = ImageDraw.Draw(img)
     
-    # 텍스트 그리기
-    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(512):
+        color = int(255 * (1 - i/512))
+        draw.rectangle([(0, i), (512, i+1)], fill=(color, color, 255))
     
-    # 테스트 패턴 그리기
-    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"📝 테스트 이미지 생성 완료: {output_path}")
-
-def submit_result(job_id, image_path):
-    """작업 결과 제출"""
-    try:
-        # 이미지를 base64로 인코딩
-        import base64
-        with open(image_path, "rb") as f:
-            image_data = base64.b64encode(f.read()).decode()
-        
-        response = requests.post(
-            f"{SERVER_URL}/run/submit_result",
-            json={"data": [job_id, image_data]},
-            headers={"Content-Type": "application/json"}
-        )
-        return response.status_code == 200
-    except Exception as e:
-        print(f"결과 제출 실패: {e}")
-        return False
-
-def main():
-    print("🚀 P2P GPU 클라이언트 시작...")
+    # 텍스트 추가
+    text_lines = [
+        f"Prompt: {prompt[:40]}...",
+        f"Generated at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+        f"Job ID: {random.randint(1000, 9999)}"
+    ]
     
-    if not register_peer():
-        print("서버 등록 실패. 프로그램을 종료합니다.")
-        return
+    y_offset = 20
+    for line in text_lines:
+        draw.text((20, y_offset), line, fill='white')
+        y_offset += 30
     
-    while True:
-        try:
-            # Heartbeat
-            if not send_heartbeat():
-                print("서버 연결 끊김. 재등록 시도...")
-                if not register_peer():
-                    time.sleep(30)
-                    continue
-            
-            # 작업 요청
-            job = request_job()
-            if job:
-                job_id = job["id"]
-                prompt = job["prompt"]
-                
-                print(f"\\n📋 새 작업 수신: {prompt}")
-                
-                # 이미지 생성
-                output_path = f"{job_id}.png"
-                
-                if check_gpu():
-                    print("🎮 GPU 모드로 생성 중...")
-                    # 실제 GPU 생성 코드가 여기 들어갑니다
-                    generate_image_cpu(prompt, output_path)
-                else:
-                    print("💻 CPU 모드로 생성 중...")
-                    generate_image_cpu(prompt, output_path)
-                
-                # 결과 업로드
-                if submit_result(job_id, output_path):
-                    print("✅ 결과 업로드 성공")
-                else:
-                    print("❌ 결과 업로드 실패")
-                
-                # 임시 파일 삭제
-                os.remove(output_path)
-            
-            time.sleep(10)  # 10초마다 확인
-            
-        except KeyboardInterrupt:
-            print("\\n👋 프로그램 종료")
-            break
-        except Exception as e:
-            print(f"⚠️ 오류 발생: {e}")
-            time.sleep(30)
-
-if __name__ == "__main__":
-    # 필요한 패키지 확인
-    try:
-        import PIL
-    except ImportError:
-        print("필요한 패키지를 설치합니다...")
-        subprocess.run([sys.executable, "-m", "pip", "install", "pillow", "requests"])
+    # 격자 패턴
+    for i in range(0, 512, 32):
+        draw.line([(i, 100), (i, 512)], fill=(200, 200, 200), width=1)
+        draw.line([(0, i+100), (512, i+100)], fill=(200, 200, 200), width=1)
     
-    main()
-'''
-
-# Create client files
-def create_client_files():
-    with open("client/peer_agent.py", "w", encoding="utf-8") as f:
-        f.write(CLIENT_CODE)
-
-    with open("client/requirements.txt", "w") as f:
-        f.write("requests\npillow\n")
+    return img
 
-    with open("client/README.md", "w", encoding="utf-8") as f:
-        f.write("""# P2P GPU 클라이언트 (Windows)
-
-## 설치 방법
-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 지원
-- NVIDIA GPU가 있으면 자동으로 감지
-- GPU가 없으면 CPU 모드로 테스트 이미지 생성
-""")
-
-create_client_files()
-
-# Cleanup old peers periodically
-def cleanup_old_peers():
-    while True:
-        time.sleep(60)  # Check every minute
-        with peer_lock:
-            current_time = datetime.now()
-            to_remove = []
-            for peer_id, peer_info in peers.items():
-                if (current_time - peer_info['last_seen']).seconds > 120:  # 2 minutes timeout
-                    to_remove.append(peer_id)
-            for peer_id in to_remove:
-                del peers[peer_id]
-
-# Start cleanup thread
-cleanup_thread = threading.Thread(target=cleanup_old_peers, daemon=True)
-cleanup_thread.start()
-
-# Gradio API functions
-def register_peer(peer_id: str):
-    """Peer 등록"""
-    with peer_lock:
-        peers[peer_id] = {
-            "status": "idle",
-            "last_seen": datetime.now(),
-            "jobs_completed": 0
-        }
-    return "registered"
-
-def heartbeat(peer_id: str):
-    """Peer heartbeat"""
-    with peer_lock:
-        if peer_id in peers:
-            peers[peer_id]["last_seen"] = datetime.now()
-            return "alive"
-    return "unregistered"
-
-def submit_job(prompt: str):
+def submit_job(prompt):
     """작업 제출"""
     if not prompt:
-        return "프롬프트를 입력해주세요."
+        return "❌ 프롬프트를 입력해주세요.", None
     
-    job_id = str(uuid.uuid4())
-    with job_lock:
-        job = {
-            "id": job_id,
-            "prompt": prompt,
-            "status": "pending",
-            "created_at": datetime.now().isoformat()
-        }
-        jobs.append(job)
+    job_id = f"job_{len(jobs)}_{datetime.now().strftime('%H%M%S')}"
+    job = {
+        "id": job_id,
+        "prompt": prompt,
+        "status": "processing",
+        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    jobs.append(job)
     
-    return f"✅ 작업이 제출되었습니다!\n작업 ID: {job_id[:8]}..."
-
-def request_job(peer_id: str):
-    """작업 요청"""
-    with job_lock:
-        for job in jobs:
-            if job["status"] == "pending":
-                job["status"] = "assigned"
-                job["peer_id"] = peer_id
-                job["assigned_at"] = datetime.now().isoformat()
-                return json.dumps(job)
-    return None
-
-def submit_result(job_id: str, image_base64: str):
-    """작업 결과 제출"""
-    import base64
+    # 시뮬레이션: 바로 이미지 생성
+    img = create_test_image(prompt)
     
-    # base64 디코딩하여 파일로 저장
-    try:
-        image_data = base64.b64decode(image_base64)
-        filename = f"{job_id}.png"
-        file_path = f"results/{filename}"
-        
-        with open(file_path, "wb") as f:
-            f.write(image_data)
-        
-        with job_lock:
-            for job in jobs:
-                if job["id"] == job_id:
-                    job["status"] = "completed"
-                    job["filename"] = filename
-                    job["completed_at"] = datetime.now().isoformat()
-                    
-                    # Peer 통계 업데이트
-                    if "peer_id" in job:
-                        with peer_lock:
-                            if job["peer_id"] in peers:
-                                peers[job["peer_id"]]["jobs_completed"] += 1
-                    break
-        
-        return "success"
-    except Exception as e:
-        print(f"Error saving result: {e}")
-        return "error"
+    # 이미지를 임시 파일로 저장
+    img_path = f"temp/{job_id}.png"
+    img.save(img_path)
+    results[job_id] = img_path
+    job["status"] = "completed"
+    
+    return f"✅ 작업이 제출되었습니다!\n작업 ID: {job_id}", img
 
 def get_status():
-    """시스템 상태 조회"""
-    with peer_lock:
-        active_peers = sum(1 for p in peers.values() 
-                          if (datetime.now() - p['last_seen']).seconds < 60)
-    
-    with job_lock:
-        pending = sum(1 for j in jobs if j['status'] == 'pending')
-        completed = sum(1 for j in jobs if j['status'] == 'completed')
+    """시스템 상태"""
+    total_jobs = len(jobs)
+    completed = sum(1 for j in jobs if j["status"] == "completed")
     
     status_text = f"""## 📊 시스템 상태
 
 ### 현재 상황
-- **활성 Peer**: {active_peers}개
-- **대기중 작업**: {pending}개
+- **전체 작업**: {total_jobs}개
 - **완료된 작업**: {completed}개
+- **대기중 작업**: {total_jobs - completed}개
 
-### 최근 작업 목록
+### 최근 작업 (최대 5개)
 """
     
-    with job_lock:
-        recent_jobs = jobs[-5:][::-1]  # Last 5 jobs, reversed
-        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아직 작업이 없습니다."
+    recent_jobs = jobs[-5:][::-1] if jobs else []
+    for job in recent_jobs:
+        emoji = "✅" if job["status"] == "completed" else "⏳"
+        status_text += f"\n{emoji} **{job['id']}**: {job['prompt'][:30]}... ({job['created_at']})"
+    
+    if not jobs:
+        status_text += "\n\n*아직 작업이 없습니다.*"
     
     return status_text
 
 def get_gallery():
-    """갤러리용 이미지 가져오기"""
-    image_files = []
-    with job_lock:
-        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):
-                    image_files.append((file_path, job['prompt']))
+    """갤러리 이미지 목록"""
+    gallery_images = []
+    
+    for job in jobs[-12:][::-1]:  # 최근 12개
+        if job["status"] == "completed" and job["id"] in results:
+            img_path = results[job["id"]]
+            if os.path.exists(img_path):
+                gallery_images.append((img_path, f"{job['prompt'][:50]}..."))
     
-    return image_files
+    return gallery_images
+
+# 클라이언트 코드
+CLIENT_CODE = """# P2P GPU Client (Demo Version)
+import time
+import random
+from datetime import datetime
 
-def download_client_file(filename):
-    """클라이언트 파일 다운로드"""
-    file_path = f"client/{filename}"
-    if os.path.exists(file_path):
-        return file_path
-    return None
+print("🚀 P2P GPU 클라이언트 시뮬레이션")
+print("실제 구현에서는 Gradio API를 통해 서버와 통신합니다.")
 
-# 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;
-}
+while True:
+    print(f"\\n[{datetime.now().strftime('%H:%M:%S')}] 작업 확인 중...")
+    
+    if random.random() > 0.7:  # 30% 확률로 작업 수신
+        print("📋 새 작업 발견!")
+        print("🎨 이미지 생성 ���...")
+        time.sleep(2)
+        print("✅ 완료! 서버로 전송")
+    else:
+        print("대기 중...")
+    
+    time.sleep(5)
 """
 
-# Create Gradio interface
-with gr.Blocks(title="P2P GPU 이미지 생성 허브", css=custom_css, theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🤖 P2P GPU 이미지 생성 허브")
-    gr.Markdown("유휴 GPU를 활용한 분산 이미지 생성 시스템")
+# Gradio 인터페이스
+with gr.Blocks(
+    title="P2P GPU 이미지 생성 허브",
+    theme=gr.themes.Soft(),
+    css="""
+    .container { max-width: 1200px; margin: 0 auto; }
+    #gallery { min-height: 400px; }
+    """
+) as demo:
+    
+    gr.Markdown("""
+    # 🤖 P2P GPU 이미지 생성 허브
+    
+    유휴 GPU를 활용한 분산 이미지 생성 시스템 (데모 버전)
+    """)
     
     with gr.Tabs():
+        # 작업 제출 탭
         with gr.Tab("🎨 작업 제출"):
             with gr.Row():
                 with gr.Column(scale=2):
                     prompt_input = gr.Textbox(
-                        label="이미지 프롬프트", 
-                        placeholder="생성하고 싶은 이미지를 설명해주세요...\n예: 푸른 하늘 아래 벚꽃이 만개한 공원",
-                        lines=4
+                        label="이미지 프롬프트",
+                        placeholder="생성하고 싶은 이미지를 설명하세요...",
+                        lines=3
                     )
-                    with gr.Row():
-                        submit_btn = gr.Button("작업 제출", variant="primary", scale=2)
-                        clear_btn = gr.Button("지우기", scale=1)
+                    submit_btn = gr.Button("🚀 작업 제출", variant="primary")
                     
-                    result_text = gr.Textbox(
-                        label="제출 결과", 
-                        interactive=False,
-                        lines=2
-                    )
+                    result_msg = gr.Textbox(label="제출 결과", interactive=False)
+                    result_img = gr.Image(label="생성된 이미지", type="pil")
                 
                 with gr.Column(scale=1):
                     gr.Markdown("""
                     ### 💡 사용 방법
-                    1. 원하는 이미지를 설명하세요
-                    2. '작업 제출' 버튼을 클릭
-                    3. Peer가 작업을 처리합니다
-                    4. 갤러리에서 결과 확인
+                    1. 프롬프트 입력
+                    2. 작업 제출 클릭
+                    3. 결과 확인
                     
-                    ### 🎯 좋은 프롬프트 예시
-                    - 구체적인 설명 포함
-                    - 스타일이나 분위기 명시
-                    - 색상, 조명 등 세부사항
+                    ### 📝 예시
+                    - 푸른 하늘과 구름
+                    - 일몰의 해변 풍경
+                    - 미래적인 도시 전경
                     """)
             
             submit_btn.click(
-                fn=submit_job, 
-                inputs=prompt_input, 
-                outputs=result_text
-            )
-            clear_btn.click(
-                fn=lambda: ("", ""),
-                outputs=[prompt_input, result_text]
+                fn=submit_job,
+                inputs=prompt_input,
+                outputs=[result_msg, result_img]
             )
         
+        # 시스템 상태 탭
         with gr.Tab("📊 시스템 상태"):
             status_display = gr.Markdown()
-            with gr.Row():
-                refresh_btn = gr.Button("🔄 새로고침", variant="secondary")
+            refresh_btn = gr.Button("🔄 새로고침")
             
-            refresh_btn.click(
-                fn=get_status, 
-                outputs=status_display
-            )
+            def refresh_status():
+                return get_status()
             
-            # Auto-refresh status on load
-            demo.load(fn=get_status, outputs=status_display)
+            refresh_btn.click(fn=refresh_status, outputs=status_display)
+            demo.load(fn=refresh_status, outputs=status_display)
         
+        # 갤러리 탭
         with gr.Tab("🖼️ 갤러리"):
-            gr.Markdown("### 최근 생성된 이미지들")
             gallery = gr.Gallery(
-                label="생성된 이미지",
-                show_label=False,
-                elem_id="gallery",
-                columns=4,
-                rows=3,
-                height="auto",
-                object_fit="contain",
-                preview=True
-            )
-            refresh_gallery_btn = gr.Button("🔄 갤러리 새로고침", variant="secondary")
-            
-            refresh_gallery_btn.click(
-                fn=get_gallery,
-                outputs=gallery
+                label="생성된 이미지들",
+                columns=3,
+                rows=2,
+                height="auto"
             )
+            gallery_refresh_btn = gr.Button("🔄 갤러리 새로고침")
             
-            # Auto-load gallery
+            gallery_refresh_btn.click(fn=get_gallery, outputs=gallery)
             demo.load(fn=get_gallery, outputs=gallery)
         
-        with gr.Tab("💻 클라이언트 다운로드"):
-            gr.Markdown("""
-            ## Windows 클라이언트 설정 가이드
-            
-            ### 📥 1단계: 파일 다운로드
-            클라이언트 파일을 다운로드하려면 아래 버튼을 클릭하세요:
-            """)
-            
-            with gr.Row():
-                download_peer_btn = gr.Button("📥 peer_agent.py 다운로드")
-                download_req_btn = gr.Button("📥 requirements.txt 다운로드")
-                download_readme_btn = gr.Button("📥 README.md 다운로드")
-            
-            download_output = gr.File(label="다운로드 파일", visible=False)
-            
-            download_peer_btn.click(
-                fn=lambda: download_client_file("peer_agent.py"),
-                outputs=download_output
-            )
-            download_req_btn.click(
-                fn=lambda: download_client_file("requirements.txt"),
-                outputs=download_output
-            )
-            download_readme_btn.click(
-                fn=lambda: download_client_file("README.md"),
-                outputs=download_output
-            )
-            
+        # 다운로드 탭
+        with gr.Tab("💻 클라이언트"):
             gr.Markdown("""
-            ### 🐍 2단계: Python 설치
-            - Python 3.8 이상 버전 필요
-            - [python.org](https://python.org)에서 다운로드
+            ## 클라이언트 프로그램
             
-            ### 📦 3단계: 패키지 설치
-            ```bash
-            pip install -r requirements.txt
-            ```
+            ### 데모 코드
+            아래는 P2P 클라이언트의 간단한 데모 코드입니다:
             
-            ### ⚙️ 4단계: 설정
-            `peer_agent.py` 파일을 열고 SERVER_URL을 이 Space의 URL로 변경:
             ```python
-            SERVER_URL = "https://당신의-space-url.hf.space"
-            ```
-            
-            ### 🚀 5단계: 실행
-            ```bash
-            python peer_agent.py
+            """ + CLIENT_CODE + """
             ```
             
-            ### ✨ 특징
-            - GPU 자동 감지
-            - CPU 폴백 지원
-            - 자동 작업 처리
-            - 10초마다 새 작업 확인
-            
-            ### 🎮 GPU 지원
-            - NVIDIA GPU가 있으면 자동으로 활용
-            - GPU가 없어도 CPU로 테스트 가능
-            - GPU 사용률 20% 미만일 때만 작업 수행
+            ### 실제 구현 시
+            - Gradio API를 통한 서버 통신
+            - GPU 자동 감지 및 활용
+            - 실제 이미지 생성 모델 연동
+            - 자동 작업 처리 및 결과 전송
             """)
-    
-    # Hidden API endpoints for client communication
-    gr.Interface(
-        fn=register_peer,
-        inputs=gr.Textbox(visible=False),
-        outputs=gr.Textbox(visible=False),
-        api_name="register_peer",
-        visible=False
-    )
-    
-    gr.Interface(
-        fn=heartbeat,
-        inputs=gr.Textbox(visible=False),
-        outputs=gr.Textbox(visible=False),
-        api_name="heartbeat",
-        visible=False
-    )
-    
-    gr.Interface(
-        fn=request_job,
-        inputs=gr.Textbox(visible=False),
-        outputs=gr.Textbox(visible=False),
-        api_name="request_job",
-        visible=False
-    )
-    
-    gr.Interface(
-        fn=submit_result,
-        inputs=[gr.Textbox(visible=False), gr.Textbox(visible=False)],
-        outputs=gr.Textbox(visible=False),
-        api_name="submit_result",
-        visible=False
-    )
 
-# Launch the app
+# 앱 실행
 if __name__ == "__main__":
     demo.launch()