quizMaker.py

import ast
import json as j
import os  # in order to delete and create new files
import sqlite3 as sq  # to make it easier to type
import tkinter as tk
import tkinter.ttk as ttk
from datetime import datetime

import customtkinter as ck

# setting empty variables as colours to avoid problems in VSC
accent = ''
pBG = ''
pFG = ''
fl025 = ''
fl1 = ''
fl2 = ''
al1 = ''


class colourScheme:
    def __init__(self, dir):
        self.dir = dir
        self.default = {
            'accent': '#9747FF',
            'pBG': '#1B1B1B',  # background
            'pFG': '#FFFFFF',  # foreground (e.g. text)
            # focus level 0.25 (more highlighted background)
            'fl025': '#262626',
            'fl1': '#373737',  # focus level 1 (more highlighted fl0.25)
            'fl2': '#585858',  # focus level 2 (more highligted fl1)
            'al1': '#AE98CB'  # accent level 1 (more highlted acccent)
        }
        self.scheme = {}
        self.schemeValidate()
        globals().update(self.scheme)

    def schemeValidate(self):
        # basic check to make sure scheme file exists
        if not os.path.exists(self.dir):
            self.createDefault()
        else:
            with open(self.dir, 'r') as schemeFile:
                try:
                    self.scheme = j.load(schemeFile)
                except Exception as e:
                    # print error instead of crashing
                    print('Could not load scheme from',
                          self.dir, '\nError:', e)
                    # reset scheme as this means that self.dir is corrupt
                    self.createDefault()
                finally:
                    # if file has loaded successfully it now needs to be valid
                    if not self.validity:
                        self.createDefault()

    def createDefault(self):
        # this creates a default schemes.json file
        try:
            with open(self.dir, 'w+') as schemeFile:
                schemeFile.write(j.dumps(self.default, indent=4))
        except Exception as e:
            # if self.dir does not exist (e.g. first startup) it may fail to create scheme file.
            print('Could create default scheme file at', self.dir, '\nError:', e)
        self.scheme = self.default

    def validity(self):
        for key in self.default:
            if key not in self.scheme:
                return False
        return True


colours = colourScheme('data/scheme.json')

# define fonts
counter_font = (
    'Montserrat',
    30,
    "bold"
)

question_font = (
    'Montserrat',
    18,
    'bold'
)

prompt_font = (
    'Poppins',
    16,
    'bold'
)

body_font = (
    'Montserrat',
    14,
    'normal'
)

smaller_font = (
    'Montserrat',
    12,
    'normal'
)


def stringToList(inp):
    return inp[1:-1].strip().split(',')

# Will attempt to create a path, returns true after creating path
# or after verifying path exists, returns false if path cant be
# created


def ifNotExistsCreate(diretory: str):
    # check if the path already exists
    if os.path.exists(diretory):
        # return true to continue
        return True
    else:
        # create directories
        try:
            os.makedirs(diretory)
        except Exception as e:
            print('Could not create directory/directories\nError:', e)
            # dont continue
            return False
        finally:
            # if process is successfull then return true
            return True

# quiz files themselves


