Upload 7 files

BreakdownFeature.py

@@ -0,0 +1,45 @@
+# Contains only NLP zero-shot classification function codes!
+import sqlite3
+from flask import g
+from transformers import pipeline
+
+# Set up zero-shot classification pipeline
+classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+
+# The main "breakdown" functionality. Performs NLP using zero-shot!
+def breakdown(userStory):
+    
+    # The results are stored into a dictionary variable with predifined labels
+    processedStory = classifier(userStory, candidate_labels=["developer", "tester", "project manager", "system admin"])
+   
+    # Extract labels and scores
+    scores = processedStory['scores']
+    labels = processedStory['labels']
+    
+    # As the index of a score is always equal to its associated label,
+    # We only need to index of the score to find correct label.
+    maxScoreIndex = scores.index(max(scores)) # Gets the index of the highest score/accuracy
+    maxLabel = labels[maxScoreIndex] # Gets the associated label name
+    
+    # Return labels 
+    return maxLabel
+
+# Function to grab all contents in the "Breakdown" table (except for unique ids)
+# If adding any additional attributes to the table, this has to be updated accordingly
+def getBreakdownContents():
+    db = getattr(g, '_database', None) # Gets the _database attribute from the 'g' object. If it does not exist, returns 'None'
+    if db is None:
+        db = g._database = sqlite3.connect('Refineverse.db') # If db is None, create a new connection for db and g._database.
+        cursor = db.cursor() # Creates a cursor object to handle data
+        cursor.execute("SELECT user_story, assignedLabel FROM Breakdown") # The cursor executes the query
+        rows = cursor.fetchall() # Stores the results of fetchall() into a variable
+    return rows
+
+# Function to insert a new row into the "Breakdown" table
+# Using "with" for the connection here seems important, as otherwise it results in an exception
+def insertBreakdownRow(user_story, assigned_label):
+    with sqlite3.connect('Refineverse.db') as conn: # 'With' will automatically take care of closing and opening the connection
+        cursor = conn.cursor()
+        cursor.execute("INSERT INTO Breakdown (user_story, assignedLabel) VALUES (?, ?)", (user_story, assigned_label))
+        conn.commit()
+

Refineverse.py

