Upload 9 files

.gitattributes

@@ -1,35 +1,36 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+users.db filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+my/
+__pycache__/
+*.db
+users.db
+.vscode/

Dockerfile

@@ -0,0 +1,32 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies if any are needed for SQLite, Pillow, or other libraries
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements file and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Hugging Face Spaces requires running as a non-root user
+RUN useradd -m -u 1000 user
+
+# Copy the rest of the application files
+COPY --chown=user:user . /app
+
+# Set permissions so the app can create and write to the SQLite database
+# We change permissions of the app directory because SQLite needs to create journal files alongside the .db file
+RUN chmod 777 /app
+RUN touch /app/users.db && chmod 666 /app/users.db
+
+# Switch to the non-root user
+USER user
+
+# Expose port 7860 as required by Hugging Face Spaces
+EXPOSE 7860
+
+# Run the app
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,11 @@
+---
+title: Struct Scan AI
+emoji: 🚀
+colorFrom: blue
+colorTo: red
+sdk: docker
+pinned: false
+short_description: Struct Scan AI is an intelligent structural inspection platf
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.js

@@ -0,0 +1,94 @@
+window.api = async function(url, options = {}) {
+  // Use mock token for now since backend doesn't properly implement JWT auth,
+  // but it does use Flask session which is automatic via cookies.
+  const headers = { ...options.headers };
+  if (!(options.body instanceof FormData)) {
+    headers["Content-Type"] = "application/json";
+  }
+  const token = localStorage.getItem("token");
+  if (token) headers["Authorization"] = "Bearer " + token;
+
+  const res = await fetch(url, { ...options, headers });
+  
+  // Handle empty responses
+  if (res.status === 204) return null;
+  
+  const text = await res.text();
+  let data = {};
+  if (text) {
+    try {
+      data = JSON.parse(text);
+    } catch (e) {
+      if (text.includes("<!DOCTYPE html>") || text.includes("<html")) {
+        data = { error: "Server error or Flask is not running on this URL. Please ensure you are running `python app.py` and accessing it via http://127.0.0.1:5000." };
+      } else {
+        data = { error: "Invalid response format from server" };
+      }
+    }
+  }
+
+  if (!res.ok) {
+    const error = new Error(data.error || "An error occurred");
+    error.status = res.status;
+    throw error;
+  }
+  return data;
+};
+
+window.Auth = {
+  setSession: (token, user) => {
+    localStorage.setItem("token", token);
+    localStorage.setItem("user", JSON.stringify(user));
+  },
+  getUser: () => {
+    const u = localStorage.getItem("user");
+    return u ? JSON.parse(u) : null;
+  },
+  getToken: () => localStorage.getItem("token"),
+  clear: () => {
+    localStorage.removeItem("token");
+    localStorage.removeItem("user");
+  },
+  requireAuth: () => {
+    if (!localStorage.getItem("token")) {
+      window.location.href = "/login";
+      return false;
+    }
+    return true;
+  },
+  redirectIfAuthed: () => {
+    if (localStorage.getItem("token")) {
+      window.location.href = "/dashboard";
+    }
+  }
+};
+
+window.toast = (msg, type = "info") => {
+  const t = document.createElement("div");
+  t.className = "toast " + type;
+  t.textContent = msg;
+  document.body.appendChild(t);
+  
+  // Trigger reflow
+  t.offsetHeight;
+  t.classList.add("show");
+  
+  setTimeout(() => {
+    t.classList.remove("show");
+    setTimeout(() => t.remove(), 300);
+  }, 3000);
+};
+
+window.initials = (name) => {
+  if (!name) return "U";
+  return name.split(" ").map(n => n[0]).join("").substring(0, 2).toUpperCase();
+};
+
+window.initReveal = () => {
+  const reveals = document.querySelectorAll('.reveal');
+  reveals.forEach((r, i) => {
+    setTimeout(() => {
+      r.classList.add('in');
+    }, i * 100);
+  });
+};

app.py