class quiz():
    def __init__(self, quizName):
        # will be used later to store files with an appropriate name
        self.name = quizName
        # create connection
        self.connection = sq.connect('quizzes/'+self.name+'.db')
        # create cursor
        self.cursor = self.connection.cursor()
        # define command to create a table
        self.create = """CREATE TABLE IF NOT EXISTS
        quiz(
            qNum INTEGER PRIMARY KEY,
            question TEXT,
            options TEXT,
            answer TEXT,
            qType NUMBER(1)
            )"""  # NUMBER(1) will only allow 0-1 inputs as there is no boolean in sql
        # execute command to create table
        self.cursor.execute(self.create)

    def add(self, qNum, question, options, answer, qType):
        try:
            self.cursor.execute("INSERT INTO quiz VALUES({},{},{},{},{})".format(
                qNum, question, options, answer, qType))
        except Exception as e:
            print('invalid data entered\nError:', e)
        self.connection.commit()

    def results(self):
        self.cursor.execute("SELECT * FROM quiz")
        print(self.cursor.fetchall())

    def delete(self, row):
        try:
            self.cursor.execute("DELETE FROM quiz WHERE qNum = {}".format(row))
            self.connection.commit()
        except:
            print('Cant delete entry, qNum {} may not exist'.format(row))

    # returns questions
    def ask(self, qNum):
        return self.fetchSingle('question', qNum)

    # return options
    def options(self, qNum):
        return stringToList(
            self.fetchSingle('options', qNum)
        )

    # return True For correct answer and False otherwise
    def answer(self, inp, qNum):
        fetch = ast.literal_eval(self.fetchSingle('answer', qNum))
        # debug print
        print(f'fetched: {fetch}\ntype: {type(fetch)}\ninput: {inp}')
        if inp != fetch:
            return False, fetch
        else:
            return True, fetch

    # returns number of questions (highest index) in quiz
    def length(self):
        self.cursor.execute(
            """SELECT MAX(qNum)
            FROM quiz"""
        )
        return self.cursor.fetchone()[0]

    # returns true if all index(s) are present else false
    def validLen(self):
        # Initiate loop that will repeat for every qNum entry.
        # The loop is going backwards as this way it will result in the fastest detection of
        # an empty entry.
        for i in range(self.length() - 1, 0, -1):
            # Start from index lower than highest index
            # because we know that the highest index must exist.
            # Get index
            self.cursor.execute(
                f"""
                SELECT qNum
                FROM quiz
                WHERE qNum = {i}
                """
            )
            # check contents of index, if index returns 'None' it means qNum does not exist.
            if self.cursor.fetchone() == None:
                # this means index does not exist so take early exit
                return False
            # iterate until invalid entry is found
        # after its done iterating with no errors
        return True

    def fetchSingle(self, target, row):
        self.cursor.execute("""SELECT {}
        FROM quiz
        WHERE qNum = {}""".format(target, row))
        return self.cursor.fetchone()[0]

# interface for quizzes


class mainWindow(ck.CTkFrame):
    def __init__(self, master, quiz: quiz, **kwargs):

        super().__init__(master, fg_color=pBG, **kwargs)

        # true if quiz is over
        self.end = False

        # logs
        self.log = quizLog()

        # prompt
        self.prompt_state = False

        # store quiz
        self.quiz = quiz
        # print(quiz)

        # initiate counter at 1
        self.hard_counter = 1

        # f = frame, so fQuestion = frame question
        # rgb colours to see frames more clearly
        self.fQuestion = ck.CTkFrame(
            self, height=100, fg_color=accent, corner_radius=0
        )
        self.fOptions = ck.CTkFrame(
            self, fg_color=pBG, corner_radius=0
        )
        self.fBottom = ck.CTkFrame(
            self, height=60, fg_color=fl1, corner_radius=0
        )

        # set grid weights
        for i in range(3):
            self.grid_columnconfigure(i, weight=1)
        self.grid_rowconfigure(0, weight=0)
        self.grid_rowconfigure(1, weight=1)
        self.grid_rowconfigure(2, weight=0)

        # make sure frame doesnt resize to contents
        self.fQuestion.grid_propagate(False)
        self.fBottom.grid_propagate(False)

        # place frame contents
        self.fillQ(self.fQuestion)

        # set up text wrapping
        self.bind(
            '<Configure>',
            lambda e:
            self.question_label.configure(
                wraplength=self.winfo_width() - 100
            )
        )

        # button to increment counter
        button = tk.Button(
            self.fOptions,
            text='Increment',
            command=self.counter.increment
        )
        # button.pack()

        # place options
        self.fillO(self.fOptions)

        # place next button and misc
        self.fillB(self.fBottom)

        # place frames
        self.fQuestion.grid(row=0, column=0, sticky='ew', columnspan=3)
        self.fOptions.grid(row=1, column=0, sticky='news',
                           columnspan=3, padx=30, pady=10)
        self.fBottom.grid(row=2, column=0, sticky='ew', columnspan=3)

    # fill question frame
    def fillQ(self, frame):
        # configure grid for this frame
        for i in range(2):
            frame.grid_rowconfigure(i, weight=0)
            frame.grid_columnconfigure(i, weight=0)

        # add counter
        self.counter = counter(
            frame,
            fg_color='#FFFFFF',
            bg_colour=fl1,
            x=100,
            y=100,
            font=counter_font
        )
        # sticky to 'west' so that counter sticks all the way at the left.
        self.counter.grid(column=0, row=0, sticky='w')

        # create stringvar containing question
        self.question = tk.StringVar(
            frame,
            self.quiz.ask(self.hard_counter)
        )

        # create label that uses string var
        self.question_label = tk.Label(
            frame,
            textvariable=self.question,
            font=question_font,
            fg=pFG,
            bg=accent
        )

        self.question_label.grid(row=0, column=1, padx=10)

    # fill options frame
    def fillO(self, frame):
        self.button = optFrame(frame, self.quiz.options(self.hard_counter))

    # submit and misc buttons
    def fillB(self, frame):
        # set up grid
        for i in range(1):
            frame.grid_rowconfigure(i, weight=1)
            frame.grid_columnconfigure(i, weight=1)

        self.next_button = nextButton(
            frame, 'Next', True, command=self.increment)
        self.next_button.grid(row=0, column=1, sticky='news', padx=20, pady=15)

    def increment(self):
        # check if we have a prompt,
        # if we dont then show prompt
        # also make sure that the quiz hasnt ended
        if not self.prompt_state and not self.end:
            # print answers
            user_input = self.button.get_states()

            # check if answer is correct and store it
            correct, correct_ans = self.quiz.answer(
                user_input, self.hard_counter)

            # log this
            self.log.add(correct, user_input, correct_ans)

            # delete options
            self.button.remove()

            # show prompt telling the user whether their answer is correct or not
            self.prompt = answerPrompt(
                self.fOptions, correct=correct, font=prompt_font)
            self.prompt.grid(row=0, column=0, sticky='news')
            # tell program that we have a prompt
            self.prompt_state = True

        # if we already have a prompt move to next question
        else:
            # delete prompt
            self.prompt.destroy()
            # tell program we dont have a prompt
            self.prompt_state = False

            # check if we are at the last question
            if self.hard_counter >= self.quiz.length():
                print('Last question reached')
                self.end = True
                # print average
                print(self.log.average())

                # trigger ending
                self.quizEnd()

            # otherwise continue
            else:
                # increment counters
                self.hard_counter += 1
                self.counter.set(self.hard_counter)

                # update question
                self.question.set(self.quiz.ask(self.hard_counter))

                # add options back
                self.fillO(self.fOptions)

        # print logs
        print(self.log)

    def quizEnd(self):
        # delete the 3 frames
        self.fQuestion.destroy()
        self.fOptions.destroy()
        self.fBottom.destroy()

        # reset weights
        for i in range(1, 3):
            self.grid_rowconfigure(i, weight=0)
            self.grid_columnconfigure(i, weight=0)

        # set weights for endFrame
        self.grid_rowconfigure(0, weight=1)
        self.grid_columnconfigure(0, weight=1)

        # create and place endframe
        self.endFrame = endFrame(self, self.log, quizName=self.quiz.name)
        self.endFrame.grid(row=0, column=0, sticky='news')


