Initial commit for TREAT project

README.md

@@ -0,0 +1,198 @@
+![Treat_Banner](static/images/readme-images/New_Treat_Banner.png)
+
+<h1 align="center">
+  Trigger Recognition for Enjoyable and Appropriate Television
+</h1>
+
+<p align="center">
+<img src="https://img.shields.io/static/v1?label=Kuberwastaken&message=TREAT&color=blue&logo=github" alt="Kuberwastaken - TREAT">
+<img src="https://img.shields.io/badge/version-2.0-blue" alt="Version 2.0">
+<img src="https://img.shields.io/badge/License-Apache_2.0-blue" alt="License Apache 2.0">
+</p>
+
+I was tired of getting grossed out watching unexpected scenes in movies and TV and losing my appetite, that's why I created TREAT.
+
+The goal of this project is to empower viewers by forewarning them about potential triggers in the content they watch, making the viewing experience more enjoyable, inclusive, and appropriate for everyone.
+
+TREAT is a web application that uses natural language processing to analyze movie and TV show scripts, identifying potential triggers to help viewers make informed choices.
+
+## Installation Instructions
+### Prerequisites
+ - Star the Repository to Show Your Support.
+ - Clone the Repository to Your Local Machine:
+
+    ```bash
+   git clone https://github.com/Kuberwastaken/TREAT.git
+    ```
+
+### Hugging Face Login Instructions for Llama-3.2-1B Model
+To use the [Llama-3.2-1B model](https://huggingface.co/meta-llama/Llama-3.2-1B), which provides a 35% increase in accuracy and efficiency over the [previous model](https://github.com/Kuberwastaken/TREAT-CS50), you must request access for it, as it is a gated model.
+
+   ![Request_Accesss_Page](static/images/readme-images/Request-Access-Page.png)
+
+1. **Login to Hugging Face in Your Environment:**
+
+    Run the following command in your terminal:
+
+    ```bash
+    huggingface-cli login
+    ```
+
+    Enter your Hugging Face access token when prompted.
+
+2. **Download the Llama-3.2-1B Model:**
+
+   The model will be downloaded automatically when running the script analysis for the first time, provided you have received access.
+
+### Environment Setup
+To set up the development environment, you will need to create a virtual environment and install the necessary dependencies.
+
+1. Create a Virtual Environment:
+
+   ```bash
+   python3 -m venv treat-env
+   ```
+
+2. Activate the Virtual Environment:
+
+   ```bash
+   source treat-env/bin/activate   # On Unix or MacOS
+   treat-env\Scriptsctivate      # On Windows
+   ```
+
+3. Install Dependencies:
+
+   Navigate to the project directory and run:
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Project Usage
+1. **Start the Flask Server:**
+
+   ```bash
+   python run.py
+   ```
+
+2. **Open Your Browser:** 
+
+   Navigate to `http://127.0.0.1:5000` to access the TREAT web interface.
+
+3. **Analyze Scripts:**
+
+   You can manually enter a script in the provided text area and click "Analyze Script."
+
+## File Descriptions
+- **app.py:** The main Flask application file that handles routing.
+
+- **app/routes.py:** Contains the Flask routes for handling script uploads.
+
+- **app/model.py:** Includes the script analysis functions using the Llama-3.2-1B model.
+
+- **templates/index.html:** The main HTML file for the web interface.
+
+- **static/css/style.css:** Custom CSS for styling the web interface.
+
+- **static/js/app.js:** JavaScript for handling client-side interactions.
+
+## Types of Triggers Detected
+The TREAT application focuses on identifying a variety of potential triggers in scripts, including but not limited to:
+
+- **Violence:** Scenes of physical aggression or harm.
+
+- **Self-Harm:** Depictions of self-inflicted injury.
+
+- **Death:** Depictions of death or dying characters.
+
+- **Sexual Content:** Any depiction or mention of sexual activity, intimacy, or behavior.
+
+- **Sexual Abuse:** Instances of sexual violence or exploitation.
+
+- **Gun Use:** Depictions of firearms and their usage.
+
+- **Gore:** Graphic depiction of injury, blood, or dismemberment.
+
+- **Vomit:** Depictions of vomiting or nausea-inducing content.
+
+- **Mental Health Issues:** Depictions of mental health struggles, including anxiety, depression, or disorders.
+
+- **Animal Cruelty:** Depictions of harm or abuse towards animals.
+
+These categories help address a very real-world problem by forewarning viewers about potentially distressing content, enhancing their viewing experience.
+
+Adding new categories is as simple as specifying a new category under model.py and utils.py
+
+## Design Choices
+
+- **Inspiration:** I aimed for a simple and intuitive user experience, focusing on simplicity and ease of use. This decision stemmed from the need to create a tool that is easy to navigate for all users, regardless of background or age.
+
+- **Theme and Color Scheme:** The chosen theme and color scheme create a visually appealing and engaging environment. The chocolate and sweets theme is intended to stick to the TREAT theme and make the experience enjoyable and pleasant.
+
+- **Script Analysis:** The Llama-3.2-1B model by Meta was chosen for its increased accuracy (about 35% better) compared to the prior FLAN-T5 version. The decision was based on its ability to provide precise trigger recognition while being open source. As a new and advanced model, it enhances the script analysis capabilities significantly.
+
+## How to Edit Sensitivity Settings or Prompts
+
+To adjust the sensitivity or modify the prompts used during script analysis, you can edit the `model.py` file located under the `treat/app` directory. This file contains various parameters and settings that control how triggers are identified and how the model processes the script. Here’s how you can adjust key settings:
+
+### Key Parameters to Edit:
+
+
+   - **max_new_tokens**: Controls the maximum number of tokens (words or characters) the model will generate in response to a prompt. A higher number can lead to more detailed results but may also increase processing time.
+
+   - **temperature**: Controls the randomness of the model's responses. A value of 1.0 means standard behavior, while lower values (e.g., 0.2) make the model's output more deterministic and focused. Higher values (e.g., 1.5) allow for more creative or varied responses.
+
+   - **top_p** (Nucleus Sampling): Controls how many of the top predicted tokens are considered during text generation. A value of 0.9 means the model will only consider the top 90% of predictions, cutting off the least likely options. A lower value can make the output more coherent but less creative.
+
+   To adjust these, look for `max_new_tokens`, `temperature`, and `top_p` in the `model.py` file and set them to your desired values. For example:
+   ```python
+   max_new_tokens = 10  # Set the maximum number of tokens
+   temperature = 0.7  # A moderate level for balanced responses
+   top_p = 0.9  # Adjust the diversity of the output
+   ```
+
+### Chunk Size and Overlap:
+To handle long scripts effectively, the text is divided into chunks before being analyzed. Adjusting the chunk size and overlap helps control how much of the script is processed at once and ensures that the model doesn't miss context between chunks.
+
+- **chunk_size**: This parameter defines the length of each chunk in tokens. A larger chunk size can help the model capture more context, but may result in higher memory usage and processing time. A smaller chunk size may process faster but could lose context.
+  
+- **overlap**: This parameter defines the number of overlapping tokens between consecutive chunks. Adding overlap ensures that context from the end of one chunk is carried over to the next chunk, preventing the model from losing important information.
+
+   To adjust these, look for `chunk_size` and `overlap` in `model.py` and set them to your desired values:
+   ```python
+   chunk_size = 1000  # Set the length of each chunk (tokens)
+   overlap = 200  # Set the number of overlapping tokens between chunks
+   ```
+
+### Adjusting Prompts:
+To modify the types of triggers detected by the model, you can edit the prompts under the `trigger_categories` section in `model.py`. This section allows you to adjust how the model recognizes various types of content in the script. Simply modify the prompts to suit your needs.
+
+### Summary of Editable Parameters:
+- **max_new_tokens, temperature, top_p**: Control the length, randomness, and diversity of the model's output.
+- **chunk_size, overlap**: Control how the script is divided into chunks and how context is maintained between chunks.
+- **trigger_categories**: Adjust the prompts to change how triggers are identified in the script.
+
+
+## To-Do List
+- Integration with an API to Directly Search Scripts by Name of Movies/Shows
+
+- Introduce multiple themes to allow users to customize the appearance of the application according to their preferences
+
+- Increasing speed and efficiency
+
+- Potentially host this online
+
+- Make the application mobile-friendly
+
+## Open Source Contribution
+This repository is completely open source and free to contribute. I intend to keep this project alive and evolve it into a tool that's extremely usable for all. Contributions are welcome and highly encouraged to add new features, improve the user interface, or enhance the script analysis.
+
+## Acknowledgements
+I would like to thank:
+
+- Meta AI: For developing and allowing me access to the Llama-3.2-1B model, a very critical component of this project.
+
+- Parasite (2019): For that unexpected jumpscare that ruined my appetite and ultimately inspired this project.
+
+## License
+This project is licensed under the [Apache 2.0 License](https://github.com/Kuberwastaken/TREAT/blob/main/LICENSE).

app/__init__.py

@@ -0,0 +1,21 @@
+from flask import Flask
+from flask_cors import CORS
+import os
+
+# Get the absolute path for the template and static folders
+base_dir = os.path.abspath(os.path.dirname(__file__))
+template_dir = os.path.join(base_dir, "../../templates") # Path to the templates folder
+static_dir = os.path.join(base_dir, "../../static") # Path to the static folder
+
+# Create an instance of the Flask class with the specified template and static folders
+app = Flask(
+    __name__,
+    template_folder=template_dir,
+    static_folder=static_dir
+)
+
+# Enable Cross-Origin Resource Sharing (CORS) for the app
+CORS(app)
+
+# Import routes after initializing the Flask app to avoid circular import issues
+from app import routes

app/routes.py

@@ -0,0 +1,24 @@
+from flask import Flask, request, jsonify, render_template
+from app import app
+from app.model import analyze_script
+
+# Define the home route which renders the index.html template
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+# Define the upload route to handle POST requests for script analysis
+@app.route('/upload', methods=['POST'])
+def upload_script():
+    try:
+        # Get the JSON data from the request
+        data = request.get_json()
+        # Extract the text content from the JSON data
+        content = data.get('text', '')
+        # Analyze the script for triggers
+        triggers = analyze_script(content)
+        # Return the triggers in a JSON response
+        return jsonify({"triggers": triggers})
+    except Exception as e:
+        # Handle any exceptions and return an error message
+        return jsonify({"error": str(e)}), 500

app/run.py

@@ -0,0 +1,12 @@
+import sys
+from os.path import dirname, abspath
+
+# Add the directory of the 'treat' folder to the system path
+sys.path.append(abspath(dirname(__file__)) + "/treat")
+
+# Import the Flask app from the app module
+from app import app
+
+if __name__ == '__main__':
+    # Run the Flask app with debug mode enabled
+    app.run(debug=True)

gradio_app.py

@@ -0,0 +1,8 @@
+import gradio as gr
+from model.model import get_detailed_analysis
+
+def analyze_script(script):
+    return get_detailed_analysis(script)
+
+iface = gr.Interface(fn=analyze_script, inputs="text", outputs="json")
+iface.launch()

model/model.py

@@ -0,0 +1,223 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+from datetime import datetime
+
+def analyze_script(script):
+    # Starting the script analysis
+    print("\n=== Starting Analysis ===")
+    print(f"Time: {datetime.now()}")  # Outputting the current timestamp
+    print("Loading model and tokenizer...")
+
+    try:
+        # Load the tokenizer and model, selecting the appropriate device (CPU or CUDA)
+        tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B", use_fast=True)
+        device = "cuda" if torch.cuda.is_available() else "cpu"  # Use CUDA if available, else use CPU
+        print(f"Using device: {device}")
+
+        model = AutoModelForCausalLM.from_pretrained(
+            "meta-llama/Llama-3.2-1B",
+            torch_dtype=torch.float16 if device == "cuda" else torch.float32,  # Use 16-bit precision for CUDA, 32-bit for CPU
+            device_map="auto"  # Automatically map model to available device
+        )
+        print("Model loaded successfully")
+
+      # Define trigger categories with their descriptions
+        trigger_categories = {
+            "Violence": {
+                "mapped_name": "Violence",
+                "description": (
+                    "Any act involving physical force or aggression intended to cause harm, injury, or death to a person, animal, or object. "
+                    "Includes direct physical confrontations (e.g., fights, beatings, or assaults), implied violence (e.g., very graphical threats or descriptions of injuries), "
+                    "or large-scale events like wars, riots, or violent protests."
+                )
+            },
+            "Death": {
+                "mapped_name": "Death References",
+                "description": (
+                    "Any mention, implication, or depiction of the loss of life, including direct deaths of characters, including mentions of deceased individuals, "
+                    "or abstract references to mortality (e.g., 'facing the end' or 'gone forever'). This also covers depictions of funerals, mourning, "
+                    "grieving, or any dialogue that centers around death, do not take metaphors into context that don't actually lead to death."
+                )
+            },
+            "Substance Use": {
+                "mapped_name": "Substance Use",
+                "description": (
+                    "Any explicit or implied reference to the consumption, misuse, or abuse of drugs, alcohol, or other intoxicating substances. "
+                    "Includes scenes of drinking, smoking, or drug use, whether recreational or addictive. May also cover references to withdrawal symptoms, "
+                    "rehabilitation, or substance-related paraphernalia (e.g., needles, bottles, pipes)."
+                )
+            },
+            "Gore": {
+                "mapped_name": "Gore",
+                "description": (
+                    "Extremely detailed and graphic depictions of highly severe physical injuries, mutilation, or extreme bodily harm, often accompanied by descriptions of heavy blood, exposed organs, "
+                    "or dismemberment. This includes war scenes with severe casualties, horror scenarios involving grotesque creatures, or medical procedures depicted with excessive detail."
+                    "only answer yes if you're completely certain."
+                )
+            },
+            "Vomit": {
+                "mapped_name": "Vomit",
+                "description": (
+                    "Any explicit reference to vomiting, whether directly described, implied, or depicted. This includes detailed sounds, visual descriptions, mentions of nausea explicitly leading to vomiting, or any aftermath involving vomit." 
+                    "Respond 'yes' only if the scene unambiguously and clearly involves vomiting, with no room for doubt."
+                )
+            },
+            "Sexual Content": {
+                "mapped_name": "Sexual Content",
+                "description": (
+                    "Any depiction or mention of sexual activity, intimacy, or sexual behavior, ranging from implied scenes to explicit descriptions. "
+                    "This includes romantic encounters, physical descriptions of characters in a sexual context, sexual dialogue, or references to sexual themes (e.g., harassment, innuendos)."
+                )
+            },
+            "Sexual Abuse": {
+               "mapped_name": "Sexual Abuse",
+               "description": (
+                  "Any form of non-consensual sexual act, behavior, or interaction, involving coercion, manipulation, or physical force. "
+                  "This includes incidents of sexual assault, molestation, exploitation, harassment, and any acts where an individual is subjected to sexual acts against their will or without their consent. "
+                  "It also covers discussions or depictions of the aftermath of such abuse, such as trauma, emotional distress, legal proceedings, or therapy. "
+                  "References to inappropriate sexual advances, groping, or any other form of sexual misconduct are also included, as well as the psychological and emotional impact on survivors. "
+                  "Scenes where individuals are placed in sexually compromising situations, even if not directly acted upon, may also fall under this category."
+                  "only answer yes if you're completely certain of it's presence."
+                )
+            },
+            "Self-Harm": {
+                "mapped_name": "Self-Harm",
+                "description": (
+                    "Any mention or depiction of behaviors where an individual intentionally causes harm to themselves. This includes cutting, burning, or other forms of physical injury, "
+                    "as well as suicidal ideation, suicide attempts, or discussions of self-destructive thoughts and actions. References to scars, bruises, or other lasting signs of self-harm are also included."
+                    "only answer yes if you're completely certain."
+                )
+            },
+            "Gun Use": {
+                "mapped_name": "Gun Use",
+                "description": (
+                    "Any explicit or implied mention of firearms being handled, fired, or used in a threatening manner. This includes scenes of gun violence, references to shootings, "
+                    "gun-related accidents, or the presence of firearms in a tense or dangerous context (e.g., holstered weapons during an argument)."
+                )
+            },
+            "Animal Cruelty": {
+                "mapped_name": "Animal Cruelty",
+                "description": (
+                    "Any act of harm or abuse toward animals, whether intentional or accidental. This includes physical abuse (e.g., hitting, injuring, or killing animals), "
+                    "mental or emotional mistreatment (e.g., starvation, isolation), and scenes where animals are subjected to pain or suffering for human entertainment or experimentation."
+                    "Respond 'yes' only if the scene unambiguously and clearly involves Animal Cruelty, with no room for doubt"
+                )
+            },
+            "Mental Health Issues": {
+                "mapped_name": "Mental Health Issues",
+                "description": (
+                    "Any reference to mental health struggles, disorders, or psychological distress. This includes mentions of depression, anxiety, PTSD, bipolar disorder, schizophrenia, "
+                    "or other conditions. Scenes depicting destructive coping mechanisms are also included."
+                    "like a character expressing feelings of worthlessness, hopelessness, or detachment from reality."
+                )
+            }
+        }
+
+        print("\nProcessing text...")  # Output indicating the text is being processed
+        chunk_size = 256  # Set the chunk size for text processing
+        overlap = 15  # Overlap between chunks for context preservation
+        script_chunks = []  # List to store script chunks
+
+        # Split the script into smaller chunks
+        for i in range(0, len(script), chunk_size - overlap):
+            chunk = script[i:i + chunk_size]
+            script_chunks.append(chunk)
+        
+        print(f"Split into {len(script_chunks)} chunks with {overlap} token overlap")  # Inform about the chunking
+
+        identified_triggers = {}  # Dictionary to store the identified triggers
+
+        # Process each chunk of the script
+        for chunk_idx, chunk in enumerate(script_chunks, 1):
+            print(f"\n--- Processing Chunk {chunk_idx}/{len(script_chunks)} ---")
+            print(f"Chunk text (preview): {chunk[:50]}...")  # Preview of the current chunk
+            
+            # Check each category for triggers
+            for category, info in trigger_categories.items():
+                mapped_name = info["mapped_name"]
+                description = info["description"]
+
+                print(f"\nAnalyzing for {mapped_name}...")
+                prompt = f"""
+                Check this text for any indication of {mapped_name} ({description}).
+                Be sensitive to subtle references or implications, make sure the text is not metaphorical.
+                Respond concisely with: YES, NO, or MAYBE.
+                Text: {chunk}
+                Answer:
+                """
+
+                print(f"Sending prompt to model...")  # Indicate that prompt is being sent to the model
+                inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)  # Tokenize the prompt
+                inputs = {k: v.to(device) for k, v in inputs.items()}  # Send inputs to the chosen device
+
+                with torch.no_grad():  # Disable gradient calculation for inference
+                    print("Generating response...")  # Indicate that the model is generating a response
+                    outputs = model.generate(
+                        **inputs,
+                        max_new_tokens=10,  # Limit response length
+                        do_sample=True,  # Enable sampling for more diverse output
+                        temperature=0.5,  # Control randomness of the output
+                        top_p=0.9,  # Use nucleus sampling
+                        pad_token_id=tokenizer.eos_token_id  # Pad token ID
+                    )
+                
+                response_text = tokenizer.decode(outputs[0], skip_special_tokens=True).strip().upper()  # Decode and format the response
+                first_word = response_text.split("\n")[-1].split()[0] if response_text else "NO"  # Get the first word of the response
+                print(f"Model response for {mapped_name}: {first_word}")
+
+                # Update identified triggers based on model response
+                if first_word == "YES":
+                   print(f"Detected {mapped_name} in this chunk!")  # Trigger detected
+                   identified_triggers[mapped_name] = identified_triggers.get(mapped_name, 0) + 1
+                elif first_word == "MAYBE":
+                   print(f"Possible {mapped_name} detected, marking for further review.")  # Possible trigger detected
+                   identified_triggers[mapped_name] = identified_triggers.get(mapped_name, 0) + 0.5
+                else:
+                   print(f"No {mapped_name} detected in this chunk.")  # No trigger detected
+
+        print("\n=== Analysis Complete ===")  # Indicate that analysis is complete
+        print("Final Results:")
+        final_triggers = []  # List to store final triggers
+
+        # Filter and output the final trigger results
+        for mapped_name, count in identified_triggers.items():
+            if count > 0.5:
+                final_triggers.append(mapped_name)
+            print(f"- {mapped_name}: found in {count} chunks")
+
+        if not final_triggers:
+            print("No triggers detected")  # No triggers detected
+            final_triggers = ["None"]
+
+        print("\nReturning results...")
+        return final_triggers  # Return the list of detected triggers
+
+    except Exception as e:
+        # Handle errors and provide stack trace
+        print(f"\nERROR OCCURRED: {str(e)}")
+        print("Stack trace:")
+        import traceback
+        traceback.print_exc()
+        return {"error": str(e)}
+
+def get_detailed_analysis(script):
+    print("\n=== Starting Detailed Analysis ===")
+    triggers = analyze_script(script)  # Call the analyze_script function
+    
+    if isinstance(triggers, list) and triggers != ["None"]:
+        result = {
+            "detected_triggers": triggers,
+            "confidence": "High - Content detected",
+            "model": "Llama-3.2-1B",
+            "analysis_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+    else:
+        result = {
+            "detected_triggers": ["None"],
+            "confidence": "High - No concerning content detected",
+            "model": "Llama-3.2-1B",
+            "analysis_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+
+    print("\nFinal Result Dictionary:", result)  # Output the final result dictionary
+    return result

requirements.txt

@@ -0,0 +1,5 @@
+flask
+flask_cors
+torch
+transformers
+accelerate

static/css/style.css

@@ -0,0 +1,222 @@
+/* Chocolate and sweets theme for TREAT */
+
+/* Set up the main styles for the body of the document */
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; /* font */
+    margin: 0; /* Remove default margin */
+    padding: 0; /* Remove default padding */
+    background-color: #836853; /* Background color resembling chocolate */
+    color: #FFFFFF; /* White text color for contrast */
+    height: 100vh; /* Full viewport height */
+    display: flex; /* Flexbox layout for centering content */
+    flex-direction: column; /* Column layout */
+    justify-content: center; /* Center content vertically */
+    align-items: center; /* Center content horizontally */
+    overflow: hidden; /* Hide overflow content */
+}
+
+/* Style the container for the main content */
+.choco-container {
+    background: rgba(78, 52, 46, 0.9); /* Semi-transparent dark chocolate background */
+    box-shadow: 0 8px 32px 0 rgba(0, 0, 0, 0.37); /* Soft shadow effect */
+    border-radius: 20px; /* Rounded corners */
+    padding: 40px; /* Padding inside the container */
+    width: 90%; /* 90% width of the viewport */
+    max-width: 1000px; /* Maximum width */
+    height: 80%; /* 80% height of the viewport */
+    animation: fadeIn 1s ease-in-out; /* Fade-in animation */
+    border: 1px solid #5d4037; /* Slightly lighter chocolate border */
+    display: flex; /* Flexbox layout for centering content */
+    flex-direction: column; /* Column layout */
+    align-items: center; /* Center content horizontally */
+    justify-content: center; /* Center content vertically */
+}
+
+/* Define the fade-in animation for the container */
+@keyframes fadeIn {
+    from {
+        opacity: 0; /* Start with no opacity */
+        transform: scale(0.95); /* Start slightly scaled down */
+    }
+    to {
+        opacity: 1; /* Fade to full opacity */
+        transform: scale(1); /* Scale to full size */
+    }
+}
+
+/* Style the header of the document */
+.header {
+    text-align: center; /* Center-align text */
+    margin-bottom: 20px; /* Margin below the header */
+}
+
+/* Style the main heading */
+.header h1 {
+    font-size: 3rem; /* Large font size */
+    color: #d7ccc8; /* Light creamy color */
+}
+
+/* Style the paragraph under the heading */
+.header p {
+    font-size: 1.5rem; /* Medium font size */
+    color: #ffab91; /* Candy-like color */
+}
+
+/* Highlight certain text */
+.highlight {
+    color: #ff7043; /* Sweet orange color */
+}
+
+/* Style the main content area */
+.main-content {
+    width: 100%; /* Full width */
+    height: 100%; /* Full height */
+    display: flex; /* Flexbox layout */
+    flex-direction: column; /* Column layout */
+    align-items: center; /* Center content horizontally */
+    justify-content: center; /* Center content vertically */
+}
+
+/* Style the form */
+.sweet-form {
+    width: 100%; /* Full width */
+    height: 100%; /* Full height */
+    display: flex; /* Flexbox layout */
+    flex-direction: column; /* Column layout */
+    align-items: center; /* Center content horizontally */
+    justify-content: center; /* Center content vertically */
+}
+
+/* Style the textarea element */
+textarea {
+    width: 100%; /* Full width */
+    height: 70%; /* 70% height of the container */
+    padding: 20px; /* Padding inside the textarea */
+    font-size: 1.2rem; /* Medium font size */
+    border: none; /* Remove default border */
+    border-radius: 10px; /* Rounded corners */
+    resize: none; /* Disable resizing */
+    background: #3e2723; /* Chocolate color background */
+    color: #ffecb3; /* Creamy color text */
+    box-shadow: inset 0 0 10px rgba(0, 0, 0, 0.5); /* Inset shadow */
+    transition: all 0.3s ease-in-out; /* Smooth transition for all properties */
+}
+
+/* Style the textarea when it is focused */
+textarea:focus {
+    outline: none; /* Remove default outline */
+    box-shadow: 0 0 15px #ffab91; /* Light glow when focused */
+}
+
+/* Style the button element */
+button {
+    width: 50%; /* 50% width of the container */
+    padding: 20px; /* Padding inside the button */
+    font-size: 1.5rem; /* Large font size */
+    margin-top: 20px; /* Margin above the button */
+    background: linear-gradient(45deg, #8d6e63, #d7ccc8); /* Chocolate gradient background */
+    color: white; /* White text color */
+    border: none; /* Remove default border */
+    border-radius: 10px; /* Rounded corners */
+    cursor: pointer; /* Pointer cursor on hover */
+    text-transform: uppercase; /* Uppercase text */
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.5); /* Soft shadow */
+    transition: all 0.3s ease; /* Smooth transition for all properties */
+    position: relative; /* Relative positioning for overlay effects */
+}
+
+/* Style the button on hover */
+button:hover {
+    background: linear-gradient(45deg, #d7ccc8, #8d6e63); /* Reversed gradient on hover */
+    box-shadow: 0 8px 20px rgba(0, 0, 0, 0.6); /* Stronger shadow on hover */
+}
+
+/* Create an overlay effect for the button */
+button::after {
+    content: ''; /* Empty content */
+    position: absolute; /* Absolute positioning */
+    top: 0; /* Position at the top */
+    left: 0; /* Position at the left */
+    width: 100%; /* Full width */
+    height: 100%; /* Full height */
+    background: rgba(255, 255, 255, 0.1); /* Light overlay */
+    border-radius: 10px; /* Rounded corners */
+    opacity: 0; /* Initially hidden */
+    transition: opacity 0.3s ease; /* Smooth transition for opacity */
+}
+
+/* Show the overlay effect on hover */
+button:hover::after {
+    opacity: 1; /* Show overlay on hover */
+}
+
+/* Style the loading bar element */
+.loading-bar {
+    display: none; /* Initially hidden */
+    width: 100%; /* Full width */
+    height: 5px; /* Fixed height */
+    background: linear-gradient(90deg, #8d6e63, #d7ccc8); /* Chocolate gradient background */
+    margin-top: 20px; /* Margin above the loading bar */
+    border-radius: 2px; /* Slightly rounded corners */
+    overflow: hidden; /* Hide overflow content */
+    position: relative; /* Relative positioning */
+}
+
+/* Create an animation for the loading bar */
+.loading-bar::before {
+    content: ''; /* Empty content */
+    position: absolute; /* Absolute positioning */
+    width: 100%; /* Full width */
+    height: 100%; /* Full height */
+    background: linear-gradient(90deg, rgba(255, 255, 255, 0.4), rgba(255, 255, 255, 0)); /* Gradient background */
+    animation: loading-animation 2s infinite; /* Infinite loading animation */
+}
+
+/* Define the loading animation */
+@keyframes loading-animation {
+    0% {
+        transform: translateX(-100%); /* Start outside on the left */
+    }
+    50% {
+        transform: translateX(0); /* Move to the center */
+    }
+    100% {
+        transform: translateX(100%); /* Move outside on the right */
+    }
+}
+
+/* Style the results container */
+#results {
+    overflow-x: auto; /* Add horizontal scrollbar only if needed */
+    overflow-y: hidden; /* Hide vertical overflow */
+    margin-top: 30px; /* Margin above the results */
+    color: #ff7043; /* Sweet orange color */
+    font-size: 1.5rem; /* Large font size */
+    font-weight: bold; /* Bold text */
+    text-shadow: 0 0 5px #ff7043, 0 0 10px #ff7043; /* Reduced shininess */
+    text-align: center; /* Center-align text */
+    word-wrap: break-word; /* Ensure text wraps appropriately */
+    overflow-wrap: break-word; /* Compatibility with other browsers */
+    padding: 10px; /* Padding inside the results container */
+    box-sizing: border-box; /* Include padding in width calculations */
+    white-space: nowrap; /* Prevent line breaks so horizontal scrolling is possible */
+}
+
+/* Style the horizontal scrollbar */
+#results::-webkit-scrollbar {
+    height: 10px; /* Horizontal scrollbar height */
+}
+
+/* Style the scrollbar thumb */
+#results::-webkit-scrollbar-thumb {
+    background: linear-gradient(45deg, #8d6e63, #d7ccc8); /* Chocolate gradient for scrollbar thumb */
+    border-radius: 5px; /* Rounded corners */
+}
+
+/* Style the scrollbar track */
+#results::-webkit-scrollbar-track {
+    background: rgba(78, 52, 46, 0.5); /* Lighter chocolate track */
+    border-radius: 5px;
+}
+
+/* To Fix: Title moving upwards when Output is shown*/

static/images/site.webmanifest

@@ -0,0 +1,14 @@
+{
+    "name": "",
+    "short_name": "",
+    "icons": [
+       {
+          "src": "/android-chrome-192x192.png",
+          "sizes": "192x192",
+          "type": "image/png"
+       }
+    ],
+    "theme_color": "#FFFFFF",
+    "background_color": "#FFFFFF",
+    "display": "standalone"
+ }

static/js/app.js

@@ -0,0 +1,36 @@
+// Add an event listener for the form submission
+document.getElementById('text-form').addEventListener('submit', async function(event) {
+    event.preventDefault(); // Prevent the default form submission behavior
+
+    const text = document.getElementById('text-input').value; // Get the text input value
+    const loadingBar = document.getElementById('loading-bar'); // Get the loading bar element
+    const resultsDiv = document.getElementById('results'); // Get the results div element
+    resultsDiv.textContent = ''; // Clear previous results
+    loadingBar.style.display = 'block'; // Display the loading bar
+
+    try {
+        // Make a POST request to the server with the text input
+        const response = await fetch('/upload', {
+            method: 'POST', // Use the POST method
+            headers: {
+                'Content-Type': 'application/json' // Set the Content-Type header
+            },
+            body: JSON.stringify({ text: text }) // Convert the text to JSON and send it in the request body
+        });
+
+        // Check if the response is not ok (status code outside the range 200-299)
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`); // Throw an error with the status code
+        }
+
+        // Parse the JSON response from the server
+        const result = await response.json();
+        resultsDiv.innerHTML = `<span>Triggers:</span> ${result.triggers.join(', ')}`; // Display the triggers in the results div
+    } catch (error) {
+        // Handle any errors that occurred during the request
+        console.error('Error analyzing text:', error); // Log the error to the console
+        resultsDiv.innerHTML = '<span>Error:</span> Unable to analyze text.'; // Display an error message in the results div
+    } finally {
+        loadingBar.style.display = 'none'; // Hide the loading bar once the request is complete
+    }
+});

templates/index.html

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0"> <!-- Ensure proper scaling on mobile devices -->
+    <title>TREAT</title> <!-- Page title -->
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}"> <!-- Link to external stylesheet -->
+
+    <!-- Favicon and Apple Touch Icons -->
+ <link rel="apple-touch-icon" sizes="180x180" href="./static/images/apple-touch-icon.png">
+ <link rel="icon" type="image/png" sizes="32x32" href="./static/images/favicon-32x32.png">
+ <link rel="icon" type="image/png" sizes="16x16" href="./static/images/favicon-16x16.png">
+ <link rel="manifest" href="./static/images/site.webmanifest">
+
+</head>
+<body>
+    <div class="choco-container"> <!-- Main container with chocolate theme -->
+        <header class="header"> <!-- Header section -->
+            <h1>TREAT</h1> <!-- Main heading -->
+            <p> <!-- Subheading with acronym explanation -->
+                <span class="highlight">T</span>rigger 
+                <span class="highlight">R</span>ecognition for 
+                <span class="highlight">E</span>njoyable and 
+                <span class="highlight">A</span>ppropriate 
+                <span class="highlight">T</span>elevision
+            </p>
+        </header>
+        <main class="main-content"> <!-- Main content section -->
+            <form id="text-form" method="POST" class="sweet-form"> <!-- Form for text input -->
+                <textarea id="text-input" name="text" rows="20" placeholder="Enter your text or script here..."></textarea> <!-- Textarea for user input -->
+                <button type="submit">Analyze Script</button> <!-- Submit button -->
+            </form>
+            <div id="loading-bar" class="loading-bar"></div> <!-- Loading bar displayed during analysis -->
+            <div id="results"></div> <!-- Div to display results -->
+        </main>
+    </div>
+    <script src="{{ url_for('static', filename='js/app.js') }}"></script> <!-- Link to external JavaScript file -->
+</body>
+</html>

utils/utils.py

@@ -0,0 +1,38 @@
+def identify_triggers(outputs):
+    # Initialize a set to store identified triggers
+    identified_triggers = set()
+
+    # Iterate over the model outputs
+    for response_text in outputs:
+        # Check if the response contains a positive indication of the category
+        if "yes" in response_text.lower():
+            # Extract the category from the response_text
+            category = extract_category(response_text)
+            if category:
+                identified_triggers.add(category)
+    
+    # Convert the set of identified triggers to a list and return it
+    return list(identified_triggers)
+
+def extract_category(response_text):
+    # Define trigger categories
+    trigger_categories = [
+        "Violence",
+        "Self-Harm",
+        "Death",
+        "Substance Use"
+        "Sexual Content"
+        "Sexual Abuse",
+        "Gun Use",
+        "Gore",
+        "Vomit", 
+        "Mental Health Issues"
+        "Animal Cruelty"
+    ]
+    
+    # Check if any category is present in the response_text
+    for category in trigger_categories:
+        if category.lower() in response_text.lower():
+            return category
+    # Return None if no category is found
+    return None