Spaces:

awacke1
/

RescuerOfStolenBikes

Running

App Files Files Community

awacke1 commited on about 1 month ago

Commit

d1f1a3b

•

1 Parent(s): b7f62c2

Update app.py

Browse files

Files changed (1) hide show

app.py +417 -9

app.py CHANGED Viewed

@@ -63,13 +63,25 @@ openai_client = OpenAI(
     organization=os.getenv('OPENAI_ORG_ID')
 )
-# Claude setup
 anthropic_key = os.getenv("ANTHROPIC_API_KEY_3")
 if anthropic_key == None:
     anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
 claude_client = anthropic.Anthropic(api_key=anthropic_key)
-# HuggingFace setup
 API_URL = os.getenv('API_URL')
 HF_KEY = os.getenv('HF_KEY')
 MODEL1 = "meta-llama/Llama-2-7b-chat-hf"
@@ -128,6 +140,7 @@ st.markdown("""
 </style>
 """, unsafe_allow_html=True)
 # Bike Collections
 bike_collections = {
     "Celestial Collection 🌌": {
@@ -180,6 +193,7 @@ bike_collections = {
     }
 }
 # Helper Functions
 def generate_filename(prompt, file_type):
     """Generate a safe filename using the prompt and file type."""
@@ -610,38 +624,44 @@ def create_media_gallery():
                         st.write(prompt)
 def display_file_manager():
-    """Display file management sidebar."""
     st.sidebar.title("📁 File Management")
     all_files = glob.glob("*.md")
     all_files.sort(reverse=True)
-    if st.sidebar.button("🗑 Delete All"):
         for file in all_files:
             os.remove(file)
         st.rerun()
-    if st.sidebar.button("⬇️ Download All"):
         zip_file = create_zip_of_files(all_files)
         st.sidebar.markdown(get_download_link(zip_file), unsafe_allow_html=True)
-    for file in all_files:
         col1, col2, col3, col4 = st.sidebar.columns([1,3,1,1])
         with col1:
-            if st.button("🌐", key="view_"+file):
                 st.session_state.current_file = file
                 st.session_state.file_content = load_file(file)
         with col2:
             st.markdown(get_download_link(file), unsafe_allow_html=True)
         with col3:
-            if st.button("📂", key="edit_"+file):
                 st.session_state.current_file = file
                 st.session_state.file_content = load_file(file)
         with col4:
-            if st.button("🗑", key="delete_"+file):
                 os.remove(file)
                 st.rerun()
 def main():
     st.sidebar.markdown("### 🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI")
@@ -725,5 +745,393 @@ def main():
     # Always show file manager in sidebar
     display_file_manager()
 if __name__ == "__main__":
     main()

     organization=os.getenv('OPENAI_ORG_ID')
 )
+# 3. Claude setup
 anthropic_key = os.getenv("ANTHROPIC_API_KEY_3")
 if anthropic_key == None:
     anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
 claude_client = anthropic.Anthropic(api_key=anthropic_key)