# used to display answer
class answerPrompt(tk.Frame):

    def __init__(self, master, *, correct: bool, font: tuple, prompt=None):
        tk.Frame.__init__(self, master, bg=pBG)
        self.placeText(correct, font, prompt)

    def placeText(self, correct, font, prompt):
        # create label text
        if correct:
            text = 'Correct!'
            if prompt is None:
                text += '\nYou did great!'
        else:
            text = 'Incorrect.'
            if prompt is None:
                text += '\nWant to have another go?'
        if not prompt is None:
            text += prompt

        # create label
        self.label = tk.Label(self, text=text, font=font, bg=pBG,
                              fg=pFG, justify='center')
        # place label
        self.label.pack(expand=True, fill='both')

# used to log correctness, user answer and actual answer


class quizLog(list):

    # quiz length used to find average
    def __init__(self):
        list.__init__(self)

    # add a new entry in the logs
    def add(self, correct: bool, user_input: list, answer: list):
        self.append(
            {
                'correct': correct,
                'user_input': user_input,
                'answer': answer,
            }
        )

    # get average,
    def average(self):
        # initialise total correct answers
        total_correct = 0
        # initialise total items in list
        total = len(self)
        for dictionary in self:
            if dictionary['correct']:
                # if answer is correct increment total correct answers
                total_correct += 1

        # return average, this may return integer or float.
        return total_correct/total, total_correct, total

    # export log to logs path or specified path
    def export(self, path='logs', quizName='Untitled'):
        # get current date
        # date will be in format: Hour-Minute-Second_Day-Month-Year
        date = datetime.today().strftime('%H-%M-%S_%d-%m-%Y')

        # create path
        if ifNotExistsCreate(path):
            # attempt to save log
            try:
                # open file as write, w+ creates file if it doesnt exist
                with open(f'{path}/{quizName}_{date}.json', 'w+') as log_file:
                    # write as json
                    log_file.write(j.dumps(self, indent=4))
            except Exception as e:
                print('Could not create log file\nError: ', e)


