added app.py and req

app.py

@@ -0,0 +1,814 @@
+import streamlit as st
+import plotly.express as px
+import plotly.graph_objects as go
+import google.generativeai as genai
+import pandas as pd
+from typing import List, Dict, Any
+import json
+import os
+import re
+from datetime import datetime, timedelta
+import logging
+from pathlib import Path
+import asyncio
+from collections import deque
+import time
+import docx
+
+# Utility Functions
+def read_file_content(file):
+    """Read content from either TXT or DOCX file"""
+    try:
+        file_extension = file.name.lower().split('.')[-1]
+        if file_extension == 'txt':
+            return file.read().decode('utf-8')
+        elif file_extension == 'docx':
+            doc_bytes = file.read()
+            with open("temp.docx", "wb") as temp_file:
+                temp_file.write(doc_bytes)
+            doc = docx.Document("temp.docx")
+            content = "\n".join([paragraph.text for paragraph in doc.paragraphs])
+            os.remove("temp.docx")
+            return content
+        else:
+            raise ValueError(f"Unsupported file format: {file_extension}")
+    except Exception as e:
+        raise Exception(f"Error reading file {file.name}: {str(e)}")
+
+# Rate Limiter Class
+class RateLimiter:
+    def __init__(self, rpm_limit=2, tpm_limit=32000, rpd_limit=50):
+        self.rpm_limit = rpm_limit
+        self.tpm_limit = tpm_limit
+        self.rpd_limit = rpd_limit
+        self.requests = deque()
+        self.tokens = deque()
+        self.daily_requests = deque()
+
+    def can_make_request(self, token_count=0):
+        now = datetime.now()
+        while self.requests and (now - self.requests[0]) > timedelta(minutes=1):
+            self.requests.popleft()
+        while self.tokens and (now - self.tokens[0][0]) > timedelta(minutes=1):
+            self.tokens.popleft()
+        while self.daily_requests and (now - self.daily_requests[0]) > timedelta(days=1):
+            self.daily_requests.popleft()
+        if (len(self.requests) >= self.rpm_limit or 
+            sum(tokens for _, tokens in self.tokens) + token_count > self.tpm_limit or 
+            len(self.daily_requests) >= self.rpd_limit):
+            return False
+        return True
+
+    def add_request(self, token_count=0):
+        now = datetime.now()
+        self.requests.append(now)
+        self.tokens.append((now, token_count))
+        self.daily_requests.append(now)
+
+    def wait_time(self):
+        if not self.requests:
+            return 0
+        oldest_request = self.requests[0]
+        return max(0, 60 - (datetime.now() - oldest_request).total_seconds())
+
+# Interview Analyzer Class
+class InterviewAnalyzer:
+    def __init__(self, api_key: str):
+        """Initialize the analyzer with API key and setup logging"""
+        self.setup_logging()
+        self.setup_gemini(api_key)
+        self.rate_limiter = RateLimiter()
+
+    def setup_logging(self):
+        """Setup logging configuration"""
+        log_dir = Path("logs")
+        log_dir.mkdir(exist_ok=True)
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            handlers=[
+                logging.FileHandler(log_dir / f'analysis_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log'),
+                logging.StreamHandler()
+            ]
+        )
+        self.logger = logging.getLogger(__name__)
+
+    def setup_gemini(self, api_key: str):
+        """Setup Gemini API"""
+        try:
+            genai.configure(api_key=api_key)
+            self.model = genai.GenerativeModel("gemini-1.5-pro")
+            self.logger.info("Gemini API initialized successfully")
+        except Exception as e:
+            self.logger.error(f"Failed to initialize Gemini API: {str(e)}")
+            raise
+
+    def extract_interview_data(self, content: str, filename: str) -> Dict[str, str]:
+        """Extract relevant information from the document content"""
+        # Extract name from content using regex
+        name_match = re.search(r'Interview\s*[-–—]\s*([^\n]+)', content)
+        name = name_match.group(1).strip() if name_match else "Unknown"
+        # Clean the content
+        cleaned_content = self.clean_text(content)
+        return {
+            'name': name,
+            'content': cleaned_content,
+            'source': filename
+        }
+
+    def clean_text(self, text: str) -> str:
+        """Clean and normalize text content"""
+        # Remove special characters and normalize whitespace
+        text = re.sub(r'\\n', '\n', text)
+        text = re.sub(r'\s+', ' ', text)
+        text = re.sub(r'\*\*', '', text) # Remove markdown-style formatting
+        return text.strip()
+
+    def clean_gemini_response(self, response_text: str) -> str:
+        """Clean and format Gemini API response to ensure valid JSON"""
+        try:
+            # Use regex to find the first JSON object
+            match = re.search(r'({.*})', response_text, re.DOTALL)
+            if not match:
+                self.logger.error("No JSON structure found in response")
+                return None
+
+            json_str = match.group(1)
+
+            # Remove any Markdown or code block indicators
+            json_str = re.sub(r'```json\s*', '', json_str)
+            json_str = re.sub(r'```\s*', '', json_str)
+
+            # Validate JSON structure
+            json.loads(json_str)
+            return json_str
+        except json.JSONDecodeError:
+            self.logger.error("Invalid JSON structure after cleaning")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error cleaning response: {str(e)}")
+            return None
+
+    def create_analysis_prompt(self, interview_data: Dict[str, str]) -> str:
+        """Create a structured prompt for analysis"""
+        return f"""
+You are a career analysis expert. Analyze this interview transcript for {interview_data['name']}
+regarding their career path prediction (Academia vs Industry).
+Provide your analysis in the following JSON format ONLY, without any additional text or markdown:
+
+{{
+"interviewee": {{
+    "name": "{interview_data['name']}",
+    "source_document": "{interview_data['source']}"
+}},
+"sentiment_analysis": {{
+    "academia": {{
+        "research": {{"score": 0.0, "quotes": []}},
+        "teaching": {{"score": 0.0, "quotes": []}},
+        "publication": {{"score": 0.0, "quotes": []}},
+        "grant_writing": {{"score": 0.0, "quotes": []}},
+        "mentoring": {{"score": 0.0, "quotes": []}},
+        "work_life_balance": {{"score": 0.0, "quotes": []}},
+        "collaboration": {{"score": 0.0, "quotes": []}}
+    }},
+    "industry": {{
+        "product_development": {{"score": 0.0, "quotes": []}},
+        "business_strategy": {{"score": 0.0, "quotes": []}},
+        "management": {{"score": 0.0, "quotes": []}},
+        "work_life_balance": {{"score": 0.0, "quotes": []}},
+        "financial_rewards": {{"score": 0.0, "quotes": []}}
+    }}
+}},
+"keyword_analysis": {{
+    "academia": [],
+    "industry": []
+}},
+"themes": [],
+"motivations": {{
+    "primary": [],
+    "intrinsic": [],
+    "extrinsic": [],
+    "evidence_quotes": []
+}},
+"risk_assessment": {{
+    "level": "",
+    "description": "",
+    "supporting_quotes": []
+}},
+"long_term_goals": {{
+    "vision": "",
+    "alignment": "",
+    "supporting_quotes": []
+}},
+"career_prediction": {{
+    "path": "",
+    "confidence": 0,
+    "rationale": ""
+}}
+}}
+
+Here is the interview transcript to analyze:
+
+{interview_data['content']}
+
+Analyze the transcript and fill in the JSON structure with your findings. Ensure all scores are between -1.0 and 1.0,
+confidence is between 1 and 10, and include relevant quotes from the text to support your analysis.
+Return ONLY the JSON structure without any additional text or formatting.
+"""
+
+    def analyze_transcript(self, interview_data: Dict[str, str]) -> Dict:
+        """Analyze a single transcript using Gemini API with rate limiting"""
+        try:
+            prompt = self.create_analysis_prompt(interview_data)
+            estimated_tokens = len(prompt.split())  # rough estimation
+
+            # Check rate limits
+            while not self.rate_limiter.can_make_request(estimated_tokens):
+                wait_time = self.rate_limiter.wait_time()
+                st.warning(f"Rate limit reached. Waiting {wait_time:.1f} seconds...")
+                time.sleep(wait_time + 1)  # Add 1 second buffer
+
+            # Make the API call
+            st.info("Making API request...")
+            response = self.model.generate_content(prompt)
+            self.rate_limiter.add_request(estimated_tokens)
+
+            if not response or not response.text:
+                st.error("Received empty response from API")
+                return None
+
+            # Clean and parse the response
+            cleaned_response = self.clean_gemini_response(response.text)
+            if not cleaned_response:
+                st.error("Failed to extract valid JSON from API response")
+                return None
+
+            # Parse the cleaned JSON
+            analysis = json.loads(cleaned_response)
+            analysis['metadata'] = {
+                'analysis_timestamp': datetime.now().isoformat(),
+                'source_document': interview_data['source']
+            }
+            return analysis
+        except Exception as e:
+            st.error(f"Analysis Error: {str(e)}")
+            self.logger.error(f"Error analyzing transcript for {interview_data['name']}: {str(e)}")
+            return None
+
+    def _validate_analysis_structure(self, analysis: Dict, interview_data: Dict) -> Dict:
+        """Validate and fix analysis structure if needed"""
+        template = {
+            "interviewee": {
+                "name": interview_data['name'],
+                "source_document": interview_data['source']
+            },
+            "sentiment_analysis": {
+                "academia": {},
+                "industry": {}
+            },
+            "keyword_analysis": {
+                "academia": [],
+                "industry": []
+            },
+            "themes": [],
+            "motivations": {
+                "primary": [],
+                "intrinsic": [],
+                "extrinsic": [],
+                "evidence_quotes": []
+            },
+            "risk_assessment": {
+                "level": "",
+                "description": "",
+                "supporting_quotes": []
+            },
+            "long_term_goals": {
+                "vision": "",
+                "alignment": "",
+                "supporting_quotes": []
+            },
+            "career_prediction": {
+                "path": "",
+                "confidence": 0,
+                "rationale": ""
+            },
+            "metadata": {
+                "analysis_timestamp": datetime.now().isoformat(),
+                "source_document": interview_data['source']
+            }
+        }
+
+        for key, value in template.items():
+            if key not in analysis:
+                analysis[key] = value
+        return analysis
+
+    def display_analysis_results(self, analysis: Dict):
+        """Display analysis results in Streamlit with enhanced visualizations"""
+        try:
+            st.subheader(f"Analysis for {analysis.get('interviewee', {}).get('name', 'Unknown')}")
+            col1, col2 = st.columns(2)
+
+            with col1:
+                st.write("#### Career Prediction")
+                prediction = analysis.get('career_prediction', {})
+                st.write(f"**Predicted Path:** {prediction.get('path', 'Unknown')}")
+                st.write(f"**Confidence:** {prediction.get('confidence', 0)}/10")
+                st.write("**Rationale:**", prediction.get('rationale', 'Not available'))
+
+            with col2:
+                st.write("#### Sentiment Analysis")
+                sentiment = analysis.get('sentiment_analysis', {})
+                st.write(f"**Academia:** {self._safe_calculate_sentiment(sentiment.get('academia', {}))}")
+                st.write(f"**Industry:** {self._safe_calculate_sentiment(sentiment.get('industry', {}))}")
+
+            # Radar Chart
+            st.write("### Sentiment Analysis Radar Chart")
+            radar_fig = self.create_radar_chart(analysis)
+            st.plotly_chart(radar_fig)
+
+            # Bar Chart
+            st.write("### Sentiment Scores Bar Chart")
+            bar_fig = self.create_bar_chart(analysis)
+            st.plotly_chart(bar_fig)
+
+            # Pie Chart for Motivations
+            st.write("### Motivations Breakdown")
+            motivations = analysis.get('motivations', {})
+            pie_fig = self.create_pie_chart({
+                'Primary': motivations.get('primary', []),
+                'Intrinsic': motivations.get('intrinsic', []),
+                'Extrinsic': motivations.get('extrinsic', [])
+            }, "Motivations Distribution")
+            st.plotly_chart(pie_fig)
+
+            # Themes
+            st.write("### Key Themes")
+            themes = analysis.get('themes', [])
+            if isinstance(themes, list):
+                for theme in themes:
+                    if isinstance(theme, dict):
+                        st.write(f"- **{theme.get('name', '')}:** {theme.get('description', '')}")
+
+            # Motivations Details
+            st.write("### Motivations")
+            motivations = analysis.get('motivations', {})
+            st.write(f"**Primary:** {', '.join(motivations.get('primary', []))}")
+            st.write(f"**Intrinsic:** {', '.join(motivations.get('intrinsic', []))}")
+            st.write(f"**Extrinsic:** {', '.join(motivations.get('extrinsic', []))}")
+
+            # Risk Assessment
+            st.write("### Risk Assessment")
+            risk = analysis.get('risk_assessment', {})
+            st.write(f"**Level:** {risk.get('level', 'Unknown')}")
+            st.write(risk.get('description', 'Not available'))
+
+            # Long Term Goals
+            st.write("### Long Term Goals")
+            goals = analysis.get('long_term_goals', {})
+            st.write(f"**Vision:** {goals.get('vision', '')}")
+            st.write(f"**Alignment:** {goals.get('alignment', '')}")
+
+        except Exception as e:
+            st.error(f"Error displaying analysis: {str(e)}")
+
+    def generate_summary_table(self, analyses: List[Dict]) -> pd.DataFrame:
+        """Generate a summary table from all analyses"""
+        summary_data = []
+        for analysis in analyses:
+            if not analysis:
+                continue
+            try:
+                themes = []
+                if isinstance(analysis.get('themes', []), list):
+                    themes = [theme.get('name', '') for theme in analysis['themes'] if isinstance(theme, dict)]
+                motivations = []
+                if isinstance(analysis.get('motivations', {}), dict):
+                    motivations = analysis['motivations'].get('primary', [])
+                summary_row = {
+                    'Name': analysis.get('interviewee', {}).get('name', 'Unknown'),
+                    'Predicted Career Path': analysis.get('career_prediction', {}).get('path', 'Unknown'),
+                    'Confidence Score': analysis.get('career_prediction', {}).get('confidence', 0),
+                    'Primary Motivations': ', '.join(motivations) if isinstance(motivations, list) else '',
+                    'Risk Level': analysis.get('risk_assessment', {}).get('level', 'Unknown'),
+                    'Key Themes': ', '.join(themes),
+                    'Academia Sentiment': self._safe_calculate_sentiment(analysis.get('sentiment_analysis', {}).get('academia', {})),
+                    'Industry Sentiment': self._safe_calculate_sentiment(analysis.get('sentiment_analysis', {}).get('industry', {})),
+                    'Source Document': analysis.get('metadata', {}).get('source_document', 'Unknown')
+                }
+                summary_data.append(summary_row)
+            except Exception as e:
+                self.logger.error(f"Error processing analysis for summary: {str(e)}")
+                st.error(f"Error processing analysis: {str(e)}")
+                continue
+        return pd.DataFrame(summary_data)
+
+    def _safe_calculate_sentiment(self, sentiment_dict: Dict) -> float:
+        """Safely calculate average sentiment score from a sentiment dictionary"""
+        try:
+            if not isinstance(sentiment_dict, dict):
+                return 0.0
+            scores = []
+            for item in sentiment_dict.values():
+                if isinstance(item, dict) and 'score' in item:
+                    try:
+                        scores.append(float(item['score']))
+                    except (ValueError, TypeError):
+                        continue
+            return round(sum(scores) / len(scores), 2) if scores else 0.0
+        except Exception:
+            return 0.0
+
+    # Visualization Methods
+    def create_radar_chart(self, analysis: Dict) -> go.Figure:
+        """Create a radar chart for sentiment analysis"""
+        try:
+            academia_scores = analysis.get('sentiment_analysis', {}).get('academia', {})
+            industry_scores = analysis.get('sentiment_analysis', {}).get('industry', {})
+
+            # Define separate categories for academia and industry
+            academia_categories = list(academia_scores.keys())
+            industry_categories = list(industry_scores.keys())
+
+            # Combine categories for consistent radar chart
+            categories = sorted(list(set(academia_categories + industry_categories)))
+
+            # Prepare values, aligning categories
+            academia_values = [academia_scores.get(cat, {}).get('score', 0.0) for cat in categories]
+            industry_values = [industry_scores.get(cat, {}).get('score', 0.0) for cat in categories]
+
+            # Create radar chart
+            fig = go.Figure()
+
+            fig.add_trace(go.Scatterpolar(
+                r=academia_values,
+                theta=categories,
+                fill='toself',
+                name='Academia'
+            ))
+            fig.add_trace(go.Scatterpolar(
+                r=industry_values,
+                theta=categories,
+                fill='toself',
+                name='Industry'
+            ))
+
+            fig.update_layout(
+                polar=dict(
+                    radialaxis=dict(
+                        visible=True,
+                        range=[-1, 1]
+                    )
+                ),
+                showlegend=True,
+                title=f"Sentiment Analysis Radar for {analysis['interviewee']['name']}"
+            )
+            return fig
+        except Exception as e:
+            self.logger.error(f"Error creating radar chart: {str(e)}")
+            return go.Figure()
+
+    def create_bar_chart(self, analysis: Dict) -> go.Figure:
+        """Create a bar chart for sentiment scores"""
+        try:
+            academia_scores = analysis.get('sentiment_analysis', {}).get('academia', {})
+            industry_scores = analysis.get('sentiment_analysis', {}).get('industry', {})
+
+            # Define categories for academia and industry
+            academia_categories = list(academia_scores.keys())
+            industry_categories = list(industry_scores.keys())
+
+            # Create separate dataframes
+            df_academia = pd.DataFrame({
+                'Category': academia_categories,
+                'Sentiment': [academia_scores[cat]['score'] for cat in academia_categories],
+                'Sector': ['Academia'] * len(academia_categories)
+            })
+
+            df_industry = pd.DataFrame({
+                'Category': industry_categories,
+                'Sentiment': [industry_scores[cat]['score'] for cat in industry_categories],
+                'Sector': ['Industry'] * len(industry_categories)
+            })
+
+            # Combine dataframes
+            df = pd.concat([df_academia, df_industry], ignore_index=True)
+
+            fig = px.bar(df, x='Category', y='Sentiment', color='Sector', barmode='group',
+                         title=f"Sentiment Scores for {analysis['interviewee']['name']}",
+                         range_y=[-1, 1])
+
+            return fig
+        except Exception as e:
+            self.logger.error(f"Error creating bar chart: {str(e)}")
+            return go.Figure()
+
+    def create_pie_chart(self, motivations: Dict[str, List[str]], title: str) -> go.Figure:
+        """Create a pie chart for motivations breakdown"""
+        try:
+            labels = list(motivations.keys())
+            values = [len(v) for v in motivations.values()]
+            fig = px.pie(names=labels, values=values, title=title)
+            return fig
+        except Exception as e:
+            self.logger.error(f"Error creating pie chart: {str(e)}")
+            return go.Figure()
+
+    # Additional Features
+    def comparative_dashboard(self):
+        """Comparative Analysis Dashboard"""
+        st.header("Comparative Analysis")
+        selected = st.multiselect("Select Interviewees to Compare", 
+                                  options=[a['interviewee']['name'] for a in st.session_state.analyses])
+
+        if len(selected) >= 2:
+            selected_analyses = [a for a in st.session_state.analyses if a['interviewee']['name'] in selected]
+            fig = go.Figure()
+
+            for analysis in selected_analyses:
+                academia_scores = analysis.get('sentiment_analysis', {}).get('academia', {})
+                industry_scores = analysis.get('sentiment_analysis', {}).get('industry', {})
+
+                academia_categories = list(academia_scores.keys())
+                industry_categories = list(industry_scores.keys())
+                categories = sorted(list(set(academia_categories + industry_categories)))
+
+                academia_values = [academia_scores.get(cat, {}).get('score', 0.0) for cat in categories]
+                industry_values = [industry_scores.get(cat, {}).get('score', 0.0) for cat in categories]
+
+                # Academia Trace
+                fig.add_trace(go.Scatterpolar(
+                    r=academia_values,
+                    theta=categories,
+                    fill='toself',
+                    name=f"{analysis['interviewee']['name']} - Academia"
+                ))
+
+                # Industry Trace
+                fig.add_trace(go.Scatterpolar(
+                    r=industry_values,
+                    theta=categories,
+                    fill='toself',
+                    name=f"{analysis['interviewee']['name']} - Industry"
+                ))
+
+            fig.update_layout(
+                polar=dict(
+                    radialaxis=dict(
+                        visible=True,
+                        range=[-1, 1]
+                    )
+                ),
+                showlegend=True,
+                title="Comparative Sentiment Analysis Radar Chart"
+            )
+            st.plotly_chart(fig)
+        elif len(selected) == 1:
+            st.info("Select at least two interviewees to compare sentiment analyses.")
+
+    def clear_chat(self):
+        """Clear the chat history"""
+        st.session_state.chat_history = []
+
+    def chat_interface(self):
+        """Chat section to ask questions about uploaded files"""
+        st.header("📢 Chat with Analysis")
+        
+        if 'chat_history' not in st.session_state:
+            st.session_state.chat_history = []
+
+        # Display chat history
+        for chat in st.session_state.chat_history:
+            if chat['role'] == 'user':
+                st.markdown(f"**You:** {chat['content']}")
+            else:
+                st.markdown(f"**Assistant:** {chat['content']}")
+
+        # User input
+        user_input = st.text_input("Ask a question about your uploaded files:")
+
+        if st.button("Send") and user_input:
+            st.session_state.chat_history.append({"role": "user", "content": user_input})
+            response = self.handle_chat(user_input)
+            st.session_state.chat_history.append({"role": "assistant", "content": response})
+
+    def handle_chat(self, question: str) -> str:
+        """Handle user questions by sending them to the Gemini API with context"""
+        try:
+            # Compile all analyses into a summary
+            summary = ""
+            for analysis in st.session_state.analyses:
+                summary += f"Interviewee: {analysis.get('interviewee', {}).get('name', 'Unknown')}\n"
+                summary += json.dumps(analysis, indent=2) + "\n\n"
+
+            # Create prompt for Gemini
+            prompt = f"""
+            You are an assistant specialized in analyzing interview data. Based on the following analysis summaries, answer the user's question concisely. Provide your answer in JSON format only, without any additional text or explanations.
+
+            Analysis Summaries:
+            {summary}
+
+            User Question: {question}
+
+            JSON Response:
+            """
+
+            # Rate limiting
+            estimated_tokens = len(prompt.split())
+            while not self.rate_limiter.can_make_request(estimated_tokens):
+                wait_time = self.rate_limiter.wait_time()
+                st.warning(f"Rate limit reached. Waiting {wait_time:.1f} seconds before answering your question...")
+                time.sleep(wait_time + 1)  # Add 1 second buffer
+
+            # Make API call
+            response = self.model.generate_content(prompt)
+            self.rate_limiter.add_request(estimated_tokens)
+
+            if not response or not response.text:
+                return "I'm sorry, I couldn't retrieve an answer at this time."
+
+            # Clean and parse the response
+            cleaned_response = self.clean_gemini_response(response.text)
+            if not cleaned_response:
+                self.logger.debug(f"Raw API response: {response.text}")
+                return "I'm sorry, I couldn't understand the response from the analysis."
+
+            return cleaned_response
+        except Exception as e:
+            self.logger.error(f"Chat Error: {str(e)}")
+            return "An error occurred while processing your request."
+# Main Application
+def main():
+    st.set_page_config(
+        page_title="Interview Analysis App",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+
+    st.title("📝 Interview Analysis App")
+    st.markdown("""
+    This app analyzes interview transcripts to predict career paths and provide detailed insights.
+    Upload your interview transcripts to get started.
+    """)
+
+    # Sidebar Configuration
+    with st.sidebar:
+        st.header("🔧 Configuration")
+        api_key = st.text_input(
+            "Enter your Gemini API Key",
+            type="password",
+            help="Your Gemini API key is required for analysis"
+        )
+
+        st.subheader("⚙️ Analysis Settings")
+        show_details = st.checkbox("Show detailed analysis", value=True)
+        confidence_threshold = st.slider(
+            "Confidence Threshold",
+            min_value=1,
+            max_value=10,
+            value=5,
+            help="Minimum confidence score for predictions"
+        )
+
+        st.markdown("""
+        ### 📈 API Rate Limits
+        - **2 requests per minute**
+        - **32,000 tokens per minute**
+        - **50 requests per day**
+        """)
+
+        if not api_key:
+            st.warning("⚠️ Please enter your Gemini API Key in the sidebar to continue")
+            st.stop()
+
+    # Initialize session state
+    if 'analyses' not in st.session_state:
+        st.session_state.analyses = []
+    if 'processed_files' not in st.session_state:
+        st.session_state.processed_files = set()
+    if 'rate_limiter' not in st.session_state:
+        st.session_state.rate_limiter = RateLimiter()
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+
+    try:
+        analyzer = InterviewAnalyzer(api_key)
+        st.header("📤 Upload Interview Transcripts")
+        uploaded_files = st.file_uploader(
+            "Upload your interview transcripts",
+            accept_multiple_files=True,
+            type=['txt', 'docx'],
+            help="Supported formats: TXT, DOCX"
+        )
+
+        if uploaded_files:
+            for file in uploaded_files:
+                file_id = f"{file.name}_{file.size}"
+                if file_id in st.session_state.processed_files:
+                    st.info(f"✅ {file.name} has already been processed.")
+                    continue
+                with st.expander(f"Processing {file.name}", expanded=True):
+                    try:
+                        st.info(f"📄 Reading file: {file.name}")
+                        content = read_file_content(file)
+                        interview_data = analyzer.extract_interview_data(content, file.name)
+                        st.write(f"🔍 Analyzing interview for: {interview_data['name']}")
+                        with st.spinner('Analyzing interview...'):
+                            analysis = analyzer.analyze_transcript(interview_data)
+                            if analysis:
+                                analyzer._validate_analysis_structure(analysis, interview_data)
+                                st.session_state.analyses.append(analysis)
+                                st.session_state.processed_files.add(file_id)
+                                st.success(f"✅ Analysis complete for {interview_data['name']}")
+                            else:
+                                st.error(f"❌ Failed to analyze {file.name}")
+                    except Exception as e:
+                        st.error(f"Error processing {file.name}: {str(e)}")
+                        continue
+
+        if st.session_state.analyses:
+            st.header("📊 Analysis Results")
+            try:
+                summary_df = analyzer.generate_summary_table(st.session_state.analyses)
+                if confidence_threshold > 1:
+                    summary_df = summary_df[summary_df['Confidence Score'] >= confidence_threshold]
+                st.subheader("📋 Summary of Analyses")
+                st.dataframe(
+                    summary_df,
+                    use_container_width=True,
+                    hide_index=True
+                )
+
+                # Download Options
+                st.subheader("💾 Download Results")
+                col1, col2 = st.columns(2)
+                with col1:
+                    json_str = json.dumps(st.session_state.analyses, indent=2)
+                    st.download_button(
+                        label="📥 Download Detailed Analysis (JSON)",
+                        data=json_str,
+                        file_name=f"interview_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+                        mime="application/json",
+                        help="Download the complete analysis results in JSON format"
+                    )
+                with col2:
+                    csv = summary_df.to_csv(index=False)
+                    st.download_button(
+                        label="📥 Download Summary (CSV)",
+                        data=csv,
+                        file_name=f"analysis_summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                        mime="text/csv",
+                        help="Download the summary table in CSV format"
+                    )
+
+                # Detailed Analysis with Visualizations
+                if show_details:
+                    st.header("🔍 Detailed Analysis")
+                    for idx, analysis in enumerate(st.session_state.analyses, 1):
+                        with st.expander(
+                            f"📊 Analysis {idx}: {analysis.get('interviewee', {}).get('name', 'Unknown')}",
+                            expanded=False
+                        ):
+                            analyzer.display_analysis_results(analysis)
+
+                # Comparative Analysis Dashboard
+                analyzer.comparative_dashboard()
+
+                # Chat Interface
+                analyzer.chat_interface()
+
+                # Clear Results Button
+                if st.button("🗑️ Clear All Results and Chat History"):
+                    st.session_state.analyses = []
+                    st.session_state.processed_files = set()
+                    st.session_state.rate_limiter = RateLimiter()
+                    st.session_state.chat_history = []
+                    st.experimental_rerun()
+
+                # Instructions
+                st.header("ℹ️ Instructions")
+                st.markdown("""
+                ### How to Use:
+                
+                1. **Enter your Gemini API key** in the sidebar.
+                2. **Upload** one or more interview transcript files (`.txt` or `.docx`).
+                3. **Wait** for the analysis to complete.
+                4. **View** results, explore detailed analyses, and download reports.
+                5. **Use the chat section** to ask specific questions about your uploaded files.
+                
+                **Supported file formats:** `.txt`, `.docx`
+                """)
+
+            except Exception as e:
+                st.error("Error displaying results")
+                st.exception(e)
+        else:
+            st.info("👆 Upload your interview transcripts to begin analysis")
+
+    except Exception as e:
+        st.error("Critical Error")
+        st.exception(e)
+        st.warning("Please refresh the page and try again")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,9 @@
+google-generativeai
+pandas
+typing
+datetime
+logging
+pathlib
+streamlit
+python-docx 
+plotly-express