Update app.py

app.py

@@ -433,103 +433,26 @@ async def try_openai_api(openai_messages):
 
 class Demo:
     def __init__(self):
-        self.file_analysis = {}  # 파일 분석 결과 저장
+        # file_state 대신 직접 속성으로 정의
+        self.last_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()
         
-        # 파일 분석 결과를 쿼리에 포함
-        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}"
-        
-        # 이미지 생성 관련 코드는 유지
+        # 파일 분석 결과가 있는 경우 컨텍스트로 추가
+        context = ""
+        if self.last_analysis:  # file_state.last_analysis 대신 직접 참조
+            context = "Based on the uploaded files:\n"
+            for filename, analysis in self.last_analysis.items():
+                context += f"\nFile '{filename}':\n{analysis}\n"
+            query = f"{context}\n\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():
@@ -537,18 +460,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.uploaded_files.items():
-            if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp')):
+
+        # 업로드된 이미지가 있는 경우 Claude API 메시지에 추가
+        for filename, file in self.uploaded_files.items():  # file_state.uploaded_files 대신 직접 참조
+            if any(filename.lower().endswith(ext) for ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']):
                 try:
-                    image = Image.open(file.name)
+                    image = Image.open(file)
                     image_bytes = io.BytesIO()
                     image.save(image_bytes, format=image.format)
                     image_base64 = base64.b64encode(image_bytes.getvalue()).decode('utf-8')
@@ -568,8 +491,7 @@ class Demo:
                         }
                     ]
                 except Exception as e:
-                    print(f"Error including image in message: {str(e)}")
-
+                    print(f"Error processing uploaded image: {str(e)}")
 
         openai_messages = [
             {"role": "system", "content": system_message},
@@ -703,10 +625,94 @@ class Demo:
             print(f"Error details: {str(e)}")
             raise ValueError(f'Error calling APIs: {str(e)}')
 
+    async def handle_file_upload(self, files):
+        """파일 업로드 처리 함수"""
+        if not files:
+            return "No files uploaded"
+        
+        results = []
+        self.last_analysis.clear()  # file_state.last_analysis 대신 직접 참조
+        self.uploaded_files.clear()  # file_state.uploaded_files 대신 직접 참조
+        
+        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-5-sonnet-20241022",
+                        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.last_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)
+
     def clear_history(self):
-        self.file_state.last_analysis.clear()
-        self.file_state.uploaded_files.clear()
+        self.last_analysis.clear()
+        self.uploaded_files.clear()
         return []
+        
+
+
+
 
     def update_file_state(self, analysis_result, files):
         """파일 분석 결과와 파일 객체 업데이트"""