@@ -0,0 +1,162 @@
+# Plugin will run on this file & Strictly only contains codes for routing between files!
+from flask import Flask, render_template, request, flash, g
+from TextSummarizationFeature import summarize, getTextSumContents, insertTextSumRow
+from BreakdownFeature import breakdown, getBreakdownContents, insertBreakdownRow
+from TranslationFeature import translate_text, switch, getTranslatedContents, insertTranslationRow
+
+app = Flask(__name__)
+app.secret_key = 'refineverseAdmin' # Used to encrypt cookies & sessions
+
+# Routing to Main Dashboard file
+@app.route('/')
+def index():
+    return render_template('RefineverseDashboardUI.html')
+
+
+# Routing to text summarization file
+@app.route('/text_summarization', methods=["POST", "GET"])
+def text_summarization():
+    if request.method == "POST":
+        try:
+            # Grab the user story text from the textarea in html form
+            Entered_story = request.form["input_text"]
+            
+            # The results are stored into a dictionary variable
+            summarizedStory = summarize(Entered_story)
+            
+            flash("Your user story has been summarized!")
+            
+            # Insert into TextSummarization table in Refineverse.db
+            insertTextSumRow(Entered_story, summarizedStory)
+            
+            #Can consider to add View Summarized History feature
+            
+            # Render and display summarized user story
+            return render_template('TextSummarizationUI.html', summarizedStory=summarizedStory)
+        
+        except ValueError as e:
+            if str(e) == "Empty input!":
+                flash("The input text cannot be empty! Please enter a user story.", 'error')
+                return render_template('TextSummarizationUI.html')
+            elif str(e) == "Incorrect format!":
+                flash("Incorrect user story format! Please enter in the right format.", 'error')
+                return render_template('TextSummarizationUI.html')
+            elif str(e) == "Invalid length!":
+                flash("Your inputted user story is too short to summarize. Please enter a longer story!", 'error')
+                return render_template('TextSummarizationUI.html')
+            else:
+                flash("An error of type '{}' occurred: {}".format(type(e).__name__, str(e)), 'error')
+                return render_template('TextSummarizationUI.html')
+        
+        # Not sure in what use-case will a KeyError be hit, but I'll leave this here for now
+        except KeyError:
+            flash("Please enter a valid user story!")
+            return render_template('TextSummarizationUI.html')
+        
+        # Catch-all exception handling
+        except Exception as e:
+            flash("An error of type '{}' occurred: {}".format(type(e).__name__, str(e)), 'error')
+            return render_template('TextSummarizationUI.html')
+    
+    else:
+        return render_template('TextSummarizationUI.html')
+
+
+# Routing to Project Task Breakdown file
+@app.route("/project_breakdown", methods=["POST", "GET"]) # This tells flask the route to get to the page
+def project_breakdown():
+    if request.method == "POST":
+        try:
+            # Grab the user story contents
+            userStory = request.form["user-story-text"]
+            
+            # The results are stored into a dictionary variable
+            processedLabel = breakdown(userStory)
+            
+            # Display success popup message
+            flash("Your user story has been allocated as a " + processedLabel + " task!")
+            
+            insertBreakdownRow(userStory, processedLabel) # Inserts data into the Breakdown table
+            rows = getBreakdownContents() # Grab all contents inside the Breakdown table
+            
+            return render_template('ProjectBreakdownUI.html', rows=rows)
+        
+        # The first matched error will be executed, and all other exception blocks will be skipped.
+        # Thus, please order exceptions from most specific to most general!        
+        except KeyError:
+            flash("Please enter a valid user story!", 'error')
+            rows = getBreakdownContents()
+            return render_template('ProjectBreakdownUI.html', row=rows)
+        
+        # Use this to get the error name and error message, then create a dedicated custom error message!
+        except Exception as e:
+            flash("An error of type '{}' occurred: {}".format(type(e).__name__, str(e)), 'error')
+            rows = getBreakdownContents()
+            return render_template('ProjectBreakdownUI.html', rows=rows)
+        
+    else: # For "GET" scenarios (the loading page, etc.)
+        # To always display the table, we must grab the contents of Breakdown every time the page loads
+        rows = getBreakdownContents()  
+        return render_template('ProjectBreakdownUI.html', rows=rows)
+
+
+# Routing to Translation file
+@app.route('/language_translation', methods=["POST", "GET"])
+def language_translation():
+    if request.method == "POST":
+        try:
+            # Grab all relevant information for processing
+            input_text = request.form['input'] # Grab user text input
+            
+            # Grab source language code
+            source_language = request.form['source_language']
+            
+            # Grab target language code
+            target_language = request.form['target_language']
+            
+            # Generate translated text using custom function
+            translatedStory = translate_text(input_text, source_language, target_language)
+            
+            # Display success popup message
+            flash("Your user story has been translated to " + switch(target_language) + "  !")
+            
+            # Insert into Translation table in Refineverse.db
+            insertTranslationRow(input_text, translatedStory)
+            
+            # Can consider to create a function to view translated history feature
+            
+            # Display the page
+            return render_template('LanguageTranslationUI.html', input_text=input_text, translatedStory=translatedStory)
+        
+        # Exception handling. Important to note that it is neccesary to still return render_template!
+        except ValueError as e:
+            if str(e) == "Empty input!":
+                flash("The input text cannot be empty! Please enter a user story.", 'error')
+                return render_template('LanguageTranslationUI.html')
+            elif str(e) == "Incorrect format!":
+                flash("Unable to translate your user story. Please enter in the correct format.", 'error')
+                return render_template('LanguageTranslationUI.html')
+            else:
+                flash("An error of type '{}' occurred: {}".format(type(e).__name__, str(e)), 'error')
+                return render_template('LanguageTranslationUI.html')
+        
+        except Exception as e:
+            flash("An error of type '{}' occurred: {}".format(type(e).__name__, str(e)), 'error')
+            return render_template('LanguageTranslationUI.html')
+    
+    else:
+        return render_template('LanguageTranslationUI.html') 
+
+
+# Used when the application is torn down
+# Its purpose is to close the database connection if it has not been closed
+@app.teardown_appcontext
+def close_connection(exception):
+    db = getattr(g, '_database', None)
+    if db is not None:
+        db.close() # Closes the database connection
+
+
+# Initialise the app
+if __name__ == '__main__':
+    app.run() # can set to True for debugging

TextSummarizationFeature.py

