Update appaaa.py

appaaa.py

@@ -1,290 +1,258 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException, Form
-from fastapi.responses import FileResponse
-from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
-from zipfile import ZipFile, BadZipfile
-import os
-import shutil
-import subprocess
+import streamlit as st
 from datetime import datetime
-import logging
-import asyncio
-from typing import List
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
-from fastapi.responses import HTMLResponse
-from fastapi.responses import RedirectResponse
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-from sqlalchemy import Column, Integer, String, DateTime, Boolean
-from langchain.document_loaders import TextLoader
-from langchain.embeddings import HuggingFaceEmbeddings
-from langchain.vectorstores import FAISS
-
+import os
+import json
+from pathlib import Path
+from json import JSONDecodeError
+from FreeLLM import HuggingChatAPI, ChatGPTAPI, BingChatAPI
+
+# Page Configuration
+st.set_page_config(
+    page_title="FREE AUTOHUGGS 🤗",
+    page_icon="🤗",
+    layout="wide",
+    menu_items={
+        "Get help": "[email protected]",
+        "About": "# *🤗 FREE AUTOHUGGS 🤗*"
+    }
+)
 
-def initialize_rag_system():
-    # Document processing
-    loader = TextLoader("deepseek_rag/documents/*.txt")
-    documents = loader.load()
+# Modern Dark Theme CSS
+st.markdown("""
+<style>
+    /* Base theme */
+    .main {
+        background-color: #0e1117;
+        color: #e0e0e0;
+    }
     
-    # Text splitting
-    text_splitter = RecursiveCharacterTextSplitter(
-        chunk_size=1000, 
-        chunk_overlap=200
-    )
+    /* Sidebar styling */
+    .css-1d391kg {
+        background-color: #1e1e2e;
+    }
     
-    # Vector storage
-    embeddings = HuggingFaceEmbeddings()
-    vector_store = FAISS.from_documents(
-        text_splitter.split_documents(documents),
-        embeddings
-    )
+    /* Input fields */
+    .stTextInput input, .stTextArea textarea, .stNumberInput input {
+        background-color: #262630;
+        color: #ffffff;
+        border: 1px solid #464660;
+        border-radius: 8px;
+        padding: 12px;
+    }
     
-    return vector_store.as_retriever()
-
-# Set up logging
-logging.basicConfig(filename="errors.log", level=logging.ERROR, format="%(asctime)s - %(levelname)s - %(message)s")
-
-app = FastAPI()
-
-# Enable CORS for development
-origins = ["*"]
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Serve static files
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-# Template engine
-templates = Jinja2Templates(directory="templates")
-
-# Define supported frameworks and their associated extensions
-FRAMEWORKS = {
-    "Python": ".py",
-    "JavaScript": ".js",
-    "PHP": ".php",
-    "Go": ".go",
-    "Ruby": ".rb",
-    "Java": ".java",
-    "C#": ".cs",
-    "C++": ".cpp",
-    "Rust": ".rs",
-}
-
-INTERPRETER_COMMANDS = {
-    "Python": "python {file_path}",
-    "JavaScript": "node {file_path}",
-    "PHP": "php -l {file_path}",
-    "Go": "go build {file_path}",
-    "Ruby": "ruby -c {file_path}",
-    "Java": "javac {file_path}",
-    "C#": "mcs {file_path}",
-    "C++": "g++ -c {file_path}",
-    "Rust": "rustc {file_path}",
-}
-
-# Database setup
-SQLALCHEMY_DATABASE_URL = "sqlite:///errors.db"  # Use SQLite for simplicity
-engine = create_engine(
-    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
-)
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-Base = declarative_base()
-
-# Database model for errors
-class TranslationError(Base):
-    __tablename__ = "translation_errors"
-
-    id = Column(Integer, primary_key=True, index=True)
-    timestamp = Column(DateTime, default=datetime.utcnow)
-    file = Column(String)
-    error = Column(String)
-    resolved = Column(Boolean, default=False)
-
-# Create tables if they don't exist
-Base.metadata.create_all(bind=engine)
-
-# Dependency for database session
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-# Load models at startup
-@app.on_event("startup")
-async def load_models():
-    app.state.translation_models = {
-        "Python": AutoModelForSeq2SeqLM.from_pretrained("microsoft/codebert-base"),
-        "JavaScript": AutoModelForSeq2SeqLM.from_pretrained("microsoft/codebert-base"),
-        # Add other frameworks as needed
+    /* Buttons */
+    .stButton>button {
+        background: linear-gradient(90deg, #ff4b4b 0%, #ff6b6b 100%);
+        color: white;
+        border: none;
+        padding: 0.6em 1.2em;
+        border-radius: 8px;
+        font-weight: 600;
+        transition: all 0.3s ease;
     }
-    app.state.tokenizer = AutoTokenizer.from_pretrained("microsoft/codebert-base")
-
-# Function to translate code using the loaded model
-def translate_code(input_code, framework):
-    prompt = f"Translate TSX to {framework}:\n{input_code}"
-    inputs = app.state.tokenizer(prompt, return_tensors="pt", truncation=True)
-    outputs = app.state.translation_models[framework].generate(**inputs)
-    return app.state.tokenizer.decode(outputs[0], skip_special_tokens=True)
+    
+    .stButton>button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(255, 75, 75, 0.3);
+    }
+    
+    /* Chat messages */
+    .chat-message {
+        padding: 1rem;
+        border-radius: 12px;
+        margin: 1rem 0;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+    }
+    
+    .user-message {
+        background-color: #2a2a3a;
+        border-left: 4px solid #ff4b4b;
+    }
+    
+    .assistant-message {
+        background-color: #323242;
+        border-left: 4px solid #4b8bff;
+    }
+    
+    /* Headers */
+    h1, h2, h3 {
+        color: #ffffff;
+    }
+</style>
+""", unsafe_allow_html=True)
 
