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 base64
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) -> str:
    screenshot_url = f"https://huggingface.co/spaces/{space_id}/screenshot.jpg"
    try:
        response = requests.get(screenshot_url, headers=get_headers())
        if response.status_code == 200:
            return base64.b64encode(response.content).decode('utf-8')
    except requests.RequestException:
        pass
    return ""

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 format_space(space: Dict) -> Dict:
    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)
    
    return {
        "id": space_id,
        "name": space_name,
        "author": space_author,
        "likes": space_likes,
        "url": space_url,
        "thumbnail": thumbnail
    }

def format_spaces(spaces: Union[List[Dict], str]) -> List[Dict]:
    if isinstance(spaces, str):
        return [{"error": spaces}]
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
        return list(executor.map(format_space, spaces))

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()
    formatted_spaces = format_spaces(spaces_list)
    print(f"Total spaces loaded: {len(formatted_spaces)}")  # 디버깅 출력

    space_choices = {f"{space['name']} by {space['author']} (Likes: {space['likes']})": space['id'] for space in formatted_spaces}

    with gr.Blocks(css="#space-list { max-height: 400px; overflow-y: auto; }") as demo:
        gr.Markdown("# Hugging Face Most Liked Spaces")
        
        with gr.Row():
            with gr.Column(scale=1):
                with gr.Column(elem_id="space-list"):
                    space_radios = []
                    for space in formatted_spaces:
                        with gr.Row():
                            radio = gr.Radio(
                                choices=[f"{space['name']} by {space['author']} (Likes: {space['likes']})"],
                                label="",
                                value=None,
                                elem_id=f"radio-{space['id']}"
                            )
                            space_radios.append(radio)
                            gr.Button("🔗", elem_id=f"link-{space['id']}")
                summarize_btn = gr.Button("요약")
            
            with gr.Column(scale=2):
                output = gr.Textbox(label="Space 정보", lines=10)
                app_py_content = gr.Code(language="python", label="app.py 내용")

        def on_select(choice):
            try:
                print(f"Selected: {choice}")  # 디버깅 출력
                selected_id = space_choices[choice[0]]  # choice is now a list with one item
                selected_space = next((space for space in formatted_spaces if space['id'] == selected_id), None)
                if selected_space:
                    app_content = get_app_py_content(selected_id)
                    print(f"Selected space: {selected_space['name']} (ID: {selected_id})")  # 디버깅 출력
                    return f"선택된 Space: {selected_space['name']} (ID: {selected_id})\nURL: {selected_space['url']}", app_content
                else:
                    print(f"Space not found for ID: {selected_id}")  # 디버깅 출력
                    return "선택된 space를 찾을 수 없습니다.", ""
            except Exception as e:
                print(f"Error in on_select: {str(e)}")
                print(traceback.format_exc())  # 상세한 오류 정보 출력
                return f"오류가 발생했습니다: {str(e)}", ""

        def on_summarize(choice):
            try:
                if choice:
                    selected_id = space_choices[choice[0]]  # choice is now a list with one item
                    selected_space = next((space for space in formatted_spaces if space['id'] == selected_id), None)
                    if selected_space:
                        summary = summarize_space(selected_space)
                        print(f"Summarizing space: {selected_space['name']}")  # 디버깅 출력
                        return summary
                print("No space selected for summarization")  # 디버깅 출력
                return "선택된 space가 없습니다. 먼저 리스트에서 space를 선택해주세요."
            except Exception as e:
                print(f"Error in on_summarize: {str(e)}")
                print(traceback.format_exc())  # 상세한 오류 정보 출력
                return f"요약 중 오류가 발생했습니다: {str(e)}"

        for radio in space_radios:
            radio.change(on_select, radio, [output, app_py_content])

        summarize_btn.click(on_summarize, inputs=[gr.State(lambda: next((radio for radio in space_radios if radio.value), None))], outputs=[output])

        # JavaScript to open links in new tabs
        link_script = """
        function setupLinkButtons() {
            document.querySelectorAll('button[id^="link-"]').forEach(button => {
                button.addEventListener('click', function() {
                    var spaceId = this.id.split('-')[1];
                    window.open('https://huggingface.co/spaces/' + spaceId, '_blank');
                });
            });
        }
        if (document.readyState === 'complete') {
            setupLinkButtons();
        } else {
            document.addEventListener('DOMContentLoaded', setupLinkButtons);
        }
        """
        demo.load(None, None, None, _js=link_script)

    return demo

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