prepforge 0.1.0__py3-none-any.whl

major_project/gui_app.py

@@ -0,0 +1,227 @@
+import sys
+import os
+from PyQt6.QtWidgets import (
+    QApplication,
+    QWidget,
+    QVBoxLayout,
+    QHBoxLayout,
+    QTextEdit,
+    QLineEdit,
+    QPushButton,
+    QComboBox,
+    QLabel,
+    QFileDialog,
+    QSpinBox,
+)
+from PyQt6.QtCore import Qt
+
+# 🔥 CORE IMPORTS
+from major_project.core.model import load_model
+from major_project.core.utils import (
+    build_prompt,
+    generate_stream,
+    chat_history,
+    last_mcq_block,
+)
+from major_project.config import DEFAULT_APP_NAME, DEFAULT_MODEL, DEFAULT_LORA
+
+os.environ["TRANSFORMERS_OFFLINE"] = "1"
+os.environ["HF_HUB_OFFLINE"] = "1"
+os.environ["QT_LOGGING_RULES"] = "*.warning=false"
+os.environ["QT_QPA_PLATFORMTHEME"] = "gtk3"
+
+APP_NAME = DEFAULT_APP_NAME
+
+
+class AIApp(QWidget):
+    def __init__(self):
+        super().__init__()
+
+        self.setWindowTitle(f"🎓 {APP_NAME}")
+        self.resize(900, 700)
+
+        self.model_name = DEFAULT_MODEL
+        self.lora_path = DEFAULT_LORA
+
+        layout = QVBoxLayout()
+
+        # TITLE
+        title = QLabel(APP_NAME)
+        title.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        title.setStyleSheet("font-size: 28px; font-weight: bold; padding: 10px;")
+        layout.addWidget(title)
+
+        # MODEL CONTROLS
+        model_layout = QHBoxLayout()
+
+        self.model_mode = QComboBox()
+        self.model_mode.addItems(["Base Model", "LoRA Adapter"])
+
+        self.lora_btn = QPushButton("Select LoRA Folder")
+        self.lora_btn.clicked.connect(self.select_lora_folder)
+
+        self.load_btn = QPushButton("Load Model")
+        self.load_btn.clicked.connect(self.load_selected_model)
+
+        model_layout.addWidget(QLabel("Model:"))
+        model_layout.addWidget(self.model_mode)
+        model_layout.addWidget(self.lora_btn)
+        model_layout.addWidget(self.load_btn)
+
+        layout.addLayout(model_layout)
+
+        # SETTINGS
+        top_layout = QHBoxLayout()
+
+        self.mode = QComboBox()
+        self.mode.addItems(["Chat", "Notes", "Study Plan", "MCQ Generator", "Practice"])
+
+        self.length_input = QSpinBox()
+        self.length_input.setRange(100, 2000)
+        self.length_input.setValue(400)
+
+        self.count_input = QSpinBox()
+        self.count_input.setRange(1, 50)
+        self.count_input.setValue(5)
+
+        top_layout.addWidget(self.mode)
+        top_layout.addWidget(self.length_input)
+        top_layout.addWidget(self.count_input)
+
+        layout.addLayout(top_layout)
+
+        # INPUT
+        self.input_box = QLineEdit()
+        layout.addWidget(self.input_box)
+
+        # BUTTONS
+        btn_layout = QHBoxLayout()
+
+        self.generate_btn = QPushButton("Generate")
+        self.generate_btn.clicked.connect(self.handle_generate)
+
+        self.clear_btn = QPushButton("Clear")
+        self.clear_btn.clicked.connect(self.clear_all)
+
+        self.save_btn = QPushButton("Save Chat")
+        self.save_btn.clicked.connect(self.save_chat)
+
+        btn_layout.addWidget(self.generate_btn)
+        btn_layout.addWidget(self.clear_btn)
+        btn_layout.addWidget(self.save_btn)
+
+        layout.addLayout(btn_layout)
+
+        # OUTPUT
+        self.output = QTextEdit()
+        self.output.setReadOnly(True)
+        layout.addWidget(self.output)
+
+        self.setLayout(layout)
+
+        self.model = None
+        self.tokenizer = None
+
+    # -----------------------------
+    # MODEL
+    # -----------------------------
+    def select_lora_folder(self):
+        path = QFileDialog.getExistingDirectory(self, "Select LoRA Folder")
+        if path:
+            self.lora_path = path
+
+    def load_selected_model(self):
+        use_lora = self.model_mode.currentText() == "LoRA Adapter"
+
+        if use_lora and not self.lora_path:
+            self.output.append("❌ Select LoRA folder first")
+            return
+
+        self.output.append("🔄 Loading model...")
+        QApplication.processEvents()
+
+        self.model, self.tokenizer = load_model(
+            self.model_name, self.lora_path if use_lora else None
+        )
+
+        self.output.append("✅ Model loaded")
+
+    # -----------------------------
+    # UTIL
+    # -----------------------------
+    def clear_all(self):
+        global chat_history, last_mcq_block
+        self.output.clear()
+        chat_history.clear()
+        last_mcq_block = None
+
+    def save_chat(self):
+        file_path, _ = QFileDialog.getSaveFileName(
+            self, "Save Chat", "", "Text Files (*.txt)"
+        )
+        if not file_path:
+            return
+        try:
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(self.output.toPlainText())
+            self.output.append(f"\n✅ Saved to {file_path}\n")
+        except Exception as e:
+            self.output.append(f"\n❌ Error saving file: {str(e)}\n")
+
+    # -----------------------------
+    # STREAM GENERATE
+    # -----------------------------
+    def handle_generate(self):
+        if self.model is None:
+            self.output.append("❌ Load model first")
+            return
+
+        user_text = self.input_box.text().strip()
+        if not user_text:
+            return
+
+        # ✅ FIX: proper spacing
+        self.output.append(f"🧑 {user_text}\n")
+
+        prompt = build_prompt(
+            self.mode.currentText(), user_text, self.count_input.value()
+        )
+
+        streamer = generate_stream(
+            self.model, self.tokenizer, prompt, self.length_input.value()
+        )
+
+        response = ""
+
+        cursor = self.output.textCursor()
+        cursor.movePosition(cursor.MoveOperation.End)
+        cursor.insertText("🤖 ")
+        self.output.setTextCursor(cursor)
+
+        for token in streamer:
+            response += token
+            cursor.insertText(token)
+            self.output.setTextCursor(cursor)
+            QApplication.processEvents()
+
+        self.output.append("\n")
+
+        chat_history.append({"role": "assistant", "content": response})
+
+        if "SECTION 1" in response and "SECTION 2" in response:
+            global last_mcq_block
+            last_mcq_block = response
+
+
+# -----------------------------
+# MAIN
+# -----------------------------
+def main():
+    app = QApplication(sys.argv)
+    window = AIApp()
+    window.show()
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