-# Function to process the uploaded zip file and translate its contents
-def process_zip(zip_path, framework):
-    translated_dir = os.path.join(os.getcwd(), "translated")
-    os.makedirs(translated_dir, exist_ok=True)
+# Sidebar Configuration
+with st.sidebar:
+    st.header("🛠️ Agent Configuration")
+    
+    assistant_role_name = st.text_input("👤 Assistant Role", "Python Programmer")
+    user_role_name = st.text_input("👥 User Role", "Stock Trader")
+    task = st.text_area("📋 Task", "Develop a trading bot for the stock market")
+    word_limit = st.slider("🔤 Word Limit", 10, 1500, 50)
     
+    st.markdown("---")
+    
+    st.header("⚙️ Advanced Options")
+    llm_choice = st.selectbox("🤖 Select LLM API", ["HuggingChat", "ChatGPT", "BingChat"])
+    auto_save = st.checkbox("💾 Auto-save conversation", value=True)
+    transcript_filename = st.text_input("📄 Transcript filename", "conversation_transcript.txt")
+
+# Cookie File Validation
+COOKIE_FILE = "cookiesHuggingChat.json"
+try:
+    if not Path(COOKIE_FILE).exists():
+        st.error(f"❌ File '{COOKIE_FILE}' not found! Please create it with your cookies in JSON format.")
+        st.stop()
+        
+    with open(COOKIE_FILE, "r") as file:
+        cookies = json.loads(file.read())
+except JSONDecodeError:
+    st.error(f"❌ Invalid JSON in '{COOKIE_FILE}'. Please check your file format!")
+    st.stop()
+except Exception as e:
+    st.error(f"❌ Error reading cookie file: {str(e)}")
+    st.stop()
+
+# LLM API Initialization
+def get_llm(api_choice: str):
+    llm_map = {
+        "HuggingChat": HuggingChatAPI.HuggingChat,
+        "ChatGPT": ChatGPTAPI.ChatGPT,
+        "BingChat": BingChatAPI.BingChat
+    }
+    
+    if api_choice not in llm_map:
+        st.error("❌ Invalid LLM API selection.")
+        st.stop()
+        
     try:
