Update app.py

app.py

@@ -1,6 +1,7 @@
 import gradio as gr
 import requests
 import json
+import time
 
 # --- API Configuration ---
 BLACKBOX_URL = "https://api.blackbox.ai/api/chat"
@@ -10,19 +11,76 @@ api_models = {
     "Lake 1 Mini": "mistralai/Mistral-Small-24B-Instruct-2501",
     "Lake 1 Base": "databricks/dbrx-instruct",
     "Lake 1 Chat": "deepseek-ai/deepseek-llm-67b-chat",
+    "Lake 1 Advanced": "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO"
 }
 
-# --- Default Settings ---
-DEFAULT_SETTINGS = {
-    'tpm': 600,  # tokens per minute
-    'rpm': 7,   # requests per minute
-    'preset': 'Normal'
+# Model-specific system prompts
+MODEL_PROMPTS = {
+    "Lake 1 Mini": "You are a general-purpose AI assistant focused on providing concise and practical answers.",
+    "Lake 1 Base": "You are a technical expert AI specializing in detailed explanations and step-by-step solutions.",
+    "Lake 1 Chat": "You are a friendly conversational AI that prioritizes natural dialogue and approachable responses.",
+    "Lake 1 Advanced": "You are an advanced AI capable of expert-level analysis and critical thinking."
 }
 
-def call_blackbox_api(prompt: str, model: str, max_new_tokens: int) -> str:
+# --- Rate Limits ---
+STANDARD_RPM = 4
+PLUS_RPM = 8
+PRO_RPM = 16
+
+STANDARD_TPM = 1200
+PLUS_TPM = 2400
+PRO_TPM = 4800
+
+# --- Magic Word Secrets ---
+MAGIC_WORD_SECRET_1 = "SourSesameManager"
+MAGIC_WORD_SECRET_2 = "BeanedSesameHockey"
+
+def get_system_message(model: str, preset: str, access: str) -> str:
+    """Generate combined system message with model-specific and access-level prompts"""
+    base_prompt = MODEL_PROMPTS.get(model, "You are a helpful AI assistant.")
+    
+    preset_modes = {
+        "Fast": "Prioritize speed over detail",
+        "Normal": "Balance speed and detail",
+        "Quality": "Prioritize detailed, comprehensive responses"
+    }
+    
+    access_levels = {
+        "standard": f"Standard access: Limited to {STANDARD_RPM} requests/min",
+        "plus": f"Plus access: Up to {PLUS_RPM} requests/min",
+        "pro": f"Pro access: Maximum {PRO_RPM} requests/min"
+    }
+    
+    return (
+        f"{base_prompt}\n"
+        f"Mode: {preset_modes[preset]}\n"
+        f"Access: {access_levels[access]}\n"
+        "Respond appropriately to the user's query:"
+    )
+
+def check_rate_limit(settings_state: dict) -> bool:
+    """Check if user has exceeded their RPM limit"""
+    current_time = time.time()
+    last_reset = settings_state.get("last_reset", 0)
+    
+    # Reset counter if more than 60 seconds have passed
+    if current_time - last_reset > 60:
+        settings_state["request_count"] = 0
+        settings_state["last_reset"] = current_time
+    
+    max_rpm = PRO_RPM if settings_state["access"] == "pro" else \
+              PLUS_RPM if settings_state["access"] == "plus" else STANDARD_RPM
+    
+    if settings_state.get("request_count", 0) >= max_rpm:
+        return False
+    
+    settings_state["request_count"] = settings_state.get("request_count", 0) + 1
+    return True
+
+def call_blackbox_api(messages: list, model: str, max_new_tokens: int) -> str:
     headers = {'Content-Type': 'application/json'}
     payload = json.dumps({
-        "messages": [{"role": "user", "content": prompt}],
+        "messages": messages,
         "model": model,
         "max_tokens": str(max_new_tokens)
     })
@@ -39,82 +97,132 @@ def call_blackbox_api(prompt: str, model: str, max_new_tokens: int) -> str:
     else:
         return f"{response.text}"
 
-def generate_response(message: str, model_name: str, preset: str) -> str:
-    max_tokens = DEFAULT_SETTINGS['tpm']
-    api_model = api_models[model_name]
-    return call_blackbox_api(message, model=api_model, max_new_tokens=max_tokens)
+def generate_response(message: str, model_name: str, preset: str, access: str) -> str:
+    max_tokens = PRO_TPM if access == "pro" else PLUS_TPM if access == "plus" else STANDARD_TPM
+    api_model = api_models.get(model_name, api_models["Lake 1 Mini"])
+    messages = [
+        {"role": "system", "content": get_system_message(model_name, preset, access)},
+        {"role": "user", "content": message}
+    ]
+    return call_blackbox_api(messages, api_model, max_tokens)
 
 def chat_handler(message, history, settings_state):
-    model = settings_state.get("model", "Lake 1 Mini")
-    preset = settings_state.get("preset", "Normal")
-    response = generate_response(message, model, preset)
-    history.append({"role": "user", "content": message})
-    history.append({"role": "assistant", "content": response})
-    return history
-
-def update_settings(model, preset):
-    new_state = {"model": model, "preset": preset}
-    settings_text = f"Model: **{model}**, Preset: **{preset}**"
-    return new_state, settings_text
+    if not check_rate_limit(settings_state):
+        return history + [
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": f"Rate limit exceeded! Current plan allows {settings_state['access']} RPM."}
+        ]
+    
+    response = generate_response(
+        message,
+        settings_state["model"],
+        settings_state["preset"],
+        settings_state["access"]
+    )
+    return history + [{"role": "user", "content": message}, {"role": "assistant", "content": response}]
+
+def update_settings(model, preset, magic_word):
+    access = "pro" if magic_word == MAGIC_WORD_SECRET_2 else \
+             "plus" if magic_word == MAGIC_WORD_SECRET_1 else "standard"
+    
+    models = ["Lake 1 Mini", "Lake 1 Base", "Lake 1 Chat"] + \
+             (["Lake 1 Advanced"] if access in ["pro", "plus"] else [])
+    
+    new_state = {
+        "model": model,
+        "preset": preset,
+        "access": access,
+        "request_count": 0,
+        "last_reset": time.time()
+    }
+    
+    return (
+        new_state,
+        f"**Settings:** Model: {model} | Preset: {preset} | Access: {access.title()}",
+        gr.update(choices=models, value=models[0])
+    )
 
 def create_interface():
-    with gr.Blocks(title="Lake AI Assistant", theme="soft") as demo:
-        settings_state = gr.State(value={"model": "Lake 1 Mini", "preset": "Normal"})
+    css = """
+    .donate-btn, .subscribe-btn {
+        background: linear-gradient(45deg, #4CAF50, #45a049);
+        color: white;
+        border: none;
+        padding: 8px 16px;
+        border-radius: 4px;
+        cursor: pointer;
+        transition: all 0.3s;
+    }
+    .donate-btn:hover, .subscribe-btn:hover {
+        transform: scale(1.05);
+        box-shadow: 0 4px 8px rgba(0,0,0,0.2);
+    }
+    .rate-limit {
+        color: #ff4444;
+        font-weight: bold;
+        margin: 10px 0;
+    }
+    @keyframes typing {
+        0% { opacity: 0.5; }
+        50% { opacity: 1; }
+        100% { opacity: 0.5; }
+    }
+    .typing-indicator {
+        animation: typing 1.5s infinite;
+        font-size: 0.9em;
+        color: #666;
+    }
+    """
+
+    with gr.Blocks(title="Lake AI", css=css, theme=gr.themes.Soft()) as app:
+        state = gr.State({
+            "model": "Lake 1 Mini",
+            "preset": "Normal",
+            "access": "standard",
+            "request_count": 0,
+            "last_reset": time.time()
+        })
         
-        with gr.Tabs():      
-            with gr.Tab("Chat"):
-                gr.Markdown("## Chat with Lake AI Assistant")
-                chatbot = gr.Chatbot(label="💬 Conversation", height=400, show_copy_button=True, type="messages")
-                chat_input = gr.Textbox(label="Your Message", placeholder="Type your message here...", interactive=True)
-                send_button = gr.Button("Send")
-                donate_button = gr.Button("Donate ☕")
-                
-                send_button.click(
-                    fn=chat_handler,
-                    inputs=[chat_input, chatbot, settings_state],
-                    outputs=chatbot
-                )
-                chat_input.submit(
-                    fn=chat_handler,
-                    inputs=[chat_input, chatbot, settings_state],
-                    outputs=chatbot
+        with gr.Tab("Chat"):
+            gr.Markdown("# 🌊 Lake AI Assistant")
+            chatbot = gr.Chatbot(height=400, label="Conversation", type="messages")
+            msg = gr.Textbox(label="Your Message", placeholder="Type here...")
+            
+            with gr.Row():
+                send_btn = gr.Button("Send", variant="primary")
+                send_btn.click(chat_handler, [msg, chatbot, state], chatbot)
+            
+            with gr.Row():
+                gr.Button("☕ Donate", elem_classes="donate-btn").click(
+                    None, None, None, js="window.open('https://buymeacoffee.com/bronio_int')"
                 )
-                # Corrected donation button implementation
-                donate_button.click(
-                    fn=None,
-                    inputs=None,
-                    outputs=None,
-                    js="window.open('https://buymeacoffee.com/bronio_int', '_blank')"
+                gr.Button("🌟 Subscribe", elem_classes="subscribe-btn").click(
+                    None, None, None, js="window.open('https://patreon.com/YourPageHere')"
                 )
 
-            with gr.Tab("Settings"):
-                gr.Markdown("## Settings")
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("### Model & Performance")
-                        model_dropdown = gr.Dropdown(
-                            label="Model Selection",
-                            interactive=True,
-                            choices=["Lake 1 Mini", "Lake 1 Base", "Lake 1 Chat"],
-                            value="Lake 1 Mini"
-                        )
-                        preset_dropdown = gr.Dropdown(
-                            label="Performance Preset",
-                            interactive=True,
-                            choices=["Fast", "Normal", "Quality"],
-                            value="Normal"
-                        )
-                        update_settings_button = gr.Button("Update Settings")
-                        settings_info = gr.Markdown("")
-                
-                update_settings_button.click(
-                    fn=update_settings,
-                    inputs=[model_dropdown, preset_dropdown],
-                    outputs=[settings_state, settings_info]
-                )
-    
-    return demo
+            msg.submit(chat_handler, [msg, chatbot, state], chatbot)
+
+        with gr.Tab("Settings"):
+            with gr.Row():
+                with gr.Column():
+                    model = gr.Dropdown(
+                        ["Lake 1 Mini", "Lake 1 Base", "Lake 1 Chat"],
+                        label="AI Model",
+                        value="Lake 1 Mini"
+                    )
+                    preset = gr.Dropdown(
+                        ["Fast", "Normal", "Quality"],
+                        label="Performance Mode",
+                        value="Normal"
+                    )
+                    key = gr.Textbox(label="Premium Key", type="password")
+                    status = gr.Markdown()
+            
+            gr.Button("Apply Settings").click(
+                update_settings, [model, preset, key], [state, status, model]
+            )
+
+    return app
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch()
+    create_interface().launch()