+# 4. Initialize session states
+if 'transcript_history' not in st.session_state:
+    st.session_state.transcript_history = []
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+if "openai_model" not in st.session_state:
+    st.session_state["openai_model"] = "gpt-4o-2024-05-13"
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+if 'last_voice_input' not in st.session_state:
+    st.session_state.last_voice_input = ""
+# 5. # HuggingFace setup
 API_URL = os.getenv('API_URL')
 HF_KEY = os.getenv('HF_KEY')
 MODEL1 = "meta-llama/Llama-2-7b-chat-hf"
 </style>
 """, unsafe_allow_html=True)
 # Bike Collections
 bike_collections = {
     "Celestial Collection 🌌": {
     }
 }
 # Helper Functions
 def generate_filename(prompt, file_type):
     """Generate a safe filename using the prompt and file type."""
                         st.write(prompt)
 def display_file_manager():
+    """Display file management sidebar with guaranteed unique button keys."""
     st.sidebar.title("📁 File Management")
     all_files = glob.glob("*.md")
     all_files.sort(reverse=True)
+    if st.sidebar.button("🗑 Delete All", key="delete_all_files_button"):
         for file in all_files:
             os.remove(file)
         st.rerun()
+    if st.sidebar.button("⬇️ Download All", key="download_all_files_button"):
         zip_file = create_zip_of_files(all_files)
         st.sidebar.markdown(get_download_link(zip_file), unsafe_allow_html=True)
+    # Create unique keys using file attributes
+    for idx, file in enumerate(all_files):
+        # Get file stats for unique identification
+        file_stat = os.stat(file)
+        unique_id = f"{idx}_{file_stat.st_size}_{file_stat.st_mtime}"
         col1, col2, col3, col4 = st.sidebar.columns([1,3,1,1])
         with col1:
+            if st.button("🌐", key=f"view_{unique_id}"):
                 st.session_state.current_file = file
                 st.session_state.file_content = load_file(file)
         with col2:
             st.markdown(get_download_link(file), unsafe_allow_html=True)
         with col3:
+            if st.button("📂", key=f"edit_{unique_id}"):
                 st.session_state.current_file = file
                 st.session_state.file_content = load_file(file)
         with col4:
+            if st.button("🗑", key=f"delete_{unique_id}"):
                 os.remove(file)
                 st.rerun()
 def main():
     st.sidebar.markdown("### 🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI")
     # Always show file manager in sidebar
     display_file_manager()
+if __name__ == "__main__":
+    main()
+# Speech Recognition HTML Component
+speech_recognition_html = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Continuous Speech Demo</title>
+    <style>
+        body {
+            font-family: sans-serif;
+            padding: 20px;
+            max-width: 800px;
+            margin: 0 auto;
+        }
+        button {
+            padding: 10px 20px;
+            margin: 10px 5px;
+            font-size: 16px;
+        }
+        #status {
+            margin: 10px 0;
+            padding: 10px;
+            background: #e8f5e9;
+            border-radius: 4px;
+        }
+        #output {
+            white-space: pre-wrap;
+            padding: 15px;
+            background: #f5f5f5;
+            border-radius: 4px;
+            margin: 10px 0;
+            min-height: 100px;
+            max-height: 400px;
+            overflow-y: auto;
+        }
+        .controls {
+            margin: 10px 0;
+        }
+    </style>
+</head>
+<body>
+    <div class="controls">
+        <button id="start">Start Listening</button>
+        <button id="stop" disabled>Stop Listening</button>
+        <button id="clear">Clear Text</button>
+    </div>
+    <div id="status">Ready</div>
+    <div id="output"></div>
+    <script>
+        if (!('webkitSpeechRecognition' in window)) {
+            alert('Speech recognition not supported');
+        } else {
+            const recognition = new webkitSpeechRecognition();
+            const startButton = document.getElementById('start');
+            const stopButton = document.getElementById('stop');
+            const clearButton = document.getElementById('clear');
+            const status = document.getElementById('status');
+            const output = document.getElementById('output');
+            let fullTranscript = '';
+            let lastUpdateTime = Date.now();
+            // Configure recognition
+            recognition.continuous = true;
+            recognition.interimResults = true;
+            // Function to start recognition
+            const startRecognition = () => {
+                try {
+                    recognition.start();
+                    status.textContent = 'Listening...';
+                    startButton.disabled = true;
+                    stopButton.disabled = false;
+                } catch (e) {
+                    console.error(e);
+                    status.textContent = 'Error: ' + e.message;
+                }
+            };
+            // Auto-start on load
+            window.addEventListener('load', () => {
+                setTimeout(startRecognition, 1000);
+            });
+            startButton.onclick = startRecognition;
+            stopButton.onclick = () => {
+                recognition.stop();
+                status.textContent = 'Stopped';
+                startButton.disabled = false;
+                stopButton.disabled = true;
+            };
+            clearButton.onclick = () => {
+                fullTranscript = '';
+                output.textContent = '';
+                window.parent.postMessage({
+                    type: 'clear_transcript',
+                }, '*');
+            };
+            recognition.onresult = (event) => {
+                let interimTranscript = '';
+                let finalTranscript = '';
+                for (let i = event.resultIndex; i < event.results.length; i++) {
+                    const transcript = event.results[i][0].transcript;
+                    if (event.results[i].isFinal) {
+                        finalTranscript += transcript + '\\n';
+                    } else {
+                        interimTranscript += transcript;
+                    }
+                }
+                if (finalTranscript || (Date.now() - lastUpdateTime > 5000)) {
+                    if (finalTranscript) {
+                        fullTranscript += finalTranscript;
+                        // Send to Streamlit
+                        window.parent.postMessage({
+                            type: 'final_transcript',
+                            text: finalTranscript
+                        }, '*');
+                    }
+                    lastUpdateTime = Date.now();
+                }
+                output.textContent = fullTranscript + (interimTranscript ? '... ' + interimTranscript : '');
+                output.scrollTop = output.scrollHeight;
+            };
+            recognition.onend = () => {
+                if (!stopButton.disabled) {
+                    try {
+                        recognition.start();
+                        console.log('Restarted recognition');
+                    } catch (e) {
+                        console.error('Failed to restart recognition:', e);
+                        status.textContent = 'Error restarting: ' + e.message;
+                        startButton.disabled = false;
+                        stopButton.disabled = true;
+                    }
+                }
+            };
+            recognition.onerror = (event) => {
+                console.error('Recognition error:', event.error);
+                status.textContent = 'Error: ' + event.error;
+                if (event.error === 'not-allowed' || event.error === 'service-not-allowed') {
+                    startButton.disabled = false;
+                    stopButton.disabled = true;
+                }
+            };
+        }
+    </script>
+</body>
+</html>
+"""
+# Helper Functions
+def generate_filename(prompt, file_type):
+    central = pytz.timezone('US/Central')
+    safe_date_time = datetime.now(central).strftime("%m%d_%H%M")
+    replaced_prompt = re.sub(r'[<>:"/\\|?*\n]', ' ', prompt)
+    safe_prompt = re.sub(r'\s+', ' ', replaced_prompt).strip()[:230]
+    return f"{safe_date_time}_{safe_prompt}.{file_type}"
+# File Management Functions
+def load_file(file_name):
+    """Load file content."""
+    with open(file_name, "r", encoding='utf-8') as file:
+        content = file.read()
+    return content
+def create_zip_of_files(files):
+    """Create zip archive of files."""
+    zip_name = "all_files.zip"
+    with zipfile.ZipFile(zip_name, 'w') as zipf:
+        for file in files:
+            zipf.write(file)
+    return zip_name
+def get_download_link(file):
+    """Create download link for file."""
+    with open(file, "rb") as f:
+        contents = f.read()
+    b64 = base64.b64encode(contents).decode()
+    return f'<a href="data:file/txt;base64,{b64}" download="{os.path.basename(file)}">Download {os.path.basename(file)}📂</a>'
+def display_file_manager():
+    """Display file management sidebar."""
+    st.sidebar.title("📁 File Management")
+    all_files = glob.glob("*.md")
+    all_files.sort(reverse=True)
+    if st.sidebar.button("🗑 Delete All"):
+        for file in all_files:
+            os.remove(file)
+        st.rerun()
+    if st.sidebar.button("⬇️ Download All"):
+        zip_file = create_zip_of_files(all_files)
+        st.sidebar.markdown(get_download_link(zip_file), unsafe_allow_html=True)
+    for file in all_files:
+        col1, col2, col3, col4 = st.sidebar.columns([1,3,1,1])
+        with col1:
+            if st.button("🌐", key="view_"+file):
+                st.session_state.current_file = file
+                st.session_state.file_content = load_file(file)
+        with col2:
+            st.markdown(get_download_link(file), unsafe_allow_html=True)
+        with col3:
+            if st.button("📂", key="edit_"+file):
+                st.session_state.current_file = file
+                st.session_state.file_content = load_file(file)
+        with col4:
+            if st.button("🗑", key="delete_"+file):
+                os.remove(file)
+                st.rerun()
+def create_media_gallery():
+    """Create the media gallery interface."""
+    st.header("🎬 Media Gallery")
+    tabs = st.tabs(["🖼️ Images", "🎵 Audio", "🎥 Video", "🎨 Scene Generator"])
+    with tabs[0]:
+        image_files = glob.glob("*.png") + glob.glob("*.jpg")
+        if image_files:
+            num_cols = st.slider("Number of columns", 1, 5, 3)
+            cols = st.columns(num_cols)
+            for idx, image_file in enumerate(image_files):
+                with cols[idx % num_cols]:
+                    img = Image.open(image_file)
+                    st.image(img, use_container_width=True)
+                    # Add GPT vision analysis option
+                    if st.button(f"Analyze {os.path.basename(image_file)}"):
+                        analysis = process_image(image_file,
+                                              "Describe this image in detail and identify key elements.")
+                        st.markdown(analysis)
+    with tabs[1]:
+        audio_files = glob.glob("*.mp3") + glob.glob("*.wav")
+        for audio_file in audio_files:
+            with st.expander(f"🎵 {os.path.basename(audio_file)}"):
+                st.markdown(get_media_html(audio_file, "audio"), unsafe_allow_html=True)
+                if st.button(f"Transcribe {os.path.basename(audio_file)}"):
+                    with open(audio_file, "rb") as f:
+                        transcription = process_audio(f)
+                        st.write(transcription)
+    with tabs[2]:
+        video_files = glob.glob("*.mp4")
+        for video_file in video_files:
+            with st.expander(f"🎥 {os.path.basename(video_file)}"):
+                st.markdown(get_media_html(video_file, "video"), unsafe_allow_html=True)
+                if st.button(f"Analyze {os.path.basename(video_file)}"):
+                    analysis = process_video_with_gpt(video_file,
+                                                    "Describe what's happening in this video.")
+                    st.markdown(analysis)
+    with tabs[3]:
+        for collection_name, bikes in bike_collections.items():
+            st.subheader(collection_name)
+            cols = st.columns(len(bikes))
+            for idx, (bike_name, details) in enumerate(bikes.items()):
+                with cols[idx]:
+                    st.markdown(f"""
+                    <div class='bike-card'>
+                        <h3>{details['emoji']} {bike_name}</h3>
+                        <p>{details['prompt']}</p>
+                    </div>
+                    """, unsafe_allow_html=True)
+                    if st.button(f"Generate {bike_name} Scene"):
+                        prompt = details['prompt']
+                        # Here you could integrate with image generation API
+                        st.write(f"Generated scene description for {bike_name}:")
+                        st.write(prompt)
+def get_media_html(media_path, media_type="video", width="100%"):
+    """Generate HTML for media player."""
+    media_data = base64.b64encode(open(media_path, 'rb').read()).decode()
+    if media_type == "video":
+        return f'''
+        <video width="{width}" controls autoplay muted loop>
+            <source src="data:video/mp4;base64,{media_data}" type="video/mp4">
+            Your browser does not support the video tag.
+        </video>
+        '''
+    else:  # audio
+        return f'''
+        <audio controls style="width: {width};">
+            <source src="data:audio/mpeg;base64,{media_data}" type="audio/mpeg">
+            Your browser does not support the audio element.
+        </audio>
+        '''
+def main():
+    st.sidebar.markdown("### 🚲BikeAI🏆 Claude and GPT Multi-Agent Research AI")
+    # Main navigation
+    tab_main = st.radio("Choose Action:",
+                        ["🎤 Voice Input", "💬 Chat", "📸 Media Gallery", "🔍 Search ArXiv", "📝 File Editor"],
+                        horizontal=True)
+    if tab_main == "🎤 Voice Input":
+        st.subheader("Voice Recognition")
+        # Display speech recognition component
+        speech_component = st.components.v1.html(speech_recognition_html, height=400)
+        # Handle speech recognition output
+        if speech_component:
+            try:
+                data = speech_component
+                if isinstance(data, dict):
+                    if data.get('type') == 'final_transcript':
+                        text = data.get('text', '').strip()
+                        if text:
+                            st.session_state.last_voice_input = text
+                            # Process voice input with AI
+                            st.subheader("AI Response to Voice Input:")
+                            col1, col2, col3 = st.columns(3)
+                            with col2:
+                                st.write("Claude-3.5 Sonnet:")
+                                try:
+                                    claude_response = process_with_claude(text)
+                                except:
+                                    st.write('Claude 3.5 Sonnet out of tokens.')
+                            with col1:
+                                st.write("GPT-4o Omni:")
+                                try:
+                                    gpt_response = process_with_gpt(text)
+                                except:
+                                    st.write('GPT 4o out of tokens')
+                            with col3:
+                                st.write("Arxiv and Mistral Research:")
+                                with st.spinner("Searching ArXiv..."):
+                                    results = perform_ai_lookup(text)
+                                    st.markdown(results)
+                    elif data.get('type') == 'clear_transcript':
+                        st.session_state.last_voice_input = ""
+                        st.experimental_rerun()
+            except Exception as e:
+                st.error(f"Error processing voice input: {e}")
+        # Display last voice input
+        if st.session_state.last_voice_input:
+            st.text_area("Last Voice Input:", st.session_state.last_voice_input, height=100)
+    # [Rest of the main function remains the same]
+    elif tab_main == "💬 Chat":
+        # [Previous chat interface code]
+        pass
+    elif tab_main == "📸 Media Gallery":
+        create_media_gallery()
+    elif tab_main == "🔍 Search ArXiv":
+        query = st.text_input("Enter your research query:")
+        if query:
+            with st.spinner("Searching ArXiv..."):
+                results = search_arxiv(query)
+                st.markdown(results)
+    elif tab_main == "📝 File Editor":
+        if hasattr(st.session_state, 'current_file'):
+            st.subheader(f"Editing: {st.session_state.current_file}")
+            new_content = st.text_area("Content:", st.session_state.file_content, height=300)
+            if st.button("Save Changes"):
+                with open(st.session_state.current_file, 'w', encoding='utf-8') as file:
+                    file.write(new_content)
+                st.success("File updated successfully!")
+    # Always show file manager in sidebar
+    display_file_manager()
 if __name__ == "__main__":
     main()