first commit v1.1

Author: anshumalivfx

.DS_Store

@@ -0,0 +1,78 @@
+import tkinter as tk
+from tkinter import messagebox
+from core import generate_questions, generate_pdf
+import pandas as pd
+
+df = pd.read_csv('sample_questions/Questions100_Abstractions.csv')
+df['question'] = df['question'].replace('\n','<br />', regex=True)
+
+class QuestionGenerator:
+    def __init__(self):
+        self.root = tk.Tk()
+        self.root.title("Question Paper Generator Abstraction")
+        self.radio_var = tk.StringVar()
+        self.radio_var.set("Easy")  # Set the default value
+
+        self.create_widgets()
+
+    def generate_pdf(self):
+        pdf_name = self.output_name_entry.get().strip()
+        
+        
+        
+        if pdf_name:
+            selected_option = self.radio_var.get()
+            ques = df[df['level'] == selected_option]
+            # Add code here to generate the PDF with the selected option and the pdf_name
+            number_of_papers = int()
+            if self.num_papers_entry.get().strip():
+                if self.num_papers_entry.get().strip().isdigit():
+                    number_of_papers = int(self.num_papers_entry.get().strip())
+                    print("number of")
+                else:
+                    messagebox.showerror("Error", "Please enter a valid number of papers.")
+            else:
+                number_of_papers = 1
+            print(number_of_papers)
+            for i in range(0, number_of_papers):
+                questions = generate_questions.generate_question(input_ques=ques)
+                
+                generate_pdf.generate_pdf(questions, pdf_name=f'{pdf_name}_{i+1}')
+        else:
+            messagebox.showerror("Error", "Please enter a valid PDF name.")
+
+    def create_widgets(self):
+        # Radio buttons
+        option1_radio = tk.Radiobutton(self.root, text="Easy", variable=self.radio_var, value="easy")
+        option2_radio = tk.Radiobutton(self.root, text="Medium", variable=self.radio_var, value="medium")
+        option3_radio = tk.Radiobutton(self.root, text="Hard", variable=self.radio_var, value="hard")
+
+
+        num_papers_label = tk.Label(self.root, text="Number of papers you want to generate:")
+        self.num_papers_entry = tk.Entry(self.root)
+        
+        # Output PDF name entry field
+        output_name_label = tk.Label(self.root, text="Output PDF Name:")
+        self.output_name_entry = tk.Entry(self.root)
+
+        # Generate Button
+        generate_button = tk.Button(self.root, text="Generate PDF", command=self.generate_pdf)
+
+        # Layout using grid
+        option1_radio.grid(row=0, column=0, padx=10, pady=5)
+        option2_radio.grid(row=1, column=0, padx=10, pady=5)
+        option3_radio.grid(row=2, column=0, padx=10, pady=5)
+
+        num_papers_label.grid(row=3, column=0, padx=10, pady=5)
+        self.num_papers_entry.grid(row=3, column=1, padx=10, pady=5)
+        
+        output_name_label.grid(row=4, column=0, padx=10, pady=5)
+        self.output_name_entry.grid(row=4, column=1, padx=10, pady=5)
+
+        generate_button.grid(row=5, column=0, columnspan=2, padx=10, pady=10)
+
+    def run(self):
+        # Start the main event loop
+        self.root.mainloop()
+
+

README.md

@@ -0,0 +1,29 @@
+import jinja2
+import pdfkit
+import os
+import sys
+
+def get_wkhtmltopdf_path() -> str:
+    if sys.platform.startswith('linux'):
+        # Linux
+        return '/usr/local/bin/wkhtmltopdf'
+    elif sys.platform.startswith('darwin'):
+        # macOS
+        return '/usr/local/bin/wkhtmltopdf'
+    elif sys.platform.startswith('win'):
+        # Windows
+        return r'C:\Program Files\wkhtmltopdf\bin\wkhtmltopdf.exe'
+    else:
+        raise OSError("Unsupported operating system. Please install wkhtmltopdf and set the path manually.")
+
+
+template = jinja2.Environment(loader=jinja2.FileSystemLoader(os.path.join(os.path.dirname(__file__), 'template')))
+template = template.get_template('index.html')
+
+wkhtmltopdf_path = get_wkhtmltopdf_path()
+conf = pdfkit.configuration(wkhtmltopdf=wkhtmltopdf_path)
+
+def generate_pdf(questions, pdf_name):
+    html = template.render(questions=questions)
+    pdfkit.from_string(html, f'{pdf_name}.pdf')
+    return True

__pycache__/app.cpython-39.pyc

