Char

Complexity

Total Complexity

6

Size/Duplication

Total Lines	21
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	get_std()	0	3	1
A	add_interval()	0	2	1
A	get_intervals()	0	2	1
A	__init__()	0	3	1
A	get_mean()	0	3	1
A	get_symbol()	0	2	1

import tkinter as tk
import time
import matplotlib.pyplot as plt
import numpy as np

class KeyStats(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Key stats")
        row = 0
        tk.Label(self,
                 text="""Click button to start and Enter to stop 
                 recording""").grid(row=row,
                                    columnspan=2,
                                    padx=10,
                                    pady=10)
        self.status_text = tk.Label(self,
                                    foreground="red",
                                    text="")
        row += 1
        self.status_text.grid(row=row,
                             columnspan=2,
                             padx=10,
                             pady=10)

        self.stats_text = tk.Label(self,
                              text="")
        row += 1
        self.stats_text.grid(row=row,
                             columnspan=2,
                             padx=10,
                             pady=10)

        row += 1
        tk.Button(self,
                  text="Start recording",
                  command=self.toggle_status).grid(row=row,
                                                   column=0,
                                                   padx=10,
                                                   pady=10)
        tk.Button(self,
                  text="Start simulation",
                  command=self.simulate).grid(row=row,
                                              column=1,
                                              padx=10,
                                              pady=10)

        self.textbox = tk.Text(self)
        row += 1
        self.textbox.grid(row=row,
                          columnspan=2,
                          padx=10,
                          pady=10)
        
        
        self.bind("<Key>", self.key)
        self.times = []
        self.chars = []
        self.status = False
        self.after(500, self.update_status)

    def update_status(self):
        if self.status:
            if self.status_text['text'] == 'Recording':
                self.status_text['text'] =''
            else: self.status_text['text'] = 'Recording'
        else:
            self.status_text['text'] =''
        
        self.update()
        self.after(500, self.update_status)
        
    def initialize(self):
        self.textbox.delete(1.0, tk.END)
        self.chars = []
        self.times = []

        
    def toggle_status(self):
        self.status = not self.status
        if not self.status:
            self.times.append(time.time())
            self.plot_histogram()
            self.plot_char_stats()
        else:
            print("Started recording")
            self.initialize()
            self.textbox.focus_set()

    def plot_char_stats(self):
        if len(self.chars) < 2:
            return
        # Generate char dictionary
        intervals = self.times[1:] - self.times[:-1]
        char_dict = {}
        for i in range(len(self.chars)):
            char = self.chars[i]
            if repr(char) in char_dict:
                char_dict[repr(char)].add_interval(intervals[i])
            else:
                char_dict[repr(char)] = Char(repr(char), intervals[i])

        # Build bar plot of chars
        means = []
        stds = []
        labels = []
        for k,v in char_dict.items():
            labels.append(v.get_symbol())
            means.append(v.get_mean())
            stds.append(v.get_std())

        
        ind = np.arange(len(labels))  # the x locations for the bars
        width = 0.7
        fig, ax = plt.subplots()
        rects = ax.bar(ind, means, width, color='r', yerr=stds)

        ax.set_ylabel('Mean interval [ms]')
        ax.set_title('Key specific interval lengths')
        plt.xticks(ind + 0.5*width, labels, rotation=60)
        
        #ax.set_xticklabels(labels)
        plt.show()
        

    def plot_histogram(self):
        if len(self.chars) < 2:
            self.initialize()
            print("Press keys at least twice")
            return
        self.times = np.array(self.times)
        intervals = self.times[1:] - self.times[:-1]
        print("Mean key press interval: {}".format(np.mean(intervals)))
        print("Standard deviation of key press interval: {}".format(np.std(intervals)))
        orig_mu = np.mean(intervals)
        orig_sigma = np.std(intervals)
        intervals = np.log(intervals)
        mu = np.mean(intervals)
        sigma = np.std(intervals)
        print("You typed {} characters.".format(len(intervals)+1))
        print("Mean of log of key press interval: {}".format(mu))
        print("Standard deviation of log of key press interval: {}".format(sigma))
        bins = int(len(intervals)/10)
        n, bins, patches = plt.hist(np.exp(intervals), normed=1,
                                    facecolor='green', alpha=0.75)
        l = plt.plot(bins, self.lognorm_pdf(bins, mu, sigma), 'r--', linewidth=1)
        plt.xlabel('Key press interval [s]')


        plt.ylabel('Normalized frequency')
        plt.title("""Key press interval stats: 
        mean = {:.2f} s, std = {:.2f} s""".format(orig_mu,
                                                  orig_sigma))
        #plt.axis([40, 160, 0, 0.03])
        plt.grid(True)

        # Calculate char-wise stats
        

    def lognorm_pdf(self, x, mu, sigma):
        y = 1/(x*sigma*np.sqrt(2*np.pi))*np.exp(-(np.log(x)-mu)**2/(2*sigma**2))
        return y
    
    def update_stats_text(self):
        if len(self.times) < 2:
            return
        times = np.array(self.times)
        intervals = times[1:] - times[:-1] 
        orig_mu = np.mean(intervals)
        orig_sigma = np.std(intervals)
        self.stats_text['text'] = """Chars: {:d}, 
        Mean: {:d} ms, Std: {:d} ms""".format(len(self.times),
                                              int(1000 * orig_mu),
                                              int(1000 * orig_sigma))

    def simulate(self):
        times = np.array(self.times)
        intervals = times[1:] - times[:-1]
        intervals = np.log(intervals)
        mu = np.mean(intervals)
        sigma = np.std(intervals)
        intervals = np.exp(sigma * np.random.randn( len(self.chars)-1) + mu)
        self.textbox.delete(1.0, tk.END)
        self.textbox.insert(tk.END, self.chars[0])
        self.update()
        for i in range(len(intervals)):
            time.sleep(intervals[i])
            # Backspace
            if self.chars[i+1] == chr(8):
                self.textbox.delete('%s-2c' % tk.END, tk.END)
            else:
                self.textbox.insert(tk.END, self.chars[i+1])
            self.update()

    def key(self, event):
        if event.char == '\r':
            self.toggle_status()
        elif self.status:
            self.record(event.char)
            
    def record(self, key):
        self.times.append(time.time())
        self.chars.append(key)
        self.update_stats_text()

class Char:
    def __init__(self, symbol, interval):
        self.intervals = [interval]
        self.symbol = symbol

    def get_symbol(self):
        return str(self.symbol) + ' ' + str(len(self.get_intervals()))

    def get_intervals(self):
        return self.intervals
    
    def add_interval(self, interval):
        self.intervals.append(interval)

    def get_mean(self):
        # Value in milliseconds
        return 1000 * np.mean(np.array(self.get_intervals()))
        
    def get_std(self):
        # Value in milliseconds
        return 1000 * np.std(np.array(self.get_intervals()))
        
app = KeyStats()
app.mainloop()