back 2 async fix2

app.py

@@ -768,6 +768,133 @@ def create_output_file(df, uploaded_file):
         return None
     
 
+               
+        
+@spaces.GPU(duration=300)
+def process_and_download(file_bytes):
+    """Synchronous wrapper for async processing"""
+    if file_bytes is None:
+        gr.Warning("Пожалуйста, загрузите файл")
+        return pd.DataFrame(), None, None, None, "Ожидание файла...", ""
+
+    async def async_process():
+        detector = None
+        gpu_manager = GPUTaskManager(
+            max_retries=3,
+            retry_delay=30,
+            cleanup_callback=lambda: detector.cleanup() if detector else None
+        )
+        
+        try:
+            file_obj = io.BytesIO(file_bytes)
+            logger.info("File loaded into BytesIO successfully")
+            
+            detector = EventDetector()
+            
+            # Read and deduplicate data with retry
+            async def read_and_dedupe():
+                df = pd.read_excel(file_obj, sheet_name='Публикации')
+                original_count = len(df)
+                df = fuzzy_deduplicate(df, 'Выдержки из текста', threshold=55)
+                return df, original_count
+                
+            df, original_count = await gpu_manager.run_with_retry(read_and_dedupe)
+            
+            # Process in smaller batches with better error handling
+            processed_rows = []
+            batches = gpu_manager.batch_process(list(df.iterrows()), batch_size=3)
+            
+            latest_result = (pd.DataFrame(), None, None, None, "Начало обработки...", "")
+            
+            for batch in batches:
+                if control.should_stop():
+                    return latest_result
+                    
+                try:
+                    # Process batch with retry mechanism
+                    async def process_batch():
+                        batch_results = []
+                        for idx, row in batch:
+                            text = str(row.get('Выдержки из текста', '')).strip()
+                            entity = str(row.get('Объект', '')).strip()
+                            
+                            if text and entity:
+                                results = detector.process_text(text, entity)
+                                batch_results.append({
+                                    'Объект': entity,
+                                    'Заголовок': str(row.get('Заголовок', '')),
+                                    'Translated': results['translated_text'],
+                                    'Sentiment': results['sentiment'],
+                                    'Impact': results['impact'],
+                                    'Reasoning': results['reasoning'],
+                                    'Event_Type': results['event_type'],
+                                    'Event_Summary': results['event_summary'],
+                                    'Выдержки из текста': text
+                                })
+                        return batch_results
+                        
+                    batch_results = await gpu_manager.run_with_retry(process_batch)
+                    processed_rows.extend(batch_results)
+                    
+                    # Update latest result
+                    if processed_rows:
+                        result_df = pd.DataFrame(processed_rows)
+                        latest_result = (
+                            result_df,
+                            None, None, None,
+                            f"Обработано {len(processed_rows)}/{len(df)} строк",
+                            f"Удалено {original_count - len(df)} дубликатов"
+                        )
+                    
+                except Exception as e:
+                    if gpu_manager.is_gpu_error(e):
+                        logger.warning(f"GPU error in batch processing: {str(e)}")
+                        continue
+                    else:
+                        logger.error(f"Non-GPU error in batch processing: {str(e)}")
+                        
+                finally:
+                    torch.cuda.empty_cache()
+                    
+            # Create final results
+            if processed_rows:
+                result_df = pd.DataFrame(processed_rows)
+                output_bytes_io = create_output_file(result_df, file_obj)
+                fig_sentiment, fig_events = create_visualizations(result_df)
+                
+                if output_bytes_io:
+                    temp_file = "results.xlsx"
+                    with open(temp_file, "wb") as f:
+                        f.write(output_bytes_io.getvalue())
+                    return (
+                        result_df,
+                        fig_sentiment, 
+                        fig_events,
+                        temp_file,
+                        "Обработка завершена!",
+                        f"Уд��лено {original_count - len(df)} дубликатов"
+                    )
+                    
+            return (pd.DataFrame(), None, None, None, "Нет обработанных данных", "")
+            
+        except Exception as e:
+            error_msg = f"Ошибка анализа: {str(e)}"
+            logger.error(error_msg)
+            return (pd.DataFrame(), None, None, None, error_msg, "")
+            
+        finally:
+            if detector:
+                detector.cleanup()
+
+    # Run the async function in the event loop
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    
+    return loop.run_until_complete(async_process())
+        
 def create_interface():
     control = ProcessControl()
     
@@ -775,7 +902,7 @@ def create_interface():
         # Create state for file data
         current_file = gr.State(None)
         
