Update app.py

app.py

@@ -433,25 +433,103 @@ async def try_openai_api(openai_messages):
 
 class Demo:
     def __init__(self):
-        self.file_state = FileAnalysisState()  # 파일 상태 관리 추가
+        self.file_analysis = {}  # 파일 분석 결과 저장
+        self.uploaded_files = {}  # 업로드된 파일 객체 저장
+
+    async def handle_file_upload(self, files):
+        """파일 업로드 처리 함수"""
+        if not files:
+            return "No files uploaded"
+        
+        results = []
+        self.file_analysis.clear()
+        self.uploaded_files.clear()
+        
+        for file in files:
+            try:
+                # 이미지 파일 처리
+                if file.name.lower().endswith(('.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp')):
+                    image = Image.open(file.name)
+                    image_bytes = io.BytesIO()
+                    image.save(image_bytes, format=image.format)
+                    image_base64 = base64.b64encode(image_bytes.getvalue()).decode('utf-8')
+                    
+                    # Claude API로 이미지 분석
+                    response = claude_client.messages.create(
+                        model="claude-3-opus-20240229",
+                        max_tokens=1000,
+                        messages=[{
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "image",
+                                    "source": {
+                                        "type": "base64",
+                                        "media_type": f"image/{image.format.lower()}",
+                                        "data": image_base64
+                                    }
+                                },
+                                {
+                                    "type": "text",
+                                    "text": "Please analyze this image and provide a detailed description."
+                                }
+                            ]
+                        }]
+                    )
+                    analysis = response.content[0].text
+                
+                # 텍스트 파일 처리
+                elif file.name.lower().endswith(('.txt', '.pdf', '.docx', '.rtf')):
+                    if file.name.lower().endswith('.pdf'):
+                        pdf = fitz.open(file.name)
+                        text_content = ""
+                        for page in pdf:
+                            text_content += page.get_text()
+                    elif file.name.lower().endswith('.docx'):
+                        doc = docx.Document(file.name)
+                        text_content = "\n".join([paragraph.text for paragraph in doc.paragraphs])
+                    else:
+                        with open(file.name, 'r', encoding='utf-8') as f:
+                            text_content = f.read()
+                    
+                    # Claude API로 텍스트 분석
+                    response = claude_client.messages.create(
+                        model="claude-3-opus-20240229",
+                        max_tokens=1000,
+                        messages=[{
+                            "role": "user",
+                            "content": f"Please analyze this text and provide a summary:\n\n{text_content[:2000]}..."
+                        }]
+                    )
+                    analysis = response.content[0].text
+                
+                else:
+                    analysis = f"Unsupported file type: {file.name}"
+                
+                # 분석 결과 저장
+                self.file_analysis[file.name] = analysis
+                self.uploaded_files[file.name] = file
+                results.append(f"Analysis for {file.name}:\n{analysis}\n")
+                
+            except Exception as e:
+                results.append(f"Error processing {file.name}: {str(e)}")
+        
+        return "\n".join(results)
 
     async def generation_code(self, query: Optional[str], _setting: Dict[str, str]):
         if not query or query.strip() == '':
             query = get_random_placeholder()
         
-        # 파일 분석 결과가 있는 경우 컨텍스트로 추가
-        context = ""
-        if self.file_state.last_analysis:
-            context = "Based on the uploaded files:\n"
-            for filename, analysis in self.file_state.last_analysis.items():
-                context += f"\nFile '{filename}':\n{analysis}\n"
-            query = f"{context}\n\nUser Query: {query}"
-
-        # 이미지 생성이 필요한지 확인
+        # 파일 분석 결과를 쿼리에 포함
+        if self.file_analysis:
+            context = "Based on the analyzed files:\n\n"
+            for filename, analysis in self.file_analysis.items():
+                context += f"File '{filename}':\n{analysis}\n\n"
+            query = f"{context}\nUser Query: {query}"
+        
+        # 이미지 생성 관련 코드는 유지
         needs_image = '이미지' in query or '그림' in query or 'image' in query.lower()
         image_prompt = None
-        
-        # 이미지 프롬프트 추출
         if needs_image:
             for keyword in ['이미지:', '그림:', 'image:']:
                 if keyword in query.lower():
@@ -459,18 +537,18 @@ class Demo:
                     break
             if not image_prompt:
                 image_prompt = query
-
+        
         messages = [{'role': Role.SYSTEM, 'content': _setting['system']}]
         messages.append({'role': Role.USER, 'content': query})
         
         system_message = messages[0]['content']
         claude_messages = [{"role": "user", "content": query}]
-
-        # 업로드된 이미지가 있는 경우 Claude API 메시지에 추가
-        for filename, file in self.file_state.uploaded_files.items():
-            if any(filename.lower().endswith(ext) for ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']):
+        
+        # 업로드된 이미지가 있는 경우 Claude API 메시지에 포함
+        for filename, file in self.uploaded_files.items():
+            if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp')):
                 try:
-                    image = Image.open(file)
+                    image = Image.open(file.name)
                     image_bytes = io.BytesIO()
                     image.save(image_bytes, format=image.format)
                     image_base64 = base64.b64encode(image_bytes.getvalue()).decode('utf-8')
@@ -490,7 +568,8 @@ class Demo:
                         }
                     ]
                 except Exception as e:
-                    print(f"Error processing uploaded image: {str(e)}")
+                    print(f"Error including image in message: {str(e)}")
+
 
         openai_messages = [
             {"role": "system", "content": system_message},
@@ -1207,43 +1286,20 @@ Use the "Generate" button for basic creation, "Enhance" button for prompt improv
                                         with antd.Tabs.Item(key="render"):
                                             sandbox = gr.HTML(elem_classes="html_content")
 
-                        async def handle_file_upload(files):
-                            if not files:
-                                return "No files uploaded"
-    
-                            if len(files) > FileProcessor.MAX_FILES:
-                                return f"Maximum {FileProcessor.MAX_FILES} files allowed"
-    
-                            results = []
-                            file_state.last_analysis.clear()
-                            file_state.uploaded_files.clear()
-    
-                            for file in files:
-                                if not FileProcessor.is_allowed_file(file.name):
-                                    results.append(f"Unsupported file: {file.name}")
-                                    continue
-        
-                                if os.path.getsize(file.name) > FileProcessor.MAX_FILE_SIZE:
-                                    results.append(f"File too large: {file.name}")
-                                    continue
-        
-                                result = await FileProcessor.process_file(file)
-                                file_state.last_analysis[file.name] = result
-                                file_state.uploaded_files[file.name] = file
-                                results.append(f"Analysis for {file.name}:\n{result}\n")
-    
-                            return "\n".join(results)
-
+                            
+                        demo_instance = Demo()  # Demo 인스턴스 생성
 
-                        # 이벤트 핸들러 연결
+                        
+    # 파일 업로드 버튼 이벤트 연결
                         analyze_btn.click(
-                            fn=handle_file_upload,
+                            fn=demo_instance.handle_file_upload,  # Demo 인스턴스의 메서드 사용
                             inputs=[file_upload],
                             outputs=[file_analysis]
                         )
 
+    # Generate 버튼 이벤트 연결
                         btn.click(
-                            demo_instance.generation_code,
+                            fn=demo_instance.generation_code,
                             inputs=[input, setting],
                             outputs=[code_output, sandbox, state_tab, code_drawer]
                         ).then(
@@ -1251,6 +1307,7 @@ Use the "Generate" button for basic creation, "Enhance" button for prompt improv
                             inputs=[],
                             outputs=[input]
                         )
+  
 
                         boost_btn.click(
                             fn=handle_boost,