prepforge 0.1.0__tar.gz

prepforge-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Himanshu Arora
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

prepforge-0.1.0/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.4
+Name: prepforge
+Version: 0.1.0
+Summary: AI Exam Preparation System with TUI, GUI, and Streamlit
+Author: Himanshu Arora
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: transformers
+Requires-Dist: peft
+Requires-Dist: rich
+Requires-Dist: prompt_toolkit
+Provides-Extra: gui
+Requires-Dist: PyQt6; extra == "gui"
+Provides-Extra: web
+Requires-Dist: streamlit; extra == "web"
+Provides-Extra: train
+Requires-Dist: datasets; extra == "train"
+Requires-Dist: trl; extra == "train"
+Provides-Extra: gpu
+Requires-Dist: torch; extra == "gpu"
+Provides-Extra: fast
+Requires-Dist: unsloth; extra == "fast"
+Dynamic: license-file
+
+# 🎓 PrepForge
+
+PrepForge is an AI-powered exam preparation system with multiple interfaces and support for base LLMs and LoRA adapters.
+
+---
+
+## 📦 Installation
+
+Install directly from PyPI:
+
+```bash
+pip install prepforge
+```
+
+PyPI: https://pypi.org/project/prepforge/0.1.0/
+
+---
+
+## ✨ Features
+
+- 🖥 Terminal UI (TUI)
+- 🪟 Desktop GUI (PyQt6)
+- 🌐 Web interface (Streamlit)
+- 🧠 Supports base models and LoRA adapters
+- 🏋️ Built-in training pipeline (QLoRA / Unsloth)
+- ⚡ Offline inference support
+
+---
+
+## 🚀 Usage
+
+### Terminal Interface (TUI)
+```bash
+prepforge run tui
+```
+
+### Desktop GUI
+```bash
+prepforge run gui
+```
+
+### Web Interface
+```bash
+prepforge run streamlit
+```
+
+---
+
+## ⚙️ Configuration
+
+Set default model:
+
+```bash
+prepforge config --model <model_name_or_path>
+```
+
+Set LoRA adapter:
+
+```bash
+prepforge config --lora <adapter_path>
+```
+
+---
+
+## 🏋️ Training
+
+```bash
+prepforge train \
+  --dataset dataset.jsonl \
+  --epochs 3 \
+  --output trained_model
+```
+
+---
+
+## 📊 Dataset Format
+
+```json
+{
+  "instruction": "Explain Newton's laws",
+  "input": "",
+  "output": "Newton's laws describe motion..."
+}
+```
+
+---
+
+## 📂 Project Structure
+
+```
+major_project/
+├── core/
+│   ├── model.py
+│   ├── train.py
+│   └── utils.py
+├── tui_app.py
+├── gui_app.py
+├── streamlit_app.py
+├── cli.py
+├── config.py
+```
+
+---
+
+## ⚠️ Notes
+
+- Models are not bundled with the package  
+- Users must download base models separately  
+- GPU (CUDA) is recommended for best performance  
+
+---
+
+## 🧑‍💻 Author
+
+Himanshu Arora
+
+---
+
+## 📜 License
+
+MIT License

prepforge-0.1.0/README.md

@@ -0,0 +1,121 @@
+# 🎓 PrepForge
+
+PrepForge is an AI-powered exam preparation system with multiple interfaces and support for base LLMs and LoRA adapters.
+
+---
+
+## 📦 Installation
+
+Install directly from PyPI:
+
+```bash
+pip install prepforge
+```
+
+PyPI: https://pypi.org/project/prepforge/0.1.0/
+
+---
+
+## ✨ Features
+
+- 🖥 Terminal UI (TUI)
+- 🪟 Desktop GUI (PyQt6)
+- 🌐 Web interface (Streamlit)
+- 🧠 Supports base models and LoRA adapters
+- 🏋️ Built-in training pipeline (QLoRA / Unsloth)
+- ⚡ Offline inference support
+
+---
+
+## 🚀 Usage
+
+### Terminal Interface (TUI)
+```bash
+prepforge run tui
+```
+
+### Desktop GUI
+```bash
+prepforge run gui
+```
+
+### Web Interface
+```bash
+prepforge run streamlit
+```
+
+---
+
+## ⚙️ Configuration
+
+Set default model:
+
+```bash
+prepforge config --model <model_name_or_path>
+```
+
+Set LoRA adapter:
+
+```bash
+prepforge config --lora <adapter_path>
+```
+
+---
+
+## 🏋️ Training
+
+```bash
+prepforge train \
+  --dataset dataset.jsonl \
+  --epochs 3 \
+  --output trained_model
+```
+
+---
+
+## 📊 Dataset Format
+
+```json
+{
+  "instruction": "Explain Newton's laws",
+  "input": "",
+  "output": "Newton's laws describe motion..."
+}
+```
+
+---
+
+## 📂 Project Structure
+
+```
+major_project/
+├── core/
+│   ├── model.py
+│   ├── train.py
+│   └── utils.py
+├── tui_app.py
+├── gui_app.py
+├── streamlit_app.py
+├── cli.py
+├── config.py
+```
+
+---
+
+## ⚠️ Notes
+
+- Models are not bundled with the package  
+- Users must download base models separately  
+- GPU (CUDA) is recommended for best performance  
+
+---
+
+## 🧑‍💻 Author
+
+Himanshu Arora
+
+---
+
+## 📜 License
+
+MIT License

