Upload 5 files

.dockerignore

@@ -0,0 +1,5 @@
+.env
+__pycache__/
+*.pyc
+.git/
+orbit.db

.env

@@ -0,0 +1,18 @@
+# ─── ORBIT Environment Variables ───────────────────────────────────────────
+# DO NOT commit this file to version control.
+
+# Flask Core
+FLASK_SECRET_KEY=8f3a9c2e6b1d4f7a0e5c8b3d6f9a2e5c8b1d4f7a0e5c8b3d6f9a2e5c8b1d4f7
+FLASK_DEBUG=true
+SERVER_NAME=127.0.0.1:5000
+PREFERRED_URL_SCHEME=http
+
+# Google OAuth 2.0
+GOOGLE_CLIENT_ID=454671308528-ecc7ckec4qktmilfg8u9fc0cjj8t6jg9.apps.googleusercontent.com
+GOOGLE_CLIENT_SECRET=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
+
+# Database
+DATABASE_URL=sqlite:///orbit.db
+
+# Allow OAuth over HTTP for local development (REMOVE in production)
+OAUTHLIB_INSECURE_TRANSPORT=1

Dockerfile

@@ -0,0 +1,19 @@
+# Gunakan Python versi ringan
+FROM python:3.10-slim
+
+# Buat folder kerja di dalam server
+WORKDIR /app
+
+# Copy daftar library dan install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy seluruh file proyekmu (kecuali .env)
+COPY . .
+
+# Hugging Face wajib menggunakan port 7860
+EXPOSE 7860
+
+# Perintah untuk menjalankan Flask
+ENV FLASK_APP=app.py
+CMD ["flask", "run", "--host=0.0.0.0", "--port=7860"]

app.py

