Update backupapp.py

backupapp.py

@@ -1,7 +1,5 @@
 import streamlit as st
 import streamlit.components.v1 as components
-
-import openai
 import os
 import base64
 import glob
@@ -17,9 +15,11 @@ import re
 import textract
 import zipfile  
 import random
-
+import httpx # add 11/13/23
+import asyncio
+from openai import OpenAI
+#from openai import AsyncOpenAI
 from datetime import datetime
-from openai import ChatCompletion
 from xml.etree import ElementTree as ET
 from bs4 import BeautifulSoup
 from collections import deque
@@ -34,11 +34,84 @@ from langchain.memory import ConversationBufferMemory
 from langchain.chains import ConversationalRetrievalChain
 from templates import css, bot_template, user_template
 from io import BytesIO
+from contextlib import redirect_stdout
+
 
+# set page config once
+st.set_page_config(page_title="Python AI Pair Programmer", layout="wide")
 
-# page config and sidebar declares up front allow all other functions to see global class variables
-st.set_page_config(page_title="GPT Streamlit Document Reasoner", layout="wide")
+# UI for sidebar controls
 should_save = st.sidebar.checkbox("💾 Save", value=True)
+col1, col2, col3, col4 = st.columns(4)
+with col1:
+    with st.expander("Settings 🧠💾", expanded=True):
+        # File type for output, model choice
+        menu = ["txt", "htm", "xlsx", "csv", "md", "py"]
+        choice = st.sidebar.selectbox("Output File Type:", menu)
+        model_choice = st.sidebar.radio("Select Model:", ('gpt-3.5-turbo', 'gpt-3.5-turbo-0301'))
+
+# Define a context dictionary to maintain the state between exec calls
+context = {}
+
+def create_file(filename, prompt, response, should_save=True):
+    if not should_save:
+        return
+
+    # Extract base filename without extension
+    base_filename, ext = os.path.splitext(filename)
+
+    # Initialize the combined content
+    combined_content = ""
+
+    # Add Prompt with markdown title and emoji
+    combined_content += "# Prompt 📝\n" + prompt + "\n\n"
+
+    # Add Response with markdown title and emoji
+    combined_content += "# Response 💬\n" + response + "\n\n"
+
+    # Check for code blocks in the response
+    resources = re.findall(r"```([\s\S]*?)```", response)
+    for resource in resources:
+        # Check if the resource contains Python code
+        if "python" in resource.lower():
+            # Remove the 'python' keyword from the code block
+            cleaned_code = re.sub(r'^\s*python', '', resource, flags=re.IGNORECASE | re.MULTILINE)
+            
+            # Add Code Results title with markdown and emoji
+            combined_content += "# Code Results 🚀\n"
+
+            # Redirect standard output to capture it
+            original_stdout = sys.stdout
+            sys.stdout = io.StringIO()
+            
+            # Execute the cleaned Python code within the context
+            try:
+                exec(cleaned_code, context)
+                code_output = sys.stdout.getvalue()
+                combined_content += f"```\n{code_output}\n```\n\n"
+                realtimeEvalResponse = "# Code Results 🚀\n" + "```" + code_output + "```\n\n"
+                st.code(realtimeEvalResponse)
+                
+            except Exception as e:
+                combined_content += f"```python\nError executing Python code: {e}\n```\n\n"
+            
+            # Restore the original standard output
+            sys.stdout = original_stdout
+        else:
+            # Add non-Python resources with markdown and emoji
+            combined_content += "# Resource 🛠️\n" + "```" + resource + "```\n\n"
+
+    # Save the combined content to a Markdown file
+    if should_save:
+        with open(f"{base_filename}.md", 'w') as file:
+            file.write(combined_content)
+            st.code(combined_content)
+
+    # Create a Base64 encoded link for the file
+    with open(f"{base_filename}.md", 'rb') as file:
+        encoded_file = base64.b64encode(file.read()).decode()
+        href = f'<a href="data:file/markdown;base64,{encoded_file}" download="{filename}">Download File 📄</a>'
+        st.markdown(href, unsafe_allow_html=True)
 
 
 # Read it aloud        