prepforge-0.1.0/major_project/cli.py

@@ -0,0 +1,186 @@
+import argparse
+import subprocess
+import os
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="prepforge",
+        description="prepforge - Multi-interface AI assistant with training support",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    subparsers.required = True
+
+    # -------------------------
+    # RUN APPS
+    # -------------------------
+    run_parser = subparsers.add_parser(
+        "run",
+        help="Run the application (tui | gui | streamlit)",
+        description=(
+            "Run prepforce in one of the following modes:\n\n"
+            "  tui        Terminal interface\n"
+            "  gui        Desktop application\n"
+            "  streamlit  Web interface\n"
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    run_parser.add_argument(
+        "mode",
+        choices=["tui", "gui", "streamlit"],
+        help="Mode to run",
+    )
+
+    # -------------------------
+    # TRAIN
+    # -------------------------
+    train_parser = subparsers.add_parser(
+        "train",
+        help="Train a LoRA adapter",
+        description=(
+            "Train a model using your dataset\n\n"
+            "Dataset Control Options:\n"
+            "  --limit N     Train on first N samples\n"
+            "  --subset F    Train on fraction (0.1 = 10%%)\n\n"
+            "Examples:\n"
+            "  prepforce train --dataset data.jsonl\n"
+            "  prepforce train --dataset data.jsonl --limit 500\n"
+            "  prepforce train --dataset data.jsonl --subset 0.05\n"
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    train_parser.add_argument(
+        "--dataset",
+        required=True,
+        help="Path to dataset file (JSON/JSONL format)",
+    )
+
+    train_parser.add_argument(
+        "--output",
+        default="trained_model",
+        help="Output directory for trained model",
+    )
+
+    train_parser.add_argument(
+        "--epochs",
+        type=int,
+        default=2,
+        help="Number of training epochs",
+    )
+
+    train_parser.add_argument(
+        "--lr",
+        type=float,
+        default=2e-4,
+        help="Learning rate",
+    )
+
+    # 🔥 Mutually exclusive group
+    group = train_parser.add_mutually_exclusive_group()
+
+    group.add_argument(
+        "--limit",
+        type=int,
+        help="Limit number of samples (e.g. 500)",
+    )
+
+    group.add_argument(
+        "--subset",
+        type=float,
+        help="Use fraction of dataset (0.05 = 5%%)",
+    )
+
+    # -------------------------
+    # CONFIG
+    # -------------------------
+    config_parser = subparsers.add_parser(
+        "config",
+        help="Set default model or LoRA",
+        description=(
+            "Configure default model and LoRA adapter\n\n"
+            "Examples:\n"
+            "  prepforce config --model meta-llama/Llama-3-8B\n"
+            "  prepforce config --lora ~/adapter\n"
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+
+    config_parser.add_argument(
+        "--model",
+        help="Set default base model",
+    )
+
+    config_parser.add_argument(
+        "--lora",
+        help="Set default LoRA adapter path",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        # -------------------------
+        # RUN MODES
+        # -------------------------
+        if args.command == "run":
+            if args.mode == "tui":
+                from .tui_app import main
+
+                main()
+
+            elif args.mode == "gui":
+                from .gui_app import main
+
+                main()
+
+            elif args.mode == "streamlit":
+                base_dir = os.path.dirname(__file__)
+                app_path = os.path.join(base_dir, "streamlit_app.py")
+
+                subprocess.run([sys.executable, "-m", "streamlit", "run", app_path])
+
+        # -------------------------
+        # TRAIN
+        # -------------------------
+        elif args.command == "train":
+            from .core.train import train_model
+
+            train_model(
+                dataset_path=args.dataset,
+                output_dir=args.output,
+                epochs=args.epochs,
+                lr=args.lr,
+                limit=args.limit,
+                subset=args.subset,
+            )
+
+        # -------------------------
+        # CONFIG
+        # -------------------------
+        elif args.command == "config":
+            from .core.config_store import load_user_config, save_user_config
+
+            config = load_user_config()
+
+            if args.model:
+                config["model"] = args.model
+                print(f"✅ Default model set to: {args.model}")
+
+            if args.lora:
+                config["lora"] = args.lora
+                print(f"✅ Default LoRA set to: {args.lora}")
+
+            if not args.model and not args.lora:
+                print("⚠️ No changes provided. Use --model or --lora")
+
+            save_user_config(config)
+
+    except Exception as e:
+        print(f"\n❌ Error: {str(e)}\n")
+
+
+if __name__ == "__main__":
+    main()

prepforge-0.1.0/major_project/config.py

@@ -0,0 +1,17 @@
+import os
+from major_project.core.config_store import load_user_config
+
+DEFAULT_MODEL = "unsloth/llama-3.2-3b-instruct-unsloth-bnb-4bit"
+DEFAULT_LORA = None
+DEFAULT_APP_NAME = "PrepForge"
+MAX_HISTORY = 6
+
+
+def get_model():
+    user_config = load_user_config()
+    return user_config.get("model") or os.getenv("MENTORAI_MODEL") or DEFAULT_MODEL
+
+
+def get_lora():
+    user_config = load_user_config()
+    return user_config.get("lora") or os.getenv("MENTORAI_LORA") or DEFAULT_LORA

prepforge-0.1.0/major_project/core/config_store.py

@@ -0,0 +1,20 @@
+import os
+import json
+
+CONFIG_DIR = os.path.expanduser("~/.prepforce")
+CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")
+
+
+def load_user_config():
+    if not os.path.exists(CONFIG_FILE):
+        return {}
+
+    with open(CONFIG_FILE, "r") as f:
+        return json.load(f)
+
+
+def save_user_config(config):
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)

prepforge-0.1.0/major_project/core/model.py

@@ -0,0 +1,112 @@
+import os
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+
+# ✅ Use shared config
+from major_project.config import get_model, get_lora
+
+
+def _check_cuda():
+    """
+    Ensure NVIDIA GPU is available.
+    """
+    if not torch.cuda.is_available():
+        raise RuntimeError(
+            "\n❌ CUDA GPU not detected.\n"
+            "This application requires an NVIDIA GPU.\n"
+            "CPU execution is not supported.\n"
+            "\n👉 Install CUDA-enabled PyTorch:\n"
+            "pip install torch --index-url https://download.pytorch.org/whl/cu121\n"
+        )
+
+
+def load_model(
+    base_model: str | None = None,
+    lora_path: str | None = None,
+    device_map: str = "auto",
+    dtype: torch.dtype = torch.float16,
+):
+    """
+    Load base model and optionally apply LoRA adapter.
+
+    Args:
+        base_model (str | None): HuggingFace model name or local path
+        lora_path (str | None): Path to LoRA adapter folder
+        device_map (str): Device mapping ("auto", "cpu", etc.)
+        dtype (torch.dtype): Torch dtype
+
+    Returns:
+        model, tokenizer
+    """
+
+    # -----------------------------
+    # 🔥 CUDA CHECK
+    # -----------------------------
+    _check_cuda()
+
+    # -----------------------------
+    # USE DEFAULT CONFIG (if not provided)
+    # -----------------------------
+    if base_model is None:
+        base_model = get_model()
+
+    if lora_path is None:
+        lora_path = get_lora()
+
+    # -----------------------------
+    # VALIDATE INPUTS
+    # -----------------------------
+    if not base_model:
+        raise ValueError("Base model path/name must be provided")
+
+    if lora_path:
+        lora_path = os.path.expanduser(lora_path)
+
+        if not os.path.exists(lora_path):
+            raise FileNotFoundError(f"LoRA path not found: {lora_path}")
+
+        expected = os.path.join(lora_path, "adapter_config.json")
+        if not os.path.exists(expected):
+            raise ValueError(
+                f"Invalid LoRA adapter folder (missing adapter_config.json): {lora_path}"
+            )
+
+    # -----------------------------
+    # LOAD BASE MODEL
+    # -----------------------------
+    print(f"[MODEL] Loading base model: {base_model}")
+
+    model = AutoModelForCausalLM.from_pretrained(
+        base_model,
+        device_map=device_map,
+        torch_dtype=dtype,
+        local_files_only=True,
+    )
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        base_model,
+        local_files_only=True,
+        use_fast=True,
+    )
+
+    # -----------------------------
+    # APPLY LORA (OPTIONAL)
+    # -----------------------------
+    if lora_path:
+        print(f"[MODEL] Applying LoRA adapter: {lora_path}")
+
+        model = PeftModel.from_pretrained(
+            model,
+            lora_path,
+            local_files_only=True,
+        )
+
+        print("[MODEL] LoRA successfully loaded")
+
+    # -----------------------------
+    # FINAL SETUP
+    # -----------------------------
+    model.eval()
+
+    return model, tokenizer