app.py

import gradio as gr
from huggingface_hub import InferenceClient
import os
import requests
from typing import List, Dict, Union
import concurrent.futures
import traceback

# 환경 변수에서 토큰 가져오기
HF_TOKEN = os.getenv("HF_TOKEN")

# 추론 API 클라이언트 설정
hf_client = InferenceClient("CohereForAI/c4ai-command-r-plus-08-2024", token=HF_TOKEN)

def get_headers():
    if not HF_TOKEN:
        raise ValueError("Hugging Face token not found in environment variables")
    return {"Authorization": f"Bearer {HF_TOKEN}"}

def get_most_liked_spaces(limit: int = 100) -> Union[List[Dict], str]:
    url = "https://huggingface.co/api/spaces"
    params = {
        "sort": "likes",
        "direction": -1,
        "limit": limit,
        "full": "true"
    }
    
    try:
        response = requests.get(url, params=params, headers=get_headers())
        response.raise_for_status()
        data = response.json()
        
        if isinstance(data, list):
            return data
        else:
            return f"Unexpected API response format: {type(data)}"
    except requests.RequestException as e:
        return f"API request error: {str(e)}"
    except ValueError as e:
        return f"JSON decoding error: {str(e)}"

def capture_thumbnail(space_id: str) -> bytes:
    screenshot_url = f"https://huggingface.co/spaces/{space_id}/thumbnail.png"
    try:
        response = requests.get(screenshot_url, headers=get_headers())
        if response.status_code == 200:
            return response.content
    except requests.RequestException:
        pass
    return None


def format_spaces(spaces: Union[List[Dict], str]) -> List[Dict]:
    if isinstance(spaces, str):
        return [{"error": spaces}]
    
    valid_spaces = []
    for space in spaces:
        if isinstance(space, dict):
            valid_spaces.append(space)
        else:
            print(f"Skipping invalid space: {space}")
    
    formatted = []
    for space in valid_spaces:
        try:
            formatted.append(format_space(space))
        except Exception as e:
            print(f"Error formatting space: {space.get('id', 'Unknown')}. Error: {str(e)}")
    
    return formatted

def format_space(space: Dict) -> Dict:
    if not isinstance(space, dict):
        raise ValueError(f"Invalid space format: {space}")
    
    space_id = space.get('id', 'Unknown')
    space_name = space_id.split('/')[-1] if '/' in space_id else space_id
    
    space_author = space.get('author', 'Unknown')
    if isinstance(space_author, dict):
        space_author = space_author.get('user', space_author.get('name', 'Unknown'))
    
    space_likes = space.get('likes', 'N/A')
    space_url = f"https://huggingface.co/spaces/{space_id}"
    
    thumbnail = capture_thumbnail(space_id)
    hardware = get_hardware_requirements(space)
    
    return {
        "id": space_id,
        "name": space_name,
        "author": space_author,
        "likes": space_likes,
        "url": space_url,
        "thumbnail": thumbnail,
        "hardware": hardware
    }

def get_hardware_requirements(space: Dict) -> str:
    if not isinstance(space, dict):
        return "Unknown"
    
    sdk = space.get('sdk', {})
    if not isinstance(sdk, dict):
        return "Unknown"
    
    hf = sdk.get('hf', {})
    if not isinstance(hf, dict):
        return "Unknown"
    
    sdk_version = hf.get('version')
    if sdk_version and int(sdk_version.split('.')[0]) >= 3:
        return sdk.get('hardware', 'Unknown')
    else:
        host_requirements = space.get('host_requirements', {})
        if isinstance(host_requirements, dict):
            hardware = host_requirements.get('hardware', {})
            if isinstance(hardware, dict):
                return 'CPU' if hardware.get('gpu') is False else 'GPU'
    return 'Unknown'

