Upload 5 files

app.py

@@ -0,0 +1,455 @@
+import streamlit as st
+import os
+from datetime import datetime
+import time
+import traceback
+
+# Import modułów
+from transcription import AudioTranscriber
+from report_generator import ReportGenerator
+from file_handler import FileHandler
+from config import NVIDIA_THEME, DEFAULT_SETTINGS
+
+# Konfiguracja strony
+st.set_page_config(
+    page_title="FGI/IDI Research Analyzer",
+    page_icon="🎙️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS - kolorystyka NVIDIA
+st.markdown(f"""
+<style>
+    .main {{
+        background-color: {NVIDIA_THEME['background']};
+        color: {NVIDIA_THEME['text']};
+    }}
+    .stButton > button {{
+        background-color: {NVIDIA_THEME['primary']};
+        color: {NVIDIA_THEME['background']};
+        border: none;
+        border-radius: 5px;
+        font-weight: bold;
+    }}
+    .stButton > button:hover {{
+        background-color: {NVIDIA_THEME['accent']};
+        color: {NVIDIA_THEME['background']};
+    }}
+    .sidebar .sidebar-content {{
+        background-color: {NVIDIA_THEME['secondary']};
+    }}
+    .stProgress > div > div {{
+        background-color: {NVIDIA_THEME['primary']};
+    }}
+    .success-box {{
+        background-color: rgba(118, 185, 0, 0.1);
+        border: 1px solid {NVIDIA_THEME['primary']};
+        border-radius: 5px;
+        padding: 10px;
+        margin: 10px 0;
+    }}
+    .error-box {{
+        background-color: rgba(255, 0, 0, 0.1);
+        border: 1px solid #ff0000;
+        border-radius: 5px;
+        padding: 10px;
+        margin: 10px 0;
+    }}
+</style>
+""", unsafe_allow_html=True)
+
+class FGIIDIAnalyzer:
+    def __init__(self):
+        self.transcriber = None
+        self.report_generator = None
+        self.file_handler = FileHandler()
+        self.initialize_session_state()
+    
+    def initialize_session_state(self):
+        """Inicjalizacja session state"""
+        if 'transcriptions' not in st.session_state:
+            st.session_state.transcriptions = {}
+        if 'uploaded_files' not in st.session_state:
+            st.session_state.uploaded_files = []
+        if 'processing_status' not in st.session_state:
+            st.session_state.processing_status = 'ready'
+        if 'final_report' not in st.session_state:
+            st.session_state.final_report = None
+        if 'research_brief' not in st.session_state:
+            st.session_state.research_brief = ""
+        if 'logs' not in st.session_state:
+            st.session_state.logs = []
+    
+    def log_message(self, message, level="INFO"):
+        """Dodaj wiadomość do logów"""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        log_entry = f"[{timestamp}] {level}: {message}"
+        st.session_state.logs.append(log_entry)
+        
+        # Ograniczenie liczby logów do 100
+        if len(st.session_state.logs) > 100:
+            st.session_state.logs = st.session_state.logs[-100:]
+    
+    def render_sidebar(self):
+        """Renderuj sidebar z konfiguracją"""
+        st.sidebar.title("🎙️ FGI/IDI Analyzer")
+        st.sidebar.markdown("---")
+        
+        # API Keys
+        st.sidebar.subheader("🔑 Konfiguracja API")
+        
+        openai_key = st.sidebar.text_input(
+            "OpenAI API Key:",
+            type="password",
+            help="Klucz do Whisper (transkrypcja) i GPT-4o-mini (raporty)"
+        )
+        
+        if openai_key:
+            self.transcriber = AudioTranscriber(openai_key)
+            self.report_generator = ReportGenerator(openai_key)
+            st.sidebar.success("✅ API połączone")
+        else:
+            st.sidebar.warning("⚠️ Wprowadź klucz API")
+        
+        st.sidebar.markdown("---")
+        
+        # Ustawienia transkrypcji
+        st.sidebar.subheader("⚙️ Ustawienia")
+        
+        max_file_size = st.sidebar.selectbox(
+            "Maksymalny rozmiar części:",
+            [15, 20, 25, 30],
+            index=1,
+            help="MB - większe pliki będą dzielone na części"
+        )
+        
+        auto_compress = st.sidebar.checkbox(
+            "Auto-kompresja dużych plików",
+            value=True,
+            help="Automatyczna kompresja plików >50MB"
+        )
+        
+        language = st.sidebar.selectbox(
+            "Język transkrypcji:",
+            ["pl", "en", "auto"],
+            index=0,
+            help="Język audio dla Whisper"
+        )
+        
+        st.sidebar.markdown("---")
+        
+        # Status systemu
+        st.sidebar.subheader("📊 Status")
+        
+        if st.session_state.uploaded_files:
+            st.sidebar.info(f"📁 Plików: {len(st.session_state.uploaded_files)}")
+        
+        if st.session_state.transcriptions:
+            st.sidebar.info(f"✅ Transkrypcji: {len(st.session_state.transcriptions)}")
+        
+        if st.session_state.final_report:
+            st.sidebar.success("📄 Raport gotowy")
+        
+        # Reset session
+        if st.sidebar.button("🔄 Reset sesji", type="secondary"):
+            for key in list(st.session_state.keys()):
+                del st.session_state[key]
+            st.rerun()
+        
+        return {
+            'openai_key': openai_key,
+            'max_file_size': max_file_size,
+            'auto_compress': auto_compress,
+            'language': language
+        }
+    
+    def render_file_upload(self, settings):
+        """Renderuj sekcję upload plików"""
+        st.header("📁 Upload plików audio/video")
+        
+        # Research brief
+        st.subheader("📋 Brief badawczy (opcjonalny)")
+        research_brief = st.text_area(
+            "Opisz cele badania, grupę docelową, kluczowe pytania badawcze:",
+            value=st.session_state.research_brief,
+            height=100,
+            help="Ten opis pomoże AI wygenerować lepszy raport"
+        )
+        st.session_state.research_brief = research_brief
+        
+        # File uploader
+        st.subheader("🎙️ Pliki do transkrypcji")
+        uploaded_files = st.file_uploader(
+            "Wybierz pliki audio/video:",
+            type=['mp3', 'wav', 'mp4', 'm4a', 'aac'],
+            accept_multiple_files=True,
+            help="Obsługiwane formaty: MP3, WAV, MP4, M4A, AAC"
+        )
+        
+        if uploaded_files:
+            # Walidacja plików
+            valid_files = []
+            total_size = 0
+            
+            for file in uploaded_files:
+                file_size_mb = file.size / (1024 * 1024)
+                total_size += file_size_mb
+                
+                # Sprawdź rozmiar pojedynczego pliku
+                if file_size_mb > 200:  # 200MB limit dla pojedynczego pliku
+                    st.error(f"❌ {file.name}: Plik za duży ({file_size_mb:.1f}MB). Maksymalnie 200MB.")
+                    continue
+                
+                valid_files.append({
+                    'file': file,
+                    'name': file.name,
+                    'size_mb': file_size_mb,
+                    'needs_splitting': file_size_mb > settings['max_file_size']
+                })
+            
+            # Wyświetl informacje o plikach
+            if valid_files:
+                st.success(f"✅ Załadowano {len(valid_files)} plików ({total_size:.1f}MB)")
+                
+                # Tabela z informacjami o plikach
+                for i, file_info in enumerate(valid_files):
+                    col1, col2, col3 = st.columns([3, 1, 1])
+                    
+                    with col1:
+                        st.write(f"📄 {file_info['name']}")
+                    
+                    with col2:
+                        st.write(f"{file_info['size_mb']:.1f}MB")
+                    
+                    with col3:
+                        if file_info['needs_splitting']:
+                            st.warning("Będzie podzielony")
+                        else:
+                            st.success("OK")
+                
+                st.session_state.uploaded_files = valid_files
+                return True
+            
+        return False
+    
+    def render_processing_section(self, settings):
+        """Renderuj sekcję przetwarzania"""
+        if not st.session_state.uploaded_files:
+            st.info("👆 Najpierw załaduj pliki audio/video")
+            return
+        
+        if not settings['openai_key']:
+            st.warning("⚠️ Wprowadź klucz OpenAI API w sidebarze")
+            return
+        
+        st.header("🚀 Przetwarzanie")
+        
+        # Przycisk start
+        if st.session_state.processing_status == 'ready':
+            if st.button("🎯 Rozpocznij transkrypcję i analizę", type="primary"):
+                st.session_state.processing_status = 'running'
+                self.process_files(settings)
+        
+        elif st.session_state.processing_status == 'running':
+            st.info("⏳ Przetwarzanie w toku...")
+            
+            if st.button("⏹️ Zatrzymaj", type="secondary"):
+                st.session_state.processing_status = 'stopped'
+                st.warning("Przetwarzanie zatrzymane")
+        
+        # Progress display
+        if st.session_state.processing_status == 'running':
+            self.render_progress()
+    
+    def render_progress(self):
+        """Renderuj postęp przetwarzania"""
+        progress_container = st.container()
+        
+        with progress_container:
+            # Overall progress
+            total_files = len(st.session_state.uploaded_files)
+            completed_files = len(st.session_state.transcriptions)
+            
+            progress = completed_files / total_files if total_files > 0 else 0
+            st.progress(progress)
+            st.write(f"📊 Postęp ogólny: {completed_files}/{total_files} plików")
+            
+            # Current file info
+            if completed_files < total_files:
+                current_file = st.session_state.uploaded_files[completed_files]['name']
+                st.write(f"🔄 Aktualnie: {current_file}")
+    
+    def process_files(self, settings):
+        """Główna logika przetwarzania plików"""
+        try:
+            self.log_message("Rozpoczynam przetwarzanie plików")
+            
+            # Container dla live updates
+            status_container = st.empty()
+            progress_container = st.empty()
+            
+            # 1. Transkrypcja wszystkich plików
+            for i, file_info in enumerate(st.session_state.uploaded_files):
+                if st.session_state.processing_status != 'running':
+                    break
+                
+                status_container.info(f"🎙️ Transkrybuję: {file_info['name']}")
+                self.log_message(f"Rozpoczynam transkrypcję: {file_info['name']}")
+                
+                try:
+                    # Przetwórz plik (podział jeśli potrzeba)
+                    processed_files = self.file_handler.process_file(
+                        file_info['file'], 
+                        settings['max_file_size'],
+                        settings['auto_compress']
+                    )
+                    
+                    # Transkrypcja
+                    transcription = self.transcriber.transcribe_files(
+                        processed_files,
+                        language=settings['language']
+                    )
+                    
+                    st.session_state.transcriptions[file_info['name']] = transcription
+                    self.log_message(f"✅ Zakończono transkrypcję: {file_info['name']}")
+                    
+                    # Update progress
+                    progress = (i + 1) / len(st.session_state.uploaded_files)
+                    progress_container.progress(progress)
+                    
+                except Exception as e:
+                    self.log_message(f"❌ Błąd transkrypcji {file_info['name']}: {str(e)}", "ERROR")
+                    st.error(f"Błąd przy {file_info['name']}: {str(e)}")
+            
+            # 2. Generowanie raportu
+            if st.session_state.transcriptions and st.session_state.processing_status == 'running':
+                status_container.info("📄 Generuję raport badawczy...")
+                self.log_message("Rozpoczynam generowanie raportu")
+                
+                try:
+                    final_report = self.report_generator.generate_comprehensive_report(
+                        st.session_state.transcriptions,
+                        st.session_state.research_brief
+                    )
+                    
+                    st.session_state.final_report = final_report
+                    st.session_state.processing_status = 'completed'
+                    
+                    status_container.success("✅ Przetwarzanie zakończone!")
+                    self.log_message("✅ Raport wygenerowany pomyślnie")
+                    
+                except Exception as e:
+                    self.log_message(f"❌ Błąd generowania raportu: {str(e)}", "ERROR")
+                    st.error(f"Błąd generowania raportu: {str(e)}")
+                    st.session_state.processing_status = 'error'
+            
+        except Exception as e:
+            self.log_message(f"💥 Błąd krytyczny: {str(e)}", "ERROR")
+            st.error(f"Błąd krytyczny: {str(e)}")
+            st.session_state.processing_status = 'error'
+    
+    def render_results(self):
+        """Renderuj wyniki"""
+        if not st.session_state.transcriptions and not st.session_state.final_report:
+            return
+        
+        st.header("📊 Wyniki")
+        
+        # Tabs dla różnych widoków
+        tab1, tab2, tab3 = st.tabs(["📄 Raport", "🎙️ Transkrypcje", "📋 Logi"])
+        
+        with tab1:
+            if st.session_state.final_report:
+                st.subheader("📄 Raport z badania")
+                
+                # Download button
+                if st.download_button(
+                    label="📥 Pobierz raport (TXT)",
+                    data=st.session_state.final_report,
+                    file_name=f"raport_badawczy_{datetime.now().strftime('%Y%m%d_%H%M')}.txt",
+                    mime="text/plain"
+                ):
+                    st.success("✅ Raport pobierany!")
+                
+                # Display report
+                st.markdown("---")
+                st.markdown(st.session_state.final_report)
+            else:
+                st.info("Raport będzie dostępny po zakończeniu przetwarzania")
+        
+        with tab2:
+            if st.session_state.transcriptions:
+                st.subheader("🎙️ Transkrypcje")
+                
+                for filename, transcription in st.session_state.transcriptions.items():
+                    with st.expander(f"📄 {filename}"):
+                        st.write(transcription)
+                        
+                        # Download individual transcription
+                        st.download_button(
+                            label=f"📥 Pobierz {filename}",
+                            data=transcription,
+                            file_name=f"transkrypcja_{filename}_{datetime.now().strftime('%Y%m%d_%H%M')}.txt",
+                            mime="text/plain",
+                            key=f"download_{filename}"
+                        )
+            else:
+                st.info("Transkrypcje będą dostępne po przetworzeniu plików")
+        
+        with tab3:
+            st.subheader("📋 Logi procesu")
+            
+            if st.session_state.logs:
+                # Scroll to bottom option
+                if st.button("⬇️ Przewiń na dół"):
+                    pass  # Auto-scroll jest w CSS
+                
+                # Display logs
+                logs_text = "\n".join(st.session_state.logs)
+                st.text_area(
+                    "Logi:",
+                    value=logs_text,
+                    height=400,
+                    disabled=True
+                )
+            else:
+                st.info("Logi będą wyświetlane podczas przetwarzania")
+    
+    def run(self):
+        """Główna funkcja aplikacji"""
+        # Sidebar
+        settings = self.render_sidebar()
+        
+        # Main content
+        st.title("🎙️ FGI/IDI Research Analyzer")
+        st.markdown("*Automatyczna transkrypcja i analiza wywiadów fokusowych oraz indywidualnych*")
+        st.markdown("---")
+        
+        # File upload section
+        files_uploaded = self.render_file_upload(settings)
+        
+        st.markdown("---")
+        
+        # Processing section
+        self.render_processing_section(settings)
+        
+        st.markdown("---")
+        
+        # Results section
+        self.render_results()
+
+# Główna aplikacja
+if __name__ == "__main__":
+    try:
+        app = FGIIDIAnalyzer()
+        app.run()
+    except Exception as e:
+        st.error(f"💥 Błąd aplikacji: {str(e)}")
+        st.code(traceback.format_exc())
+        
+        # Log error for debugging
+        with open('error_log.txt', 'w', encoding='utf-8') as f:
+            f.write(f"Error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
+        
+        st.info("Szczegóły błędu zapisane w error_log.txt")

config.py

@@ -0,0 +1,296 @@
+# config.py - Konfiguracja aplikacji FGI/IDI Analyzer
+
+# Kolorystyka NVIDIA - Gaming/Tech Style
+NVIDIA_THEME = {
+    'primary': '#00FF88',      # Bright neon green (akcenty)
+    'secondary': '#1B1B1B',    # Very dark gray (tło sekcji)
+    'background': '#0A0A0A',   # Near black (główne tło)
+    'text': '#E0E0E0',         # Light gray text
+    'text_secondary': '#A0A0A0', # Darker gray for secondary text
+    'accent': '#00CC66',       # Darker green for hover states
+    'error': '#FF4444',        # Red
+    'warning': '#FFAA00',      # Orange
+    'success': '#00FF88',      # Same as primary
+    'border': '#333333',       # Dark border
+    'card_bg': '#151515',      # Card backgrounds
+}
+
+# Ustawienia domyślne
+DEFAULT_SETTINGS = {
+    'max_file_size_mb': 20,
+    'max_total_size_mb': 500,
+    'supported_formats': ['mp3', 'wav', 'mp4', 'm4a', 'aac'],
+    'whisper_model': 'whisper-1',
+    'gpt_model': 'gpt-4o-mini',
+    'default_language': 'pl',
+    'chunk_overlap_seconds': 30,
+    'max_retries': 3,
+    'timeout_seconds': 300,
+}
+
+# Prompty dla różnych etapów raportowania
+REPORT_PROMPTS = {
+    'outline_generator': """
+Jesteś ekspertem analizy badań jakościowych. Na podstawie dostarczonych transkrypcji z wywiadów {interview_type} oraz briefu badawczego, stwórz szczegółowy plan raportu badawczego.
+
+TRANSKRYPCJE:
+{transcriptions}
+
+BRIEF BADAWCZY:
+{brief}
+
+ZADANIE:
+Przeanalizuj materiał i stwórz outline raportu, który:
+1. Odpowie na cele badawcze z briefu
+2. Uwzględni specyfikę {interview_type} 
+3. Będzie miał logiczną strukturę od ogółu do szczegółu
+4. Pozwoli na głęboką analizę insights
+
+WYMAGANIA:
+- Outline powinien mieć 5-8 głównych sekcji
+- Każda sekcja z 3-5 podpunktami
+- Uwzględnij cytaty/przykłady tam gdzie to sensowne
+- Zaplanuj miejsca na insights, wnioski, rekomendacje
+
+FORMAT ODPOWIEDZI:
+```
+# OUTLINE RAPORTU
+
+## 1. [Nazwa sekcji]
+- [Podpunkt 1]
+- [Podpunkt 2]
+- [Podpunkt 3]
+
+## 2. [Nazwa sekcji]
+...
+```
+""",
+
+    'section_generator': """
+Jesteś ekspertem analizy badań jakościowych. Napisz szczegółową sekcję raportu zgodnie z planem.
+
+CONTEXT:
+- Typ wywiadu: {interview_type}
+- Brief badawczy: {brief}
+- Plan całego raportu: {outline}
+
+TRANSKRYPCJE:
+{transcriptions}
+
+ZADANIE:
+Napisz sekcję: "{section_title}"
+Podpunkty do uwzględnienia: {section_points}
+
+WYMAGANIA:
+- Sekcja powinna mieć 800-1500 słów
+- Użyj konkretnych cytatów z transkrypcji
+- Analizuj głęboko, nie tylko opisuj
+- Połącz insights z celami biznesowymi
+- Używaj podtytułów dla czytelności
+- Zachowaj obiektywność ale wyciągnij wnioski
+
+STYLE:
+- Profesjonalny ale przystępny język
+- Strukturyzowany, z jasnymi insights
+- Cytaty w cudzysłowach z oznaczeniem respondenta
+- Wnioski poparte danymi z wywiadów
+""",
+
+    'section_expander': """
+Otrzymałeś sekcję raportu, która jest zbyt krótka i powierzchowna. Twoim zadaniem jest ją znacznie rozszerzyć i pogłębić.
+
+OBECNA SEKCJA:
+{current_section}
+
+DOSTĘPNE TRANSKRYPCJE:
+{transcriptions}
+
+CONTEXT:
+{brief}
+
+ZADANIE:
+Rozszerz tę sekcję do 1000-1500 słów poprzez:
+
+1. **Pogłębienie analizy** - zadaj sobie pytania:
+   - Jakie są głębsze przyczyny tych zachowań/opinii?
+   - Jakie wzorce widać w różnych grupach respondentów?
+   - Jak to łączy się z celami biznesowymi?
+
+2. **Dodanie cytatów** - znajdź w transkrypcjach:
+   - Konkretne przykłady wspierające tezy
+   - Różnorodne perspektywy respondentów
+   - Emocjonalne reakcje i spontaniczne komentarze
+
+3. **Strukturyzacja** - podziel na podsekcje:
+   - Główne tematy/wątki
+   - Segmenty respondentów
+   - Konkretne insights
+
+4. **Praktyczne wnioski** - dodaj:
+   - Implikacje dla biznesu
+   - Możliwe działania
+   - Ryzyka i szanse
+
+WYMAGANIA:
+- Zachowaj oryginalną strukturę ale ją rozbuduj
+- Dodaj minimum 5 cytatów z transkrypcji
+- Każdy wniosek uzasadnij danymi
+- Użyj podtytułów dla czytelności
+""",
+
+    'final_assembly': """
+Jesteś ekspertem analizy badań jakościowych. Twoim zadaniem jest sfinalizowanie raportu - dodanie wprowadzenia, executive summary i spójne połączenie wszystkich sekcji.
+
+SEKCJE RAPORTU:
+{sections}
+
+BRIEF BADAWCZY:
+{brief}
+
+METADANE:
+- Typ badania: {interview_type}
+- Liczba wywiadów: {interviews_count}
+- Data analizy: {date}
+
+ZADANIE:
+Stwórz kompletny raport dodając:
+
+1. **EXECUTIVE SUMMARY** (300-500 słów):
+   - Główne insights z każdej sekcji
+   - Key takeaways dla biznesu
+   - Top 3 rekomendacje
+
+2. **WPROWADZENIE** (200-300 słów):
+   - Cele badania
+   - Metodologia
+   - Struktura raportu
+
+3. **ZAKOŃCZENIE** (300-400 słów):
+   - Podsumowanie głównych wniosków
+   - Rekomendacje działań
+   - Sugerowane dalsze kroki
+
+4. **SPÓJNOŚĆ**:
+   - Dodaj przejścia między sekcjami
+   - Ujednolic style i terminologię
+   - Sprawdź logiczny przepływ
+
+FORMAT:
+```
+# RAPORT Z BADANIA [TYP]
+
+## EXECUTIVE SUMMARY
+[treść]
+
+## 1. WPROWADZENIE
+[treść]
+
+## 2. METODOLOGIA
+[treść]
+
+[SEKCJE GŁÓWNE]
+
+## ZAKOŃCZENIE I REKOMENDACJE
+[treść]
+
+## APPENDIX
+- Informacje o respondentach
+- Dodatkowe cytaty
+```
+""",
+
+    'quality_checker': """
+Otrzymałeś sekcję raportu do oceny jakości. Sprawdź czy spełnia standardy profesjonalnego raportu z badań jakościowych.
+
+SEKCJA DO OCENY:
+{section}
+
+KRYTERIA OCENY:
+1. **Długość**: Czy ma 800+ słów?
+2. **Głębokość**: Czy analizuje przyczyny, nie tylko opisuje?
+3. **Cytaty**: Czy ma konkretne przykłady z wywiadów?
+4. **Struktura**: Czy ma logiczny podział i podtytuły?
+5. **Insights**: Czy wyciąga praktyczne wnioski?
+6. **Biznesowość**: Czy łączy z celami biznesowymi?
+
+ZADANIE:
+Oceń sekcję w skali 1-10 za każde kryterium i podaj:
+- Ogólną ocenę
+- Konkretne problemy do poprawy
+- Sugestie rozszerzeń
+
+FORMAT:
+```
+OCENA JAKOŚCI:
+- Długość: X/10
+- Głębokość: X/10  
+- Cytaty: X/10
+- Struktura: X/10
+- Insights: X/10
+- Biznesowość: X/10
+
+ŚREDNIA: X/10
+
+PROBLEMY:
+- [konkretny problem 1]
+- [konkretny problem 2]
+
+SUGESTIE:
+- [sugestia poprawy 1]
+- [sugestia poprawy 2]
+
+CZY WYMAGA POPRAWY: TAK/NIE
+```
+"""
+}
+
+# Ustawienia modeli
+MODEL_SETTINGS = {
+    'whisper': {
+        'model': 'whisper-1',
+        'language': 'pl',
+        'temperature': 0,
+        'max_retries': 3,
+    },
+    
+    'gpt': {
+        'model': 'gpt-4o-mini',
+        'temperature': 0.3,
+        'max_tokens': 4000,
+        'max_retries': 3,
+        'timeout': 300,
+    }
+}
+
+# Mapowanie typów wywiadów
+INTERVIEW_TYPES = {
+    'fgi': 'Focus Group Interview (wywiad fokusowy)',
+    'idi': 'In-Depth Interview (wywiad indywidualny)',
+    'auto': 'automatyczne rozpoznanie na podstawie treści'
+}
+
+# Ustawienia przetwarzania plików
+FILE_PROCESSING = {
+    'max_single_file_mb': 200,
+    'chunk_size_mb': 20,
+    'supported_audio_formats': ['mp3', 'wav', 'm4a', 'aac'],
+    'supported_video_formats': ['mp4', 'mov', 'avi'],
+    'compression_quality': 64,  # kbps dla audio
+    'sample_rate': 16000,  # Hz
+}
+
+# Komunikaty dla użytkownika  
+USER_MESSAGES = {
+    'file_too_large': "Plik {filename} jest za duży ({size}MB). Maksymalnie {max_size}MB. Czy chcesz go skompresować automatycznie?",
+    'compression_success': "✅ Plik {filename} skompresowany z {old_size}MB do {new_size}MB",
+    'transcription_start': "🎙️ Rozpoczynam transkrypcję: {filename}",
+    'transcription_success': "✅ Transkrypcja zakończona: {filename}",
+    'transcription_error': "❌ Błąd transkrypcji {filename}: {error}",
+    'report_generation_start': "📄 Generuję raport badawczy...",
+    'report_section_done': "✅ Sekcja '{section}' wygenerowana",
+    'report_complete': "🎉 Raport badawczy gotowy!",
+    'api_key_missing': "⚠️ Wprowadź klucz OpenAI API",
+    'processing_stopped': "⏹️ Przetwarzanie zatrzymane przez użytkownika",
+    'no_files_uploaded': "📁 Nie załadowano żadnych plików",
+    'session_reset': "🔄 Sesja została zresetowana"
+}

file_handler.py

@@ -0,0 +1,277 @@
+# file_handler.py - Obsługa plików audio/video dla HuggingFace
+
+import os
+import tempfile
+import math
+from io import BytesIO
+from typing import List, Dict, Tuple, Union
+import streamlit as st
+
+try:
+    from pydub import AudioSegment
+    PYDUB_AVAILABLE = True
+except ImportError:
+    PYDUB_AVAILABLE = False
+    st.warning("⚠️ Pydub nie jest dostępny. Zainstaluj: pip install pydub")
+
+try:
+    import librosa
+    import soundfile as sf
+    LIBROSA_AVAILABLE = True
+except ImportError:
+    LIBROSA_AVAILABLE = False
+
+from config import FILE_PROCESSING, USER_MESSAGES
+
+class FileHandler:
+    """Klasa do obsługi plików audio/video - optymalizowana dla HuggingFace"""
+    
+    def __init__(self):
+        self.temp_files = []  # Lista plików tymczasowych do wyczyszczenia
+        self.processing_stats = {}
+        
+    def process_file(self, uploaded_file, max_chunk_size_mb: int = 20, auto_compress: bool = True) -> List[str]:
+        """
+        Główna funkcja przetwarzania pliku
+        Returns: Lista ścieżek do plików gotowych do transkrypcji
+        """
+        try:
+            file_size_mb = uploaded_file.size / (1024 * 1024)
+            
+            # Loguj rozpoczęcie przetwarzania
+            st.info(f"🔄 Przetwarzam {uploaded_file.name} ({file_size_mb:.1f}MB)")
+            
+            # Sprawdź czy plik wymaga kompresji
+            if file_size_mb > 50 and auto_compress:
+                compressed_file = self._compress_audio(uploaded_file)
+                if compressed_file:
+                    uploaded_file = compressed_file
+                    file_size_mb = compressed_file.size / (1024 * 1024)
+                    st.success(f"✅ Skompresowano do {file_size_mb:.1f}MB")
+            
+            # Sprawdź czy plik wymaga dzielenia
+            if file_size_mb > max_chunk_size_mb:
+                return self._split_audio_file(uploaded_file, max_chunk_size_mb)
+            else:
+                # Plik nie wymaga dzielenia - zapisz bezpośrednio
+                temp_path = self._save_temp_file(uploaded_file)
+                return [temp_path]
+                
+        except Exception as e:
+            st.error(f"❌ Błąd przetwarzania {uploaded_file.name}: {str(e)}")
+            return []
+    
+    def _compress_audio(self, uploaded_file) -> Union[BytesIO, None]:
+        """Kompresja pliku audio używając pydub"""
+        if not PYDUB_AVAILABLE:
+            st.warning("Pydub niedostępny - pomijam kompresję")
+            return None
+            
+        try:
+            # Załaduj audio
+            audio_data = uploaded_file.read()
+            audio = AudioSegment.from_file(BytesIO(audio_data))
+            
+            # Kompresja: mono, lower bitrate, lower sample rate
+            compressed = audio.set_channels(1)  # Mono
+            compressed = compressed.set_frame_rate(16000)  # 16kHz (wystarczy dla mowy)
+            
+            # Export do BytesIO
+            output = BytesIO()
+            compressed.export(
+                output, 
+                format="mp3", 
+                bitrate="64k",  # Niska jakość dla kompresji
+                parameters=["-ac", "1"]  # Force mono
+            )
+            output.seek(0)
+            
+            # Stwórz nowy "uploaded file" object
+            output.name = uploaded_file.name.replace('.', '_compressed.')
+            output.size = len(output.getvalue())
+            
+            return output
+            
+        except Exception as e:
+            st.warning(f"Kompresja nieudana: {str(e)}")
+            return None
+    
+    def _split_audio_file(self, uploaded_file, max_chunk_size_mb: int) -> List[str]:
+        """Dzieli plik audio na mniejsze części"""
+        try:
+            if not PYDUB_AVAILABLE:
+                st.error("❌ Pydub wymagany do dzielenia plików. Zainstaluj: pip install pydub")
+                return []
+            
+            # Załaduj cały plik audio
+            audio_data = uploaded_file.read()
+            audio = AudioSegment.from_file(BytesIO(audio_data))
+            
+            # Oblicz parametry dzielenia
+            total_duration_ms = len(audio)
+            file_size_mb = uploaded_file.size / (1024 * 1024)
+            
+            # Estymacja liczby części na podstawie rozmiaru
+            estimated_parts = math.ceil(file_size_mb / max_chunk_size_mb)
+            chunk_duration_ms = total_duration_ms // estimated_parts
+            
+            # Dodaj overlap między częściami (30 sekund)
+            overlap_ms = 30 * 1000
+            
+            st.info(f"📂 Dzielę na {estimated_parts} części (~{chunk_duration_ms//60000:.1f} min każda)")
+            
+            parts = []
+            base_name = os.path.splitext(uploaded_file.name)[0]
+            
+            for i in range(estimated_parts):
+                start_ms = max(0, i * chunk_duration_ms - overlap_ms if i > 0 else 0)
+                end_ms = min(total_duration_ms, (i + 1) * chunk_duration_ms + overlap_ms)
+                
+                # Wytnij część
+                chunk = audio[start_ms:end_ms]
+                
+                # Zapisz do pliku tymczasowego
+                temp_fd, temp_path = tempfile.mkstemp(suffix=f"_part{i+1:02d}.mp3", prefix=f"{base_name}_")
+                os.close(temp_fd)
+                
+                chunk.export(temp_path, format="mp3", bitrate="128k")
+                parts.append(temp_path)
+                self.temp_files.append(temp_path)
+                
+                st.success(f"✅ Część {i+1}/{estimated_parts}: {(end_ms-start_ms)//60000:.1f} min")
+            
+            return parts
+            
+        except Exception as e:
+            st.error(f"❌ Błąd dzielenia pliku: {str(e)}")
+            return []
+    
+    def _save_temp_file(self, uploaded_file) -> str:
+        """Zapisuje uploaded file do pliku tymczasowego"""
+        try:
+            # Stwórz plik tymczasowy
+            suffix = f".{uploaded_file.name.split('.')[-1]}"
+            temp_fd, temp_path = tempfile.mkstemp(suffix=suffix)
+            
+            # Zapisz dane
+            with os.fdopen(temp_fd, 'wb') as tmp_file:
+                tmp_file.write(uploaded_file.read())
+            
+            self.temp_files.append(temp_path)
+            return temp_path
+            
+        except Exception as e:
+            st.error(f"❌ Błąd zapisu tymczasowego: {str(e)}")
+            return ""
+    
+    def get_audio_duration(self, file_path: str) -> float:
+        """Pobierz długość pliku audio w sekundach"""
+        try:
+            if LIBROSA_AVAILABLE:
+                duration = librosa.get_duration(filename=file_path)
+                return duration
+            elif PYDUB_AVAILABLE:
+                audio = AudioSegment.from_file(file_path)
+                return len(audio) / 1000.0  # Convert ms to seconds
+            else:
+                # Fallback - estymacja na podstawie rozmiaru
+                file_size = os.path.getsize(file_path)
+                # Przybliżenie: 1MB ≈ 60 sekund dla typowego audio MP3
+                return file_size / (1024 * 1024) * 60
+        except:
+            # Ostateczny fallback
+            file_size = os.path.getsize(file_path)
+            return file_size / (1024 * 1024) * 60
+    
+    def validate_file(self, uploaded_file) -> Tuple[bool, str]:
+        """Walidacja pliku audio/video"""
+        try:
+            # Sprawdź rozmiar
+            file_size_mb = uploaded_file.size / (1024 * 1024)
+            if file_size_mb > FILE_PROCESSING['max_single_file_mb']:
+                return False, f"Plik za duży: {file_size_mb:.1f}MB > {FILE_PROCESSING['max_single_file_mb']}MB"
+            
+            # Sprawdź rozszerzenie
+            file_ext = uploaded_file.name.split('.')[-1].lower()
+            supported_formats = (
+                FILE_PROCESSING['supported_audio_formats'] + 
+                FILE_PROCESSING['supported_video_formats']
+            )
+            
+            if file_ext not in supported_formats:
+                return False, f"Nieobsługiwany format: .{file_ext}"
+            
+            # Sprawdź czy plik nie jest pusty
+            if uploaded_file.size == 0:
+                return False, "Plik jest pusty"
+            
+            return True, "OK"
+            
+        except Exception as e:
+            return False, f"Błąd walidacji: {str(e)}"
+    
+    def estimate_processing_time(self, uploaded_files: List) -> Dict:
+        """Estymuj czas przetwarzania"""
+        total_size_mb = sum(f.size for f in uploaded_files) / (1024 * 1024)
+        total_duration_est = total_size_mb * 60  # 1MB ≈ 60s audio
+        
+        # Estymacja czasu transkrypcji (Whisper ~1:10 ratio)
+        transcription_time = total_duration_est * 1.1
+        
+        # Estymacja czasu generowania raportu (zależnie od liczby wywiadów)
+        report_time = len(uploaded_files) * 30  # ~30s per interview dla raportu
+        
+        return {
+            'total_size_mb': total_size_mb,
+            'estimated_audio_duration': total_duration_est,
+            'estimated_transcription_time': transcription_time,
+            'estimated_report_time': report_time,
+            'total_estimated_time': transcription_time + report_time
+        }
+    
+    def get_file_info(self, uploaded_file) -> Dict:
+        """Pobierz informacje o pliku"""
+        file_size_mb = uploaded_file.size / (1024 * 1024)
+        file_ext = uploaded_file.name.split('.')[-1].lower()
+        
+        return {
+            'name': uploaded_file.name,
+            'size_mb': file_size_mb,
+            'format': file_ext,
+            'needs_compression': file_size_mb > 50,
+            'needs_splitting': file_size_mb > 20,
+            'estimated_duration': file_size_mb * 60  # Rough estimate
+        }
+    
+    def cleanup_temp_files(self):
+        """Wyczyść pliki tymczasowe"""
+        cleaned = 0
+        for temp_file in self.temp_files:
+            try:
+                if os.path.exists(temp_file):
+                    os.remove(temp_file)
+                    cleaned += 1
+            except Exception as e:
+                st.warning(f"Nie można usunąć {temp_file}: {e}")
+        
+        self.temp_files = []
+        if cleaned > 0:
+            st.success(f"🧹 Wyczyszczono {cleaned} plików tymczasowych")
+    
+    def get_processing_stats(self) -> Dict:
+        """Zwróć statystyki przetwarzania"""
+        return {
+            'temp_files_count': len(self.temp_files),
+            'processing_stats': self.processing_stats,
+            'libraries_available': {
+                'pydub': PYDUB_AVAILABLE,
+                'librosa': LIBROSA_AVAILABLE
+            }
+        }
+
+# Test funkcji
+if __name__ == "__main__":
+    print("🧪 Test FileHandler")
+    handler = FileHandler()
+    print(f"📊 Dostępne biblioteki: {handler.get_processing_stats()['libraries_available']}")
+    print("✅ FileHandler gotowy do użycia")

report_generator.py

@@ -0,0 +1,399 @@
+# report_generator.py - Inteligentny generator raportów z self-prompting
+
+import time
+import streamlit as st
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime
+
+try:
+    from openai import OpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    st.error("❌ OpenAI library nie jest dostępna")
+
+from config import REPORT_PROMPTS, MODEL_SETTINGS, INTERVIEW_TYPES
+
+class ReportGenerator:
+    """Inteligentny generator długich raportów badawczych z self-prompting"""
+    
+    def __init__(self, api_key: str):
+        if not OPENAI_AVAILABLE:
+            raise Exception("OpenAI library nie jest dostępna")
+            
+        self.client = OpenAI(api_key=api_key)
+        self.api_key = api_key
+        self.generation_stats = {
+            'sections_generated': 0,
+            'sections_expanded': 0,
+            'total_tokens_used': 0,
+            'total_cost_estimate': 0,
+            'generation_time': 0
+        }
+        
+    def generate_comprehensive_report(self, transcriptions: Dict[str, str], brief: str = "") -> str:
+        """
+        Główna funkcja generowania kompletnego raportu
+        Używa strategii wieloetapowej z self-prompting
+        """
+        start_time = time.time()
+        
+        try:
+            st.info("📋 Rozpoczynam generowanie raportu...")
+            
+            # Przygotuj dane
+            combined_transcriptions = self._combine_transcriptions(transcriptions)
+            interview_type = self._detect_interview_type(combined_transcriptions)
+            
+            st.info(f"🔍 Wykryto typ: {INTERVIEW_TYPES.get(interview_type, 'nieznany')}")
+            
+            # ETAP 1: Generowanie outline'u
+            st.info("📝 Etap 1/4: Tworzenie struktury raportu...")
+            outline = self._generate_outline(combined_transcriptions, brief, interview_type)
+            
+            if not outline:
+                raise Exception("Nie udało się wygenerować struktury raportu")
+            
+            # ETAP 2: Generowanie sekcji po sekcji
+            st.info("✍️ Etap 2/4: Generowanie treści sekcji...")
+            sections = self._generate_sections_iteratively(
+                outline, combined_transcriptions, brief, interview_type
+            )
+            
+            # ETAP 3: Rozszerzanie zbyt krótkich sekcji (self-prompting)
+            st.info("🔍 Etap 3/4: Pogłębianie analizy...")
+            expanded_sections = self._expand_short_sections(
+                sections, combined_transcriptions, brief
+            )
+            
+            # ETAP 4: Finalne scalenie z wprowadzeniem i podsumowaniem
+            st.info("📄 Etap 4/4: Finalne scalenie...")
+            final_report = self._assemble_final_report(
+                expanded_sections, brief, interview_type, len(transcriptions)
+            )
+            
+            # Statystyki
+            self.generation_stats['generation_time'] = time.time() - start_time
+            
+            st.success(f"🎉 Raport wygenerowany! ({self.generation_stats['generation_time']:.1f}s)")
+            self._log_generation_stats()
+            
+            return final_report
+            
+        except Exception as e:
+            st.error(f"❌ Błąd generowania raportu: {str(e)}")
+            raise e
+    
+    def _combine_transcriptions(self, transcriptions: Dict[str, str]) -> str:
+        """Połącz wszystkie transkrypcje w jeden tekst z oznaczeniami"""
+        combined = []
+        
+        for i, (filename, transcription) in enumerate(transcriptions.items(), 1):
+            header = f"\n\n=== WYWIAD {i}: {filename} ===\n\n"
+            combined.append(header + transcription)
+        
+        return "\n".join(combined)
+    
+    def _detect_interview_type(self, transcriptions: str) -> str:
+        """Automatyczne rozpoznanie typu wywiadu"""
+        text_lower = transcriptions.lower()
+        
+        # Wskaźniki FGI
+        fgi_indicators = [
+            'moderator', 'grupa', 'wszyscy', 'uczestnicy', 'dyskusja',
+            'czy zgadzacie się', 'co myślicie', 'focus group'
+        ]
+        
+        # Wskaźniki IDI  
+        idi_indicators = [
+            'wywiad indywidualny', 'jeden na jeden', 'interviewer',
+            'opowiedz mi', 'jak się czujesz', 'twoje doświadczenie'
+        ]
+        
+        fgi_score = sum(1 for indicator in fgi_indicators if indicator in text_lower)
+        idi_score = sum(1 for indicator in idi_indicators if indicator in text_lower)
+        
+        if fgi_score > idi_score:
+            return 'fgi'
+        elif idi_score > fgi_score:
+            return 'idi'
+        else:
+            return 'auto'
+    
+    def _generate_outline(self, transcriptions: str, brief: str, interview_type: str) -> Dict:
+        """Generuj strukturę raportu"""
+        try:
+            prompt = REPORT_PROMPTS['outline_generator'].format(
+                transcriptions=transcriptions[:8000],  # Limit dla API
+                brief=brief or "Brak szczegółowego briefu",
+                interview_type=INTERVIEW_TYPES.get(interview_type, 'wywiad')
+            )
+            
+            response = self._call_gpt(prompt)
+            outline = self._parse_outline(response)
+            
+            st.success(f"✅ Outline: {len(outline)} sekcji zaplanowanych")
+            return outline
+            
+        except Exception as e:
+            st.error(f"❌ Błąd generowania outline: {e}")
+            return {}
+    
+    def _generate_sections_iteratively(self, outline: Dict, transcriptions: str, brief: str, interview_type: str) -> Dict:
+        """Generuj sekcje raportu jedna po drugiej"""
+        sections = {}
+        
+        for section_title, section_points in outline.items():
+            if not section_title or section_title.startswith('#'):
+                continue
+                
+            st.info(f"📝 Generuję: {section_title}")
+            
+            try:
+                prompt = REPORT_PROMPTS['section_generator'].format(
+                    transcriptions=transcriptions,
+                    brief=brief or "Brak szczegółowego briefu",
+                    interview_type=INTERVIEW_TYPES.get(interview_type, 'wywiad'),
+                    outline=str(outline),
+                    section_title=section_title,
+                    section_points=section_points
+                )
+                
+                section_content = self._call_gpt(prompt)
+                sections[section_title] = section_content
+                
+                self.generation_stats['sections_generated'] += 1
+                st.success(f"✅ {section_title} ({len(section_content.split())} słów)")
+                
+                # Krótka przerwa żeby nie przekroczyć rate limits
+                time.sleep(2)
+                
+            except Exception as e:
+                st.warning(f"⚠️ Błąd sekcji '{section_title}': {e}")
+                sections[section_title] = f"[BŁĄD GENEROWANIA SEKCJI: {e}]"
+        
+        return sections
+    
+    def _expand_short_sections(self, sections: Dict, transcriptions: str, brief: str) -> Dict:
+        """Self-prompting: rozszerz zbyt krótkie sekcje"""
+        expanded_sections = {}
+        
+        for section_title, section_content in sections.items():
+            word_count = len(section_content.split())
+            
+            # Sprawdź czy sekcja wymaga rozszerzenia
+            if word_count < 500:  # Za krótka sekcja
+                st.info(f"🔍 Rozszerzam: {section_title} ({word_count} słów)")
+                
+                try:
+                    prompt = REPORT_PROMPTS['section_expander'].format(
+                        current_section=section_content,
+                        transcriptions=transcriptions,
+                        brief=brief or "Brak szczegółowego briefu"
+                    )
+                    
+                    expanded_content = self._call_gpt(prompt)
+                    expanded_sections[section_title] = expanded_content
+                    
+                    new_word_count = len(expanded_content.split())
+                    self.generation_stats['sections_expanded'] += 1
+                    
+                    st.success(f"✅ Rozszerzone: {section_title} ({word_count} → {new_word_count} słów)")
+                    
+                    time.sleep(2)  # Rate limit protection
+                    
+                except Exception as e:
+                    st.warning(f"⚠️ Nie udało się rozszerzyć '{section_title}': {e}")
+                    expanded_sections[section_title] = section_content
+            else:
+                # Sekcja już wystarczająco długa
+                expanded_sections[section_title] = section_content
+                st.success(f"✅ {section_title} OK ({word_count} słów)")
+        
+        return expanded_sections
+    
+    def _assemble_final_report(self, sections: Dict, brief: str, interview_type: str, interviews_count: int) -> str:
+        """Scal wszystko w finalny raport"""
+        try:
+            sections_text = "\n\n".join([
+                f"## {title}\n\n{content}" 
+                for title, content in sections.items()
+            ])
+            
+            prompt = REPORT_PROMPTS['final_assembly'].format(
+                sections=sections_text,
+                brief=brief or "Brak szczegółowego briefu",
+                interview_type=INTERVIEW_TYPES.get(interview_type, 'wywiad'),
+                interviews_count=interviews_count,
+                date=datetime.now().strftime("%Y-%m-%d")
+            )
+            
+            final_report = self._call_gpt(prompt, max_tokens=4000)
+            
+            # Dodaj metadane na koniec
+            metadata = f"""
+
+---
+
+## METADATA RAPORTU
+- **Wygenerowano**: {datetime.now().strftime("%Y-%m-%d %H:%M")}
+- **Typ badania**: {INTERVIEW_TYPES.get(interview_type, 'nieznany')}
+- **Liczba wywiadów**: {interviews_count}
+- **Sekcji wygenerowanych**: {self.generation_stats['sections_generated']}
+- **Sekcji rozszerzonych**: {self.generation_stats['sections_expanded']}
+- **Czas generowania**: {self.generation_stats['generation_time']:.1f}s
+- **Generator**: FGI/IDI Research Analyzer v1.0
+"""
+            
+            return final_report + metadata
+            
+        except Exception as e:
+            st.error(f"❌ Błąd finalnego scalenia: {e}")
+            # Fallback - zwróć przynajmniej sekcje
+            return self._create_fallback_report(sections, brief, interview_type)
+    
+    def _call_gpt(self, prompt: str, max_tokens: int = 3000) -> str:
+        """Wywołanie GPT API z error handling"""
+        try:
+            response = self.client.chat.completions.create(
+                model=MODEL_SETTINGS['gpt']['model'],
+                messages=[
+                    {"role": "system", "content": "Jesteś ekspertem analizy badań jakościowych. Tworzysz profesjonalne, szczegółowe raporty badawcze."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=MODEL_SETTINGS['gpt']['temperature'],
+                max_tokens=max_tokens
+            )
+            
+            # Statystyki
+            if hasattr(response, 'usage'):
+                self.generation_stats['total_tokens_used'] += response.usage.total_tokens
+                # Estymacja kosztu GPT-4o-mini: ~$0.00015 per 1K tokens
+                self.generation_stats['total_cost_estimate'] += (response.usage.total_tokens / 1000) * 0.00015
+            
+            return response.choices[0].message.content
+            
+        except Exception as e:
+            if "rate limit" in str(e).lower():
+                st.warning("⏳ Rate limit - czekam 60s...")
+                time.sleep(60)
+                return self._call_gpt(prompt, max_tokens)
+            else:
+                raise e
+    
+    def _parse_outline(self, outline_text: str) -> Dict:
+        """Parsuj outline z odpowiedzi GPT"""
+        outline = {}
+        current_section = None
+        
+        for line in outline_text.split('\n'):
+            line = line.strip()
+            
+            if line.startswith('## '):
+                # Nowa sekcja
+                current_section = line[3:].strip()
+                outline[current_section] = []
+            elif line.startswith('- ') and current_section:
+                # Podpunkt sekcji
+                outline[current_section].append(line[2:].strip())
+        
+        return outline
+    
+    def _create_fallback_report(self, sections: Dict, brief: str, interview_type: str) -> str:
+        """Fallback raport jeśli final assembly nie zadziała"""
+        report_parts = [
+            f"# RAPORT Z BADANIA {INTERVIEW_TYPES.get(interview_type, 'INTERVIEW').upper()}",
+            f"\n**Data**: {datetime.now().strftime('%Y-%m-%d')}",
+            f"**Brief**: {brief or 'Brak szczegółowego briefu'}",
+            "\n---\n"
+        ]
+        
+        for title, content in sections.items():
+            report_parts.append(f"## {title}\n\n{content}\n\n")
+        
+        return "\n".join(report_parts)
+    
+    def _log_generation_stats(self):
+        """Wyświetl statystyki generowania"""
+        stats = self.generation_stats
+        
+        st.info(f"""
+📊 **Statystyki generowania:**
+- Sekcji: {stats['sections_generated']} wygenerowanych, {stats['sections_expanded']} rozszerzonych
+- Tokeny: ~{stats['total_tokens_used']:,}
+- Koszt: ~${stats['total_cost_estimate']:.4f}
+- Czas: {stats['generation_time']:.1f}s
+        """)
+    
+    def evaluate_section_quality(self, section_content: str) -> Dict:
+        """Oceń jakość sekcji (dla debugowania)"""
+        try:
+            prompt = REPORT_PROMPTS['quality_checker'].format(section=section_content)
+            evaluation = self._call_gpt(prompt, max_tokens=500)
+            
+            # Parsuj ocenę (uproszczone)
+            lines = evaluation.split('\n')
+            scores = {}
+            
+            for line in lines:
+                if ':' in line and '/10' in line:
+                    criterion = line.split(':')[0].strip()
+                    score = line.split(':')[1].strip().split('/')[0]
+                    try:
+                        scores[criterion] = int(score)
+                    except:
+                        pass
+            
+            needs_improvement = 'TAK' in evaluation.upper()
+            
+            return {
+                'scores': scores,
+                'needs_improvement': needs_improvement,
+                'evaluation_text': evaluation
+            }
+            
+        except Exception as e:
+            return {'error': str(e)}
+    
+    def get_generation_stats(self) -> Dict:
+        """Zwróć statystyki generowania"""
+        return self.generation_stats.copy()
+
+# Funkcje pomocnicze
+def estimate_report_length(transcriptions: Dict[str, str]) -> Dict:
+    """Estymuj długość finalnego raportu"""
+    total_words = sum(len(text.split()) for text in transcriptions.values())
+    
+    # Raporty są zwykle 15-25% długości transkrypcji
+    estimated_report_words = int(total_words * 0.2)
+    estimated_pages = estimated_report_words / 250  # ~250 słów na stronę
+    
+    return {
+        'transcription_words': total_words,
+        'estimated_report_words': estimated_report_words,
+        'estimated_pages': estimated_pages,
+        'estimated_generation_time': len(transcriptions) * 120  # ~2 min per interview
+    }
+
+# Test modułu
+if __name__ == "__main__":
+    print("🧪 Test ReportGenerator")
+    
+    # Test bez prawdziwego API
+    try:
+        generator = ReportGenerator("test-key")
+        print("✅ ReportGenerator zainicjalizowany")
+        
+        # Test estymacji
+        test_transcriptions = {
+            "test1.mp3": "To jest przykładowa transkrypcja wywiadu. " * 100,
+            "test2.mp3": "To jest druga transkrypcja z badania. " * 150
+        }
+        
+        estimates = estimate_report_length(test_transcriptions)
+        print(f"📊 Estymacja: {estimates['estimated_report_words']} słów, {estimates['estimated_pages']:.1f} stron")
+        
+    except Exception as e:
+        print(f"❌ Błąd testu: {e}")
+    
+    print("✅ Test zakończony")

transcription.py

@@ -0,0 +1,287 @@
+# transcription.py - Moduł transkrypcji audio używając OpenAI Whisper
+
+import os
+import time
+import streamlit as st
+from typing import List, Dict, Optional
+from pathlib import Path
+
+try:
+    from openai import OpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    st.error("❌ OpenAI library nie jest dostępna. Zainstaluj: pip install openai")
+
+from config import MODEL_SETTINGS, USER_MESSAGES
+
+class AudioTranscriber:
+    """Klasa do transkrypcji audio używając OpenAI Whisper API"""
+    
+    def __init__(self, api_key: str):
+        if not OPENAI_AVAILABLE:
+            raise Exception("OpenAI library nie jest dostępna")
+            
+        self.client = OpenAI(api_key=api_key)
+        self.api_key = api_key
+        self.transcription_stats = {
+            'total_files': 0,
+            'successful': 0,
+            'failed': 0,
+            'total_duration': 0,
+            'total_cost_estimate': 0
+        }
+        
+    def transcribe_files(self, file_paths: List[str], language: str = "pl") -> str:
+        """
+        Transkrypcja listy plików audio
+        Returns: Połączona transkrypcja wszystkich plików
+        """
+        transcriptions = []
+        
+        for i, file_path in enumerate(file_paths):
+            if not os.path.exists(file_path):
+                st.error(f"❌ Plik nie istnieje: {file_path}")
+                continue
+                
+            try:
+                # Pokaż postęp
+                if len(file_paths) > 1:
+                    st.info(f"🎙️ Transkrybuję część {i+1}/{len(file_paths)}")
+                
+                # Transkrypcja pojedynczego pliku
+                transcription = self._transcribe_single_file(file_path, language)
+                
+                if transcription:
+                    transcriptions.append(transcription)
+                    self.transcription_stats['successful'] += 1
+                    st.success(f"✅ Część {i+1} zakończona")
+                else:
+                    self.transcription_stats['failed'] += 1
+                    st.error(f"❌ Błąd części {i+1}")
+                    
+            except Exception as e:
+                st.error(f"❌ Błąd transkrypcji części {i+1}: {str(e)}")
+                self.transcription_stats['failed'] += 1
+        
+        # Połącz wszystkie transkrypcje
+        if transcriptions:
+            # Jeśli było więcej niż jeden plik, dodaj separatory
+            if len(transcriptions) > 1:
+                final_transcription = "\n\n=== CZĘŚĆ 1 ===\n\n".join([
+                    transcriptions[0]
+                ] + [
+                    f"=== CZĘŚĆ {i+1} ===\n\n{text}" 
+                    for i, text in enumerate(transcriptions[1:], 1)
+                ])
+            else:
+                final_transcription = transcriptions[0]
+            
+            return final_transcription
+        else:
+            raise Exception("Wszystkie transkrypcje zakończone błędem")
+    
+    def _transcribe_single_file(self, file_path: str, language: str = "pl") -> Optional[str]:
+        """Transkrypcja pojedynczego pliku"""
+        try:
+            self.transcription_stats['total_files'] += 1
+            
+            # Sprawdź rozmiar pliku
+            file_size = os.path.getsize(file_path)
+            file_size_mb = file_size / (1024 * 1024)
+            
+            # OpenAI Whisper ma limit 25MB
+            if file_size_mb > 25:
+                raise Exception(f"Plik za duży dla Whisper API: {file_size_mb:.1f}MB > 25MB")
+            
+            st.info(f"📤 Wysyłam do Whisper ({file_size_mb:.1f}MB)...")
+            
+            # Otwórz plik i wyślij do API
+            with open(file_path, 'rb') as audio_file:
+                transcript = self.client.audio.transcriptions.create(
+                    model=MODEL_SETTINGS['whisper']['model'],
+                    file=audio_file,
+                    language=language if language != 'auto' else None,
+                    temperature=MODEL_SETTINGS['whisper']['temperature']
+                )
+            
+            # Estymacja kosztu (Whisper API: $0.006 per minute)
+            estimated_duration = file_size_mb * 60  # Rough estimate: 1MB ≈ 1 minute
+            estimated_cost = (estimated_duration / 60) * 0.006
+            self.transcription_stats['total_duration'] += estimated_duration
+            self.transcription_stats['total_cost_estimate'] += estimated_cost
+            
+            st.success(f"✅ Transkrypcja otrzymana (~{estimated_duration:.1f}s audio)")
+            
+            return transcript.text
+            
+        except Exception as e:
+            st.error(f"❌ Błąd Whisper API: {str(e)}")
+            
+            # Jeśli błąd rate limit, poczekaj i spróbuj ponownie
+            if "rate limit" in str(e).lower():
+                st.warning("⏳ Rate limit - czekam 60s i próbuję ponownie...")
+                time.sleep(60)
+                return self._transcribe_single_file(file_path, language)
+            
+            return None
+    
+    def transcribe_with_retries(self, file_path: str, language: str = "pl", max_retries: int = 3) -> Optional[str]:
+        """Transkrypcja z ponawianiem przy błędach"""
+        for attempt in range(max_retries):
+            try:
+                result = self._transcribe_single_file(file_path, language)
+                if result:
+                    return result
+                    
+            except Exception as e:
+                st.warning(f"⚠️ Próba {attempt + 1}/{max_retries} nieudana: {str(e)}")
+                
+                if attempt < max_retries - 1:
+                    wait_time = (attempt + 1) * 30  # Exponential backoff
+                    st.info(f"⏳ Czekam {wait_time}s przed następną próbą...")
+                    time.sleep(wait_time)
+                else:
+                    st.error(f"❌ Wszystkie {max_retries} prób nieudane")
+        
+        return None
+    
+    def estimate_transcription_time(self, file_paths: List[str]) -> Dict:
+        """Estymuj czas i koszt transkrypcji"""
+        total_size = sum(os.path.getsize(path) for path in file_paths if os.path.exists(path))
+        total_size_mb = total_size / (1024 * 1024)
+        
+        # Estymacje
+        estimated_duration_minutes = total_size_mb  # 1MB ≈ 1 minute
+        estimated_api_time = estimated_duration_minutes * 0.1  # Whisper jest ~10x szybszy niż realtime
+        estimated_cost = estimated_duration_minutes * 0.006  # $0.006 per minute
+        
+        return {
+            'total_size_mb': total_size_mb,
+            'estimated_audio_duration': estimated_duration_minutes,
+            'estimated_processing_time': estimated_api_time,
+            'estimated_cost_usd': estimated_cost,
+            'files_count': len(file_paths)
+        }
+    
+    def validate_api_key(self) -> bool:
+        """Sprawdź czy klucz API działa"""
+        try:
+            # Spróbuj pobrać listę modeli
+            models = self.client.models.list()
+            return True
+        except Exception as e:
+            st.error(f"❌ Nieprawidłowy klucz API: {str(e)}")
+            return False
+    
+    def get_transcription_stats(self) -> Dict:
+        """Zwróć statystyki transkrypcji"""
+        return self.transcription_stats.copy()
+    
+    def detect_interview_type(self, transcription: str) -> str:
+        """
+        Automatyczne rozpoznanie typu wywiadu na podstawie treści
+        Returns: 'fgi', 'idi', lub 'unknown'
+        """
+        text_lower = transcription.lower()
+        
+        # Wskaźniki FGI (Focus Group)
+        fgi_indicators = [
+            'moderator', 'grupa', 'wszyscy', 'kto jeszcze', 'a państwo',
+            'czy zgadzacie się', 'co myślicie', 'focus group',
+            'uczestnicy', 'grupa fokusowa', 'dyskusja grupowa'
+        ]
+        
+        # Wskaźniki IDI (Individual)
+        idi_indicators = [
+            'wywiad indywidualny', 'jeden na jeden', 'prywatnie',
+            'osobiście', 'indywidualne', 'w cztery oczy'
+        ]
+        
+        fgi_score = sum(1 for indicator in fgi_indicators if indicator in text_lower)
+        idi_score = sum(1 for indicator in idi_indicators if indicator in text_lower)
+        
+        # Sprawdź także liczbę różnych głosów/osób
+        # (FGI zwykle ma więcej przerywników, overlapping speech)
+        interruption_patterns = ['...', '[', ']', '(', ')', '--']
+        interruption_count = sum(text_lower.count(pattern) for pattern in interruption_patterns)
+        
+        if fgi_score > idi_score and interruption_count > 10:
+            return 'fgi'
+        elif idi_score > fgi_score:
+            return 'idi'
+        elif interruption_count > 20:  # Dużo przerywników = prawdopodobnie grupa
+            return 'fgi'
+        else:
+            return 'unknown'
+    
+    def clean_transcription(self, transcription: str) -> str:
+        """Oczyszczenie i formatowanie transkrypcji"""
+        try:
+            # Usuń nadmiarowe spacje
+            lines = transcription.split('\n')
+            cleaned_lines = []
+            
+            for line in lines:
+                line = line.strip()
+                if line:  # Pomijaj puste linie
+                    # Usuń nadmiarowe spacje
+                    line = ' '.join(line.split())
+                    cleaned_lines.append(line)
+            
+            # Połącz z pojedynczymi przerwami linii
+            cleaned = '\n\n'.join(cleaned_lines)
+            
+            # Dodaj informacje metadata na początek
+            metadata = f"""TRANSKRYPCJA AUDIO
+Data: {time.strftime('%Y-%m-%d %H:%M')}
+Typ: {self.detect_interview_type(cleaned).upper()}
+Długość: ~{len(cleaned.split())} słów
+
+---
+
+"""
+            
+            return metadata + cleaned
+            
+        except Exception as e:
+            st.warning(f"⚠️ Błąd czyszczenia transkrypcji: {e}")
+            return transcription
+
+# Funkcje pomocnicze dla kompatybilności
+def validate_audio_file(file_path: str) -> bool:
+    """Sprawdź czy plik audio jest prawidłowy"""
+    if not os.path.exists(file_path):
+        return False
+    
+    # Sprawdź rozmiar
+    file_size = os.path.getsize(file_path)
+    if file_size == 0:
+        return False
+    
+    # Sprawdź rozszerzenie
+    valid_extensions = ['.mp3', '.wav', '.mp4', '.m4a', '.aac']
+    file_ext = Path(file_path).suffix.lower()
+    
+    return file_ext in valid_extensions
+
+# Test modułu
+if __name__ == "__main__":
+    print("🧪 Test AudioTranscriber")
+    
+    # Test bez prawdziwego API key
+    try:
+        transcriber = AudioTranscriber("test-key")
+        print("✅ AudioTranscriber zainicjalizowany")
+        
+        # Test rozpoznania typu wywiadu
+        test_fgi = "Moderator: Co wszyscy myślicie o produkcie? Czy zgadzacie się z tym?"
+        test_idi = "Interviewer: A teraz opowiedz mi o swoich doświadczeniach..."
+        
+        print(f"Test FGI: {transcriber.detect_interview_type(test_fgi)}")
+        print(f"Test IDI: {transcriber.detect_interview_type(test_idi)}")
+        
+    except Exception as e:
+        print(f"❌ Błąd testu: {e}")
+    
+    print("✅ Test zakończony")