app.py

# test_preloaded_model.py
import gradio as gr
import pickle
import os

# --- Dependencies needed for the Class Definition ---
from transformers import pipeline
import torch

# --- Define the Class to Hold Both Pipelines ---
# IMPORTANT: This exact class definition MUST be present here,
# identical to the one in save_combined_model.py, for unpickling to work.
class CombinedAnalyzer:
    """
    A class to encapsulate sentiment analysis and AI text detection pipelines.
    NOTE: This definition must match the one used when saving the .pkl file.
    """
    def __init__(self, sentiment_model_name="distilbert-base-uncased-finetuned-sst-2-english",
                 detector_model_name="Hello-SimpleAI/chatgpt-detector-roberta"):
        print("Initializing CombinedAnalyzer structure...")
        self.device = 0 if torch.cuda.is_available() else -1
        self.sentiment_model_name = sentiment_model_name
        self.detector_model_name = detector_model_name
        self.sentiment_pipeline = None
        self.detector_pipeline = None
        print(f"Class structure defined. Expecting pipelines for models: {sentiment_model_name}, {detector_model_name}")

    def analyze(self, text):
        """
        Analyzes the input text for both sentiment and authenticity.
        """
        if not isinstance(text, str) or not text.strip():
             return "Error: Input text cannot be empty."
        results = []
        # 1. Sentiment Analysis
        if self.sentiment_pipeline and callable(self.sentiment_pipeline):
            try:
                sentiment_result = self.sentiment_pipeline(text)[0]
                sentiment_label = sentiment_result['label']
                sentiment_score = round(sentiment_result['score'] * 100, 2)
                results.append(f"Sentiment: {sentiment_label} (Confidence: {sentiment_score}%)")
            except Exception as e:
                results.append(f"Sentiment Analysis Error in loaded model: {e}")
        else:
             results.append("Sentiment Analysis: Model not available or not callable in loaded object.")
        # 2. AI Text Detection (Authenticity)
        if self.detector_pipeline and callable(self.detector_pipeline):
            try:
                 detector_result = self.detector_pipeline(text)[0]
                 auth_label_raw = detector_result['label']
                 auth_score = round(detector_result['score'] * 100, 2)
                 if auth_label_raw.lower() in ['chatgpt', 'ai', 'generated']:
                     auth_label_display = "Likely AI-Generated"
                 elif auth_label_raw.lower() in ['human', 'real']:
                      auth_label_display = "Likely Human-Written"
                 else:
                     auth_label_display = f"Label: {auth_label_raw}"
                 results.append(f"Authenticity: {auth_label_display} (Confidence: {auth_score}%)")
            except Exception as e:
                results.append(f"AI Text Detection Error in loaded model: {e}")
        else:
            results.append("Authenticity: AI Text Detector model not available or not callable in loaded object.")
        return "\n".join(results)

# --- Load the Model Automatically on Startup ---
analyzer = None
pickle_filename = "combined_analyzer.pkl"
model_dir = "saved_model"
pickle_filepath = os.path.join(model_dir, pickle_filename)
model_load_error = None # Store potential loading error message

print(f"Attempting to load pre-saved model from: {pickle_filepath}")
try:
    print("\n--- SECURITY WARNING ---")
    print(f"Loading '{pickle_filepath}'. Unpickling data from untrusted sources is a security risk.")
    print("Ensure this .pkl file was created by you or a trusted source.\n")

    if not os.path.exists(pickle_filepath):
        raise FileNotFoundError(f"Model file not found at {pickle_filepath}")
    with open(pickle_filepath, 'rb') as f:
        analyzer = pickle.load(f)
    if not hasattr(analyzer, 'analyze') or not callable(analyzer.analyze):
        raise TypeError("Loaded object is not a valid analyzer (missing 'analyze' method).")
    else:
        print("Model loaded successfully.")
        sentiment_name = getattr(analyzer, 'sentiment_model_name', 'Unknown')
        detector_name = getattr(analyzer, 'detector_model_name', 'Unknown')
        print(f" -> Sentiment Model: {sentiment_name}")
        print(f" -> Detector Model: {detector_name}")

except FileNotFoundError as e:
    model_load_error = f"ERROR loading model: {e}"
    print(model_load_error)
    print("Please ensure 'save_combined_model.py' was run successfully and")
    print(f"the file '{pickle_filename}' exists in the '{model_dir}' directory.")
except (pickle.UnpicklingError, TypeError, AttributeError) as e:
    model_load_error = f"ERROR loading model: The pickle file might be corrupted, incompatible, or from a different version. Details: {e}"
    print(model_load_error)
except Exception as e:
    model_load_error = f"An unexpected ERROR occurred during model loading: {e}"
    print(model_load_error)

# --- Define the Gradio Analysis Function ---
def analyze_text_interface(text_input):
    """Function called by Gradio to perform analysis using the pre-loaded model."""
    if analyzer is None:
        # Use the stored error message if available
        error_msg = model_load_error or f"ERROR: The analyzer model could not be loaded from '{pickle_filepath}'."
        return error_msg
    if not text_input or not text_input.strip():
        return "Please enter some text to analyze."
    print(f"Analyzing text: '{text_input[:60]}...'")
    try:
        results = analyzer.analyze(text_input)
        print("Analysis complete.")
        return results
    except Exception as e:
        print(f"Error during analysis: {e}")
        return f"An error occurred during analysis:\n{e}"

# --- Build the Gradio Interface ---

# **CORRECTION HERE:** Define the warning message string separately
warning_message_text = ""
if analyzer is None:
    # Use newline characters safely outside the f-string expression
    warning_message_text = "\n\n***WARNING: MODEL FAILED TO LOAD. ANALYSIS WILL NOT WORK.***"

# Construct the full description string
description_text = (
    f"Enter text to analyze using the pre-loaded model from '{pickle_filepath}'.\n"
    "Checks for sentiment (Positive/Negative) and predicts if text is Human-Written or AI-Generated."
    f"{warning_message_text}" # Use the variable here
)

interface = gr.Interface(
    fn=analyze_text_interface,
    inputs=gr.Textbox(lines=7, label="Text to Analyze", placeholder="Enter review text here..."),
    outputs=gr.Textbox(lines=7, label="Analysis Results", interactive=False),
    title="Sentiment & Authenticity Analyzer",
    description=description_text, # Use the constructed description string
    allow_flagging='never'
)

# --- Launch the Interface ---
if __name__ == "__main__":
    if analyzer is None:
        print("\n--- Interface launched, but MODEL IS NOT LOADED. Analysis will fail. ---")
    else:
        print("\n--- Launching Gradio Interface with pre-loaded model ---")
    interface.launch()