major_project/streamlit_app.py

@@ -0,0 +1,171 @@
+import os
+
+# -----------------------------
+# 🔥 FORCE OFFLINE MODE
+# -----------------------------
+os.environ["TRANSFORMERS_OFFLINE"] = "1"
+os.environ["HF_HUB_OFFLINE"] = "1"
+
+import streamlit as st
+
+# 🔥 CORE IMPORTS
+from major_project.core.model import load_model
+from major_project.core.utils import (
+    build_prompt,
+    generate_stream,
+    chat_history,
+    last_mcq_block,
+)
+from major_project.config import DEFAULT_APP_NAME, DEFAULT_LORA, DEFAULT_MODEL
+
+# -----------------------------
+# CONFIG
+# -----------------------------
+APP_NAME = DEFAULT_APP_NAME
+st.set_page_config(page_title=APP_NAME, layout="wide")
+
+
+# -----------------------------
+# MODEL CACHE
+# -----------------------------
+@st.cache_resource
+def cached_model(base_model, lora_path):
+    return load_model(base_model, lora_path)
+
+
+# -----------------------------
+# SIDEBAR
+# -----------------------------
+st.sidebar.title("⚙️ Model Settings")
+
+model_name = DEFAULT_MODEL
+model_mode = st.sidebar.selectbox("Model Type", ["Base Model", "LoRA Adapter"])
+
+lora_path = DEFAULT_LORA
+if model_mode == "LoRA Adapter":
+    lora_path = st.sidebar.text_input("LoRA Path")
+
+load_btn = st.sidebar.button("🚀 Load Model")
+
+
+# -----------------------------
+# SESSION STATE
+# -----------------------------
+if "model" not in st.session_state:
+    st.session_state.model = None
+    st.session_state.tokenizer = None
+
+if "history" not in st.session_state:
+    st.session_state.history = []
+
+if "last_mcq" not in st.session_state:
+    st.session_state.last_mcq = ""
+
+
+# -----------------------------
+# LOAD MODEL
+# -----------------------------
+if load_btn:
+    if model_mode == "LoRA Adapter" and not lora_path:
+        st.sidebar.error("Provide LoRA path")
+    else:
+        with st.spinner("Loading model..."):
+            model, tokenizer = cached_model(
+                model_name,
+                lora_path if model_mode == "LoRA Adapter" else None,
+            )
+            st.session_state.model = model
+            st.session_state.tokenizer = tokenizer
+
+        st.sidebar.success("Model loaded")
+
+
+model = st.session_state.model
+tokenizer = st.session_state.tokenizer
+
+
+# -----------------------------
+# SAFETY
+# -----------------------------
+if model is None or tokenizer is None:
+    st.title(f"🎓 {APP_NAME}")
+    st.warning("Load model from sidebar")
+    st.stop()
+
+
+# -----------------------------
+# UI
+# -----------------------------
+st.title(f"🎓 {APP_NAME}")
+
+mode = st.sidebar.selectbox(
+    "Mode", ["Chat", "Notes", "Study Plan", "MCQ Generator", "Practice"]
+)
+
+length = st.sidebar.slider("Response Length", 100, 2000, 600)
+count = st.sidebar.number_input("Number of Questions", 1, 50, 5)
+
+
+# -----------------------------
+# RESET
+# -----------------------------
+if st.sidebar.button("🧹 Reset Chat"):
+    st.session_state.history = []
+    chat_history.clear()
+    st.session_state.last_mcq = ""
+
+
+# -----------------------------
+# DISPLAY HISTORY
+# -----------------------------
+for msg in st.session_state.history:
+    with st.chat_message(msg["role"]):
+        st.write(msg["content"])
+
+
+# -----------------------------
+# INPUT
+# -----------------------------
+user_input = st.chat_input(f"Ask {APP_NAME}...")
+
+if user_input:
+    with st.chat_message("user"):
+        st.write(user_input)
+
+    # 🔥 USE SHARED PROMPT BUILDER
+    prompt = build_prompt(mode, user_input, count)
+
+    with st.chat_message("assistant"):
+        placeholder = st.empty()
+        response = ""
+
+        # 🔥 USE SHARED STREAM ENGINE
+        streamer = generate_stream(model, tokenizer, prompt, length)
+
+        for token in streamer:
+            response += token
+            placeholder.markdown(response)
+
+    st.session_state.history.append({"role": "user", "content": user_input})
+    st.session_state.history.append({"role": "assistant", "content": response})
+
+    # 🔥 MCQ STORAGE
+    if "SECTION 1" in response and "SECTION 2" in response:
+        st.session_state.last_mcq = response
+
+
+# -----------------------------
+# SAVE CHAT
+# -----------------------------
+if st.session_state.history:
+    chat_text = f"=== {APP_NAME} Notes ===\n\n"
+
+    for msg in st.session_state.history:
+        role = "User" if msg["role"] == "user" else APP_NAME
+        chat_text += f"{role}:\n{msg['content']}\n\n"
+
+    st.sidebar.download_button(
+        "💾 Download Chat",
+        chat_text,
+        file_name=f"{APP_NAME.lower()}_chat.txt",
+    )