@@ -0,0 +1,498 @@
+import sqlite3
+import base64
+import random
+import io
+from functools import wraps
+from flask import Flask, request, jsonify, session, render_template, send_from_directory
+from werkzeug.security import generate_password_hash, check_password_hash
+
+app = Flask(__name__)
+app.secret_key = 'super_secret_structscan_key'
+DB_PATH = 'users.db'
+
+# ==============================================================================
+# Database Initialization & Management
+# ==============================================================================
+def init_db():
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            email TEXT UNIQUE NOT NULL,
+            password TEXT NOT NULL
+        )
+    ''')
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS projects (
+            id TEXT PRIMARY KEY,
+            user_id INTEGER,
+            name TEXT,
+            structure_type TEXT,
+            age_years TEXT,
+            location TEXT,
+            material_brand TEXT,
+            material_amount TEXT,
+            material_composition TEXT,
+            inspection_zone TEXT,
+            notes TEXT
+        )
+    ''')
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS analyses (
+            project_id TEXT PRIMARY KEY,
+            risk_level TEXT,
+            risk_desc TEXT,
+            primary_defect TEXT,
+            health INTEGER,
+            image_b64 TEXT,
+            boxes_json TEXT,
+            probabilities_json TEXT,
+            specs_json TEXT,
+            report_text TEXT
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+init_db()
+
+def login_required_api(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'user_id' not in session:
+            return jsonify({"error": "Unauthorized. Please log in."}), 401
+        return f(*args, **kwargs)
+    return decorated_function
+
+# ==============================================================================
+# Page Routes
+# ==============================================================================
+@app.route("/")
+def index():
+    return render_template("index.html")
+
+@app.route("/login")
+def login():
+    return render_template("login.html")
+
+@app.route("/signup")
+def signup():
+    return render_template("signup.html")
+
+@app.route("/dashboard")
+def dashboard():
+    return render_template("dashboard.html")
+
+@app.route("/app.js")
+def serve_app_js():
+    return send_from_directory(".", "app.js")
+
+# ==============================================================================
+# Auth API
+# ==============================================================================
+@app.route("/api/auth/register", methods=["POST"])
+def api_register():
+    data = request.get_json() or {}
+    name = data.get("name", "").strip()
+    email = data.get("email", "").strip()
+    password = data.get("password", "")
+
+    if not name or not email or len(password) < 6:
+        return jsonify({"error": "Invalid registrations input criteria parameters."}), 400
+        
+    if " " in name:
+        return jsonify({"error": "Spaces are not allowed in the username."}), 400
+        
+    if " " in password:
+        return jsonify({"error": "Spaces are not allowed in the password."}), 400
+
+    hashed_pw = generate_password_hash(password)
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        c = conn.cursor()
+        c.execute("INSERT INTO users (name, email, password) VALUES (?, ?, ?)", (name, email, hashed_pw))
+        user_id = c.lastrowid
+        conn.commit()
+        conn.close()
+        
+        session['user_id'] = user_id
+        session['username'] = name
+        return jsonify({
+            "token": f"mock_token_{user_id}",
+            "user": {"id": user_id, "name": name, "email": email}
+        }), 201
+    except sqlite3.IntegrityError:
+        return jsonify({"error": "Account registration email already coordinates inside user files."}), 400
+
+@app.route("/api/auth/login", methods=["POST"])
+def api_login():
+    data = request.get_json() or {}
+    email = data.get("email", "").strip()
+    password = data.get("password", "")
+    
+    if " " in password:
+        return jsonify({"error": "Spaces are not allowed in the password."}), 400
+
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("SELECT id, name, password FROM users WHERE email = ?", (email,))
+    row = c.fetchone()
+    conn.close()
+
+    if row and check_password_hash(row[2], password):
+        session['user_id'] = row[0]
+        session['username'] = row[1]
+        return jsonify({
+            "token": f"mock_token_{row[0]}",
+            "user": {"id": row[0], "name": row[1], "email": email}
+        }), 200
+    return jsonify({"error": "Invalid account email or credential authorization signature verification failure."}), 401
+
+@app.route("/api/auth/profile", methods=["PUT"])
+@login_required_api
+def update_profile():
+    data = request.get_json() or {}
+    name = data.get("name", "").strip()
+    password = data.get("password", "")
+    user_id = session.get("user_id")
+
+    if not name:
+        return jsonify({"error": "Name cannot be empty."}), 400
+    if " " in name:
+        return jsonify({"error": "Spaces are not allowed in the username."}), 400
+        
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    
+    if password:
+        if " " in password:
+            conn.close()
+            return jsonify({"error": "Spaces are not allowed in the password."}), 400
+        if len(password) < 6:
+            conn.close()
+            return jsonify({"error": "Password must be at least 6 characters."}), 400
+        hashed_pw = generate_password_hash(password)
+        c.execute("UPDATE users SET name = ?, password = ? WHERE id = ?", (name, hashed_pw, user_id))
+    else:
+        c.execute("UPDATE users SET name = ? WHERE id = ?", (name, user_id))
+        
+    conn.commit()
+    conn.close()
+    
+    session['username'] = name
+    return jsonify({"success": True, "name": name}), 200
+
+# ==============================================================================
+# Projects API
+# ==============================================================================
+@app.route("/api/projects", methods=["GET"])
+@login_required_api
+def get_projects():
+    user_id = session['user_id']
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    c = conn.cursor()
+    c.execute("""
+        SELECT p.*, a.risk_level, a.risk_desc, a.primary_defect, a.health, 
+               a.image_b64, a.boxes_json, a.probabilities_json, a.specs_json, a.report_text 
+        FROM projects p 
+        LEFT JOIN analyses a ON p.id = a.project_id
+        WHERE p.user_id = ?
+    """, (user_id,))
+    rows = c.fetchall()
+    conn.close()
+
+    import json
+    project_list = []
+    for row in rows:
+        project_dict = {
+            "id": row["id"],
+            "name": row["name"],
+            "structure_type": row["structure_type"],
+            "age_years": row["age_years"],
+            "location": row["location"],
+            "material_brand": row["material_brand"],
+            "material_amount": row["material_amount"],
+            "material_composition": row["material_composition"],
+            "inspection_zone": row["inspection_zone"],
+            "notes": row["notes"],
+            "last_analysis": None
+        }
+        if row["health"] is not None:
+            project_dict["last_analysis"] = {
+                "risk_level": row["risk_level"],
+                "risk_desc": row["risk_desc"],
+                "primary_defect": row["primary_defect"],
+                "health": row["health"],
+                "image_b64": row["image_b64"],
+                "boxes": json.loads(row["boxes_json"]) if row["boxes_json"] else [],
+                "probabilities": json.loads(row["probabilities_json"]) if row["probabilities_json"] else [],
+                "specs": json.loads(row["specs_json"]) if row["specs_json"] else {},
+                "report": row["report_text"]
+            }
+        project_list.append(project_dict)
+
+    return jsonify(project_list), 200
+
+@app.route("/api/projects", methods=["POST"])
+@login_required_api
+def create_project():
+    data = request.get_json() or {}
+    name = data.get("name", "").strip()
+    loc = data.get("location", "").strip()
+    brand = data.get("material_brand", "").strip()
+    amount = data.get("material_amount", "").strip()
+
+    if not name or not loc or not brand or not amount:
+        return jsonify({"error": "Missing essential structure data fields configuration bounds."}), 400
+
+    project_id = f"proj_{int(random.random() * 1000000)}"
+    user_id = session['user_id']
+
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("""
+        INSERT INTO projects (id, user_id, name, structure_type, age_years, location, 
+                             material_brand, material_amount, material_composition, inspection_zone, notes)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """, (project_id, user_id, name, data.get("structure_type"), data.get("age_years"), loc,
+          brand, amount, data.get("material_composition"), data.get("inspection_zone"), data.get("notes")))
+    conn.commit()
+    conn.close()
+
+    return jsonify({
+        "id": project_id,
+        "name": name,
+        "structure_type": data.get("structure_type"),
+        "age_years": data.get("age_years"),
+        "location": loc,
+        "material_brand": brand,
+        "material_amount": amount,
+        "material_composition": data.get("material_composition"),
+        "inspection_zone": data.get("inspection_zone"),
+        "notes": data.get("notes"),
+        "last_analysis": None
+    }), 201
+
+@app.route("/api/projects/<project_id>/analyze", methods=["POST"])
+@login_required_api
+def analyze_project(project_id):
+    if "file" not in request.files:
+        return jsonify({"error": "No image resource payload submitted inside structural file paths."}), 400
+
+    file = request.files["file"]
+    img_bytes = file.read()
+
+    # Fetch project details to get the grade
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    c = conn.cursor()
+    c.execute("SELECT material_composition, material_brand FROM projects WHERE id = ?", (project_id,))
+    proj = c.fetchone()
+    
+    grade = proj["material_composition"] if proj and proj["material_composition"] else "OPC 43"
+    brand = proj["material_brand"] if proj and proj["material_brand"] else "Unknown"
+    
+    lookup_grade = grade
+    if grade and "OPC 33" in grade: lookup_grade = "OPC 33"
+    elif grade and "OPC 43" in grade: lookup_grade = "OPC 43"
+    elif grade and "OPC 53" in grade: lookup_grade = "OPC 53"
+    elif grade and "PPC" in grade: lookup_grade = "PPC"
+    elif grade and "PSC" in grade: lookup_grade = "PSC"
+    else: lookup_grade = "OPC 43"
+    
+    cement_info = CEMENT_DATA.get(lookup_grade, CEMENT_DATA["OPC 43"])
+
+    cement_str = f"\n\n**CEMENT STRENGTH ANALYSIS**\n"
+    cement_str += f"Material Selected: {brand} ({grade})\n"
+    cement_str += f"28-Day Compressive Strength: {cement_info['strength']} MPa [{cement_info['category']}]\n"
+    cement_str += f"Recommended Applications: {', '.join(cement_info['applications'])}\n"
+    cement_str += f"Engineering Remarks: {cement_info['remark']}"
+
+    # Simulate dynamic AI model responses
+    defects = [
+        {"name": "Concrete Cracking", "risk": "medium", "desc": "Surface micro-fractures tracking stress vectors.", "min_h": 65, "max_h": 85},
+        {"name": "Spalling & Delamination", "risk": "high", "desc": "Severe localized concrete spalling exposing rebar.", "min_h": 40, "max_h": 60},
+        {"name": "Efflorescence / Water Seepage", "risk": "low", "desc": "Minor salt deposits due to water ingress.", "min_h": 80, "max_h": 90},
+        {"name": "Structural Deformation", "risk": "high", "desc": "Abnormal deflection or structural bowing detected.", "min_h": 30, "max_h": 50},
+        {"name": "Healthy Surface", "risk": "low", "desc": "No major structural anomalies detected.", "min_h": 92, "max_h": 100}
+    ]
+    
+    import random
+    import hashlib
+    from PIL import Image, ImageFilter, ImageStat
+    import io
+    
+    # Create deterministic seed based on image contents
+    img_hash = hashlib.md5(img_bytes).hexdigest()
+    random.seed(img_hash)
+
+    defect = random.choice(defects)
+    
+    try:
+        pil_img = Image.open(io.BytesIO(img_bytes)).convert("L")
+        edges = pil_img.filter(ImageFilter.FIND_EDGES)
+        stat = ImageStat.Stat(edges)
+        edge_intensity = stat.mean[0]
+        
+        if edge_intensity > 20:
+            defect_name = random.choice(["Concrete Cracking", "Spalling & Delamination", "Structural Deformation"])
+            defect = next(d for d in defects if d["name"] == defect_name)
+        elif edge_intensity < 8:
+            defect = next(d for d in defects if d["name"] == "Healthy Surface")
+    except Exception:
+        pass
+    health_score = random.randint(defect["min_h"], defect["max_h"])
+    confidence = round(random.uniform(75.0, 98.9), 1)
+
+    boxes = []
+    if defect["name"] != "Healthy Surface":
+        num_boxes = random.randint(2, 6)
+        for _ in range(num_boxes):
+            bx = random.randint(5, 70)
+            by = random.randint(5, 70)
+            bw = random.randint(15, min(40, 95 - bx))
+            bh = random.randint(15, min(40, 95 - by))
+            boxes.append({
+                "x": bx, "y": by, "w": bw, "h": bh,
+                "label": defect["name"],
+                "confidence": round(random.uniform(max(50.0, confidence - 15.0), confidence), 1)
+            })
+
+    needs_demolish = "Yes" if defect["risk"] == "high" and health_score < 45 else "No"
+    if defect["name"] == "Healthy Surface":
+        cost_inr = 0
+    elif defect["risk"] == "low":
+        cost_inr = random.randint(5000, 25000)
+    elif defect["risk"] == "medium":
+        cost_inr = random.randint(30000, 100000)
+    else:
+        cost_inr = random.randint(150000, 1000000)
+
+    encoded_source = f"data:image/jpeg;base64,{base64.b64encode(img_bytes).decode()}"
+    report_data = {
+        "risk_level": defect["risk"],
+        "risk_desc": defect["desc"],
+        "primary_defect": defect["name"],
+        "health": health_score,
+        "image_b64": encoded_source,
+        "boxes": boxes,
+        "probabilities": [
+            {"label": defect["name"], "prob": confidence, "severity": defect["risk"]},
+            {"label": "Secondary Anomaly", "prob": round(random.uniform(5.0, 25.0), 1), "severity": "low"}
+        ],
+        "specs": {
+            "edge_density": f"{round(random.uniform(0.1, 0.6), 3)} px⁻¹",
+            "luminance": f"{random.randint(90, 180)} cd/m²",
+            "rgb": [str(random.randint(90, 150)), str(random.randint(90, 150)), str(random.randint(90, 150))],
+            "model": "StructScan Core (Deterministic Simulation)",
+            "demolish": needs_demolish,
+            "cost": f"₹ {cost_inr:,}"
+        },
+        "report": f"**STRUCTURAL DIAGNOSTIC REVIEWS**\nDiagnostic pass complete. {defect['desc']}" + cement_str
+    }
+    
+    # Reset seed so we don't affect global random state
+    random.seed()
+    import json
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute("""
+        INSERT OR REPLACE INTO analyses 
+        (project_id, risk_level, risk_desc, primary_defect, health, image_b64, boxes_json, probabilities_json, specs_json, report_text)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    """, (
+        project_id,
+        report_data["risk_level"],
+        report_data["risk_desc"],
+        report_data["primary_defect"],
+        report_data["health"],
+        report_data["image_b64"],
+        json.dumps(report_data["boxes"]),
+        json.dumps(report_data["probabilities"]),
+        json.dumps(report_data["specs"]),
+        report_data["report"]
+    ))
+    conn.commit()
+    conn.close()
+
+    return jsonify(report_data), 200
+
+# ==============================================================================
+# Cement Strength API
+# ==============================================================================
+CEMENT_DATA = {
+    "OPC 33": {
+        "strength": "33",
+        "category": "Standard Strength",
+        "applications": ["Plastering", "Masonry Work", "Residential Construction"],
+        "remark": "OPC 33 grade cement provides adequate baseline compressive strength."
+    },
+    "OPC 43": {
+        "strength": "43",
+        "category": "Medium-High Strength",
+        "applications": ["RCC Structures", "Slabs", "Beams", "Columns"],
+        "remark": "OPC 43 grade delivers a robust 43 MPa compressive strength after 28 days."
+    },
+    "OPC 53": {
+        "strength": "53",
+        "category": "High Strength",
+        "applications": ["High-Rise Buildings", "Bridges", "Industrial Structures", "Heavy Load Bearing Elements"],
+        "remark": "OPC 53 grade achieves rapid and high compressive strength."
+    },
+    "PPC": {
+        "strength": "33-53",
+        "category": "Durable Concrete",
+        "applications": ["Dams", "Marine Structures", "Mass Concreting", "Long-Life Construction"],
+        "remark": "Portland Pozzolana Cement (PPC) offers superior resistance to sulfate attacks."
+    },
+    "PSC": {
+        "strength": "33-53",
+        "category": "High Durability Concrete",
+        "applications": ["Coastal Structures", "Foundations", "Sewage Treatment Plants", "Aggressive Environmental Conditions"],
+        "remark": "Portland Slag Cement (PSC) features excellent durability against chloride."
+    }
+}
+
+@app.route('/api/cement/strength', methods=['POST'])
+def cement_strength():
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "Invalid request payload."}), 400
+            
+        brand = data.get('brand', '').strip()
+        grade = data.get('grade', '').strip()
+        
+        if not brand or not grade:
+            return jsonify({"error": "Both brand and grade must be provided."}), 400
+            
+        lookup_grade = grade
+        if "OPC 33" in grade: lookup_grade = "OPC 33"
+        elif "OPC 43" in grade: lookup_grade = "OPC 43"
+        elif "OPC 53" in grade: lookup_grade = "OPC 53"
+        elif "PPC" in grade: lookup_grade = "PPC"
+        elif "PSC" in grade: lookup_grade = "PSC"
+        
+        if lookup_grade not in CEMENT_DATA:
+            return jsonify({"error": "Invalid cement grade selected."}), 400
+            
+        result = CEMENT_DATA[lookup_grade]
+        
+        response_data = {
+            "brand": brand,
+            "grade": grade,
+            "strength": result["strength"],
+            "category": result["category"],
+            "applications": result["applications"],
+            "remark": result["remark"]
+        }
+        return jsonify(response_data), 200
+    except Exception as e:
+        print(f"Error processing cement request: {e}")
+        return jsonify({"error": "An internal processing error occurred."}), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)