# displays completion percentage and tells user they are finished
class endFrame(tk.Frame):

    def __init__(self, master, log: quizLog, prompt='Quiz completed.', quizName='Untitled'):
        self.padding = 30
        self.log = log
        self.prompt = prompt
        self.name = quizName

        # get quiz values
        self.average, self.total_correct, self.total = self.log.average()

        # initiate self as a frame
        tk.Frame.__init__(self, master, bg=pBG)

        # Configure grids
        self.grid_rowconfigure(3, weight=1)
        self.grid_columnconfigure(0, weight=1)

        # place widgets
        self.placePrompt()
        self.placeBar()
        self.placeTotal()
        self.placeButton()

    def placeBar(self):
        self.progress_bar = ttk.Progressbar(
            self, orient=tk.HORIZONTAL, mode='determinate', value=self.average*100)
        self.progress_bar.grid(
            row=1, column=0, padx=self.padding, sticky='ew')

    def placePrompt(self):
        self.label = tk.Label(
            self, text=self.prompt, justify='left', bg=pBG, fg=pFG, font=prompt_font,
        )
        self.label.grid(row=0, column=0, padx=self.padding,
                        pady=self.padding, sticky='w')

    def placeTotal(self):
        self.total_label = tk.Label(
            self,
            text=f'{self.total_correct}/{self.total} questions correct',
            fg=pFG,
            bg=pBG,
            font=body_font,
        )
        self.total_label.grid(row=2, column=0, sticky='w', padx=self.padding)

    def placeButton(self):
        self.button = nextButton(
            master=self,
            text='Exit',
            color=True,
            font=smaller_font,
            command=self.exit,
        )
        self.button.grid(row=3, column=0, sticky='es',
                         padx=self.padding, pady=self.padding)

    def exit(self):
        self.log.export(quizName=self.name)
        self.destroy()


class nextButton(ck.CTkButton):

    def __init__(self, master, text: str, color: bool, font=None, *, command=None):
        ck.CTkButton.__init__(
            self,
            master,
            text=text
        )

        # color just specifies the style
        # so here the button should be pink
        if color:
            self.configure(
                fg_color=accent,
                hover_color=al1,
                text_color='white',
            )

        # and here it should be grey
        else:
            self.configure(
                fg_color=fl1,
                hover_color=fl2,
                text_color='white',
            )

        # if there is a specified font, use it
        if not font is None:
            self.configure(
                font=font
            )

        # if there is a specified command, use it
        if not command is None:
            self.configure(
                command=command
            )

# creates a counter with a square box


class counter(tk.Frame):
    # x = x dimension (size) y = y dimension (size)
    def __init__(self, master, startNum=1, *, fg_color, bg_colour, x, y, font):
        # create container
        tk.Frame.__init__(
            self,
            master,
            bg=bg_colour,
            width=x,
            height=y
        )

        # stop frame from resizing to its contents
        self.pack_propagate(False)

        # initialise variables, counter is the actual counter and string var is what is displayed
        self.counter = startNum
        self.counter_var = tk.StringVar(self, str(self.counter))

        # create label containig StringVar
        self.label = tk.Label(
            self,
            textvariable=self.counter_var,
            fg=fg_color,
            bg=bg_colour,
            font=font
        )

        # pack frame
        self.label.pack(expand=True, fill='both')

    def increment(self, step=1):
        self.counter += step
        self.counter_var.set(str(self.counter))

    def set(self, value):
        self.counter = value
        self.counter_var.set(str(self.counter))

# Button to select option from quiz