-        gr.Markdown("# AI-анализ мониторинга новостей v.2.0 + добавка")
+        gr.Markdown("# AI-анализ мониторинга новостей v.2.1 + ext")
         
         with gr.Row():
             file_input = gr.File(
@@ -825,7 +952,6 @@ def create_interface():
             with gr.Column(scale=1):
                 events_plot = gr.Plot(label="Распределение событий")
                 
-        # Create a download row with file component only
         with gr.Row():
             file_output = gr.File(
                 label="Скачать результаты",
@@ -836,125 +962,10 @@ def create_interface():
         def stop_processing():
             control.request_stop()
             return "Остановка обработки..."
-                
-        
-        @spaces.GPU(duration=300)
-        async def process_and_download(file_bytes):
-            if file_bytes is None:
-                gr.Warning("Пожалуйста, загрузите файл")
-                yield (pd.DataFrame(), None, None, None, "Ожидание файла...", "")
-                return
-
-            detector = None
-            gpu_manager = GPUTaskManager(
-                max_retries=3,
-                retry_delay=30,
-                cleanup_callback=lambda: detector.cleanup() if detector else None
-            )
-            
-            try:
-                file_obj = io.BytesIO(file_bytes)
-                logger.info("File loaded into BytesIO successfully")
-                
-                detector = EventDetector()
-                
-                # Read and deduplicate data with retry
-                async def read_and_dedupe():
-                    df = pd.read_excel(file_obj, sheet_name='Публикации')
-                    original_count = len(df)
-                    df = fuzzy_deduplicate(df, 'Выдержки из текста', threshold=55)
-                    return df, original_count
-                    
-                df, original_count = await gpu_manager.run_with_retry(read_and_dedupe)
-                
-                # Process in smaller batches with better error handling
-                processed_rows = []
-                batches = gpu_manager.batch_process(list(df.iterrows()), batch_size=3)
-                
-                for batch in batches:
-                    if control.should_stop():
-                        break
-                        
-                    try:
-                        # Process batch with retry mechanism
-                        async def process_batch():
-                            batch_results = []
-                            for idx, row in batch:
-                                text = str(row.get('Выдержки из текста', '')).strip()
-                                entity = str(row.get('Объект', '')).strip()
-                                
-                                if text and entity:
-                                    results = detector.process_text(text, entity)
-                                    batch_results.append({
-                                        'Объект': entity,
-                                        'Заголовок': str(row.get('Заголовок', '')),
-                                        'Translated': results['translated_text'],
-                                        'Sentiment': results['sentiment'],
-                                        'Impact': results['impact'],
-                                        'Reasoning': results['reasoning'],
-                                        'Event_Type': results['event_type'],
-                                        'Event_Summary': results['event_summary'],
-                                        'Выдержки из текста': text
-                                    })
-                            return batch_results
-                            
-                        batch_results = await gpu_manager.run_with_retry(process_batch)
-                        processed_rows.extend(batch_results)
-                        
-                        # Create intermediate results
-                        if processed_rows:
-                            result_df = pd.DataFrame(processed_rows)
-                            yield (
-                                result_df,
-                                None, None, None,
-                                f"Обработано {len(processed_rows)}/{len(df)} строк",
-                                f"Удалено {original_count - len(df)} дубликатов"
-                            )
-                        
-                    except Exception as e:
-                        if gpu_manager.is_gpu_error(e):
-                            logger.warning(f"GPU error in batch processing: {str(e)}")
-                            continue
-                        else:
-                            logger.error(f"Non-GPU error in batch processing: {str(e)}")
-                            
-                    finally:
-                        torch.cuda.empty_cache()
-                        
-                # Create final results
-                if processed_rows:
-                    result_df = pd.DataFrame(processed_rows)
-                    output_bytes_io = create_output_file(result_df, file_obj)
-                    fig_sentiment, fig_events = create_visualizations(result_df)
-                    
-                    if output_bytes_io:
-                        temp_file = "results.xlsx"
-                        with open(temp_file, "wb") as f:
-                            f.write(output_bytes_io.getvalue())
-                        yield (
-                            result_df,
-                            fig_sentiment, 
-                            fig_events,
-                            temp_file,
-                            "Обработка завершена!",
-                            f"Удалено {original_count - len(df)} дубликатов"
-                        )
-                        return
-                        
-                yield (pd.DataFrame(), None, None, None, "Нет обработанных данных", "")
-                
-            except Exception as e:
-                error_msg = f"Ошибка анализа: {str(e)}"
-                logger.error(error_msg)
-                yield (pd.DataFrame(), None, None, None, error_msg, "")
-                
-            finally:
-                if detector:
-                    detector.cleanup()
         
         stop_btn.click(fn=stop_processing, outputs=[progress])
         
-        # Main processing - simplified outputs
+        # Main processing with synchronous function
         analyze_btn.click(
             fn=process_and_download,
             inputs=[file_input],
@@ -970,6 +981,7 @@ def create_interface():
         
     return app
 
+
 if __name__ == "__main__":
     app = create_interface()
     app.launch(share=True)