@@ -72,47 +145,53 @@ def readitaloud(result):
     components.html(documentHTML5, width=800, height=300)
     #return result
 
+def generate_filename(prompt, file_type):
+    central = pytz.timezone('US/Central')
+    safe_date_time = datetime.now(central).strftime("%m%d_%H%M")
+    replaced_prompt = prompt.replace(" ", "_").replace("\n", "_")
+    safe_prompt = "".join(x for x in replaced_prompt if x.isalnum() or x == "_")[:90]
+    return f"{safe_date_time}_{safe_prompt}.{file_type}"
+
 # Chat and Chat with files
 def chat_with_model(prompt, document_section, model_choice='gpt-3.5-turbo'):
     model = model_choice
-    conversation = [{'role': 'system', 'content': 'You are a helpful assistant.'}]
+    conversation = [{'role': 'system', 'content': 'You are a python script writer.'}]
     conversation.append({'role': 'user', 'content': prompt})
     if len(document_section)>0:
         conversation.append({'role': 'assistant', 'content': document_section})
-        
     start_time = time.time()
     report = []
     res_box = st.empty()
     collected_chunks = []
     collected_messages = []
-    
     key = os.getenv('OPENAI_API_KEY')
-    openai.api_key = key
-    for chunk in openai.ChatCompletion.create(
+
+    client = OpenAI(
+        api_key= os.getenv('OPENAI_API_KEY')
+    )
+    stream = client.chat.completions.create(
         model='gpt-3.5-turbo',
         messages=conversation,
-        temperature=0.5,
-        stream=True  
-    ):
-        
-        collected_chunks.append(chunk)  # save the event response
-        chunk_message = chunk['choices'][0]['delta']  # extract the message
+        stream=True,
+    )
+    all_content = ""  # Initialize an empty string to hold all content
+    for part in stream:
+        chunk_message = (part.choices[0].delta.content or "")
         collected_messages.append(chunk_message)  # save the message
-        
-        content=chunk["choices"][0].get("delta",{}).get("content")
-        
+        content=part.choices[0].delta.content
         try:
-            report.append(content)
             if len(content) > 0:
+                report.append(content)
+                all_content += content  
                 result = "".join(report).strip()
-                #result = result.replace("\n", "")        
                 res_box.markdown(f'*{result}*') 
         except:
             st.write(' ')
-        
-    full_reply_content = ''.join([m.get('content', '') for m in collected_messages])
+    full_reply_content = all_content
     st.write("Elapsed time:")
     st.write(time.time() - start_time)
+    filename = generate_filename(full_reply_content, choice)
+    create_file(filename, prompt, full_reply_content, should_save)
     readitaloud(full_reply_content)
     return full_reply_content
 
@@ -121,17 +200,96 @@ def chat_with_file_contents(prompt, file_content, model_choice='gpt-3.5-turbo'):
     conversation.append({'role': 'user', 'content': prompt})
     if len(file_content)>0:
         conversation.append({'role': 'assistant', 'content': file_content})
-    response = openai.ChatCompletion.create(model=model_choice, messages=conversation)
+        client = OpenAI(
+            api_key= os.getenv('OPENAI_API_KEY')
+        )
+    response = client.chat.completions.create(model=model_choice, messages=conversation)
     return response['choices'][0]['message']['content']
 
-
 def link_button_with_emoji(url, title, emoji_summary):
     emojis = ["💉", "🏥", "🌡️", "🩺", "🔬", "💊", "🧪", "👨‍⚕️", "👩‍⚕️"]
     random_emoji = random.choice(emojis)
     st.markdown(f"[{random_emoji} {emoji_summary} - {title}]({url})")
 