-        with ZipFile(zip_path, 'r') as zip_ref:
-            zip_ref.extractall(translated_dir)
-    except BadZipfile:
-        logging.error(f"Invalid ZIP file: {zip_path}")
-        raise HTTPException(status_code=400, detail="Invalid ZIP file.")
-
-    for root, _, files in os.walk(translated_dir):
-        for file in files:
-            if file.endswith(".tsx"):
-                tsx_path = os.path.join(root, file)
-                try:
-                    translated_code = translate_code(open(tsx_path).read(), framework)
-                    new_path = tsx_path.replace(".tsx", FRAMEWORKS[framework])
-                    with open(new_path, 'w') as f:
-                        f.write(translated_code)
-                    os.remove(tsx_path)
-                except Exception as e:
-                    logging.error(f"Error translating {file}: {e}")
-                    raise HTTPException(status_code=500, detail="Translation failed.")
-
-    output_zip = os.path.join(os.getcwd(), "translated_app.zip")
-    with ZipFile(output_zip, 'w') as zipf:
-        for foldername, _, filenames in os.walk(translated_dir):
-            for filename in filenames:
-                zipf.write(os.path.join(foldername, filename), arcname=filename)
-    return output_zip
-
-# Chat endpoint to handle user queries
-@app.post("/chat")
-async def handle_chat(query: dict):
-    error_context = get_last_translation_errors()  # Retrieve from DB/state
-    response = generate_ai_response(query['message'], error_context)
-    return {"response": response}
-
-def generate_ai_response(message, errors=None):
-    if "error" in message.lower() and errors:
-        return """f"Your translation failed with: {', '.join(errors[:3])}"""
-    elif "support" in message.lower():
-        return """f"Supported frameworks: {', '.join(FRAMEWORKS.keys())}"""
-    return "Ask about translation errors or framework support"
+        return llm_map[api_choice](cookiepath=str(Path(COOKIE_FILE)))
+    except Exception as e:
+        st.error(f"❌ Error initializing {api_choice}: {str(e)}")
+        st.stop()
+
+llm = get_llm(llm_choice)
+
+# Initialize session state
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+if "conversation_start" not in st.session_state:
+    st.session_state.conversation_start = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+# Main chat interface
+st.title("💬 AI Chat Interface")
+
+# Display chat history
+for message in st.session_state.chat_history:
+    if message["role"] == "assistant":
+        st.markdown(
+            f"<div class='chat-message assistant-message'><strong>{assistant_role_name}:</strong> {message['content']}</div>",
+            unsafe_allow_html=True
+        )
+    elif message["role"] == "user":
+        st.markdown(
+            f"<div class='chat-message user-message'><strong>{user_role_name}:</strong> {message['content']}</div>",
+            unsafe_allow_html=True
+        )
+    else:
+        st.markdown(
+            f"<div class='chat-message'><em>{message['content']}</em></div>",
+            unsafe_allow_html=True
+        )
 
-# Translation endpoint to handle file uploads and translations
-@app.post("/translate")
-async def translate(files: List[UploadFile] = File(...), framework: str = Form(...), retries: int = 3):
-    if framework not in FRAMEWORKS:
-        logging.error(f"Unsupported framework: {framework}")
-        raise HTTPException(status_code=400, detail="Unsupported framework.")
+# Input area
+user_input = st.text_input("💭 Your message:", key="user_input")
 
-    for file in files:
-        file_path = os.path.join(os.getcwd(), file.filename)
-        with open(file_path, "wb") as buffer:
-            shutil.copyfileobj(file.file, buffer)
+col1, col2, col3 = st.columns(3)
 
-        for attempt in range(retries):
+with col1:
+    if st.button("📤 Send"):
+        if user_input:
+            # Add user message to history
+            st.session_state.chat_history.append({"role": "user", "content": user_input})
+            
+            # Get AI response
             try:
-                translated_zip = process_zip(file_path, framework)
-                return FileResponse(translated_zip)
+                with st.spinner("🤔 AI is thinking..."):
+                    response = llm(user_input)
+                st.session_state.chat_history.append({"role": "assistant", "content": response})
+                
+                # Auto-save if enabled
+                if auto_save:
+                    with open(transcript_filename, "a", encoding="utf-8") as f:
+                        f.write(f":User  {user_input}\n")
+                        f.write(f"Assistant: {response}\n")
+                        
+                st.experimental_rerun()
             except Exception as e:
