❌ File not found: {file}
" - except Exception as e: - return f"❌ Error creating download link: {str(e)}
" + # ▶ 4) Show or hide custom component (optional example) + mycomponent = components.declare_component("mycomponent", path="mycomponent") + val = mycomponent(my_input_value="Hello from MyComponent") -def play_and_download_audio(file_path: str, file_type: str = "mp3"): - """ - Display audio player and download link for audio file. - Includes error handling and file validation. - """ - if not file_path: - st.warning("No audio file provided.") - return - - if not os.path.exists(file_path): - st.error(f"Audio file not found: {file_path}") - return - - try: - # Display audio player - st.audio(file_path) - - # Create and display download link - dl_link = get_download_link(file_path, file_type=file_type) - st.markdown(dl_link, unsafe_allow_html=True) - - except Exception as e: - st.error(f"Error playing audio: {str(e)}") - -def get_file_info(file_path: str) -> dict: - """ - Get detailed information about a file. - Returns dictionary with size, modification time, and other metadata. - """ - try: - stats = os.stat(file_path) - - # Get basic file information - info = { - 'name': os.path.basename(file_path), - 'path': file_path, - 'size': stats.st_size, - 'modified': datetime.fromtimestamp(stats.st_mtime), - 'created': datetime.fromtimestamp(stats.st_ctime), - 'type': os.path.splitext(file_path)[1].lower().strip('.'), - } - - # Add formatted size - if info['size'] < 1024: - info['size_fmt'] = f"{info['size']} B" - elif info['size'] < 1024 * 1024: - info['size_fmt'] = f"{info['size']/1024:.1f} KB" - else: - info['size_fmt'] = f"{info['size']/(1024*1024):.1f} MB" - - # Add formatted dates - info['modified_fmt'] = info['modified'].strftime("%Y-%m-%d %H:%M:%S") - info['created_fmt'] = info['created'].strftime("%Y-%m-%d %H:%M:%S") - - return info - - except Exception as e: - st.error(f"Error getting file info: {str(e)}") - return None - -def sanitize_filename(filename: str) -> str: - """ - Clean and sanitize a filename to ensure it's safe for filesystem. - Removes/replaces unsafe characters and enforces length limits. - """ - # Remove or replace unsafe characters - filename = re.sub(r'[<>:"/\\|?*]', '_', filename) - - # Remove leading/trailing spaces and dots - filename = filename.strip('. ') - - # Limit length (reserving space for extension) - max_length = 255 - name, ext = os.path.splitext(filename) - if len(filename) > max_length: - return name[:(max_length-len(ext))] + ext - - return filename - -def create_file_with_metadata(filename: str, content: str, metadata: dict = None): - """ - Create a file with optional metadata header. - Useful for storing additional information with files. - """ - try: - # Sanitize filename - safe_filename = sanitize_filename(filename) - - # Ensure directory exists - os.makedirs(os.path.dirname(safe_filename) or '.', exist_ok=True) - - # Prepare content with metadata - if metadata: - metadata_str = json.dumps(metadata, indent=2) - full_content = f"""--- -{metadata_str} ---- -{content}""" - else: - full_content = content - - # Write file - with open(safe_filename, 'w', encoding='utf-8') as f: - f.write(full_content) - - return safe_filename - - except Exception as e: - st.error(f"Error creating file: {str(e)}") - return None - -def read_file_with_metadata(filename: str) -> tuple: - """ - Read a file and extract any metadata header. - Returns tuple of (content, metadata). - """ - try: - with open(filename, 'r', encoding='utf-8') as f: - content = f.read() - - # Check for metadata section - if content.startswith('---\n'): - # Find end of metadata section - end_meta = content.find('\n---\n', 4) - if end_meta != -1: - try: - metadata = json.loads(content[4:end_meta]) - content = content[end_meta+5:] - return content, metadata - except json.JSONDecodeError: - pass - - return content, None - - except Exception as e: - st.error(f"Error reading file: {str(e)}") - return None, None - -def archive_files(file_paths: list, archive_name: str = None) -> str: - """ - Create a zip archive containing the specified files. - Returns path to created archive. - """ - try: - # Generate archive name if not provided - if not archive_name: - timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") - archive_name = f"archive_{timestamp}.zip" - - # Create zip file - with zipfile.ZipFile(archive_name, 'w', zipfile.ZIP_DEFLATED) as zf: - for file_path in file_paths: - if os.path.exists(file_path): - zf.write(file_path, os.path.basename(file_path)) - - return archive_name - - except Exception as e: - st.error(f"Error creating archive: {str(e)}") - return None - -def list_files_by_type(directory: str = ".", - extensions: list = None, - recursive: bool = False) -> dict: - """ - List files in directory filtered by extension. - Returns dict grouping files by type. - """ - try: - if extensions is None: - extensions = ['md', 'mp3', 'wav', 'pdf', 'txt', 'json', 'csv'] - - files = {} - pattern = "**/*" if recursive else "*" - - for ext in extensions: - glob_pattern = f"{pattern}.{ext}" - matches = glob.glob(os.path.join(directory, glob_pattern), - recursive=recursive) - if matches: - files[ext] = matches - - return files - - except Exception as e: - st.error(f"Error listing files: {str(e)}") - return {} - - - - - - -def get_central_time() -> datetime: - """Get current time in US Central timezone.""" - central = pytz.timezone('US/Central') - return datetime.now(central) - -def format_timestamp_prefix() -> str: - """Generate timestamp prefix in format MM_dd_yy_hh_mm_AM/PM.""" - ct = get_central_time() - return ct.strftime("%m_%d_%y_%I_%M_%p") - -def get_formatted_time(dt: datetime = None, - timezone: str = 'US/Central', - include_timezone: bool = True, - include_seconds: bool = False) -> str: - """ - Format a datetime object with specified options. - If no datetime is provided, uses current time. - """ - if dt is None: - tz = pytz.timezone(timezone) - dt = datetime.now(tz) - elif dt.tzinfo is None: - tz = pytz.timezone(timezone) - dt = tz.localize(dt) - - format_string = "%Y-%m-%d %I:%M" - if include_seconds: - format_string += ":%S" - format_string += " %p" - if include_timezone: - format_string += " %Z" - - return dt.strftime(format_string) - -def parse_timestamp(timestamp_str: str, - timezone: str = 'US/Central') -> Optional[datetime]: - """ - Parse a timestamp string in various formats. - Returns timezone-aware datetime object. - """ - try: - # Try different format patterns - patterns = [ - "%m_%d_%y_%I_%M_%p", # Standard app format - "%Y-%m-%d %I:%M %p", # Common 12-hour format - "%Y-%m-%d %H:%M", # 24-hour format - "%m/%d/%y %I:%M %p", # US date format - "%d/%m/%y %I:%M %p" # European date format - ] - - dt = None - for pattern in patterns: - try: - dt = datetime.strptime(timestamp_str, pattern) - break - except ValueError: - continue - - if dt is None: - raise ValueError(f"Could not parse timestamp: {timestamp_str}") - - # Add timezone if not present - if dt.tzinfo is None: - tz = pytz.timezone(timezone) - dt = tz.localize(dt) - - return dt - - except Exception as e: - st.error(f"Error parsing timestamp: {str(e)}") - return None - -def get_time_ago(dt: datetime) -> str: - """ - Convert datetime to human-readable "time ago" format. - E.g., "2 hours ago", "3 days ago", etc. - """ - try: - now = datetime.now(dt.tzinfo) - diff = now - dt - - seconds = diff.total_seconds() - - if seconds < 60: - return "just now" - elif seconds < 3600: - minutes = int(seconds / 60) - return f"{minutes} minute{'s' if minutes != 1 else ''} ago" - elif seconds < 86400: - hours = int(seconds / 3600) - return f"{hours} hour{'s' if hours != 1 else ''} ago" - elif seconds < 604800: - days = int(seconds / 86400) - return f"{days} day{'s' if days != 1 else ''} ago" - elif seconds < 2592000: - weeks = int(seconds / 604800) - return f"{weeks} week{'s' if weeks != 1 else ''} ago" - elif seconds < 31536000: - months = int(seconds / 2592000) - return f"{months} month{'s' if months != 1 else ''} ago" + if val: + val_stripped = val.replace('\\n', ' ') + edited_input = st.text_area("✏️ Edit Input:", value=val_stripped, height=100) + run_option = st.selectbox("Model:", ["Arxiv", "Other (demo)"]) + col1, col2 = st.columns(2) + with col1: + autorun = st.checkbox("⚙ AutoRun", value=True) + with col2: + full_audio = st.checkbox("📚FullAudio", value=False) + + input_changed = (val != st.session_state.old_val) + + if autorun and input_changed: + st.session_state.old_val = val + st.session_state.last_query = edited_input + perform_ai_lookup(edited_input, + vocal_summary=True, + extended_refs=False, + titles_summary=True, + full_audio=full_audio) else: - years = int(seconds / 31536000) - return f"{years} year{'s' if years != 1 else ''} ago" - - except Exception as e: - st.error(f"Error calculating time ago: {str(e)}") - return "unknown time ago" - -def format_duration(seconds: float) -> str: - """ - Format a duration in seconds to human-readable string. - E.g., "2m 30s", "1h 15m", etc. - """ - try: - if seconds < 0: - return "invalid duration" - - # Handle special cases - if seconds < 1: - return f"{seconds * 1000:.0f}ms" - if seconds < 60: - return f"{seconds:.1f}s" - - # Calculate hours, minutes, seconds - hours = int(seconds // 3600) - minutes = int((seconds % 3600) // 60) - secs = seconds % 60 - - # Build duration string - parts = [] - if hours > 0: - parts.append(f"{hours}h") - if minutes > 0: - parts.append(f"{minutes}m") - if secs > 0 and hours == 0: # Only show seconds if less than an hour - parts.append(f"{secs:.1f}s") - - return " ".join(parts) - - except Exception as e: - st.error(f"Error formatting duration: {str(e)}") - return "unknown duration" - - - - - - -async def create_paper_audio_files(papers: List[Dict], input_question: str): - """Generate audio files for papers asynchronously with improved naming.""" - with PerformanceTimer("paper_audio_generation"): - tasks = [] - for paper in papers: - try: - # Prepare text for audio generation - audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}" - audio_text = clean_for_speech(audio_text) - - # Create sanitized title for filename - safe_title = paper['title'].lower() - safe_title = re.sub(r'[^\w\s-]', '', safe_title) # Remove special chars - safe_title = re.sub(r'\s+', '_', safe_title) # Replace spaces with underscores - safe_title = safe_title[:100] # Limit length - - # Generate timestamp - timestamp = format_timestamp_prefix() - - # Create filename with timestamp and title - filename = f"{timestamp}_{safe_title}.{st.session_state['audio_format']}" - - # Create task for audio generation - async def generate_audio(text, filename): - rate_str = "0%" - pitch_str = "0Hz" - communicate = edge_tts.Communicate(text, st.session_state['tts_voice']) - await communicate.save(filename) - return filename - - task = generate_audio(audio_text, filename) - tasks.append((paper, task, filename)) - - except Exception as e: - st.warning(f"Error preparing audio for paper {paper['title']}: {str(e)}") - continue - - # Process all audio generation tasks concurrently - for paper, task, filename in tasks: - try: - audio_file = await task - if audio_file: - paper['full_audio'] = audio_file - if st.session_state['enable_download']: - paper['download_base64'] = create_download_link_with_cache( - audio_file, - st.session_state['audio_format'] - ) - except Exception as e: - st.warning(f"Error generating audio for paper {paper['title']}: {str(e)}") - paper['full_audio'] = None - paper['download_base64'] = '' - - - - - - - - - -# ───────────────────────────────────────────────────────── -# 4. PAPER PROCESSING & DISPLAY -# ───────────────────────────────────────────────────────── - -def parse_arxiv_refs(ref_text: str) -> List[Dict[str, str]]: - """Parse arxiv references with improved error handling.""" - if not ref_text: - return [] - - with PerformanceTimer("parse_refs"): - results = [] - current_paper = {} - lines = ref_text.split('\n') - - for i, line in enumerate(lines): - try: - if line.count('|') == 2: - # Found a new paper line - if current_paper: - results.append(current_paper) - if len(results) >= 20: # Limit to 20 papers - break - - # Parse header parts - header_parts = line.strip('* ').split('|') - date = header_parts[0].strip() - title = header_parts[1].strip() - url_match = re.search(r'(https://arxiv.org/\S+)', line) - url = url_match.group(1) if url_match else f"paper_{len(results)}" - - current_paper = { - 'date': date, - 'title': title, - 'url': url, - 'authors': '', - 'summary': '', - 'full_audio': None, - 'download_base64': '', - } - - elif current_paper: - # Add content to current paper - line = line.strip('* ') - if not current_paper['authors']: - current_paper['authors'] = line - else: - if current_paper['summary']: - current_paper['summary'] += ' ' + line - else: - current_paper['summary'] = line - - except Exception as e: - st.warning(f"Error parsing line {i}: {str(e)}") - continue - - # Add final paper if exists - if current_paper: - results.append(current_paper) - - return results[:20] # Ensure we don't exceed 20 papers - -async def create_paper_audio_files(papers: List[Dict], input_question: str): - """Generate audio files for papers asynchronously with progress tracking.""" - with PerformanceTimer("paper_audio_generation"): - tasks = [] - for paper in papers: - try: - # Prepare text for audio generation - audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}" - audio_text = clean_for_speech(audio_text) - - # Create task for audio generation - task = async_edge_tts_generate( - audio_text, - voice=st.session_state['tts_voice'], - file_format=st.session_state['audio_format'] - ) - tasks.append((paper, task)) - - except Exception as e: - st.warning(f"Error preparing audio for paper {paper['title']}: {str(e)}") - continue - - # Process all audio generation tasks concurrently - for paper, task in tasks: - try: - audio_file, gen_time = await task - if audio_file: - paper['full_audio'] = audio_file - if st.session_state['enable_download']: - paper['download_base64'] = create_download_link_with_cache( - audio_file, - st.session_state['audio_format'] - ) - except Exception as e: - st.warning(f"Error generating audio for paper {paper['title']}: {str(e)}") - paper['full_audio'] = None - paper['download_base64'] = '' - - -def initialize_marquee_settings(): - """Initialize default marquee settings if not present in session state.""" - if 'marquee_settings' not in st.session_state: - st.session_state['marquee_settings'] = { - "background": "#1E1E1E", - "color": "#FFFFFF", - "font-size": "14px", - "animationDuration": "20s", - "width": "100%", - "lineHeight": "35px" - } - -def get_marquee_settings(): - """Get current marquee settings, initializing if needed.""" - initialize_marquee_settings() - return st.session_state['marquee_settings'] - -def update_marquee_settings_ui(): - """Add color pickers & sliders for marquee configuration in sidebar.""" - st.sidebar.markdown("### 🎯 Marquee Settings") - - # Create two columns for settings - cols = st.sidebar.columns(2) - - # Column 1: Color settings - with cols[0]: - # Background color picker - bg_color = st.color_picker( - "🎨 Background", - st.session_state['marquee_settings']["background"], - key="bg_color_picker" - ) - - # Text color picker - text_color = st.color_picker( - "✍️ Text Color", - st.session_state['marquee_settings']["color"], - key="text_color_picker" - ) - - # Column 2: Size and speed settings - with cols[1]: - # Font size slider - font_size = st.slider( - "📏 Font Size", - 10, 24, 14, - key="font_size_slider" - ) - - # Animation duration slider - duration = st.slider( - "⏱️ Animation Speed", - 1, 20, 20, - key="duration_slider" - ) - - # Update session state with new settings - st.session_state['marquee_settings'].update({ - "background": bg_color, - "color": text_color, - "font-size": f"{font_size}px", - "animationDuration": f"{duration}s" - }) - -def display_marquee(text: str, settings: dict, key_suffix: str = ""): - """Show marquee text with specified style settings.""" - # Truncate long text to prevent performance issues - truncated_text = text[:280] + "..." if len(text) > 280 else text - - # Display the marquee - streamlit_marquee( - content=truncated_text, - **settings, - key=f"marquee_{key_suffix}" - ) - - # Add spacing after marquee - st.write("") - -def create_paper_links_md(papers: list) -> str: - """Creates a minimal markdown file linking to each paper's arxiv URL.""" - lines = ["# Paper Links\n"] - for i, p in enumerate(papers, start=1): - lines.append(f"{i}. **{p['title']}** — [Arxiv]({p['url']})") - return "\n".join(lines) - -def apply_custom_styling(): - """Apply custom CSS styling to the app.""" + if st.button("▶ Run"): + st.session_state.old_val = val + st.session_state.last_query = edited_input + perform_ai_lookup(edited_input, + vocal_summary=True, + extended_refs=False, + titles_summary=True, + full_audio=full_audio) + + # ───────────────────────────────────────────────────────── + # TAB: ArXiv + # ───────────────────────────────────────────────────────── + if tab_main == "🔍 ArXiv": + st.subheader("🔍 Query ArXiv") + q = st.text_input("🔍 Query:", key="arxiv_query") + + st.markdown("### 🎛 Options") + vocal_summary = st.checkbox("🎙ShortAudio", value=True, key="option_vocal_summary") + extended_refs = st.checkbox("📜LongRefs", value=False, key="option_extended_refs") + titles_summary = st.checkbox("🔖TitlesOnly", value=True, key="option_titles_summary") + full_audio = st.checkbox("📚FullAudio", value=False, key="option_full_audio") + full_transcript = st.checkbox("🧾FullTranscript", value=False, key="option_full_transcript") + + if q and st.button("🔍Run"): + st.session_state.last_query = q + result = perform_ai_lookup(q, + vocal_summary=vocal_summary, + extended_refs=extended_refs, + titles_summary=titles_summary, + full_audio=full_audio) + if full_transcript: + create_file(q, result, "md") + + # ───────────────────────────────────────────────────────── + # TAB: Voice + # ───────────────────────────────────────────────────────── + elif tab_main == "🎤 Voice": + display_voice_tab() + + # ───────────────────────────────────────────────────────── + # TAB: Media + # ─────────────────��─────────────────────────────────────── + elif tab_main == "📸 Media": + st.header("📸 Media Gallery") + tabs = st.tabs(["🎵 Audio", "🖼 Images", "🎥 Video"]) + + # ▶ AUDIO sub-tab + with tabs[0]: + st.subheader("🎵 Audio Files") + audio_files = glob.glob("*.mp3") + glob.glob("*.wav") + if audio_files: + for a in audio_files: + with st.expander(os.path.basename(a)): + st.audio(a) + ext = os.path.splitext(a)[1].replace('.', '') + dl_link = create_download_link_with_cache(a, file_type=ext) + st.markdown(dl_link, unsafe_allow_html=True) + else: + st.write("No audio files found.") + + # ▶ IMAGES sub-tab + with tabs[1]: + st.subheader("🖼 Image Files") + imgs = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.jpeg") + if imgs: + c = st.slider("Cols", 1, 5, 3, key="cols_images") + cols = st.columns(c) + for i, f in enumerate(imgs): + with cols[i % c]: + st.image(Image.open(f), use_container_width=True) + else: + st.write("No images found.") + + # ▶ VIDEO sub-tab + with tabs[2]: + st.subheader("🎥 Video Files") + vids = glob.glob("*.mp4") + glob.glob("*.mov") + glob.glob("*.avi") + if vids: + for v in vids: + with st.expander(os.path.basename(v)): + st.video(v) + else: + st.write("No videos found.") + + # ───────────────────────────────────────────────────────── + # TAB: Editor + # ───────────────────────────────────────────────────────── + elif tab_main == "📝 Editor": + st.write("### 📝 File Editor (Minimal Demo)") + st.write("Select or create a file to edit. More advanced features can be added as needed.") + + # ───────────────────────────────────────────────────────── + # SIDEBAR: FILE HISTORY + PERFORMANCE METRICS + # ───────────────────────────────────────────────────────── + display_file_history_in_sidebar() + log_performance_metrics() + + # ▶ Some light CSS styling st.markdown(""" - + """, unsafe_allow_html=True) -def display_performance_metrics(timings: dict): - """Display performance metrics with visualizations.""" - st.sidebar.markdown("### ⏱️ Performance Metrics") - - # Calculate total time - total_time = sum(timings.values()) - st.sidebar.write(f"**Total Processing Time:** {total_time:.2f}s") - - # Show breakdown of operations - st.sidebar.markdown("#### Operation Breakdown") - for operation, duration in timings.items(): - percentage = (duration / total_time) * 100 if total_time > 0 else 0 - st.sidebar.write(f"**{operation}:** {duration:.2f}s ({percentage:.1f}%)") - - # Create a progress bar for visual representation - st.sidebar.progress(percentage / 100) - - - - -def display_papers(papers: List[Dict], marquee_settings: Dict): - """Display paper information with enhanced visualization.""" - with PerformanceTimer("paper_display"): - st.write("## 📚 Research Papers") - - # Create tabs for different views - tab1, tab2 = st.tabs(["📋 List View", "📊 Grid View"]) - - with tab1: - for i, paper in enumerate(papers, start=1): - # Create marquee for paper title - marquee_text = f"📄 {paper['title']} | 👤 {paper['authors'][:120]}" - display_marquee(marquee_text, marquee_settings, key_suffix=f"paper_{i}") - - # Paper details expander - with st.expander(f"{i}. 📄 {paper['title']}", expanded=True): - # Create PDF link - pdf_url = paper['url'].replace('/abs/', '/pdf/') - - # Display paper information - st.markdown(f""" - **Date:** {paper['date']} - **Title:** {paper['title']} - **Links:** 📄 [Abstract]({paper['url']}) | 📑 [PDF]({pdf_url}) - """) - st.markdown(f"**Authors:** {paper['authors']}") - st.markdown(f"**Summary:** {paper['summary']}") - - # Audio player and download if available - if paper.get('full_audio'): - st.write("🎧 Paper Audio Summary") - st.audio(paper['full_audio']) - if paper['download_base64']: - st.markdown(paper['download_base64'], unsafe_allow_html=True) - - with tab2: - # Create a grid layout of papers - cols = st.columns(3) - for i, paper in enumerate(papers): - with cols[i % 3]: - st.markdown(f""" - ### 📄 {paper['title'][:50]}... - **Date:** {paper['date']} - [Abstract]({paper['url']}) | [PDF]({paper['url'].replace('/abs/', '/pdf/')}) - """) - if paper.get('full_audio'): - st.audio(paper['full_audio']) - -def display_papers_in_sidebar(papers: List[Dict]): - """Display paper listing in sidebar with lazy loading.""" - with PerformanceTimer("sidebar_display"): - st.sidebar.title("📚 Papers Overview") - - # Add filter options - filter_date = st.sidebar.date_input("Filter by date:", None) - search_term = st.sidebar.text_input("Search papers:", "") - - # Filter papers based on criteria - filtered_papers = papers - if filter_date: - filtered_papers = [p for p in filtered_papers - if filter_date.strftime("%Y-%m-%d") in p['date']] - if search_term: - search_lower = search_term.lower() - filtered_papers = [p for p in filtered_papers - if search_lower in p['title'].lower() - or search_lower in p['authors'].lower()] - - # Display filtered papers - for i, paper in enumerate(filtered_papers, start=1): - paper_key = f"paper_{paper['url']}" - if paper_key not in st.session_state: - st.session_state[paper_key] = False - - with st.sidebar.expander(f"{i}. {paper['title'][:50]}...", expanded=False): - # Paper metadata - st.markdown(f"**Date:** {paper['date']}") - - # Links - pdf_url = paper['url'].replace('/abs/', '/pdf/') - st.markdown(f"📄 [Abstract]({paper['url']}) | 📑 [PDF]({pdf_url})") - - # Preview of authors and summary - st.markdown(f"**Authors:** {paper['authors'][:100]}...") - if paper['summary']: - st.markdown(f"**Summary:** {paper['summary'][:200]}...") - - # Audio controls - if paper['full_audio']: - if st.button("🎵 Load Audio", key=f"btn_{paper_key}"): - st.session_state[paper_key] = True - - if st.session_state[paper_key]: - st.audio(paper['full_audio']) - if paper['download_base64']: - st.markdown(paper['download_base64'], unsafe_allow_html=True) + # ▶ Rerun if needed + if st.session_state.should_rerun: + st.session_state.should_rerun = False + st.experimental_rerun() # ───────────────────────────────────────────────────────── -# 5. FILE MANAGEMENT & HISTORY +# 8. RUN APP # ───────────────────────────────────────────────────────── -def create_file(prompt: str, response: str, file_type: str = "md") -> str: - """Create a file with proper naming and error handling.""" - with PerformanceTimer("file_creation"): - try: - # Generate filename - filename = generate_filename(prompt.strip(), response.strip(), file_type) - - # Ensure directory exists - os.makedirs("generated_files", exist_ok=True) - filepath = os.path.join("generated_files", filename) - - # Write content - with open(filepath, 'w', encoding='utf-8') as f: - if file_type == "md": - f.write(f"# Query\n{prompt}\n\n# Response\n{response}") - else: - f.write(f"{prompt}\n\n{response}") - - return filepath - - except Exception as e: - st.error(f"Error creating file: {str(e)}") - return "" - -def get_high_info_terms(text: str, top_n: int = 10) -> List[str]: - """Extract most informative terms from text.""" - # Common English stop words to filter out - stop_words = set([ - 'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', - 'for', 'of', 'with', 'by', 'from', 'up', 'about', 'into', 'over', - 'after', 'the', 'this', 'that', 'these', 'those', 'what', 'which' - ]) - - # Extract words and bi-grams - words = re.findall(r'\b\w+(?:-\w+)*\b', text.lower()) - bi_grams = [' '.join(pair) for pair in zip(words, words[1:])] - - # Combine and filter terms - combined = words + bi_grams - filtered = [term for term in combined - if term not in stop_words - and len(term.split()) <= 2 - and len(term) > 3] - - # Count and return top terms - counter = Counter(filtered) - return [term for term, freq in counter.most_common(top_n)] - -def clean_text_for_filename(text: str) -> str: - """Clean text for use in filenames.""" - # Remove special characters - text = text.lower() - text = re.sub(r'[^\w\s-]', '', text) - - # Remove common unhelpful words - stop_words = set([ - 'the', 'and', 'for', 'with', 'this', 'that', 'what', 'which', - 'where', 'when', 'why', 'how', 'who', 'whom', 'whose', 'ai', - 'library', 'function', 'method', 'class', 'object', 'variable' - ]) - - words = text.split() - filtered = [w for w in words if len(w) > 3 and w not in stop_words] - - return '_'.join(filtered)[:200] - -def generate_filename(prompt: str, response: str, file_type: str = "md", - max_length: int = 200) -> str: - """Generate descriptive filename from content.""" - # Get timestamp prefix - prefix = format_timestamp_prefix() + "_" - - # Extract informative terms - combined_text = (prompt + " " + response)[:500] - info_terms = get_high_info_terms(combined_text, top_n=5) - - # Get content snippet - snippet = (prompt[:40] + " " + response[:40]).strip() - snippet_cleaned = clean_text_for_filename(snippet) - - # Combine and deduplicate parts - name_parts = info_terms + [snippet_cleaned] - seen = set() - unique_parts = [] - for part in name_parts: - if part not in seen: - seen.add(part) - unique_parts.append(part) - - # Create final filename - full_name = '_'.join(unique_parts).strip('_') - leftover_chars = max_length - len(prefix) - len(file_type) - 1 - if len(full_name) > leftover_chars: - full_name = full_name[:leftover_chars] - - return f"{prefix}{full_name}.{file_type}" - -def create_zip_of_files(md_files: List[str], mp3_files: List[str], - wav_files: List[str], input_question: str) -> Optional[str]: - """Create zip archive of files with optimization.""" - with PerformanceTimer("zip_creation"): - # Filter out readme and empty files - md_files = [f for f in md_files - if os.path.basename(f).lower() != 'readme.md' - and os.path.getsize(f) > 0] - - all_files = md_files + mp3_files + wav_files - if not all_files: - return None - - try: - # Generate zip name - all_content = [] - for f in all_files: - if f.endswith('.md'): - with open(f, 'r', encoding='utf-8') as file: - all_content.append(file.read()) - elif f.endswith(('.mp3', '.wav')): - basename = os.path.splitext(os.path.basename(f))[0] - all_content.append(basename.replace('_', ' ')) - - all_content.append(input_question) - combined_content = " ".join(all_content) - info_terms = get_high_info_terms(combined_content, top_n=10) - - timestamp = format_timestamp_prefix() - name_text = '-'.join(term for term in info_terms[:5]) - zip_name = f"archive_{timestamp}_{name_text[:50]}.zip" - - # Create zip file - with zipfile.ZipFile(zip_name, 'w', zipfile.ZIP_DEFLATED) as z: - for f in all_files: - z.write(f, os.path.basename(f)) - - return zip_name - - except Exception as e: - st.error(f"Error creating zip archive: {str(e)}") - return None - -# ───────────────────────────────────────────────────────── -# 6. OPTIMIZED AI LOOKUP & PROCESSING -# ───────────────────────────────────────────────────────── - -def perform_ai_lookup(q: str, vocal_summary: bool = True, - extended_refs: bool = False, - titles_summary: bool = True, - full_audio: bool = False) -> Tuple[str, Dict[str, float]]: - """Main AI lookup routine with performance optimization.""" - with PerformanceTimer("total_lookup") as total_timer: - timings = {} - - # Add operation controls if not present - if 'operation_controls' not in st.session_state: - st.sidebar.markdown("### 🔧 Operation Controls") - st.session_state['enable_claude'] = st.sidebar.checkbox( - "Enable Claude Search", - value=st.session_state['enable_claude'] - ) - st.session_state['enable_audio'] = st.sidebar.checkbox( - "Generate Audio", - value=st.session_state['enable_audio'] - ) - st.session_state['enable_download'] = st.sidebar.checkbox( - "Create Download Links", - value=st.session_state['enable_download'] - ) - st.session_state['operation_controls'] = True - - result = "" - - # 1. Claude API (if enabled) - if st.session_state['enable_claude']: - with PerformanceTimer("claude_api") as claude_timer: - try: - client = anthropic.Anthropic(api_key=anthropic_key) - response = client.messages.create( - model="claude-3-sonnet-20240229", - max_tokens=1000, - messages=[{"role": "user", "content": q}] - ) - st.write("Claude's reply 🧠:") - st.markdown(response.content[0].text) - result = response.content[0].text - timings['claude_api'] = time.time() - claude_timer.start_time - except Exception as e: - st.error(f"Error with Claude API: {str(e)}") - result = "Error occurred during Claude API call" - timings['claude_api'] = 0 - - # 2. Async save and audio generation - async def process_results(): - with PerformanceTimer("results_processing") as proc_timer: - md_file, audio_file, md_time, audio_time = await async_save_qa_with_audio( - q, result - ) - timings['markdown_save'] = md_time - timings['audio_generation'] = audio_time - - if audio_file and st.session_state['enable_audio']: - st.subheader("📝 Main Response Audio") - st.audio(audio_file) - - if st.session_state['enable_download']: - st.markdown( - create_download_link_with_cache( - audio_file, - st.session_state['audio_format'] - ), - unsafe_allow_html=True - ) - - # Run async operations - asyncio.run(process_results()) - - # 3. Arxiv RAG with performance tracking - if st.session_state['enable_claude']: - with PerformanceTimer("arxiv_rag") as rag_timer: - try: - st.write('Running Arxiv RAG with Claude inputs.') - client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern") - refs = client.predict( - q, - 10, - "Semantic Search", - "mistralai/Mixtral-8x7B-Instruct-v0.1", - api_name="/update_with_rag_md" - )[0] - timings['arxiv_rag'] = time.time() - rag_timer.start_time - - # Process papers asynchronously - papers = parse_arxiv_refs(refs) - if papers: - with PerformanceTimer("paper_processing") as paper_timer: - async def process_papers(): - # Create minimal links page - paper_links = create_paper_links_md(papers) - links_file = create_file(q, paper_links, "md") - st.markdown(paper_links) - - # Generate audio and display papers - await create_paper_audio_files(papers, q) - display_papers(papers, get_marquee_settings()) - display_papers_in_sidebar(papers) - - asyncio.run(process_papers()) - timings['paper_processing'] = time.time() - paper_timer.start_time - else: - st.warning("No papers found in the response.") - except Exception as e: - st.error(f"Error during Arxiv RAG: {str(e)}") - timings['arxiv_rag'] = 0 - - return result, timings - -def process_voice_input(text: str): - """Process voice input with enhanced error handling and feedback.""" - if not text: - st.warning("Please provide some input text.") - return - - with PerformanceTimer("voice_processing"): - try: - st.subheader("🔍 Search Results") - result, timings = perform_ai_lookup( - text, - vocal_summary=True, - extended_refs=False, - titles_summary=True, - full_audio=True - ) - - # Save results - md_file, audio_file = save_qa_with_audio(text, result) - - # Display results - st.subheader("📝 Generated Files") - col1, col2 = st.columns(2) - with col1: - st.write(f"📄 Markdown: {os.path.basename(md_file)}") - st.markdown(get_download_link(md_file, "md"), unsafe_allow_html=True) - - with col2: - if audio_file: - st.write(f"🎵 Audio: {os.path.basename(audio_file)}") - play_and_download_audio( - audio_file, - st.session_state['audio_format'] - ) - - except Exception as e: - st.error(f"Error processing voice input: {str(e)}") - -# ───────────────────────────────────────────────────────── -# 7. SIDEBAR AND FILE HISTORY -# ───────────────────────────────────────────────────────── - -def display_file_history_in_sidebar(): - """Display file history with enhanced organization and filtering.""" - with PerformanceTimer("file_history"): - st.sidebar.markdown("---") - st.sidebar.markdown("### 📂 File History") - - # Gather all files - md_files = glob.glob("*.md") - mp3_files = glob.glob("*.mp3") - wav_files = glob.glob("*.wav") - all_files = md_files + mp3_files + wav_files - - if not all_files: - st.sidebar.write("No files found.") - return - - # Add file management controls - col1, col2 = st.sidebar.columns(2) - with col1: - if st.button("🗑 Delete All"): - try: - for f in all_files: - os.remove(f) - st.session_state.should_rerun = True - st.success("All files deleted successfully.") - except Exception as e: - st.error(f"Error deleting files: {str(e)}") - - with col2: - if st.button("⬇️ Zip All"): - zip_name = create_zip_of_files( - md_files, - mp3_files, - wav_files, - st.session_state.get('last_query', '') - ) - if zip_name: - st.sidebar.markdown( - get_download_link(zip_name, "zip"), - unsafe_allow_html=True - ) - - # Add file filtering options - st.sidebar.markdown("### 🔍 Filter Files") - file_search = st.sidebar.text_input("Search files:", "") - file_type_filter = st.sidebar.multiselect( - "File types:", - ["Markdown", "Audio"], - default=["Markdown", "Audio"] - ) - - # Sort files by modification time - all_files.sort(key=os.path.getmtime, reverse=True) - - # Filter files based on search and type - filtered_files = [] - for f in all_files: - if file_search.lower() in f.lower(): - ext = os.path.splitext(f)[1].lower() - if (("Markdown" in file_type_filter and ext == ".md") or - ("Audio" in file_type_filter and ext in [".mp3", ".wav"])): - filtered_files.append(f) - - # Display filtered files - for f in filtered_files: - fname = os.path.basename(f) - ext = os.path.splitext(fname)[1].lower().strip('.') - emoji = FILE_EMOJIS.get(ext, '📦') - - # Get file metadata - mod_time = datetime.fromtimestamp(os.path.getmtime(f)) - time_str = mod_time.strftime("%Y-%m-%d %H:%M:%S") - file_size = os.path.getsize(f) / 1024 # Size in KB - - with st.sidebar.expander(f"{emoji} {fname}"): - st.write(f"**Modified:** {time_str}") - st.write(f"**Size:** {file_size:.1f} KB") - - if ext == "md": - try: - with open(f, "r", encoding="utf-8") as file_in: - snippet = file_in.read(200).replace("\n", " ") - if len(snippet) == 200: - snippet += "..." - st.write(snippet) - st.markdown( - get_download_link(f, file_type="md"), - unsafe_allow_html=True - ) - except Exception as e: - st.error(f"Error reading markdown file: {str(e)}") - - elif ext in ["mp3", "wav"]: - st.audio(f) - st.markdown( - get_download_link(f, file_type=ext), - unsafe_allow_html=True - ) - - else: - st.markdown(get_download_link(f), unsafe_allow_html=True) - -# ───────────────────────────────────────────────────────── -# 8. MAIN APPLICATION -# ───────────────────────────────────────────────────────── - -def main(): - """Main application entry point with enhanced UI and error handling.""" - try: - # 1. Setup marquee UI in sidebar - update_marquee_settings_ui() - marquee_settings = get_marquee_settings() - - # 2. Display welcome marquee - display_marquee( - st.session_state['marquee_content'], - {**marquee_settings, "font-size": "28px", "lineHeight": "50px"}, - key_suffix="welcome" - ) - - # 3. Main action tabs - tab_main = st.radio( - "Action:", - ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], - horizontal=True - ) - - # Custom component usage - mycomponent = components.declare_component( - "mycomponent", - path="mycomponent" - ) - val = mycomponent(my_input_value="Hello") - - if val: - # Process input value - val_stripped = val.replace('\\n', ' ') - edited_input = st.text_area( - "✏️ Edit Input:", - value=val_stripped, - height=100 - ) - - # Model selection and options - run_option = st.selectbox("Model:", ["Arxiv"]) - col1, col2 = st.columns(2) - - with col1: - #autorun = st.checkbox("⚙ AutoRun", value=True) - autorun = st.checkbox("⚙ AutoRun", value=False) - with col2: - full_audio = st.checkbox("📚 FullAudio", value=False) - - # Check for input changes - input_changed = (val != st.session_state.old_val) - - if autorun and input_changed: - st.session_state.old_val = val - st.session_state.last_query = edited_input - result, timings = perform_ai_lookup( - edited_input, - vocal_summary=True, - extended_refs=False, - titles_summary=True, - full_audio=full_audio - ) - - # Display performance metrics - display_performance_metrics(timings) - - else: - if st.button("▶ Run"): - st.session_state.old_val = val - st.session_state.last_query = edited_input - result, timings = perform_ai_lookup( - edited_input, - vocal_summary=True, - extended_refs=False, - titles_summary=True, - full_audio=full_audio - ) - - # Display performance metrics - display_performance_metrics(timings) - - # Tab-specific content - if tab_main == "🔍 ArXiv": - display_arxiv_tab() - elif tab_main == "🎤 Voice": - display_voice_tab() - elif tab_main == "📸 Media": - display_media_tab() - elif tab_main == "📝 Editor": - display_editor_tab() - - # Display file history - display_file_history_in_sidebar() - - # Apply styling - apply_custom_styling() - - # Check for rerun - if st.session_state.should_rerun: - st.session_state.should_rerun = False - st.rerun() - - except Exception as e: - st.error(f"An error occurred in the main application: {str(e)}") - st.info("Please try refreshing the page or contact support if the issue persists.") - if __name__ == "__main__": - main() \ No newline at end of file + main()