class optionButton(ck.CTkButton):

    def __init__(self, master, text):
        ck.CTkButton.__init__(
            self,
            master,
            text=text,
            fg_color=fl025,
            text_color=pFG,
            corner_radius=15,
            border_width=2,  # creating a border and setting border to be same colour
            # as the background, therefore making it invisible.
            border_color=fl025,
            hover=False,
        )
        # state of the button (toggle)
        self.state = False  # false = off, true = on

        # text wrapping
        self.bind(
            '<Configure>',
            lambda e:
            self._text_label.configure(
                wraplength=self.winfo_width() - 25
            )
        )

        # binding hover and click events

        # set pressed status to be false
        self.pressed = False
        # hover
        self.bind('<Enter>', self.on_hover)
        self.bind('<Leave>', self.out_hover)

        # hold click
        self.bind('<ButtonPress-1>', self.on_click)
        self.bind('<ButtonRelease-1>', self.off_click)

    # change colour on hover
    def on_hover(self, event):
        if not self.pressed and not self.state:
            self.configure(
                border_color=al1,
                fg_color=fl1,
            )

    def out_hover(self, event):
        if not self.pressed and not self.state:
            self.configure(
                border_color=fl025,
                fg_color=fl025
            )

    # change colour on button click
    def on_click(self, event):
        self.pressed = True
        self.configure(
            border_color=pFG,
            fg_color=pFG,
            text_color=pBG,
        )

    def off_click(self, event):
        self.pressed = False
        self.configure(
            border_color=fl025,
            fg_color=fl025,
            text_color=pFG,
        )
        self.button_press()

    # command to execute on button press
    def button_press(self):
        # toggle state
        self.state = not self.state
        # print(f'state: {self.state}')
        if self.state:
            self.configure(
                border_color=accent,
                fg_color=accent,
                text_color=pFG,
            )
        else:
            self.configure(
                border_color=al1,
                fg_color=fl1,
                text_color=pFG,
            )

# Creates an array of buttons and places them


class optFrame:

    def __init__(self, master, option_list):
        self.button_list = []
        self.master = master
        self.option_list = option_list
        self.grid_allignment = self.allign(len(self.option_list))
        self.place_buttons()

    # returns grid coordinates to
    def allign(self, opt_len):

        # i = column, j = row
        j = 0
        output = []
        while opt_len > 0:
            for i in range(2):
                output.append([i, j])
                # decrement numButtons
                opt_len -= 1
            # increment row
            j += 1
        return output

    # set grid weights and place the buttons
    def place_buttons(self):
        # setup grid columns
        self.master.grid_columnconfigure(0, weight=1)
        self.master.grid_columnconfigure(1, weight=1)

        # set up rows
        for i in range(sum(divmod((len(self.option_list)), 2))):
            self.master.grid_rowconfigure(i, weight=1)

        # place buttons
        for index, text in enumerate(self.option_list):
            self.button_list.append(optionButton(self.master, text))

            # place buttons
            self.button_list[index].grid(
                row=self.grid_allignment[index][1],
                column=self.grid_allignment[index][0],
                sticky='news',
                pady=10,
                padx=10,
            )

    def get_states(self):
        output = []
        for i in range(len(self.button_list)):
            output.append(self.button_list[i].state)
        return output

    # remove all options on screen so that they can be redefined
    def remove(self):
        for i in range(len(self.button_list)):
            self.button_list[i].destroy()


# connect to quiz file
compSci = quiz('compSci')

# print(compSci.ask(1))


def testWindow():
    # test window
    root = ck.CTk()
    root.geometry('1280x720')

    # generate an array of test text
    # list1 = []
    # for i in range(5):
    # list1.append(f'test{i}')
    # placeButtons(root, list1)
    # buttons = optFrame(root, list1)

    # set grid up
    for i in range(1):
        root.grid_rowconfigure(i, weight=1)
        root.grid_columnconfigure(i, weight=1)

    frame = mainWindow(root, compSci)
    frame.grid(row=0, column=0, sticky='news')
    # sample log
    # log = quizLog()
    # log.add(False, ['Hello'], ['World'])
    #
    # # make and place main window
    # frame = endFrame(root, log)
    # frame.grid(row=0, column=0, sticky='news')

    root.mainloop()

testWindow()

# compSci.delete(1)
# compSci.add(
#     1,
#     '"Which of these are cat breeds"',
#     '"[Siamese, Golden Retriever, Persian, British Shorthair]"',
#     '"[True, False, True, True]"',
#     1
# )
# print(compSci.answer([False, False, True, True], 1))
#
# compSci.add(
#     2,
#     '"How many countries are there in the UK?"',
#     '"[1, 2, 3, 4]"',
#     '"[False, False, False, True]"',
#     1
# )
#
# compSci.add(
#     3,
#     '"Which country has the highest population?"',
#     '"[Indonesia, Russia, India, China]"',
#     '"[False, False, False, True]"',
#     0
# )
#
# compSci.add(
#     1,
#     '"Which language has the most native speakers?"',
#     '"[English,Spanish]"',
#     '"[False,True]"',
#     0
# )

# test_log = quizLog()
# test_log.add(False, ['Hello'], ['World'])
# test_log.add(True, ['Correct'], ['Answer'])
# test_log.export(quizName='test')