-                logging.error(f"Translation attempt {attempt + 1} failed: {e}")
-                if attempt < retries - 1:
-                    # Exponential backoff (adjust as needed)
-                    wait_time = 2 ** attempt
-                    print(f"Retrying translation in {wait_time} seconds...")
-                    await asyncio.sleep(wait_time)
-                else:
-                    return {"error": "Translation failed after multiple attempts."}
-
-# Error detection function
-def pre_execute_error_detection(file_path, framework):
+                st.error(f"❌ Error getting AI response: {str(e)}")
+with col2:
+    if st.button("📝 Clear Chat"):
+        st.session_state.chat_history = []
+        st.experimental_rerun()
+with col3:
+    if st.button("💾 Save Transcript"):
+        try:
+            transcript = "\n".join([
+                f"{msg['role'].capitalize()}: {msg['content']}"
+                for msg in st.session_state.chat_history
+            ])
+            with open(transcript_filename, "w", encoding="utf-8") as f:
+                f.write(transcript)
+            st.success("✅ Transcript saved successfully!")
+        except Exception as e:
+            st.error(f"❌ Error saving transcript: {str(e)}") ```python
+# Additional Features
+# Function to display the current time
+def display_time():
+    current_time = datetime.now().strftime("%H:%M:%S")
+    st.sidebar.markdown(f"🕒 Current Time: {current_time}")
+
+# Call the function to display time
+display_time()
+
+# Function to handle user input and AI response
+def handle_input(user_input):
+    if user_input:
+        st.session_state.chat_history.append({"role": "user", "content": user_input})
+        try:
+            with st.spinner("🤔 AI is thinking..."):
+                response = llm(user_input)
+            st.session_state.chat_history.append({"role": "assistant", "content": response})
+            if auto_save:
+                with open(transcript_filename, "a", encoding="utf-8") as f:
+                    f.write(f":User  {user_input}\n")
+                    f.write(f"Assistant: {response}\n")
+            st.experimental_rerun()
+        except Exception as e:
+            st.error(f"❌ Error getting AI response: {str(e)}")
+
+# Input area with button to send message
+if st.button("📤 Send"):
+    handle_input(user_input)
+
+# Function to clear chat history
+def clear_chat():
+    st.session_state.chat_history = []
+    st.experimental_rerun()
+
+# Clear chat button
+if st.button("📝 Clear Chat"):
+    clear_chat()
+
+# Function to save transcript
+def save_transcript():
     try:
-        result = subprocess.run(
-            INTERPRETER_COMMANDS[framework].format(file_path=file_path),
-            capture_output=True,
-            text=True,
-            shell=True
-        )
-        if result.returncode != 0:
-            log_error(file_path, result.stderr)  # Store in persistent storage
-            return False, result.stderr
-        return True, ""
+        transcript = "\n".join([
+            f"{msg['role'].capitalize()}: {msg['content']}"
+            for msg in st.session_state.chat_history
+        ])
+        with open(transcript_filename, "w", encoding="utf-8") as f:
+            f.write(transcript)
+        st.success("✅ Transcript saved successfully!")
     except Exception as e:
-        return False, str(e)
-
-# Error logging function
-def log_error(file_path, error, db: SessionLocal):
-    error_entry = TranslationError(file=file_path, error=error)
-    db.add(error_entry)
-    db.commit()
-
-# Function to retrieve last translation errors
-def get_last_translation_errors(db: SessionLocal):
-    errors = db.query(TranslationError).order_by(TranslationError.timestamp.desc()).limit(5).all()
-    return [error.error for error in errors]
-
-# Chat input model
-class ChatInput(BaseModel):
-    message: str
-
-# Chat endpoint with HTML template
-@app.get("/chat")
-async def chat_page(request: ChatInput, db: SessionLocal = Depends(get_db)):
-    error_context = get_last_translation_errors(db)
-    response = generate_ai_response(request.message, error_context)
-    return templates.TemplateResponse("chat.html", {"request": request, "response": response})
-
-# Home page
-@app.get("/")
-async def home_page(request: ChatInput):
-    return templates.TemplateResponse("index.html", {"request": request})
-
-# Translation page
-@app.get("/translate")
-async def translate_page(request: ChatInput):
-    return templates.TemplateResponse("translate.html", {"request": request})
-
-# Handle translation form submission
-@app.post("/translate")
-async def handle_translate(files: List[UploadFile] = File(...), framework: str = Form(...), retries: int = 3, db: SessionLocal = Depends(get_db)):
-    if framework not in FRAMEWORKS:
-        logging.error(f"Unsupported framework: {framework}")
-        raise HTTPException(status_code=400, detail="Unsupported framework.")
-
-    for file in files:
-        file_path = os.path.join(os.getcwd(), file.filename)
-        with open(file_path, "wb") as buffer:
-            shutil.copyfileobj(file.file, buffer)
-
-        for attempt in range(retries):
-            try:
-                translated_zip = process_zip(file_path, framework)
-                return FileResponse(translated_zip)
-            except Exception as e:
-                logging.error(f"Translation attempt {attempt + 1} failed: {e}")
-                log_error(file_path, str(e), db)
-                if attempt < retries - 1:
-                    # Exponential backoff (adjust as needed)
-                    wait_time = 2 ** attempt
-                    print(f"Retrying translation in {wait_time} seconds...")
-                    await asyncio.sleep(wait_time)
-                else:
-                    return {"error": "Translation failed after multiple attempts."}
+        st.error(f"❌ Error saving transcript: {str(e)}")
 
-# Run the application
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+# Save transcript button
+if st.button("💾 Save Transcript"):
+    save_transcript()