@@ -0,0 +1,84 @@
+# Contains only NLP text summarization function codes!
+import re # Python's built-in library for regular expressions (or Regex)
+import sqlite3
+from flask import g
+from transformers import pipeline
+
+def summarize(Entered_story):
+    
+    # Check if the input is empty
+    if not Entered_story.strip():
+        raise ValueError("Empty input!")
+    
+    # Validate that the input is in the correct format
+    if not validate_story(Entered_story):
+        raise ValueError("Incorrect format!")
+    
+    # Before we do anything, make sure the input is long enough for summarization.
+    if len(Entered_story) < 200:
+        raise ValueError("Invalid length!")
+    
+    # Set the pipeline to use the correct NLP type and model
+    summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
+        
+    # Take note: The max_length & min_length variables refer to the OUTPUT length!
+    summary = summarizer(Entered_story, max_length=100, min_length=30, do_sample=False)[0]["summary_text"]
+    
+    return summary
+
+
+# User Input Format Validation Function for english only
+def validate_story(Entered_story):
+    pattern = r'As a (?P<role>[^,.]+), I want to (?P<goal>[^,.]+)(,|.)+so that (?P<benefit>.+)'
+    match = re.search(pattern, Entered_story, flags=re.DOTALL)
+    return bool(match)
+
+
+# User Input Format Validation Function for all 4 languages
+#def validate_story(Entered_story):
+    
+    # Pattern for English language
+    #pattern_en = r'As a (?P<role>[^,.]+), I want to (?P<goal>[^,.]+)(,|.)+so that (?P<benefit>.+)'
+    
+    # Pattern for Chinese language
+    #pattern_zh = r'作为(?P<role>[^,.]+)，我想要(?P<goal>[^,.]+)(，|。)+以便(?P<benefit>.+)'
+
+    # Pattern for Malay language
+    #pattern_ms = r'Sebagai(?P<role>[^,.]+), saya mahu(?P<goal>[^,.]+)(,|.)+supaya(?P<benefit>.+)'
+
+    # Pattern for Tamil language
+    #pattern_ta = r'என(?P<role>[^,.]+) எனக்கு வேண்டும்(?P<goal>[^,.]+)(,|.)+அதனால்(?P<benefit>.+) பயன்படுத்தி வைக்கும்'
+
+    # Pattern for Thai language
+    #pattern_th = r'ในฐานะ(?P<role>[^,.]+) ฉันต้องการ(?P<goal>[^,.]+)(,|.)+เพื่อที่ฉัน(?P<benefit>.+)'
+
+    # Try each pattern to see if there is a match
+    #match_en = re.search(pattern_en, Entered_story, flags=re.DOTALL)
+    #match_zh = re.search(pattern_zh, Entered_story, flags=re.DOTALL)
+    #match_ms = re.search(pattern_ms, Entered_story, flags=re.DOTALL)
+    #match_ta = re.search(pattern_ta, Entered_story, flags=re.DOTALL)
+    #match_th = re.search(pattern_th, Entered_story, flags=re.DOTALL)
+
+    # Return True if at least one pattern matches, otherwise False
+    #return bool(match_en or match_zh or match_ms or match_ta or match_th)
+
+
+# Function to grab all contents in the "TextSummarization" table (except for unique ids)
+# If adding any additional attributes to the table, this has to be updated accordingly
+def getTextSumContents():
+    db = getattr(g, '_database', None) # Gets the _database attribute from the 'g' object. If it does not exist, returns 'None'
+    if db is None:
+        db = g._database = sqlite3.connect('Refineverse.db') # If db is None, create a new connection for db and g._database.
+        cursor = db.cursor() # Creates a cursor object to handle data
+        cursor.execute("SELECT Entered_story, summary FROM TextSummarization") # The cursor executes the query
+        rows = cursor.fetchall() # Stores the results of fetchall() into a variable
+    return rows
+
+
+# Function to insert a new row into the "TextSummarization" table
+# Using "with" for the connection here seems important, as otherwise it results in an exception
+def insertTextSumRow( Entered_story, summary):
+    with sqlite3.connect('Refineverse.db') as conn: # 'With' will automatically take care of closing and opening the connection
+        cursor = conn.cursor()
+        cursor.execute("INSERT INTO TextSummarization (Entered_story, summary) VALUES (?, ?)", (Entered_story, summary))
+        conn.commit()

TranslationFeature.py

