Update app-backup10.py

app-backup10.py

@@ -2,7 +2,7 @@ import gradio as gr
 from huggingface_hub import InferenceClient, HfApi
 import os
 import requests
-from typing import List, Dict, Union
+from typing import List, Dict, Union, Tuple
 import traceback
 from PIL import Image
 from io import BytesIO
@@ -11,6 +11,7 @@ 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)
@@ -61,13 +62,16 @@ def get_space_structure(space_id: str) -> Dict:
         return {"error": f"API request error: {str(e)}"}
 
 def format_tree_structure(tree_data: Dict, indent: str = "") -> str:
-    formatted = f"{indent}{tree_data['name']}\n"
-    if tree_data["type"] == "directory":
-        for child in sorted(tree_data.get("children", []), key=lambda x: (x["type"] != "directory", x["name"])):
+    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) -> str:
+def summarize_code(app_content: str):
     system_message = "당신은 Python 코드를 분석하고 요약하는 AI 조수입니다. 주어진 코드를 3줄 이내로 간결하게 요약해주세요."
     user_message = f"다음 Python 코드를 3줄 이내로 요약해주세요:\n\n{app_content}"
     
@@ -82,7 +86,7 @@ def summarize_code(app_content: str) -> str:
     except Exception as e:
         return f"요약 생성 중 오류 발생: {str(e)}"
 