+    
+# Python parts and their corresponding emojis, with expanded details
+python_parts = {
+    "Syntax": "✏️",
+    "Data Types": "📊",
+    "Control Structures": "🔁",
+    "Functions": "🔧",
+    "Classes": "🏗️",
+    "API Interaction": "🌐",
+    "Data Visualization": "📈",
+    "Error Handling": "⚠️",
+    "Libraries": "📚"
+}
+
+python_parts_extended = {
+    "Syntax": "✏️ (Variables, Comments, Printing)",
+    "Data Types": "📊 (Numbers, Strings, Lists, Tuples, Sets, Dictionaries)",
+    "Control Structures": "🔁 (If, Elif, Else, Loops, Break, Continue)",
+    "Functions": "🔧 (Defining, Calling, Parameters, Return Values)",
+    "Classes": "🏗️ (Creating, Inheritance, Methods, Properties)",
+    "API Interaction": "🌐 (Requests, JSON Parsing, HTTP Methods)",
+    "Data Visualization": "📈 (Matplotlib, Seaborn, Plotly)",
+    "Error Handling": "⚠️ (Try, Except, Finally, Raising)",
+    "Libraries": "📚 (Numpy, Pandas, Scikit-Learn, TensorFlow)"
+}
+
+# Placeholder for chat responses and interactive examples
+response_placeholders = {}
+example_placeholders = {}
+
+# Function to display Python concepts with expanders, examples, and quizzes
+def display_python_parts():
+    st.title("Python Interactive Learning Platform")
+
+    for part, emoji in python_parts.items():
+        with st.expander(f"{emoji} {part} - {python_parts_extended[part]}", expanded=False):
+            # Interactive examples
+            if st.button(f"Show Example for {part}", key=f"example_{part}"):
+                example = generate_example(part)
+                example_placeholders[part] = example
+                st.code(example_placeholders[part], language="python")
+                response = chat_with_model('Create a STEM related 3 to 5 line python code example with output for:' + example_placeholders[part], part)
+
+            # Quizzes
+            if st.button(f"Take Quiz on {part}", key=f"quiz_{part}"):
+                quiz = generate_quiz(part)
+                response = chat_with_model(quiz, part)
+
+            # Chat responses
+            prompt = f"Learn about {python_parts_extended[part]}"
+            if st.button(f"Explore {part}", key=part):
+                response = chat_with_model(prompt, part)
+                response_placeholders[part] = response
+
+            # Display the chat response if available
+            if part in response_placeholders:
+                st.markdown(f"**Response:** {response_placeholders[part]}")
+
+def generate_example(part):
+    # This function will return a relevant Python example based on the selected part
+    # Examples could be pre-defined or dynamically generated
+    return "Python example for " + part
+
+def generate_quiz(part):
+    # This function will create a simple quiz related to the Python part
+    # Quizzes could be multiple-choice questions, true/false, etc.
+    return "Python script quiz example for " + part
+                
 # Define function to add paper buttons and links
 def add_paper_buttons_and_links():
+    # Python Pair Programmer
+    page = st.sidebar.radio("Choose a page:", ["Python Pair Programmer"])
+    if page == "Python Pair Programmer":
+        # Display Python concepts and interactive sections
+        display_python_parts()
+
+
+        
+
     col1, col2, col3, col4 = st.columns(4)
 
     with col1:
@@ -206,13 +364,6 @@ def extract_feature_and_detail(paragraph):
         return header, detail
     return None, None
 