model.py

@@ -0,0 +1,492 @@
+import io
+import base64
+import random
+from PIL import Image, ImageFilter, ImageStat, ImageEnhance, ImageDraw
+
+# Try to import PyTorch, fallback if unavailable
+try:
+    import torch
+    import torch.nn as nn
+    HAS_TORCH = True
+except ImportError:
+    HAS_TORCH = False
+
+if HAS_TORCH:
+    class AdvancedStructuralSHMNet(nn.Module):
+        """
+        A PyTorch CNN classifier that extracts features from input tensors
+        and predicts logits for 12 structural defect classes and 5 severity levels.
+        """
+        def __init__(self, num_defect_classes=12):
+            super().__init__()
+            self.backbone = nn.Sequential(
+                nn.Conv2d(3, 16, 3, padding=1),
+                nn.BatchNorm2d(16),
+                nn.ReLU(),
+                nn.MaxPool2d(2, 2),
+                
+                nn.Conv2d(16, 32, 3, padding=1),
+                nn.BatchNorm2d(32),
+                nn.ReLU(),
+                nn.MaxPool2d(2, 2),
+                
+                nn.Conv2d(32, 64, 3, padding=1),
+                nn.BatchNorm2d(64),
+                nn.ReLU(),
+                nn.AdaptiveAvgPool2d((1, 1))
+            )
+            self.defect_fc = nn.Linear(64, num_defect_classes)
+            self.severity_fc = nn.Linear(64, 5) # 5 severity levels
+
+        def forward(self, x):
+            features = self.backbone(x)
+            features = torch.flatten(features, 1)
+            defect_logits = self.defect_fc(features)
+            severity_logits = self.severity_fc(features)
+            return {
+                "defect_logits": defect_logits,
+                "severity_logits": severity_logits
+            }
+else:
+    AdvancedStructuralSHMNet = None
+
+
+class StructuralDecisionEngine:
+    """
+    Expert decision engine that integrates neural network predictions,
+    image features (edges, color), and metadata to generate structural
+    diagnostics, recommendations, localized bounding boxes, and heatmaps.
+    """
+    def __init__(self):
+        self.defect_classes = [
+            "Longitudinal Crack",
+            "Transverse Crack",
+            "Fatigue / Grid Crack",
+            "Spalling / Delamination",
+            "Concrete Efflorescence",
+            "Rebar Exposure & Corrosion",
+            "Honeycomb / Voiding",
+            "Settlement / Subsidence Crack",
+            "Moisture / Water Seepage",
+            "Joint Failure / Gap Expansion",
+            "Surface Erosion / Abrasion",
+            "Biological Growth / Vegetation"
+        ]
+        
+        self.severity_levels = [
+            "Negligible (Severity 1)",
+            "Low / Minor (Severity 2)",
+            "Moderate / Medium (Severity 3)",
+            "High / Severe (Severity 4)",
+            "Critical / Extreme (Severity 5)"
+        ]
+
+    def _extract_visual_features(self, img_bytes: bytes) -> dict:
+        """Analyze image characteristics dynamically using PIL."""
+        try:
+            img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+            width, height = img.size
+            
+            # Color distributions
+            stat = ImageStat.Stat(img)
+            mean_r, mean_g, mean_b = stat.mean
+            
+            # Edge density / texture analyzer
+            gray = img.convert("L")
+            edges = gray.filter(ImageFilter.FIND_EDGES)
+            edge_stat = ImageStat.Stat(edges)
+            edge_intensity = edge_stat.mean[0]  # Average brightness of edge image
+            
+            return {
+                "edge_intensity": edge_intensity,
+                "mean_r": mean_r,
+                "mean_g": mean_g,
+                "mean_b": mean_b,
+                "width": width,
+                "height": height
+            }
+        except Exception as e:
+            print(f"Error in visual feature extraction: {e}")
+            return {
+                "edge_intensity": 12.0,
+                "mean_r": 128.0,
+                "mean_g": 128.0,
+                "mean_b": 128.0,
+                "width": 800,
+                "height": 600
+            }
+
+    def _generate_defect_heatmap(self, img_bytes: bytes) -> str:
+        """Generate a realistic blended defect heatmap overlay (simulated Grad-CAM)."""
+        try:
+            orig = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+            w, h = orig.size
+            
+            # Resize for performance
+            scale_w = min(600, w)
+            scale_h = int(h * (scale_w / w))
+            img = orig.resize((scale_w, scale_h), Image.Resampling.LANCZOS)
+            
+            # Get edges
+            gray = img.convert("L")
+            edges = gray.filter(ImageFilter.FIND_EDGES)
+            
+            # Dilate and blur to make it look like a smooth neural activation map
+            heatmap_mask = edges.filter(ImageFilter.MaxFilter(5))
+            heatmap_mask = heatmap_mask.filter(ImageFilter.GaussianBlur(radius=15))
+            
+            # Sharp heatmap mask for core defects
+            strong_edges = edges.filter(ImageFilter.MaxFilter(3))
+            strong_edges = strong_edges.filter(ImageFilter.GaussianBlur(radius=5))
+            
+            # Overlays
+            red_overlay = Image.new("RGB", (scale_w, scale_h), (247, 129, 102))  # Theme Accent
+            yellow_overlay = Image.new("RGB", (scale_w, scale_h), (255, 166, 87)) # Theme Warn
+            
+            # Base heatmap
+            heatmap = Image.new("RGB", (scale_w, scale_h), (13, 17, 40)) # Dark blueish base
+            
+            # Composite colors
+            heatmap = Image.composite(yellow_overlay, heatmap, heatmap_mask)
+            heatmap = Image.composite(red_overlay, heatmap, strong_edges)
+            
+            # Enhance
+            heatmap = ImageEnhance.Contrast(heatmap).enhance(1.4)
+            
+            # Blend back with original image (45% opacity)
+            blended = Image.blend(img, heatmap, 0.45)
+            
+            # Convert to base64
+            buf = io.BytesIO()
+            blended.save(buf, format="JPEG", quality=85)
+            return base64.b64encode(buf.getvalue()).decode()
+        except Exception as e:
+            print(f"Error generating heatmap: {e}")
+            return ""
+
+    def _detect_defect_boxes(self, img_bytes: bytes, edge_intensity: float) -> list:
+        """Find coordinates of high-texture regions to build real defect bounding boxes."""
+        try:
+            img = Image.open(io.BytesIO(img_bytes)).convert("L")
+            w, h = img.size
+            
+            # Use grid-based thresholding
+            gw, gh = 8, 8
+            img_resized = img.resize((gw, gh))
+            edges = img_resized.filter(ImageFilter.FIND_EDGES)
+            pixels = list(edges.getdata())
+            
+            # Determine threshold based on average edge intensity
+            threshold = max(12.0, edge_intensity * 0.8)
+            
+            active_cells = []
+            for y in range(gh):
+                for x in range(gw):
+                    idx = y * gw + x
+                    val = pixels[idx]
+                    if val > threshold:
+                        active_cells.append((x, y, val))
+                        
+            # BFS clustering
+            visited = set()
+            clusters = []
+            for x, y, val in active_cells:
+                if (x, y) in visited:
+                    continue
+                queue = [(x, y)]
+                cluster = []
+                while queue:
+                    cx, cy = queue.pop(0)
+                    if (cx, cy) in visited:
+                        continue
+                    visited.add((cx, cy))
+                    cluster.append((cx, cy))
+                    for nx in [cx-1, cx, cx+1]:
+                        for ny in [cy-1, cy, cy+1]:
+                            if 0 <= nx < gw and 0 <= ny < gh:
+                                n_idx = ny * gw + nx
+                                if pixels[n_idx] > threshold and (nx, ny) not in visited:
+                                    queue.append((nx, ny))
+                clusters.append(cluster)
+                
+            boxes = []
+            # Map of possible defects depending on sequential clusters
+            possible_defects = [
+                ("Longitudinal Crack", "Linear cracking running parallel to structural axis. Indicates bending stress or shrinkage."),
+                ("Concrete Spalling", "Chipping/fracturing of concrete cover exposing inner layers. Suggests rebar oxidation expansion."),
+                ("Rebar Corrosion", "Visible oxidation of steel reinforcement. Highly critical due to loss of tensile strength."),
+                ("Moisture Seepage", "Dampness/water filtration through pores. Accelerates concrete carbonation and structural decay."),
+                ("Efflorescence", "Salt deposits left after water evaporation. Indicates persistent internal moisture transport.")
+            ]
+            
+            for idx, cluster in enumerate(clusters[:4]): # limit to max 4 defect boxes
+                min_x = min(c[0] for c in cluster)
+                max_x = max(c[0] for c in cluster)
+                min_y = min(c[1] for c in cluster)
+                max_y = max(c[1] for c in cluster)
+                
+                # Convert to percentages
+                x1 = max(0, min_x * 12.5 - 2)
+                y1 = max(0, min_y * 12.5 - 2)
+                x2 = min(100, (max_x + 1) * 12.5 + 2)
+                y2 = min(100, (max_y + 1) * 12.5 + 2)
+                
+                def_name, def_desc = possible_defects[idx % len(possible_defects)]
+                conf = float(min(98.4, 65.0 + (sum(pixels[c[1]*gw + c[0]] for c in cluster) / len(cluster)) * 1.2))
+                
+                boxes.append({
+                    "id": f"defect_{idx}",
+                    "class": def_name,
+                    "description": def_desc,
+                    "confidence": round(conf, 1),
+                    "box": [round(x1, 1), round(y1, 1), round(x2, 1), round(y2, 1)]
+                })
+                
+            return boxes
+        except Exception as e:
+            print(f"Error in bounding box detection: {e}")
+            return []
+
+    def process_inference(self, outputs: dict, meta: dict, img_bytes: bytes = None) -> tuple:
+        """
+        Process logits, image features, and metadata to generate the final
+        detailed Inspection Report text and a dictionary of analytical metrics.
+        """
+        # Parse logits from PyTorch output
+        defect_logits = outputs.get("defect_logits")
+        severity_logits = outputs.get("severity_logits")
+        
+        # Softmax to get probabilities (simulate if torch doesn't have logits)
+        if HAS_TORCH and isinstance(defect_logits, torch.Tensor):
+            defect_probs = torch.softmax(defect_logits, dim=-1).squeeze().tolist()
+            severity_probs = torch.softmax(severity_logits, dim=-1).squeeze().tolist()
+        else:
+            defect_probs = [0.08] * 12
+            severity_probs = [0.2] * 5
+            
+        # Extract visual details from image if available
+        vis = self._extract_visual_features(img_bytes) if img_bytes else {
+            "edge_intensity": 10.0, "mean_r": 128, "mean_g": 128, "mean_b": 128, "width": 800, "height": 600
+        }
+        
+        edge_intensity = vis["edge_intensity"]
+        
+        # Bias defect probabilities based on visual characteristics and metadata
+        # 1. Biological Growth (driven by Green color bias)
+        g_ratio = vis["mean_g"] / max(1.0, vis["mean_r"] + vis["mean_b"])
+        if g_ratio > 0.55:
+            defect_probs[11] += 0.40 # Biological Growth
+            
+        # 2. Rebar Corrosion (driven by Red/Brown color bias)
+        r_ratio = vis["mean_r"] / max(1.0, vis["mean_g"] + vis["mean_b"])
+        if r_ratio > 0.58:
+            defect_probs[5] += 0.40 # Rebar Corrosion / Rust
+            
+        # 3. Moisture / Seepage (driven by overall dark/blue levels)
+        if vis["mean_b"] > 140 and vis["mean_r"] < 100:
+            defect_probs[8] += 0.35 # Moisture Seepage
+            
+        # 4. Crack categories (driven by high edge intensity)
+        if edge_intensity > 25.0:
+            defect_probs[0] += 0.25 # Longitudinal Crack
+            defect_probs[1] += 0.25 # Transverse Crack
+            defect_probs[2] += 0.20 # Fatigue Crack
+            defect_probs[3] += 0.15 # Spalling
+            
+        # Normalize probabilities
+        def_sum = sum(defect_probs)
+        defect_probs = [p / def_sum for p in defect_probs]
+        
+        # Determine highest probability defect
+        max_defect_idx = defect_probs.index(max(defect_probs))
+        detected_defect = self.defect_classes[max_defect_idx]
+        
+        # Compute dynamic health score (starts at 100, drops based on edge intensity & defect severity)
+        # Higher edge intensity -> lower health score. Heavy corrosion/cracking -> lower health score.
+        severity_score = sum(i * p for i, p in enumerate(severity_probs)) # 0 to 4
+        health_penalty = (edge_intensity * 1.5) + (severity_score * 12.0)
+        
+        # Add metadata-based age penalty (older structures have slightly lower base health)
+        age_str = meta.get("age", "").lower()
+        age_years = 0
+        for word in age_str.split():
+            if word.isdigit():
+                age_years = int(word)
+                break
+        if age_years > 20:
+            health_penalty += min(15.0, age_years * 0.25)
+            
+        health_score = max(5.0, min(100.0, 100.0 - health_penalty))
+        
+        # Risk assessment level based on health score
+        if health_score < 40.0:
+            risk_level = "Critical"
+            verdict = "UNSAFE - High structural hazard. Immediate stabilization required."
+            is_critical_alert = True
+        elif health_score < 65.0:
+            risk_level = "High"
+            verdict = "POTENTIALLY HAZARDOUS - Significant deterioration. Restrict load limit."
+            is_critical_alert = False
+        elif health_score < 85.0:
+            risk_level = "Medium"
+            verdict = "STABLE WITH DEFECTS - Preventive maintenance and repair needed."
+            is_critical_alert = False
+        else:
+            risk_level = "Low"
+            verdict = "STRUCTURALLY SOUND - Negligible anomalies. Maintain standard monitoring."
+            is_critical_alert = False
+
+        # Build list of dynamic defect breakdown for UI
+        defect_breakdown = []
+        for idx, p in enumerate(defect_probs):
+            if p > 0.05: # Report anything above 5% confidence
+                defect_breakdown.append({
+                    "name": self.defect_classes[idx],
+                    "confidence": round(p * 100.0, 1)
+                })
+        defect_breakdown = sorted(defect_breakdown, key=lambda x: x["confidence"], reverse=True)
+        
+        # Get heatmap and boxes
+        heatmap_b64 = self._generate_defect_heatmap(img_bytes) if img_bytes else ""
+        bounding_boxes = self._detect_defect_boxes(img_bytes, edge_intensity) if img_bytes else []
+        
+        # Match detected boxes with classes or populate them if empty
+        if not bounding_boxes:
+            # Fallback boxes if none detected
+            bounding_boxes = [{
+                "id": "defect_0",
+                "class": detected_defect,
+                "description": "Primary structural anomaly detected in the high-contrast surface regions.",
+                "confidence": round(defect_probs[max_defect_idx] * 100, 1),
+                "box": [25.0, 30.0, 75.0, 70.0]
+            }]
+        
+        # Set primary defect name
+        primary_defect = bounding_boxes[0]["class"]
+        primary_confidence = bounding_boxes[0]["confidence"]
+        
+        # Generate the structured Report text for the frontend parser
+        lines = []
+        if is_critical_alert:
+            lines.append("CRITICAL STRUCTURAL WARNING")
+            lines.append("===========================")
+            lines.append("HIGH RISK: EMERGENCY INTERVENTION STRONGLY ADVISED.")
+            lines.append("")
+
+        # Executive Summary
+        lines.append("Executive Summary")
+        lines.append("-----------------")
+        lines.append(f"During visual inspection of the {meta.get('location')}, anomalies were detected. The primary defect identified is {primary_defect} with an estimated model confidence of {primary_confidence}%. Overall, the structure is rated at {round(health_score, 1)}/100 on the Structural Health Index, placing it in a {risk_level.upper()} risk category. {verdict}")
+        lines.append("")
+
+        # Structure Overview
+        lines.append("Structure Overview")
+        lines.append("------------------")
+        lines.append(f"Structure Type: {meta.get('type')}")
+        lines.append(f"Material Type: {meta.get('material')}")
+        lines.append(f"Estimated Age: {meta.get('age')}")
+        lines.append(f"Inspection Zone: {meta.get('location')}")
+        lines.append("")
+
+        # Detected Defects
+        lines.append("Detected Defects")
+        lines.append("----------------")
+        for db in defect_breakdown[:3]:
+            lines.append(f"{db['name']}: {db['confidence']}% Confidence")
+        lines.append("")
+
+        # Root Cause Analysis
+        lines.append("Root Cause Analysis")
+        lines.append("-------------------")
+        if primary_defect == "Longitudinal Crack" or primary_defect == "Transverse Crack" or primary_defect == "Fatigue / Grid Crack":
+            lines.append("Crack propagation is likely driven by thermal stress fatigue, excessive load cycles, or drying shrinkage of the concrete matrix.")
+        elif primary_defect == "Concrete Spalling":
+            lines.append("Spalling occurs due to internal tensile stress, typically generated by the volumetric expansion of corroding steel reinforcement.")
+        elif primary_defect == "Rebar Exposure & Corrosion":
+            lines.append("Carbonation or chloride ingress has compromised the concrete alkaline passivation layer, resulting in rapid steel reinforcement oxidation.")
+        elif primary_defect == "Moisture / Water Seepage" or primary_defect == "Concrete Efflorescence":
+            lines.append("Hydrostatic pressure or poor drainage interfaces are forcing water through capillaries, carrying soluble salts that deposit on the outer face.")
+        else:
+            lines.append("Surface anomalies are driven by environmental erosion, material degradation over time, or dynamic loading variations.")
+        lines.append("")
+
+        # Structural Risk Assessment
+        lines.append("Structural Risk Assessment")
+        lines.append("--------------------------")
+        lines.append(f"Risk Rating: {risk_level}")
+        lines.append(f"Health Score: {round(health_score, 1)} / 100")
+        lines.append(f"Structural Integrity Degradation: {round(100.0 - health_score, 1)}%")
+        lines.append(f"Load Bearing Reduction Required: {'Yes' if health_score < 60.0 else 'No'}")
+        lines.append("")
+
+        # Recoverability Assessment
+        lines.append("Recoverability Assessment")
+        lines.append("-------------------------")
+        if health_score < 30.0:
+            lines.append("Repair Difficulty: High (Structural reinforcement required)")
+            lines.append("Demolition Recommended: Yes (High risk of progressive collapse)")
+        elif health_score < 60.0:
+            lines.append("Repair Difficulty: Moderate (Specialized shoring and grouting required)")
+            lines.append("Demolition Recommended: No")
+        else:
+            lines.append("Repair Difficulty: Low (Standard patch repairs and waterproofing)")
+            lines.append("Demolition Recommended: No")
+        lines.append("")
+
+        # Recommended Repairs
+        lines.append("Recommended Repairs")
+        lines.append("-------------------")
+        if primary_defect == "Longitudinal Crack" or primary_defect == "Transverse Crack" or primary_defect == "Fatigue / Grid Crack":
+            lines.append("1. Epoxy resin pressure injection to seal structural cracks.")
+            lines.append("2. Carbon fiber reinforced polymer (CFRP) wrapping to restore tensile load transfer.")
+        elif primary_defect == "Concrete Spalling":
+            lines.append("1. Remove loose concrete down to sound aggregate.")
+            lines.append("2. Clean rust from steel rebar, apply anti-corrosive coating, and patch with polymer-modified repair mortar.")
+        elif primary_defect == "Rebar Exposure & Corrosion":
+            lines.append("1. Sandblast exposed steel bars to SA 2.5 finish.")
+            lines.append("2. Install sacrificial zinc anodes to control galvanic corrosion, then rebuild section.")
+        elif primary_defect == "Moisture / Water Seepage" or primary_defect == "Concrete Efflorescence":
+            lines.append("1. Inject polyurethane expansion grout to seal leakage pathways.")
+            lines.append("2. Apply crystalline silane/siloxane water-repellent coating to external faces.")
+        else:
+            lines.append("1. Localized surface cleaning and patch repairs.")
+            lines.append("2. Re-apply protective sealants.")
+        lines.append("")
+
+        # Urgent Actions
+        lines.append("Urgent Actions")
+        lines.append("--------------")
+        if health_score < 40.0:
+            lines.append("1. EVACUATE / RESTRICT AREA: Suspend heavy vehicle/load movement immediately.")
+            lines.append("2. SHORING: Install immediate emergency structural props.")
+            lines.append("3. DETAILED INVESTIGATION: Schedule a full core-drilling and ultrasonic inspection.")
+        elif health_score < 65.0:
+            lines.append("1. SHORING: Recommend temporary structural support under damaged sections.")
+            lines.append("2. DETAILED INVESTIGATION: Perform non-destructive testing (NDT) within 7 days.")
+        else:
+            lines.append("1. MONITORING: Review crack widths every 6 months.")
+            lines.append("2. GENERAL REPAIR: Seal cracks during upcoming routine maintenance cycle.")
+        lines.append("")
+
+        # Final Verdict
+        lines.append("Final Verdict")
+        lines.append("-------------")
+        lines.append(f"Verdict: {verdict}")
+
+        report_text = "\n".join(lines)
+        
+        # Prepare JSON analytics payload
+        analysis_data = {
+            "health_score": round(health_score, 1),
+            "risk_level": risk_level,
+            "defects": defect_breakdown[:4],
+            "bounding_boxes": bounding_boxes,
+            "edge_intensity": round(edge_intensity, 2),
+            "color_balance": {
+                "r": round(vis["mean_r"], 1),
+                "g": round(vis["mean_g"], 1),
+                "b": round(vis["mean_b"], 1)
+            }
+        }
+        
+        return report_text, analysis_data, heatmap_b64

requirements.txt

@@ -0,0 +1,6 @@
+flask>=3.0
+torch
+torchvision
+pillow
+gunicorn
+

users.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f81e255e0f7f8df0381362207dece48aaf0603490029f553ba6a29704ef79312
+size 2514944