@@ -0,0 +1,427 @@
+"""
+ORBIT – Flask Application (SaaS Edition)
+Backend: Google OAuth · SQLite · Multi-provider LLM routing
+"""
+import os
+import json
+import requests
+import fitz  # PyMuPDF
+
+from functools import wraps
+from datetime import datetime
+
+from flask import (
+    Flask, render_template, redirect, url_for,
+    session, jsonify, request, abort,
+)
+from flask_cors import CORS
+from authlib.integrations.flask_client import OAuth
+
+from config import Config
+from extensions import db
+from models import User, UserSettings
+
+# ── Allow HTTP for local OAuth (dev only) ───────────────────────────────────
+os.environ.setdefault("OAUTHLIB_INSECURE_TRANSPORT", "1")
+
+# ── App Factory ─────────────────────────────────────────────────────────────
+app = Flask(__name__, template_folder="templates", static_folder="static")
+app.config.from_object(Config)
+CORS(app)
+db.init_app(app)
+
+# ── OAuth Setup ─────────────────────────────────────────────────────────────
+oauth = OAuth(app)
+google = oauth.register(
+    name="google",
+    client_id=app.config["GOOGLE_CLIENT_ID"],
+    client_secret=app.config["GOOGLE_CLIENT_SECRET"],
+    server_metadata_url="https://accounts.google.com/.well-known/openid-configuration",
+    client_kwargs={"scope": "openid email profile"},
+)
+
+# ── DB Init ──────────────────────────────────────────────────────────────────
+with app.app_context():
+    db.create_all()
+
+
+# ─────────────────────────────────────────────
+# Auth helpers
+# ─────────────────────────────────────────────
+def login_required(f):
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        if "user_id" not in session:
+            if request.path.startswith("/api/"):
+                return jsonify({"error": "Authentication required."}), 401
+            return redirect(url_for("login_page"))
+        return f(*args, **kwargs)
+    return decorated
+
+
+def get_current_user() -> User | None:
+    uid = session.get("user_id")
+    if not uid:
+        return None
+    return db.session.get(User, uid)
+
+
+def seed_user_settings(user: User):
+    """Create default UserSettings for a brand-new user."""
+    cfg = Config
+    settings = UserSettings(
+        user_id           = user.id,
+        provider          = cfg.DEFAULT_PROVIDER,
+        base_url          = cfg.DEFAULT_BASE_URL,
+        api_key           = "",
+        current_model     = cfg.DEFAULT_MODEL,
+        models_openrouter = list(cfg.DEFAULT_MODELS_OPENROUTER),
+        models_nvidia     = list(cfg.DEFAULT_MODELS_NVIDIA),
+    )
+    db.session.add(settings)
+    db.session.commit()
+
+
+# ─────────────────────────────────────────────
+# Auth Routes
+# ─────────────────────────────────────────────
+@app.route("/auth/login")
+def auth_login():
+    redirect_uri = url_for("auth_callback", _external=True)
+    return google.authorize_redirect(redirect_uri)
+
+
+@app.route("/auth/callback")
+def auth_callback():
+    try:
+        token     = google.authorize_access_token()
+        user_info = token.get("userinfo") or google.userinfo()
+    except Exception as e:
+        return f"<h3>OAuth Error: {e}</h3><a href='/'>Retry</a>", 400
+
+    google_id = user_info.get("sub")
+    email     = user_info.get("email", "")
+    name      = user_info.get("name", email)
+    picture   = user_info.get("picture", "")
+
+    # Upsert user
+    user = User.query.filter_by(google_id=google_id).first()
+    is_new = user is None
+
+    if is_new:
+        user = User(google_id=google_id, email=email, name=name, picture=picture)
+        db.session.add(user)
+        db.session.flush()  # get user.id before commit
+    else:
+        user.name    = name
+        user.picture = picture
+        user.last_login = datetime.utcnow()
+
+    db.session.commit()
+
+    # Seed settings for first-time users
+    if is_new or user.settings is None:
+        seed_user_settings(user)
+
+    session.permanent = True
+    session["user_id"] = user.id
+    return redirect(url_for("index"))
+
+
+@app.route("/auth/logout")
+def auth_logout():
+    session.clear()
+    return redirect(url_for("login_page"))
+
+
+# ─────────────────────────────────────────────
+# Page Routes
+# ���────────────────────────────────────────────
+@app.route("/login")
+def login_page():
+    if "user_id" in session:
+        return redirect(url_for("index"))
+    return render_template("login.html")
+
+
+@app.route("/")
+@login_required
+def index():
+    return render_template("index.html")
+
+
+# ─────────────────────────────────────────────
+# API: Current User
+# ─────────────────────────────────────────────
+@app.route("/api/me")
+@login_required
+def api_me():
+    user = get_current_user()
+    if not user:
+        return jsonify({"error": "User not found."}), 404
+    return jsonify(user.to_dict())
+
+
+# ─────────────────────────────────────────────
+# API: User Settings
+# ─────────────────────────────────────────────
+@app.route("/api/settings", methods=["GET"])
+@login_required
+def api_settings_get():
+    user = get_current_user()
+    s    = user.settings
+    if not s:
+        seed_user_settings(user)
+        s = user.settings
+    return jsonify(s.to_dict())
+
+
+@app.route("/api/settings", methods=["POST"])
+@login_required
+def api_settings_post():
+    user = get_current_user()
+    s    = user.settings
+    if not s:
+        seed_user_settings(user)
+        s = user.settings
+
+    data = request.get_json(force=True) or {}
+
+    if "provider" in data:
+        s.provider = data["provider"]
+        # Auto-set base_url from known providers
+        s.base_url = Config.PROVIDER_URLS.get(data["provider"], s.base_url)
+
+    if "base_url" in data and data["base_url"].strip():
+        s.base_url = data["base_url"].strip()
+
+    if "api_key" in data:
+        s.api_key = data["api_key"].strip()
+
+    if "current_model" in data:
+        s.current_model = data["current_model"].strip()
+
+    if "models_openrouter" in data and isinstance(data["models_openrouter"], list):
+        s.models_openrouter = [m for m in data["models_openrouter"] if m]
+
+    if "models_nvidia" in data and isinstance(data["models_nvidia"], list):
+        s.models_nvidia = [m for m in data["models_nvidia"] if m]
+
+    s.updated_at = datetime.utcnow()
+    db.session.commit()
+    return jsonify(s.to_dict())
+
+
+# ─────────────────────────────────────────────
+# API: Chat
+# ─────────────────────────────────────────────
+@app.route("/api/chat", methods=["POST"])
+@login_required
+def api_chat():
+    user = get_current_user()
+    s    = user.settings
+    if not s:
+        return jsonify({"error": "Settings not configured. Please save your API key first."}), 400
+
+    data     = request.get_json(force=True) or {}
+    prompt   = (data.get("prompt") or "").strip()
+    messages = data.get("messages", [])
+    # Allow client to override model (from the dropdown)
+    model    = (data.get("model") or s.current_model or "").strip()
+
+    if not prompt:
+        return jsonify({"error": "Prompt is required."}), 400
+    if not s.api_key:
+        return jsonify({"error": "No API key saved. Please open Settings and add your API key."}), 400
+    if not model:
+        return jsonify({"error": "No model selected."}), 400
+
+    SYSTEM_PROMPT = (
+        "You are ORBIT, an intelligent Educational Research Assistant. "
+        "Provide accurate, well-structured academic answers. "
+        "Use Markdown formatting (bold, bullet points, code blocks) where appropriate. "
+        "Keep responses concise unless the user requests more detail."
+    )
+
+    api_key  = s.api_key
+    base_url = s.base_url
+    provider = s.provider
+
+    try:
+        # ── Google Gemini ────────────────────────────────────────────────
+        if provider == "Google Gemini":
+            gemini_url = (
+                f"https://generativelanguage.googleapis.com/v1beta/models/"
+                f"{model}:generateContent?key={api_key}"
+            )
+            contents = []
+            for m in messages[-10:]:
+                role = "user" if m.get("role") == "user" else "model"
+                contents.append({"role": role, "parts": [{"text": m.get("content", "")}]})
+            if not contents or contents[-1]["role"] != "user":
+                contents.append({"role": "user", "parts": [{"text": f"{SYSTEM_PROMPT}\n\n{prompt}"}]})
+
+            resp = requests.post(gemini_url, json={"contents": contents}, timeout=60)
+            if resp.status_code != 200:
+                return jsonify({"error": f"Gemini error [{resp.status_code}]: {resp.text}"}), resp.status_code
+
+            result = resp.json()
+            try:
+                reply = result["candidates"][0]["content"]["parts"][0]["text"].strip()
+            except (KeyError, IndexError):
+                reply = json.dumps(result)
+            return jsonify({"reply": reply})
+
+        # ── OpenAI-Compatible ────────────────────────────────────────────
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}",
+            "HTTP-Referer": "https://orbit-assistant.app",
+            "X-Title": "ORBIT Educational Assistant",
+        }
+        composed = [{"role": "system", "content": SYSTEM_PROMPT}]
+        for m in messages[-10:]:
+            if m.get("role") in ("user", "assistant"):
+                composed.append({"role": m["role"], "content": m.get("content", "")})
+        if not composed or composed[-1].get("content") != prompt:
+            composed.append({"role": "user", "content": prompt})
+
+        payload = {"model": model, "messages": composed, "temperature": 0.6, "max_tokens": 1536}
+        resp    = requests.post(base_url, headers=headers, json=payload, timeout=60)
+
+        if resp.status_code != 200:
+            try:
+                err = json.dumps(resp.json())
+            except Exception:
+                err = resp.text
+            return jsonify({"error": f"API error [{resp.status_code}]: {err}"}), resp.status_code
+
+        reply = resp.json()["choices"][0]["message"]["content"].strip()
+        return jsonify({"reply": reply})
+
+    except requests.exceptions.Timeout:
+        return jsonify({"error": "Request timed out. The model is taking too long."}), 504
+    except requests.exceptions.ConnectionError:
+        return jsonify({"error": "Could not connect to the AI provider."}), 503
+    except Exception as e:
+        return jsonify({"error": f"Server error: {str(e)}"}), 500
+
+
+# ─────────────────────────────────────────────
+# API: Upload PDF
+# ─────────────────────────────────────────────
+@app.route("/api/upload_pdf", methods=["POST"])
+@login_required
+def api_upload_pdf():
+    if "file" not in request.files:
+        return jsonify({"error": "No file field in request."}), 400
+
+    f = request.files["file"]
+    if not f or not f.filename:
+        return jsonify({"error": "No file selected."}), 400
+    if not f.filename.lower().endswith(".pdf"):
+        return jsonify({"error": "Only PDF files are supported."}), 415
+
+    try:
+        pdf_bytes = f.read()
+        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+
+        parts, word_count, MAX = [], 0, 3000
+        for page in doc:
+            text = page.get_text().strip()
+            if not text:
+                continue
+            words = text.split()
+            remaining = MAX - word_count
+            if remaining <= 0:
+                break
+            if len(words) > remaining:
+                parts.append(" ".join(words[:remaining]))
+                word_count += remaining
+                break
+            parts.append(text)
+            word_count += len(words)
+        doc.close()
+
+        full_text = "\n\n".join(parts).strip()
+        if not full_text:
+            return jsonify({"error": "Could not extract readable text. PDF may be image-based."}), 422
+
+        return jsonify({"text": full_text, "filename": f.filename, "word_count": word_count})
+
+    except fitz.FileDataError:
+        return jsonify({"error": "Not a valid PDF file."}), 422
+    except Exception as e:
+        return jsonify({"error": f"PDF error: {str(e)}"}), 500
+
+
+# ─────────────────────────────────────────────
+# API: Validate DOI
+# ─────────────────────────────────────────────
+@app.route("/api/validate_doi", methods=["POST"])
+@login_required
+def api_validate_doi():
+    data    = request.get_json(force=True) or {}
+    raw_doi = (data.get("doi") or "").strip()
+    if not raw_doi:
+        return jsonify({"error": "DOI is required."}), 400
+
+    for prefix in ["https://doi.org/", "http://doi.org/", "doi.org/"]:
+        if raw_doi.startswith(prefix):
+            raw_doi = raw_doi[len(prefix):]
+            break
+
+    try:
+        resp = requests.get(
+            f"https://api.crossref.org/works/{raw_doi}",
+            headers={"User-Agent": "ORBIT/2.0 (mailto:orbit@example.com)"},
+            timeout=15,
+        )
+        if resp.status_code == 404:
+            return jsonify({"error": f"DOI '{raw_doi}' not found in CrossRef."}), 404
+        if resp.status_code != 200:
+            return jsonify({"error": f"CrossRef error [{resp.status_code}]."}), resp.status_code
+
+        work = resp.json().get("message", {})
+
+        titles  = work.get("title", [])
+        title   = titles[0] if titles else "No title available"
+
+        authors_raw = work.get("author", [])
+        if authors_raw:
+            names = [f"{a.get('given','')} {a.get('family','')}".strip() for a in authors_raw[:5]]
+            authors = ", ".join(names)
+            if len(authors_raw) > 5:
+                authors += f" et al. (+{len(authors_raw)-5} more)"
+        else:
+            authors = "Not available"
+
+        year = "N/A"
+        for field in ["published-print", "published-online", "issued", "created"]:
+            parts = work.get(field, {}).get("date-parts", [[]])
+            if parts and parts[0]:
+                year = str(parts[0][0])
+                break
+
+        containers = work.get("container-title", [])
+        journal    = containers[0] if containers else work.get("publisher", "N/A")
+        pub_type   = work.get("type", "journal-article").replace("-", " ").title()
+
+        return jsonify({"doi": raw_doi, "title": title, "authors": authors,
+                        "year": year, "journal": journal, "type": pub_type})
+
+    except requests.exceptions.Timeout:
+        return jsonify({"error": "CrossRef timed out."}), 504
+    except requests.exceptions.ConnectionError:
+        return jsonify({"error": "Could not connect to CrossRef."}), 503
+    except Exception as e:
+        return jsonify({"error": f"DOI error: {str(e)}"}), 500
+
+
+# ─────────────────────────────────────────────
+# Entry Point
+# ─────────────────────────────────────────────
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 5000))
+    print(f"[ORBIT] http://127.0.0.1:{port}")
+    app.run(host="0.0.0.0", port=port, debug=Config.DEBUG)

requirements.txt

@@ -0,0 +1,7 @@
+flask>=3.0.0
+flask-cors>=4.0.0
+flask-sqlalchemy>=3.1.0
+authlib>=1.3.0
+python-dotenv>=1.0.0
+requests>=2.31.0
+PyMuPDF>=1.23.0