Update app.py

app.py

@@ -1,125 +1,26 @@
 import gradio as gr
-import torch
-import torch.nn as nn
-import pickle
-import numpy as np
+import os
 
-# ---------------------------------------------------------
-# 1. Define the Neural Network Architecture
-# ---------------------------------------------------------
-# Since your file is an OrderedDict, we must define the class 
-# that matches the layers inside it. 
-# I am assuming a standard 5-input architecture based on your feature extractor.
-class PhishingNet(nn.Module):
-    def __init__(self, input_size=5, hidden_size=10, output_size=2):
-        super(PhishingNet, self).__init__()
-        self.fc1 = nn.Linear(input_size, hidden_size)
-        self.relu = nn.ReLU()
-        self.fc2 = nn.Linear(hidden_size, output_size)
-        
-    def forward(self, x):
-        out = self.fc1(x)
-        out = self.relu(out)
-        out = self.fc2(out)
-        return out
-
-# ---------------------------------------------------------
-# 2. Load Resources (Model + Scaler)
-# ---------------------------------------------------------
-MODEL_PATH = "models/phishing_rf_model.pt"
-SCALER_PATH = "models/scaler.pkl"
-
-model = None
-scaler = None
-load_status = ""
-
-try:
-    # --- Load Scaler ---
-    with open(SCALER_PATH, "rb") as f:
-        scaler = pickle.load(f)
-    load_status += "✅ Scaler loaded.\n"
-
-    # --- Load Model Weights ---
-    # We load the weights (OrderedDict)
-    state_dict = torch.load(MODEL_PATH, map_location=torch.device('cpu'))
+def inspect_file():
+    path = "models/scaler.pkl"
     
-    # We create the structure. 
-    # NOTE: If this crashes with "Shape Mismatch", we will catch it below.
-    model = PhishingNet()
-    model.load_state_dict(state_dict)
-    model.eval() # Set to evaluation mode
-    load_status += "✅ Model weights loaded into Neural Net.\n"
-
-except Exception as e:
-    load_status += f"❌ LOAD ERROR: {str(e)}\n"
-    print(load_status)
-
-# ---------------------------------------------------------
-# 3. Feature Extraction (Must match your Scaler!)
-# ---------------------------------------------------------
-def extract_features(url: str) -> np.ndarray:
-    length = len(url)
-    dots = url.count('.')
-    hyphens = url.count('-')
-    digits = sum(c.isdigit() for c in url)
-    at_sign = url.count('@')
+    if not os.path.exists(path):
+        return f"❌ File not found at: {path}"
     
-    # Return shape [1, 5]
-    return np.array([[length, dots, hyphens, digits, at_sign]], dtype=float)
-
-# ---------------------------------------------------------
-# 4. Prediction Logic
-# ---------------------------------------------------------
-def predict_phishing(url):
-    # Check if things loaded correctly
-    if model is None or scaler is None:
-        return {"Error": 0}, f"System not ready.\n{load_status}"
-        
-    if not url:
-        return None, "Please enter a URL."
-
+    # Read the file as plain text to see if it's an LFS pointer
     try:
-        # 1. Extract
-        features = extract_features(url)
-        
-        # 2. Scale (Using your scaler)
-        features_scaled = scaler.transform(features)
-        
-        # 3. Convert to Torch Tensor
-        features_tensor = torch.tensor(features_scaled, dtype=torch.float32)
-        
-        # 4. Predict
-        with torch.no_grad():
-            logits = model(features_tensor)
-            probs = torch.nn.functional.softmax(logits, dim=1)
-            
-            # Assume Index 0 = Safe, Index 1 = Phishing
-            safe_conf = float(probs[0][0])
-            phish_conf = float(probs[0][1])
-
-        return {"✅ Safe": safe_conf, "🚨 Phishing": phish_conf}, "Success"
-
-    except Exception as e:
-        return {"Error": 0}, f"Prediction Failed: {str(e)}"
-
-# ---------------------------------------------------------
-# 5. UI Setup
-# ---------------------------------------------------------
-with gr.Blocks(theme=gr.themes.Soft()) as iface:
-    gr.Markdown("# 🛡️ PhishScope (Custom Model)")
-    
-    with gr.Row():
-        url_input = gr.Textbox(label="URL to Check", placeholder="https://example.com")
-        submit_btn = gr.Button("Analyze", variant="primary")
-        
-    with gr.Row():
-        label_output = gr.Label(label="Result")
-        debug_output = gr.Textbox(label="System Status", value=load_status, lines=4)
-
-    submit_btn.click(
-        fn=predict_phishing,
-        inputs=url_input,
-        outputs=[label_output, debug_output]
-    )
-
-iface.launch()
+        with open(path, "r", encoding="utf-8") as f:
+            content = f.read(200) # Read first 200 characters
+            return f"⚠️ FILE CONTENT (Read as Text):\n\n{content}\n\n(If you see 'version https://git-lfs...', this is a FAKE file.)"
+    except UnicodeDecodeError:
+        # If it fails to read as text, that's actually GOOD news (it might be binary)
+        file_size = os.path.getsize(path)
+        return f"✅ Good News! The file is binary (not text). Size: {file_size} bytes."
+
+with gr.Blocks() as demo:
+    gr.Markdown("# File Inspector")
+    btn = gr.Button("Check Scaler File")
+    out = gr.Textbox(label="Result")
+    btn.click(fn=inspect_file, inputs=None, outputs=out)
+
+demo.launch()