app.py

import gradio as gr
from huggingface_hub import InferenceClient, HfApi
import os
import requests
from typing import List, Dict, Union, Tuple
import traceback
from PIL import Image
from io import BytesIO
import asyncio
from gradio_client import Client
import time
import threading
import json
import re

HF_TOKEN = os.getenv("HF_TOKEN")
hf_client = InferenceClient("CohereForAI/c4ai-command-r-plus-08-2024", token=HF_TOKEN)
hf_api = HfApi(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_file_content(space_id: str, file_path: str) -> str:
    file_url = f"https://huggingface.co/spaces/{space_id}/raw/main/{file_path}"
    try:
        response = requests.get(file_url, headers=get_headers())
        if response.status_code == 200:
            return response.text
        else:
            return f"File not found or inaccessible: {file_path}"
    except requests.RequestException:
        return f"Error fetching content for file: {file_path}"

def get_space_structure(space_id: str) -> Dict:
    try:
        files = hf_api.list_repo_files(repo_id=space_id, repo_type="space")
        
        tree = {"type": "directory", "path": "", "name": space_id, "children": []}
        for file in files:
            path_parts = file.split('/')
            current = tree
            for i, part in enumerate(path_parts):
                if i == len(path_parts) - 1:  # 파일
                    current["children"].append({"type": "file", "path": file, "name": part})
                else:  # 디렉토리
                    found = False
                    for child in current["children"]:
                        if child["type"] == "directory" and child["name"] == part:
                            current = child
                            found = True
                            break
                    if not found:
                        new_dir = {"type": "directory", "path": '/'.join(path_parts[:i+1]), "name": part, "children": []}
                        current["children"].append(new_dir)
                        current = new_dir
        
        return tree
    except Exception as e:
        print(f"Error in get_space_structure: {str(e)}")
        return {"error": f"API request error: {str(e)}"}

def format_tree_structure(tree_data: Dict, indent: str = "") -> str:
    if "error" in tree_data:
        return tree_data["error"]
    
    formatted = f"{indent}{'📁' if tree_data.get('type') == 'directory' else '📄'} {tree_data.get('name', 'Unknown')}\n"
    if tree_data.get("type") == "directory":
        for child in sorted(tree_data.get("children", []), key=lambda x: (x.get("type", "") != "directory", x.get("name", ""))):
            formatted += format_tree_structure(child, indent + "  ")
    return formatted

def summarize_code(app_content: str):
    system_message = "당신은 Python 코드를 분석하고 요약하는 AI 조수입니다. 주어진 코드를 3줄 이내로 간결하게 요약해주세요."
    user_message = f"다음 Python 코드를 3줄 이내로 요약해주세요:\n\n{app_content}"
    
    messages = [
        {"role": "system", "content": system_message},
        {"role": "user", "content": user_message}
    ]
    
    try:
        response = hf_client.chat_completion(messages, max_tokens=200, temperature=0.7)
        return response.choices[0].message.content
    except Exception as e:
        return f"요약 생성 중 오류 발생: {str(e)}"

def analyze_code(app_content: str):
    system_message = """당신은 Python 코드를 분석하는 AI 조수입니다. 주어진 코드를 분석하여 다음 항목에 대해 설명해주세요:
    A. 배경 및 필요성
    B. 기능적 효용성 및 가치
    C. 특장점
    D. 적용 대상 및 타겟
    E. 기대효과
    기존 및 유사 프로젝트와 비교하여 분석해주세요. Markdown 형식으로 출력하세요."""
    user_message = f"다음 Python 코드를 분석해주세요:\n\n{app_content}"
    
    messages = [
        {"role": "system", "content": system_message},
        {"role": "user", "content": user_message}
    ]
    
    try:
        response = hf_client.chat_completion(messages, max_tokens=1000, temperature=0.7)
        return response.choices[0].message.content
    except Exception as e:
        return f"분석 생성 중 오류 발생: {str(e)}"

def explain_usage(app_content: str):
    system_message = "당신은 Python 코드를 분석하여 사용법을 설명하는 AI 조수입니다. 주어진 코드를 바탕으로 마치 화면을 보는 것처럼 사용법을 상세히 설명해주세요. Markdown 형식으로 출력하세요."
    user_message = f"다음 Python 코드의 사용법을 설명해주세요:\n\n{app_content}"
    
    messages = [
        {"role": "system", "content": system_message},
        {"role": "user", "content": user_message}
    ]
    
    try:
        response = hf_client.chat_completion(messages, max_tokens=800, temperature=0.7)
        return response.choices[0].message.content
    except Exception as e:
        return f"사용법 설명 생성 중 오류 발생: {str(e)}"



def analyze_space(url: str, progress=gr.Progress()):
    try:
        space_id = url.split('spaces/')[-1]
        
        # Space ID 유효성 검사 수정
        if not re.match(r'^[\w.-]+/[\w.-]+$', space_id):
            raise ValueError(f"Invalid Space ID format: {space_id}")
        
        progress(0.1, desc="파일 구조 분석 중...")
        tree_structure = get_space_structure(space_id)
        if "error" in tree_structure:
            raise ValueError(tree_structure["error"])
        tree_view = format_tree_structure(tree_structure)
        
        progress(0.3, desc="app.py 내용 가져오는 중...")
        app_content = get_file_content(space_id, "app.py")
        
        progress(0.5, desc="코드 요약 중...")
        summary = summarize_code(app_content)
        
        progress(0.7, desc="코드 분석 중...")
        analysis = analyze_code(app_content)
        
        progress(0.9, desc="사용법 설명 생성 중...")
        usage = explain_usage(app_content)
        
        progress(1.0, desc="완료")
        return app_content, tree_view, tree_structure, space_id, summary, analysis, usage
    except Exception as e:
        print(f"Error in analyze_space: {str(e)}")
        print(traceback.format_exc())
        return f"오류가 발생했습니다: {str(e)}", "", None, "", "", "", ""

        
def respond(message: str, chat_history: List[Dict[str, str]], max_tokens: int, temperature: float, top_p: float) -> str:
    system_message = """당신은 허깅페이스에 특화된 AI 코딩 전문가입니다. 사용자의 질문에 친절하고 상세하게 답변해주세요. 
    Gradio 특성을 정확히 인식하고 Requirements.txt 누락없이 코딩과 오류를 해결해야 합니다.
    항상 정확하고 유용한 정보를 제공하도록 노력하세요."""
    
    messages = [{"role": "system", "content": system_message}]
    for chat in chat_history:
        messages.append({"role": "user", "content": chat["content"]})
        messages.append({"role": "assistant", "content": chat["content"]})
    messages.append({"role": "user", "content": message})
    
    try:
        response = hf_client.chat_completion(messages, max_tokens=max_tokens, temperature=temperature, top_p=top_p)
        return response.choices[0].message.content
    except Exception as e:
        return f"응답 생성 중 오류 발생: {str(e)}"

def create_ui():
    try:
        css = """
        footer {visibility: hidden;}
        .output-group {
            border: 1px solid #ddd;
            border-radius: 5px;
            padding: 10px;
            margin-bottom: 20px;
        }
        .scroll-lock {
            overflow-y: auto !important;
            max-height: calc((100vh - 200px) / 5) !important;
        }
        .full-height {
            height: calc(100vh - 200px) !important;
            overflow-y: auto !important;
        }
        .tab-nav {
            background-color: #2c3e50;
            border-radius: 5px 5px 0 0;
            overflow: hidden;
        }
        .tab-nav button {
            color: #ecf0f1 !important;
            background-color: #34495e;
            border: none;
            padding: 10px 20px;
            margin: 0;
            transition: background-color 0.3s;
        }
        .tab-nav button:hover {
            background-color: #2980b9;
        }
        .tab-nav button.selected {
            color: #2c3e50 !important;
            background-color: #ecf0f1;
            font-weight: bold;
        }
        .file-button {
            background-color: #f0f0f0;
            border: 1px solid #ddd;
            padding: 5px 10px;
            margin: 2px 0;
            cursor: pointer;
            text-align: left;
            width: 100%;
        }
        .file-button:hover {
            background-color: #e0e0e0;
        }
        input[type="text"], textarea {
            color: #2c3e50 !important;
            background-color: #ecf0f1 !important;
        }
        """


        with gr.Blocks(css=css, theme="Nymbo/Nymbo_Theme") as demo:
            gr.Markdown("# HuggingFace Space Analyzer")
            
            with gr.Tabs(elem_classes="main-tabs") as tabs:
                with gr.TabItem("분석"):
                    with gr.Row():
                        with gr.Column(scale=6):  # 왼쪽 60%
                            url_input = gr.Textbox(label="HuggingFace Space URL")
                            analyze_button = gr.Button("분석")
                            
                            with gr.Group(elem_classes="output-group scroll-lock"):
                                summary_output = gr.Markdown(label="요약 (3줄 이내)")
                            
                            with gr.Group(elem_classes="output-group scroll-lock"):
                                analysis_output = gr.Markdown(label="분석")
                            
                            with gr.Group(elem_classes="output-group scroll-lock"):
                                usage_output = gr.Markdown(label="사용법")
                            
                            with gr.Group(elem_classes="output-group scroll-lock"):
                                tree_view_output = gr.Textbox(label="파일 구조 (Tree View)", lines=20)
                            
                            with gr.Group(elem_classes="output-group scroll-lock"):
                                file_buttons = gr.HTML(label="파일 리스트")
                        
                        with gr.Column(scale=4):  # 오른쪽 40%
                            with gr.Group(elem_classes="output-group full-height"):
                                code_tabs = gr.Tabs(elem_classes="code-tabs")
                                with code_tabs:
                                    app_py_tab = gr.TabItem("app.py")
                                    with app_py_tab:
                                        app_py_content = gr.Code(language="python", label="app.py", lines=30)
                                    requirements_tab = gr.TabItem("requirements.txt")
                                    with requirements_tab:
                                        requirements_content = gr.Textbox(label="requirements.txt", lines=30)


                with gr.TabItem("AI 코딩"):
                    chatbot = gr.Chatbot(label="대화", type="message")
                    msg = gr.Textbox(label="메시지")
                    
                    # 숨겨진 상태로 파라미터 설정
                    max_tokens = gr.Slider(minimum=1, maximum=8000, value=4000, label="Max Tokens", visible=False)
                    temperature = gr.Slider(minimum=0, maximum=1, value=0.7, label="Temperature", visible=False)
                    top_p = gr.Slider(minimum=0, maximum=1, value=0.9, label="Top P", visible=False)
                    
                    examples = [
                        ["상세한 사용 방법을 마치 화면을 보면서 설명하듯이 4000 토큰 이상 자세히 설명하라"],
                        ["FAQ 20건을 상세하게 작성하라. 4000토큰 이상 사용하라."],
                        ["사용 방법과 차별점, 특징, 강점을 중심으로 4000 토큰 이상 유튜브 영상 스크립트 형태로 작성하라"],
                        ["본 서비스를 SEO 최적화하여 블로그 포스트(배경 및 필요성, 기존 유사 서비스와 비교하여 특장점, 활용처, 가치, 기대효과, 결론을 포함)로 4000 토큰 이상 작성하라"],
                        ["특허 출원에 활용할 기술 및 비즈니스모델 측면을 포함하여 특허 출원서 구성에 맞게 혁신적인 창의 발명 내용을 중심으로 4000토큰 이상 작성하라."],
                        ["계속 이어서 답변하라"],
                    ]

                    gr.Examples(examples, inputs=msg)

                    def respond_wrapper(message, chat_history, max_tokens, temperature, top_p):
                        bot_message = respond(message, chat_history, max_tokens, temperature, top_p)
                        chat_history.append({"role": "user", "content": message})
                        chat_history.append({"role": "assistant", "content": bot_message})
                        return "", chat_history

                    msg.submit(respond_wrapper, [msg, chatbot, max_tokens, temperature, top_p], [msg, chatbot])



            space_id_state = gr.State()
            tree_structure_state = gr.State()

            def update_file_buttons(tree_structure, space_id):
                if tree_structure is None:
                    return ""
                
                def get_files(node):
                    files = []
                    if node["type"] == "file":
                        files.append(node)
                    elif node["type"] == "directory":
                        for child in node.get("children", []):
                            files.extend(get_files(child))
                    return files

                files = get_files(tree_structure)
                buttons_html = "<div style='display: flex; flex-direction: column;'>"
                for file in files:
                    buttons_html += f"<button class='file-button' onclick='openFile(\"{file['path']}\", \"{space_id}\")'>{file['path']}</button>"
                buttons_html += "</div>"
                return buttons_html

            def open_file(file_path: str, space_id: str):
                content = get_file_content(space_id, file_path)
                file_name = file_path.split('/')[-1]
                if file_name == "requirements.txt":
                    return gr.Tabs.update(selected="requirements.txt"), gr.Textbox.update(value=content, label=file_name)
                else:
                    return gr.Tabs.update(selected=file_name), gr.Code.update(value=content, language="python" if file_name.endswith('.py') else "plaintext", label=file_name)

            analyze_button.click(
                analyze_space,
                inputs=[url_input],
                outputs=[app_py_content, tree_view_output, tree_structure_state, space_id_state, summary_output, analysis_output, usage_output]
            ).then(
                update_file_buttons,
                inputs=[tree_structure_state, space_id_state],
                outputs=[file_buttons]
            ).then(
                lambda space_id: get_file_content(space_id, "requirements.txt"),
                inputs=[space_id_state],
                outputs=[requirements_content]
            )

            file_path_input = gr.Textbox(visible=False)
            space_id_input = gr.Textbox(visible=False)

            file_path_input.change(
                open_file,
                inputs=[file_path_input, space_id_input],
                outputs=[code_tabs, code_tabs]
            )

            # JavaScript 코드를 HTML에 직접 삽입
            gr.HTML("""
            <script>
            function openFile(path, spaceId) {
                const filePathInput = document.querySelector('input[data-testid="file_path_input"]');
                const spaceIdInput = document.querySelector('input[data-testid="space_id_input"]');
                if (filePathInput && spaceIdInput) {
                    filePathInput.value = path;
                    spaceIdInput.value = spaceId;
                    filePathInput.dispatchEvent(new Event('change'));
                }
            }
            </script>
            """)

        return demo

    except Exception as e:
        print(f"Error in create_ui: {str(e)}")
        print(traceback.format_exc())
        raise


if __name__ == "__main__":
    try:
        print("Starting HuggingFace Space Analyzer...")
        demo = create_ui()
        print("UI created successfully.")
        
        print("Configuring Gradio queue...")
        demo.queue()
        print("Gradio queue configured.")
        
        print("Launching Gradio app...")
        demo.launch(
            server_name="0.0.0.0",  # 모든 네트워크 인터페이스에서 접근 가능하도록 설정
            server_port=7860,  # 기본 Gradio 포트
            share=False,
            debug=True,
            show_api=False
        )
        print("Gradio app launched successfully.")
    except Exception as e:
        print(f"Error in main: {str(e)}")
        print("Detailed error information:")
        print(traceback.format_exc())
        raise

print("Script execution completed.")