@@ -0,0 +1,100 @@
+import pandas as pd
+from pandas import DataFrame
+import re
+import random
+import string
+from parrot import Parrot
+
+
+parrot = Parrot(model_tag="prithivida/parrot_paraphraser_on_T5", use_gpu=False)
+
+
+
+def modify_question(ques: str) -> str:
+    # Regular expressions to match variable, class, and function names
+    variable_pattern:str = r'\b(int|double|float|char|bool)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*;'
+    class_pattern:str = r'\bclass\s+([a-zA-Z_][a-zA-Z0-9_]*)\b'
+    function_pattern:str = r'\b(int|double|float|char|bool)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\((.*)\)\s*{'
+    inherit_pattern:str = r'\bclass\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*public\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*{'
+    # new object created pattern eg :- B b;
+    new_object_pattern:str = r'\b([a-zA-Z_][a-zA-Z0-9_]*)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*;'
+    # Objects calling functions pattern eg :- b.func();
+    object_function_pattern:str = r'\b([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\s*\((.*)\)\s*;'
+    
+    function_declaration_pattern:str = r'\b(int|double|float|char|bool|void)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\((.*)\)\s*;'
+    pattern = r"(?i)(?:what|how|when|why|which|who|whom|where|can|do|is)\s.*[?].*"
+    
+    
+    # Function to generate random word
+    def generate_random_word() -> str:
+        prefix:str = random.choice(['Alpha', 'Beta', 'Gamma', 'Delta', 'Epsilon', 'Zeta', 'Eta', 'Theta'])
+        suffix = ''.join(random.choices(string.ascii_uppercase, k=random.randint(1, 3)))
+        return f'{prefix}{suffix}'
+    
+    def random_letter() -> str:
+        return random.choice(string.ascii_lowercase)
+    
+
+    # Replace variable, class, and function names with random words
+    # Does code have classes
+    replaced_code = ques
+    
+    
+    if re.search(pattern, ques):
+        # Replace class names with random words
+        questions = re.findall(pattern, ques)
+        print(questions[0])
+        new_questions = parrot.augment(input_phrase=questions[0], use_gpu=False)
+        # choose any random from the new_questions that is a list of tuples 
+        if new_questions:
+            new_question = random.choice(new_questions)
+            new_question = new_question[0]
+            replaced_code = re.sub(pattern, new_question, ques)
+    
+    
+    if re.search(class_pattern, ques):
+        # Replace class names with random words
+        new_class_name = generate_random_word()
+        replaced_code = re.sub(class_pattern, 'class ' + new_class_name, ques)
+        
+        # Does code have inheritance
+        if re.search(inherit_pattern, replaced_code):
+            # Replace inheritance names with random words
+            replaced_code = re.sub(inherit_pattern, 'class ' + generate_random_word() + ' : public ' + new_class_name, replaced_code)
+    # Doe
+    # Does code have functions
+    if re.search(function_pattern, replaced_code):
+        # Replace function names with random words
+        replaced_code = re.sub(function_pattern, 'int ' + generate_random_word() + '()', replaced_code)
+        
+    # Does code have function declarations
+    if re.search(function_declaration_pattern, replaced_code):
+        # Replace function names with random words
+        replaced_code = re.sub(function_declaration_pattern, 'int ' + generate_random_word() + '();', replaced_code)
+        
+    # Does code have variables
+    if re.search(variable_pattern, replaced_code):
+        # Replace variable names with random words
+        replaced_code = re.sub(variable_pattern, 'int ' + random_letter() + ';', replaced_code)
+        
+    # Does code have new objects
+    if re.search(new_object_pattern, replaced_code):
+        # Replace new object names with random words with new class names
+        object_name = random_letter()
+        replaced_code = re.sub(new_object_pattern, new_class_name + ' ' + object_name + ';', replaced_code)
+    
+    # Does code have objects calling functions
+    if re.search(object_function_pattern, replaced_code):
+        # Replace object names with random words
+        replaced_code = re.sub(object_function_pattern, object_name + '.' + generate_random_word() + '();', replaced_code)
+    return replaced_code
+
+
+
+def generate_question(input_ques: DataFrame) -> str:
+    print("Hello")
+    ques:str = ""
+    for i in range(len(input_ques)):
+        ques += f"Q.{i+1} " + modify_question(input_ques.iloc[i]['question']) + "<br/><br/>" + "A." + str(input_ques.iloc[i]['a']) + "<br/>" + "B." + str(input_ques.iloc[i]['b']) + "<br />" + "C." + str(input_ques.iloc[i]['c']) + "<br/>" + "D." + str(input_ques.iloc[i]['d']) + "<br /><br/>"
+
+    return ques