@@ -0,0 +1,104 @@
+# Contains only NLP translation codes!
+import re
+import sqlite3
+from flask import g
+from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
+
+model = M2M100ForConditionalGeneration.from_pretrained("facebook/m2m100_1.2B") # Setting the model to use
+tokenizer = M2M100Tokenizer.from_pretrained("facebook/m2m100_1.2B") # Setting the tokenizer to use
+
+# Main function of the translation feature. Performs translation!
+def translate_text(input_text, source_language, target_language):
+    
+    # Grabs the source language to be used in the tokenizer
+    tokenizer.src_lang = source_language
+    
+    # Check if the input is empty
+    if not input_text.strip():
+        raise ValueError("Empty input!")
+    
+    # Validate that the input is in the correct format
+    if not validate_input(input_text):
+        raise ValueError("Incorrect format!")
+    
+    # Creates encoded text
+    encoded_text = tokenizer(input_text, return_tensors="pt")
+    
+    # Generates new tokens using encoded text from source language
+    generated_tokens = model.generate(**encoded_text, forced_bos_token_id=tokenizer.get_lang_id(target_language), max_new_tokens=512)
+    
+    # Decode and display text
+    translated_text = tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)[0]
+    
+    return translated_text
+
+
+# Helper function for displaying appropriate language names in flash messages.
+# Note: Python does not have a built-in switch function, so this is just a rough implementation of the logic. 
+def switch(lang):
+    if lang == "en":
+        return "English"
+    elif lang == "zh":
+        return "Chinese"
+    elif lang == "ms":
+        return "Malay"
+    elif lang == "ta":
+        return "Tamil"
+    elif lang == "th":
+        return "Thai"
+
+
+# User Input Format Validation Function for all 4 languages
+def validate_input(input_text):
+    
+    # Pattern for English language
+    pattern_en = r'As a (?P<role>[^,.]+), I want to (?P<goal>[^,.]+)(,|.)+so that (?P<benefit>.+)'
+    
+    # Pattern for Chinese language
+    pattern_zh = r'作为(?P<role>[^,.]+)，我想要(?P<goal>[^,.]+)(，|。)+以便(?P<benefit>.+)'
+
+    # Pattern for Malay language
+    pattern_ms = r'Sebagai(?P<role>[^,.]+), saya mahu(?P<goal>[^,.]+)(,|.)+supaya(?P<benefit>.+)'
+
+    # Pattern for Tamil language
+    pattern_ta = r'என(?P<role>[^,.]+) எனக்கு வேண்டும்(?P<goal>[^,.]+)(,|.)+அதனால்(?P<benefit>.+) பயன்படுத்தி வைக்கும்'
+
+    # Pattern for Thai language
+    pattern_th = r'ในฐานะ(?P<role>[^,.]+) ฉันต้องการ(?P<goal>[^,.]+)(,|.)+เพื่อที่ฉัน(?P<benefit>.+)'
+
+    # Try each pattern to see if there is a match
+    match_en = re.search(pattern_en, input_text, flags=re.DOTALL)
+    match_zh = re.search(pattern_zh, input_text, flags=re.DOTALL)
+    match_ms = re.search(pattern_ms, input_text, flags=re.DOTALL)
+    match_ta = re.search(pattern_ta, input_text, flags=re.DOTALL)
+    match_th = re.search(pattern_th, input_text, flags=re.DOTALL)
+
+    # Return True if at least one pattern matches, otherwise False
+    return bool(match_en or match_zh or match_ms or match_ta or match_th)
+
+#For english language only
+#def validate_input(input_text):
+    #pattern = r'As a (?P<role>[^,.]+), I want to (?P<goal>[^,.]+)(,|.)+so that (?P<benefit>.+)'
+    #match = re.search(pattern, input_text, flags=re.DOTALL)
+    #return bool(match)
+
+
+# Function to grab all contents in the "Translation" table (except for unique ids)
+# If adding any additional attributes to the table, this has to be updated accordingly
+def getTranslatedContents():
+    db = getattr(g, '_database', None) # Gets the _database attribute from the 'g' object. If it does not exist, returns 'None'
+    if db is None:
+        db = g._database = sqlite3.connect('Refineverse.db') # If db is None, create a new connection for db and g._database.
+        cursor = db.cursor() # Creates a cursor object to handle data
+        cursor.execute("SELECT input_text, translated_text FROM Translation") # The cursor executes the query
+        rows = cursor.fetchall() # Stores the results of fetchall() into a variable
+    return rows
+
+
+# Function to insert a new row into the "Translation" table
+# Using "with" for the connection here seems important, as otherwise it results in an exception
+def insertTranslationRow(input_text, translated_text):
+    with sqlite3.connect('Refineverse.db') as conn: # 'With' will automatically take care of closing and opening the connection
+        cursor = conn.cursor()
+        cursor.execute("INSERT INTO Translation (input_text, translated_text) VALUES (?, ?)", (input_text, translated_text))
+        conn.commit()

createDatabase.py

@@ -0,0 +1,36 @@
+# This file is used to create an SQLite database.
+# If adding more tables, you should delete the exising databases, or alter the code here to drop the pre-exising tables first.
+import sqlite3
+
+# Establishes a connection to the specified DB. If the DB does not exist, it creates a new one.
+connection = sqlite3.connect("Refineverse.db")
+cursor = connection.cursor() # A cursor object that is used to handle data.
+
+# Creating the Breakdown table
+cursor.execute('''
+    CREATE TABLE IF NOT EXISTS Breakdown (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_story TEXT,
+        assignedLabel TEXT
+    )
+''')
+
+# Creating the TextSummarization table
+cursor.execute('''
+    CREATE TABLE IF NOT EXISTS TextSummarization (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        Entered_story TEXT,
+        summary TEXT
+    )
+''')
+
+# Creating the Translation table
+cursor.execute('''
+    CREATE TABLE IF NOT EXISTS Translation (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        input_text TEXT,
+        translated_text TEXT
+    )
+''')
+
+connection.close() # Closes the connection