major_project/tui_app.py

@@ -0,0 +1,241 @@
+import os
+import subprocess
+import warnings
+from transformers.utils import logging
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.live import Live
+from rich.panel import Panel
+
+# prompt_toolkit
+from prompt_toolkit.application import Application
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import Layout
+from prompt_toolkit.widgets import Box, Frame, TextArea
+
+# 🔥 IMPORT SHARED MODULES
+from major_project.core.model import load_model
+from major_project.core.utils import (
+    build_prompt,
+    generate_stream,
+    chat_history,
+    last_mcq_block,
+)
+from major_project.config import DEFAULT_APP_NAME, DEFAULT_MODEL, DEFAULT_LORA
+
+# -----------------------------
+# CONFIG
+# -----------------------------
+APP_NAME = DEFAULT_APP_NAME
+console = Console()
+
+# -----------------------------
+# LLAMA TEMPLATE
+# -----------------------------
+LLAMA3_TEMPLATE = (
+    "{% for message in messages %}"
+    "{% if loop.first and messages[0]['role'] == 'system' %}"
+    "{{ '<|begin_of_text|><|start_header_id|>system<|end_header_id|>\\n\\n' + message['content'] + '<|eot_id|>' }}"
+    "{% else %}"
+    "{{ '<|start_header_id|>' + message['role'] + '<|end_header_id|>\\n\\n' + message['content'] + '<|eot_id|>' }}"
+    "{% endif %}"
+    "{% endfor %}"
+    "{% if add_generation_prompt %}"
+    "{{ '<|start_header_id|>assistant<|end_header_id|>\\n\\n' }}"
+    "{% endif %}"
+)
+
+
+# -----------------------------
+# BANNER
+# -----------------------------
+def print_banner():
+    try:
+        result = subprocess.run(["figlet", APP_NAME], capture_output=True, text=True)
+        console.print(f"[bold cyan]{result.stdout}[/bold cyan]", justify="center")
+        console.print("[dim]AI Exam Preparation System[/dim]\n", justify="center")
+    except Exception:
+        console.print(f"[bold cyan]\n=== {APP_NAME.upper()} ===\n[/bold cyan]")
+
+
+# -----------------------------
+# ENV
+# -----------------------------
+os.environ["TRANSFORMERS_VERBOSITY"] = "error"
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+warnings.filterwarnings("ignore")
+logging.set_verbosity_error()
+
+print_banner()
+
+
+# -----------------------------
+# INPUT HELPERS
+# -----------------------------
+def get_valid_length(default):
+    while True:
+        value = Prompt.ask("Response length (100-2000)", default=str(default))
+        try:
+            val = int(value)
+            if 100 <= val <= 2000:
+                return val
+        except:
+            pass
+        console.print("[red]Invalid input[/red]")
+
+
+def get_question_count(default=5):
+    while True:
+        value = Prompt.ask("How many questions?", default=str(default))
+        try:
+            val = int(value)
+            if 1 <= val <= 50:
+                return val
+        except:
+            pass
+        console.print("[red]Enter a number between 1-50[/red]")
+
+
+def save_chat():
+    file_path = Prompt.ask("Enter file path")
+    if not file_path:
+        return
+    try:
+        file_path = os.path.expanduser(file_path)
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(f"=== {APP_NAME} Notes ===\n\n")
+            for msg in chat_history:
+                role = "User" if msg["role"] == "user" else "AI"
+                f.write(f"{role}:\n{msg['content']}\n\n")
+        console.print(f"[green]Saved to {file_path}[/green]")
+    except Exception as e:
+        console.print(f"[red]{str(e)}[/red]")
+
+
+def select_model_mode():
+    return Prompt.ask("Choose model mode", choices=["base", "lora"], default="base")
+
+
+def get_lora_path():
+    path = Prompt.ask("Enter LoRA adapter path (leave empty to cancel)")
+    return path if path else None
+
+
+# -----------------------------
+# MODEL
+# -----------------------------
+console.print(f"[bold green]Loading {APP_NAME} model...[/bold green]")
+
+model_mode = select_model_mode()
+lora_path = DEFAULT_LORA if model_mode == "lora" else None
+
+if model_mode == "lora":
+    user_lora = get_lora_path()
+    if user_lora:
+        lora_path = user_lora
+
+model, tokenizer = load_model(base_model=DEFAULT_MODEL, lora_path=lora_path)
+
+tokenizer.padding_side = "left"
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+tokenizer.chat_template = LLAMA3_TEMPLATE
+
+console.print("Model loaded!\n")
+
+
+# -----------------------------
+# MODE MENU
+# -----------------------------
+def select_mode():
+    options = ["chat", "notes", "mcq", "plan", "practice", "exit"]
+    index = [0]
+
+    def get_text():
+        return "\n".join(
+            [f"{'>' if i == index[0] else ' '} {opt}" for i, opt in enumerate(options)]
+        )
+
+    text_area = TextArea(text=get_text(), focusable=False)
+    kb = KeyBindings()
+
+    @kb.add("up")
+    def _(event):
+        index[0] = (index[0] - 1) % len(options)
+        text_area.text = get_text()
+
+    @kb.add("down")
+    def _(event):
+        index[0] = (index[0] + 1) % len(options)
+        text_area.text = get_text()
+
+    @kb.add("enter")
+    def _(event):
+        event.app.exit(result=options[index[0]])
+
+    root = Frame(Box(text_area, padding=1), title=f" {APP_NAME} ")
+    app = Application(layout=Layout(root), key_bindings=kb)
+    return app.run()
+
+
+# -----------------------------
+# MAIN LOOP
+# -----------------------------
+def main():
+    global last_mcq_block
+
+    mode, length = None, None
+    first_run = True
+
+    while True:
+        console.print(f"\n=== {APP_NAME} ===")
+
+        if first_run:
+            mode = select_mode()
+            if mode == "exit":
+                break
+            length = get_valid_length(400)
+            first_run = False
+        else:
+            if Prompt.ask("Change settings(y/n)?", default="n") == "y":
+                mode = select_mode()
+                if mode == "exit":
+                    break
+                length = get_valid_length(length)
+
+        console.print(f"Mode: {mode} | length: {length}")
+
+        try:
+            user_input = Prompt.ask("\nAsk your question (or 'save' to save chat)")
+        except KeyboardInterrupt:
+            break
+
+        if user_input == "exit":
+            break
+        if user_input == "save":
+            save_chat()
+            continue
+
+        count = get_question_count() if mode in ["mcq", "practice"] else None
+        prompt = build_prompt(mode, user_input, count)
+
+        console.print("\nThinking...\n")
+
+        streamer = generate_stream(model, tokenizer, prompt, length)
+        response = ""
+
+        with Live(Panel("", title="Response"), refresh_per_second=10) as live:
+            for token in streamer:
+                response += token
+                live.update(Panel(response, title="Response"))
+
+        chat_history.append({"role": "assistant", "content": response})
+
+        if "SECTION 1" in response and "SECTION 2" in response:
+            last_mcq_block = response
+
+
+if __name__ == "__main__":
+    main()