Update app.py

app.py

@@ -10,194 +10,34 @@ from selenium.webdriver.chrome.service import Service
 from selenium.webdriver.chrome.options import Options
 from webdriver_manager.chrome import ChromeDriverManager
 from huggingface_hub import InferenceClient
-from selenium.common.exceptions import WebDriverException
-import random
-import yaml
-
-# Check for Hugging Face API key
-api_key = os.getenv('access')
-if not api_key:
-    raise EnvironmentError("Error: Hugging Face API key not found. Please set the 'access' environment variable.")
 
 # Configure logging
-log_dir = "logs"
-if not os.path.exists(log_dir):
-    os.makedirs(log_dir)
-
-logging.basicConfig(
-    filename=os.path.join(log_dir, "gradio_log.txt"),
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
-    filemode="a+",
-)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-logger = logging.getLogger(__name__)
+# Define constants
+PREFIX = "Task started at {date_time_str}. Purpose: {purpose}"
+TASK_PROMPT = "Current task: {task}. History:\n{history}"
 
-# Load custom prompts
-try:
-    with open('custom_prompts.yaml', 'r') as fp:
-        custom_prompts = yaml.safe_load(fp)
-except FileNotFoundError:
-    custom_prompts = {
-        "WEB_DEV": "",
-        "AI_SYSTEM_PROMPT": "",
-        "PYTHON_CODE_DEV": "",
-        "CODE_GENERATION": "",
-        "CODE_INTERPRETATION": "",
-        "CODE_TRANSLATION": "",
-        "CODE_IMPLEMENTATION": ""
-    }
+# Define current date/time
+date_time_str = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
-for key, val in custom_prompts.items():
-    globals()[key] = val
-
-# Define advanced prompts
-CODE_GENERATION = """
-You are an expert AI code generation assistant. Your task is to generate high-quality, production-ready code based on the given requirements. You should be able to generate code in various programming languages, including Python, JavaScript, Java, C++, and more.
-When generating code, follow these guidelines:
-1. Understand the requirements thoroughly and ask clarifying questions if needed.
-2. Write clean, modular, and maintainable code following best practices and industry standards.
-3. Implement proper error handling, input validation, and edge case handling.
-4. Optimize the code for performance and scalability when necessary.
-5. Provide clear and concise comments to explain the code's functionality and logic.
-6. If applicable, suggest and implement testing strategies (unit tests, integration tests, etc.).
-7. Ensure the generated code is compatible with the target environment (e.g., web, mobile, desktop).
-8. Provide examples or usage instructions if required.
-Remember to always prioritize code quality, maintainability, and security. Your generated code should be ready for production use or further development.
+# Define purpose
+purpose = """
+You go to Culvers sites, you continuously seek changes on them since your last observation.
+Anything new that gets logged and dumped into csv, stored in your log folder at user/app/scraped_data.
 """
 
-CODE_INTERPRETATION = """
-You are an expert AI code interpretation assistant. Your task is to analyze and explain existing code in various programming languages, including Python, JavaScript, Java, C++, and more.
-When interpreting code, follow these guidelines:
-1. Read and understand the code thoroughly, including its functionality, logic, and structure.
-2. Identify and explain the purpose of each code block, function, or module.
-3. Highlight any potential issues, inefficiencies, or areas for improvement.
-4. Suggest refactoring or optimization techniques if applicable.
-5. Explain the code's input and output, as well as any dependencies or external libraries used.
-6. Provide clear and concise explanations, using code comments or separate documentation.
-7. If applicable, explain the testing strategies or methodologies used in the code.
-8. Ensure your interpretations are accurate, unbiased, and tailored to the target audience's skill level.
-Remember to prioritize clarity, accuracy, and completeness in your code interpretations. Your explanations should help developers understand the code's functionality and potential areas for improvement.
-"""
-
-CODE_TRANSLATION = """
-You are an expert AI code translation assistant. Your task is to translate code from one programming language to another, ensuring the translated code maintains the original functionality and follows best practices in the target language.
-When translating code, follow these guidelines:
-1. Understand the original code's functionality, logic, and structure thoroughly.
-2. Identify and translate all code elements, including variables, functions, classes, and data structures.
-3. Ensure the translated code adheres to the coding conventions and best practices of the target language.
-4. Optimize the translated code for performance and readability in the target language.
-5. Preserve comments and documentation, translating them to the target language if necessary.
-6. Handle any language-specific features or constructs appropriately during the translation process.
-7. Implement error handling, input validation, and edge case handling in the translated code.
-8. Provide clear and concise comments or documentation to explain any necessary changes or deviations from the original code.
-Remember to prioritize accuracy, maintainability, and idiomatic usage in the target language. Your translated code should be functionally equivalent to the original code while adhering to the best practices of the target language.
-"""
-
-CODE_IMPLEMENTATION = """
-You are an expert AI code implementation assistant. Your task is to take existing code or requirements and implement them in a production-ready environment, ensuring proper integration, deployment, and maintenance.
-When implementing code, follow these guidelines:
-1. Understand the code's functionality, dependencies, and requirements thoroughly.
-2. Set up the appropriate development environment, including installing necessary tools, libraries, and frameworks.
-3. Integrate the code with existing systems, APIs, or databases, if applicable.
-4. Implement proper configuration management, version control, and continuous integration/deployment processes.
-5. Ensure the code is properly tested, including unit tests, integration tests, and end-to-end tests.
-6. Optimize the code for performance, scalability, and security in the production environment.
-7. Implement monitoring, logging, and error handling mechanisms for the deployed code.
-8. Document the implementation process, including any specific configurations, deployment steps, or maintenance procedures.
-Remember to prioritize reliability, maintainability, and scalability in your code implementations. Your implementations should be production-ready, well-documented, and aligned with industry best practices for software development and deployment.
-"""
+# Define history
+history = []
 
-# Update the custom_prompts dictionary with the new prompts
-custom_prompts.update({
-    "CODE_GENERATION": CODE_GENERATION,
-    "CODE_INTERPRETATION": CODE_INTERPRETATION,
-    "CODE_TRANSLATION": CODE_TRANSLATION,
-    "CODE_IMPLEMENTATION": CODE_IMPLEMENTATION
-})
+# Define current task
+current_task = None
 
-now = datetime.now()
-date_time_str = now.strftime("%Y-%m-%d %H:%M:%S")
+# Default file path
+default_file_path = "user/app/scraped_data/culver/culvers_changes.csv"
 
-client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1")
-
-VERBOSE = True
-MAX_HISTORY = 125
-
-def format_prompt(message, history):
-    prompt = "<s>"
-    for user_prompt, bot_response in history:
-        prompt += f"[INST] {user_prompt} [/INST]"
-        prompt += f" {bot_response}</s> "
-    prompt += f"[INST] {message} [/INST]"
-    return prompt
-
-agents = [
-    "WEB_DEV",
-    "AI_SYSTEM_PROMPT",
-    "PYTHON_CODE_DEV",
-    "CODE_GENERATION",
-    "CODE_INTERPRETATION",
-    "CODE_TRANSLATION",
-    "CODE_IMPLEMENTATION"
-]
-
-def generate(
-        prompt, history, agent_name=agents[0], sys_prompt="", temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.7,
-):
-    seed = random.randint(1, 1111111111111111)
-    agent = custom_prompts[agent_name]
-    
-    system_prompt = agent if sys_prompt == "" else sys_prompt
-    temperature = max(float(temperature), 1e-2)
-    top_p = float(top_p)
-
-    generate_kwargs = dict(
-        temperature=temperature,
-        max_new_tokens=max_new_tokens,
-        top_p=top_p,
-        repetition_penalty=repetition_penalty,
-        do_sample=True,
-        seed=seed,
-    )
-
-    formatted_prompt = format_prompt(f"{system_prompt}\n\n{prompt}", history)
-    output = client.text_generation(formatted_prompt, **generate_kwargs, stream=False, return_full_text=False)
-    
-    return output
-
-def update_sys_prompt(agent):
-    return custom_prompts[agent]
-
-def get_helpful_tip(agent):
-    tips = {
-        'WEB_DEV': "Provide information related to Web Development tasks.",
-        'AI_SYSTEM_PROMPT': "Update the system instructions for the assistant here.",
-        'PYTHON_CODE_DEV': "Describe what you want me to help you with regarding Python coding tasks.",
-        'CODE_GENERATION': "Provide requirements for the code you want me to generate.",
-        'CODE_INTERPRETATION': "Share the code you want me to analyze and explain.",
-        'CODE_TRANSLATION': "Specify the source and target programming languages, and provide the code you want me to translate.",
-        'CODE_IMPLEMENTATION': "Provide the code or requirements you want me to implement in a production-ready environment."
-    }
-    return tips.get(agent, "Select an agent to get started.")
-
-def chat_interface(prompt, history, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty):
-    generated_text = generate(prompt, history, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty)
-    history.append((prompt, generated_text))
-    return history, ""
-
-def log_messages(*args):
-    logger.info(f'Input: {args}')
-
-examples = [
-    ["Based on previous interactions, generate an interactive preview of the user's requested application.", "WEB_DEV", "", 0.9, 1024, 0.95, 1.2],
-    ["Utilize the relevant code snippets and components from previous interactions.", "PYTHON_CODE_DEV", "", 0.9, 1024, 0.95, 1.2],
-    ["Assemble a working demo that showcases the core functionality of the application.", "CODE_IMPLEMENTATION", "", 0.9, 1024, 0.95, 1.2],
-    ["Present the demo in an interactive environment within the Gradio interface.", "WEB_DEV", "", 0.9, 1024, 0.95, 1.2],
-    ["Allow the user to explore and interact with the demo to test its features.", "CODE_GENERATION", "", 0.9, 1024, 0.95, 1.2],
-    ["Gather feedback from the user about the demo and potential improvements.", "AI_SYSTEM_PROMPT", "", 0.9, 1024, 0.95, 1.2],
-    ["If the user approves of the app's running state, provide a bash script that will automate all aspects of a local run and a docker image for ease-of-launch in addition to the huggingface-ready app.py with all functions and GUI, and the requirements.txt file comprised of all required libraries and packages the application is dependent on, avoiding OpenAI API at all points since we only use Hugging Face transformers, models, agents, libraries, and API.", "CODE_IMPLEMENTATION", "", 0.9, 2048, 0.95, 1.2],
-]
+# Ensure the directory exists
+os.makedirs(os.path.dirname(default_file_path), exist_ok=True)
 
 # Function to monitor URLs for changes
 def monitor_urls(storage_location, url1, url2, scrape_interval, content_type):
@@ -218,80 +58,104 @@ def monitor_urls(storage_location, url1, url2, scrape_interval, content_type):
         options.add_argument("--no-sandbox")
         options.add_argument("--disable-dev-shm-usage")
         
-        try:
-            with webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options) as driver:
-                try:
-                    while True:
-                        for i, url in enumerate(urls):
-                            try:
-                                driver.get(url)
-                                time.sleep(2)  # Wait for the page to load
-                                if content_type == "text":
-                                    current_content = driver.page_source
-                                elif content_type == "media":
-                                    current_content = driver.find_elements_by_tag_name("img")
-                                else:
-                                    current_content = driver.page_source
-                                
-                                current_hash = hashlib.md5(str(current_content).encode('utf-8')).hexdigest()
-                                
-                                if current_hash != previous_hashes[i]:
-                                    previous_hashes[i] = current_hash
-                                    date_time_str = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                                    history.append(f"Change detected at {url} on {date_time_str}")
-                                    csv_toolkit.writerow({"date": date_time_str.split()[0], "time": date_time_str.split()[1], "url": url, "change": "Content changed"})
-                                    logging.info(f"Change detected at {url} on {date_time_str}")
-                            except Exception as e:
-                                logging.error(f"Error accessing {url}: {e}")
-                        
-                        time.sleep(scrape_interval * 60)  # Check every scrape_interval minutes
-                except KeyboardInterrupt:
-                    logging.info("Monitoring stopped by user.")
-        except WebDriverException as e:
-            logging.error(f"WebDriverException: {e}")
-            raise
+        with webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options) as driver:
+            try:
+                while True:
+                    for i, url in enumerate(urls):
+                        try:
+                            driver.get(url)
+                            time.sleep(2)  # Wait for the page to load
+                            if content_type == "text":
+                                current_content = driver.page_source
+                            elif content_type == "media":
+                                current_content = driver.find_elements_by_tag_name("img")
+                            else:
+                                current_content = driver.page_source
+                            
+                            current_hash = hashlib.md5(str(current_content).encode('utf-8')).hexdigest()
+                            
+                            if current_hash != previous_hashes[i]:
+                                previous_hashes[i] = current_hash
+                                date_time_str = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                                history.append(f"Change detected at {url} on {date_time_str}")
+                                csv_toolkit.writerow({"date": date_time_str.split()[0], "time": date_time_str.split()[1], "url": url, "change": "Content changed"})
+                                logging.info(f"Change detected at {url} on {date_time_str}")
+                        except Exception as e:
+                            logging.error(f"Error accessing {url}: {e}")
+                    
+                    time.sleep(scrape_interval * 60)  # Check every scrape_interval minutes
+            except KeyboardInterrupt:
+                logging.info("Monitoring stopped by user.")
+            finally:
+                driver.quit()
 
 # Define main function to handle user input
-def handle_input(task, storage_location, url1, url2, scrape_interval, content_type):
+def handle_input(storage_location, url1, url2, scrape_interval, content_type):
     global current_task, history
 
-    if task == "Monitor URLs for Changes":
-        current_task = f"Monitoring URLs: {url1}, {url2}"
-        history.append(f"Task started: {current_task}")
-        monitor_urls(storage_location, url1, url2, scrape_interval, content_type)
-        return TASK_PROMPT.format(task=current_task, history="\n".join(history))
-    elif task == "Chat with a Friendly Chatbot":
-        return "You can chat with the friendly chatbot below."
-
-# Create Gradio interface
-with gr.Blocks() as iface:
-    gr.Markdown("# School Site Monitor and Chatbot")
-
-    chatbot = gr.Chatbot()
-    msg = gr.Textbox()
-    clear = gr.Button("Clear")
+    current_task = f"Monitoring URLs: {url1}, {url2}"
+    history.append(f"Task started: {current_task}")
+    monitor_urls(storage_location, url1, url2, scrape_interval, content_type)
+    return TASK_PROMPT.format(task=current_task, history="\n".join(history))
+
+# Define the chat response function
+client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+):
+    messages = [{"role": "system", "content": system_message}]
 
-    agent_dropdown = gr.Dropdown(label="Agents", choices=agents, value=agents[0])
-    sys_prompt = gr.Textbox(label="System Prompt", max_lines=1)
-    temperature = gr.Slider(label="Temperature", value=0.65, minimum=0.0, maximum=2.0, step=0.01)
-    max_new_tokens = gr.Slider(label="Max new tokens", value=8000, minimum=0, maximum=8000, step=64)
-    top_p = gr.Slider(label="Top-p (nucleus sampling)", value=0.90, minimum=0.0, maximum=1, step=0.05)
-    repetition_penalty = gr.Slider(label="Repetition penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05)
+    for val in history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
 
-    helpful_tip = gr.Markdown()
+    messages.append({"role": "user", "content": message})
 
-    msg.submit(chat_interface, 
-               [msg, chatbot, agent_dropdown, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty], 
-               [chatbot, msg])
-    clear.click(lambda: None, None, chatbot, queue=False)
+    response = ""
 
-    gr.Examples(examples, [msg, agent_dropdown, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty])
+    for message in client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        token = message.choices[0].delta.content
 
-    agent_dropdown.change(fn=get_helpful_tip, inputs=agent_dropdown, outputs=helpful_tip)
-    agent_dropdown.change(fn=update_sys_prompt, inputs=agent_dropdown, outputs=sys_prompt)
+        response += token
+        yield response
 
-    for component in [msg, agent_dropdown, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty]:
-        component.change(fn=log_messages, inputs=[component])
+# Create Gradio interface
+demo = gr.ChatInterface(
+    respond,
+    additional_inputs=[
+        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-p (nucleus sampling)",
+        ),
+        gr.Textbox(value=default_file_path, label="Storage Location"),
+        gr.Textbox(value="https://www.culver.k12.in.us/", label="URL 1"),
+        gr.Textbox(value="https://www.facebook.com/CulverCommunitySchools", label="URL 2"),
+        gr.Slider(minimum=1, maximum=60, value=5, step=1, label="Scrape Interval (minutes)"),
+        gr.Radio(choices=["text", "media", "both"], value="text", label="Content Type"),
+    ],
+    title="Culvers Site Monitor and Chatbot",
+    description="Monitor changes on Culvers' websites and log them into a CSV file. Also, chat with a friendly chatbot."
+)
 
 if __name__ == "__main__":
-    iface.launch()
+    demo.launch()