def get_app_py_content(space_id: str) -> str:
    app_py_url = f"https://huggingface.co/spaces/{space_id}/raw/main/app.py"
    try:
        response = requests.get(app_py_url, headers=get_headers())
        if response.status_code == 200:
            return response.text
        else:
            return f"app.py file not found or inaccessible for space: {space_id}"
    except requests.RequestException:
        return f"Error fetching app.py content for space: {space_id}"

def summarize_space(space: Dict) -> str:
    system_message = "당신은 Hugging Face Space의 내용을 요약하는 AI 조수입니다. 주어진 정보를 바탕으로 간결하고 명확한 요약을 제공해주세요."
    user_message = f"다음 Hugging Face Space를 요약해주세요: {space['name']} by {space['author']}. 좋아요 수: {space['likes']}. URL: {space['url']}"
    
    messages = [
        {"role": "system", "content": system_message},
        {"role": "user", "content": user_message}
    ]
    
    response = hf_client.chat_completion(messages, max_tokens=150, temperature=0.7)
    return response.choices[0].message.content

def create_ui():
    spaces_list = get_most_liked_spaces()
    print(f"Type of spaces_list: {type(spaces_list)}")
    if isinstance(spaces_list, str):
        print(f"Error in get_most_liked_spaces: {spaces_list}")
        return gr.Blocks().launch()
    
    formatted_spaces = format_spaces(spaces_list)
    print(f"Total spaces loaded: {len(formatted_spaces)}")  # 디버깅 출력
    

    css = """
    footer {
        visibility: hidden;
    }
    .minimal-button {
        min-width: 30px !important;
        height: 25px !important;
        line-height: 1 !important;
        font-size: 12px !important;
        padding: 2px 5px !important;
    }
    .space-row {
        margin-bottom: 5px !important;
    }
    .thumbnail {
        width: 100px;
        height: 100px;
        object-fit: cover;
    }
    .hardware-info {
        font-size: 12px;
        color: #666;
    }
    """

    def on_select(space):
        try:
            summary = summarize_space(space)
            app_content = get_app_py_content(space['id'])
            info = f"선택된 Space: {space['name']} (ID: {space['id']})\n"
            info += f"Author: {space['author']}\n"
            info += f"Likes: {space['likes']}\n"
            info += f"Hardware: {space['hardware']}\n"
            info += f"URL: {space['url']}\n\n"
            info += f"요약:\n{summary}"
            return info, app_content
        except Exception as e:
            print(f"Error in on_select: {str(e)}")
            print(traceback.format_exc())
            return f"오류가 발생했습니다: {str(e)}", ""

    with gr.Blocks(css=css, theme="Nymbo/Nymbo_Theme") as demo:
        gr.Markdown("# Hugging Face Most Liked Spaces")
        
        with gr.Row():
            with gr.Column(scale=1):
                space_rows = []
                for space in formatted_spaces:
                    with gr.Row(elem_classes="space-row") as space_row:
                        if space['thumbnail']:
                            gr.Image(value=space['thumbnail'], shape=(100, 100), show_label=False, elem_classes="thumbnail")
                        else:
                            gr.Image(value="https://huggingface.co/front/assets/huggingface_logo-noborder.svg", shape=(100, 100), show_label=False, elem_classes="thumbnail")
                        with gr.Column():
                            gr.Markdown(f"{space['name']} by {space['author']} (Likes: {space['likes']})", elem_classes="space-info")
                            gr.Markdown(f"Hardware: {space['hardware']}", elem_classes="hardware-info")
                            button = gr.Button("클릭", elem_classes="minimal-button")
                    space_rows.append((space_row, button, space))
            
            with gr.Column(scale=1):
                info_output = gr.Textbox(label="Space 정보 및 요약", lines=10)
                app_py_content = gr.Code(language="python", label="app.py 내용")

        for _, button, space in space_rows:
            button.click(
                lambda s=space: on_select(s),
                inputs=[],
                outputs=[info_output, app_py_content]
            )

    return demo

if __name__ == "__main__":
    demo = create_ui()
    demo.launch()