-def analyze_code(app_content: str) -> str:
+def analyze_code(app_content: str):
     system_message = """당신은 Python 코드를 분석하는 AI 조수입니다. 주어진 코드를 분석하여 다음 항목에 대해 설명해주세요:
     A. 배경 및 필요성
     B. 기능적 효용성 및 가치
@@ -103,7 +107,7 @@ def analyze_code(app_content: str) -> str:
     except Exception as e:
         return f"분석 생성 중 오류 발생: {str(e)}"
 
-def explain_usage(app_content: str) -> str:
+def explain_usage(app_content: str):
     system_message = "당신은 Python 코드를 분석하여 사용법을 설명하는 AI 조수입니다. 주어진 코드를 바탕으로 마치 화면을 보는 것처럼 사용법을 상세히 설명해주세요. Markdown 형식으로 출력하세요."
     user_message = f"다음 Python 코드의 사용법을 설명해주세요:\n\n{app_content}"
     
@@ -118,33 +122,73 @@ def explain_usage(app_content: str) -> str:
     except Exception as e:
         return f"사용법 설명 생성 중 오류 발생: {str(e)}"
 
+def adjust_lines_for_code(code_content: str, min_lines: int = 10, max_lines: int = 100) -> int:
+    """
+    코드 내용에 따라 lines 수를 동적으로 조정합니다.
+    
+    Parameters:
+    - code_content (str): 코드 텍스트 내용
+    - min_lines (int): 최소 lines 수
+    - max_lines (int): 최대 lines 수
+    
+    Returns:
+    - int: 설정된 lines 수
+    """
+    # 코드의 줄 수 계산
+    num_lines = len(code_content.split('\n'))
+    # 줄 수가 min_lines보다 적다면 min_lines 사용, max_lines보다 크면 max_lines 사용
+    return min(max(num_lines, min_lines), max_lines)
+
 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.4, desc="코드 요약 중...")
+        progress(0.5, desc="코드 요약 중...")
         summary = summarize_code(app_content)
         
-        progress(0.6, desc="코드 분석 중...")
+        progress(0.7, desc="코드 분석 중...")
         analysis = analyze_code(app_content)
         
-        progress(0.8, desc="사용법 설명 생성 중...")
+        progress(0.9, desc="사용법 설명 생성 중...")
         usage = explain_usage(app_content)
         
+        # 줄 수 계산하여 lines 설정
+        app_py_lines = adjust_lines_for_code(app_content)
+        
         progress(1.0, desc="완료")
-        return summary, analysis, usage, app_content, tree_view, tree_structure, space_id
+        return app_content, tree_view, tree_structure, space_id, summary, analysis, usage, app_py_lines
     except Exception as e:
         print(f"Error in analyze_space: {str(e)}")
         print(traceback.format_exc())
-        return f"오류가 발생했습니다: {str(e)}", "", "", "", "", None, ""
+        return f"오류가 발생했습니다: {str(e)}", "", None, "", "", "", "", 10
 
+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}]
+    messages.extend(chat_history)
+    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:
@@ -160,107 +204,142 @@ def create_ui():
             overflow-y: auto !important;
             max-height: calc((100vh - 200px) / 5) !important;
         }
+        .tree-view-scroll {
+            overflow-y: auto !important;
+            max-height: calc((100vh - 200px) / 2) !important;
+        }
         .full-height {
-            height: calc(100vh - 200px) !important;
+            height: calc(200em * 1.2) !important;
             overflow-y: auto !important;
         }
-        """
-
-        js = """
-        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'));
-            }
+        .code-box {
+            overflow-x: auto !important;
+            overflow-y: auto !important;
+            white-space: pre !important;
+            word-wrap: normal !important;
+            height: 100% !important;
+        }
+        .code-box > div {
+            min-width: 100% !important;
+        }
+        .code-box > div > textarea {
+            word-break: normal !important;
+            overflow-wrap: normal !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;
+            font-size: 16px;
+            font-weight: bold;
+        }
+        .tab-nav button:hover {
+            background-color: #2980b9;
+        }
+        .tab-nav button.selected {
+            color: #2c3e50 !important;
+            background-color: #ecf0f1;
+        }
+        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.Blocks(theme="Nymbo/Nymbo_Theme", css=css) as demo:
+            gr.Markdown("# Mouse: HuggingFace")
             
-            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.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 tree-view-scroll"):  # 트리 뷰 스크롤 추가
+                                tree_view_output = gr.Textbox(label="파일 구조 (Tree View)", lines=30)
+
+                        with gr.Column(scale=4):  # 오른쪽 40%
+                            with gr.Group(elem_classes="output-group full-height"):
+                                code_tabs = gr.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=200,
+                                            elem_classes="full-height code-box"
+                                        )
+                                    requirements_tab = gr.TabItem("requirements.txt")
+                                    with requirements_tab:
+                                        requirements_content = gr.Textbox(
+                                            label="requirements.txt",
+                                            lines=200,
+                                            elem_classes="full-height code-box"
+                                        )
+
+                with gr.TabItem("AI 코딩"):
+                    chatbot = gr.Chatbot(label="대화", type='messages')
+                    msg = gr.Textbox(label="메시지")
                     
-                    with gr.Group(elem_classes="output-group scroll-lock"):
-                        tree_view_output = gr.Textbox(label="파일 구조 (Tree View)", lines=20)
+                    # 숨겨진 상태로 파라미터 설정
+                    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)
                     
-                    with gr.Group(elem_classes="output-group scroll-lock"):
-                        file_buttons = gr.Dataframe(
-                            headers=["파일 이름", "열기"],
-                            datatype=["str", "html"],
-                            col_count=(2, "fixed"),
-                            label="파일 리스트"
-                        )
-                
-                with gr.Column(scale=4):  # 오른쪽 40%
-                    with gr.Group(elem_classes="output-group full-height"):
-                        code_tabs = gr.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)
+                    examples = [
+                        ["상세한 사용 방법을 마치 화면을 보면서 설명하듯이 4000 토큰 이상 자세히 설명하라"],
+                        ["FAQ 20건을 상세하게 작성하라. 4000토큰 이상 사용하라."],
+                        ["사용 방법과 차별점, 특징, 강점을 중심으로 4000 토큰 이상 유튜브 영상 스크립트 형태로 작성하라"],
+                        ["본 서비스를 SEO 최적화하여 블로그 포스트(배경 및 필요성, 기존 유사 서비스와 비교하여 특장점, 활용처, 가치, 기대효과, 결론을 포함)로 4000 토큰 이상 작성하라"],
+                        ["특허 출원에 활용할 기술 및 비즈니스모델 측면을 포함하여 특허 출원서 구성에 맞게 혁신적인 창의 발명 내용을 중심으로 4000토큰 이상 작성하라."],
+                        ["계속 이어서 답변하라"],
+                    ]
 
-            space_id_state = gr.State()
-            tree_structure_state = gr.State()
+                    gr.Examples(examples, inputs=msg)
 
-            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
+                    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
 
-                files = get_files(tree_structure)
-                return [[file["path"], f'<button onclick="openFile(\'{file["path"]}\', \'{space_id}\')">열기</button>'] for file in files]
+                    msg.submit(respond_wrapper, [msg, chatbot, max_tokens, temperature, top_p], [msg, chatbot])
 
-            def open_file(file_path: str, space_id: str):
-                content = get_file_content(space_id, file_path)
-                return gr.Tabs.update(selected=file_path), gr.Code(value=content, language="python", label=file_path, lines=30)
+            space_id_state = gr.State()
+            tree_structure_state = gr.State()
+            app_py_content_lines = gr.State()
 
             analyze_button.click(
                 analyze_space,
                 inputs=[url_input],
-                outputs=[summary_output, analysis_output, usage_output, app_py_content, tree_view_output, tree_structure_state, space_id_state]
+                outputs=[app_py_content, tree_view_output, tree_structure_state, space_id_state, summary_output, analysis_output, usage_output, app_py_content_lines]
             ).then(
-                update_file_buttons,
-                inputs=[tree_structure_state, space_id_state],
-                outputs=[file_buttons]
-            )
-
-            file_path_input = gr.Textbox(visible=False)
-            space_id_input = gr.Textbox(visible=False)
-
-            def handle_file_open(file_path, space_id):
-                return file_path, space_id
-
-            file_path_input.change(
-                open_file,
-                inputs=[file_path_input, space_id_input],
-                outputs=[code_tabs, code_tabs]
+                lambda space_id: get_file_content(space_id, "requirements.txt"),
+                inputs=[space_id_state],
+                outputs=[requirements_content]
             )
 
-            # JavaScript 코드를 HTML에 직접 삽입
-            gr.HTML(f"<script>{js}</script>")
+            # lines 수를 동적으로 설정
+            app_py_content.change(lambda lines: gr.update(lines=lines), inputs=[app_py_content_lines], outputs=[app_py_content])
 
         return demo
 
@@ -271,9 +350,25 @@ def create_ui():
 
 if __name__ == "__main__":
     try:
+        print("Starting HuggingFace Space Analyzer...")
         demo = create_ui()
+        print("UI created successfully.")
+        
+        print("Configuring Gradio queue...")
         demo.queue()
-        demo.launch()
+        print("Gradio queue configured.")
+        
+        print("Launching Gradio app...")
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            debug=True,
+            show_api=False
+        )
+        print("Gradio app launched successfully.")
     except Exception as e:
         print(f"Error in main: {str(e)}")
-        print(traceback.format_exc())
+        print("Detailed error information:")
+        print(traceback.format_exc())
+        raise