-def generate_filename(prompt, file_type):
-    central = pytz.timezone('US/Central')
-    safe_date_time = datetime.now(central).strftime("%m%d_%H%M")
-    replaced_prompt = prompt.replace(" ", "_").replace("\n", "_")
-    safe_prompt = "".join(x for x in replaced_prompt if x.isalnum() or x == "_")[:90]
-    return f"{safe_date_time}_{safe_prompt}.{file_type}"
-
 def transcribe_audio(file_path, model):
     key = os.getenv('OPENAI_API_KEY')
     headers = {
@@ -251,62 +402,6 @@ def save_and_play_audio(audio_recorder):
     return None
 
 
-# Define a context dictionary to maintain the state between exec calls
-context = {}
-
-def create_file(filename, prompt, response, should_save=True):
-    if not should_save:
-        return
-
-    # Extract base filename without extension
-    base_filename, ext = os.path.splitext(filename)
-
-    # Initialize the combined content
-    combined_content = ""
-
-    # Add Prompt with markdown title and emoji
-    combined_content += "# Prompt 📝\n" + prompt + "\n\n"
-
-    # Add Response with markdown title and emoji
-    combined_content += "# Response 💬\n" + response + "\n\n"
-
-    # Check for code blocks in the response
-    resources = re.findall(r"```([\s\S]*?)```", response)
-    for resource in resources:
-        # Check if the resource contains Python code
-        if "python" in resource.lower():
-            # Remove the 'python' keyword from the code block
-            cleaned_code = re.sub(r'^\s*python', '', resource, flags=re.IGNORECASE | re.MULTILINE)
-            
-            # Add Code Results title with markdown and emoji
-            combined_content += "# Code Results 🚀\n"
-
-            # Redirect standard output to capture it
-            original_stdout = sys.stdout
-            sys.stdout = io.StringIO()
-            
-            # Execute the cleaned Python code within the context
-            try:
-                exec(cleaned_code, context)
-                code_output = sys.stdout.getvalue()
-                combined_content += f"```\n{code_output}\n```\n\n"
-                realtimeEvalResponse = "# Code Results 🚀\n" + "```" + code_output + "```\n\n"
-                st.write(realtimeEvalResponse)
-                
-            except Exception as e:
-                combined_content += f"```python\nError executing Python code: {e}\n```\n\n"
-            
-            # Restore the original standard output
-            sys.stdout = original_stdout
-        else:
-            # Add non-Python resources with markdown and emoji
-            combined_content += "# Resource 🛠️\n" + "```" + resource + "```\n\n"
-
-    # Save the combined content to a Markdown file
-    if should_save:
-        with open(f"{base_filename}.md", 'w') as file:
-            file.write(combined_content)
-
 
 def truncate_document(document, length):
     return document[:length]
@@ -470,15 +565,6 @@ def get_zip_download_link(zip_file):
     
 def main():
 
-    col1, col2, col3, col4 = st.columns(4)
-
-    with col1:
-        with st.expander("Settings 🧠💾", expanded=False):
-            # File type for output, model choice
-            menu = ["txt", "htm", "xlsx", "csv", "md", "py"]
-            choice = st.sidebar.selectbox("Output File Type:", menu)
-            model_choice = st.sidebar.radio("Select Model:", ('gpt-3.5-turbo', 'gpt-3.5-turbo-0301'))
-
     # Audio, transcribe, GPT:
     filename = save_and_play_audio(audio_recorder)
 
@@ -520,9 +606,7 @@ def main():
             else:
                 if st.button(f"Chat about Section {i+1}"):
                     st.write('Reasoning with your inputs...')
-                    response = chat_with_model(user_prompt, section, model_choice) # *************************************
-                    st.write('Response:')
-                    st.write(response)
+                    response = chat_with_model(user_prompt, section, model_choice)
                     document_responses[i] = response
                     filename = generate_filename(f"{user_prompt}_section_{i+1}", choice)
                     create_file(filename, user_prompt, response, should_save)
@@ -538,14 +622,7 @@ def main():
             # Process each section with the model
             response = chat_with_model(prompt_section, ''.join(list(document_sections)), model_choice)
             full_response += response + '\n'  # Combine the responses
-        
-        #st.write('Response:')
-        #st.write(full_response)
-
         response = full_response
-        st.write('Response:')
-        st.write(response)
-        
         filename = generate_filename(user_prompt, choice)
         create_file(filename, user_prompt, response, should_save)
         st.sidebar.markdown(get_table_download_link(filename), unsafe_allow_html=True)
@@ -631,4 +708,4 @@ with st.sidebar:
             st.session_state.conversation = get_chain(vectorstore)
             st.markdown('# AI Search Index of Length:' + length + ' Created.')  # add timing
             filename = generate_filename(raw, 'txt')
-            create_file(filename, raw, '', should_save)
+            create_file(filename, raw, '', should_save)