MinimPy Code
Brought to you by:
msaghaei
Menu
▾
▴
Diff of /minimpy.py [000000] .. [r1] Maximize Restore
Switch to side-by-side view
--- a +++ b/minimpy.py @@ -0,0 +1,1047 @@ +#! /usr/bin/env python +# -*- coding: utf-8 -*- + +import sys +import pickle +import random +import tempfile +import functions +from model import Model +from minimclass import Minim + +try: + import pygtk + pygtk.require("2.0") + import gobject +except: + print("pygtk Not Availible") + sys.exit(1) +try: + import gtk +except: + print("GTK Not Availible") + sys.exit(1) + +class ModelInteface(object): + def close_window(self, widget, data=None): + if self.trial_file_name: + self.save_trial(self.trial_file_name) + self.window.destroy() + if __name__ == "__main__": + sys.exit(0) + + def delete_event(self, widget, event): + if self.trial_file_name: + self.save_trial(self.trial_file_name) + self.window.destroy() + if __name__ == "__main__": + sys.exit(0) + + def group_cell_edited(self, cell, row, new_text, col): + if col == 0: + # names must not be repeated + for r in range(len(self.group_liststore)): + if r != row and new_text == self.group_liststore[r][0]: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Group name already in use! Choose another name!") + return False + if len(new_text) == 0: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Group name can not be empty!") + return False + if col == 1: + if not new_text.isdigit(): + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Allocation ratio must be an integer!") + return False + new_text = int(new_text) + if not new_text: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Allocation ratio must be zero!") + return False + self.group_liststore[row][col] = new_text + self.update_allocations() + + def group_add_button(self, widget, data=None): + self.group_liststore.append(('Group {0}'.format(len(self.group_liststore)+1), 1)) + self.update_allocations() + + def group_delete_button(self, widget, data=None): + if self.group_treeview.get_cursor()[0]: + row = self.group_treeview.get_cursor()[0][0] + self.group_liststore.remove(self.group_liststore.get_iter(row)) + for idx, record in enumerate(self.allocations): + if record['allocation'] == row: + self.ui_pool.append(self.allocations[idx]['UI']) + self.allocations[idx] = False + elif record['allocation'] > row: + record['allocation'] -= 1 + self.allocations = filter(None, self.allocations) + self.update_allocations() + else: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Please select a group first!") + return False + + def variable_cell_edited(self, cell, row, new_text, col): + if col == 0: + for r in range(len(self.variable_liststore)): + if r != row and new_text == self.variable_liststore[r][0]: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: This variable name already in use! Choose another name!") + return False + if len(new_text) == 0: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Variable names can not be empty!") + return False + if col == 1: + new_text = float(new_text) + if not new_text: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Variable weight can not be zero!") + return False + if col == 2: + # check for deleting a level + old_levels = self.variable_liststore[row][col].split(',') + new_levels = new_text.split(',') + if len(new_levels) < 2: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: At least two variable levels should be entered! Separate levels with commas") + return False + if len(old_levels) > len(new_levels): + # which levels has been deleted? + del_levels = list(set(old_levels) - set(new_levels)) + # convert items to indices + del_levels = [old_levels.index(level) for level in del_levels] + del_levels.sort() + for idx in range(len(self.allocations)): + for i, level in enumerate(self.allocations[idx]['levels']): + if level in del_levels: + self.ui_pool.append(self.allocations[idx]['UI']) + self.allocations[idx] = False + # deleting false items + self.allocations = filter(None, self.allocations) + for idx in range(len(self.allocations)): + for i, level in enumerate(self.allocations[idx]['levels']): + d = 0 + for del_level in del_levels: + # for each del_level less than level the level index number should decrement one unit + if level > del_level: + d += 1 + self.allocations[idx]['levels'][i] -= d + self.variable_liststore[row][col] = new_text + self.update_allocations() + + def variable_add_button(self, widget, data=None): + self.variable_liststore.append(('Variable {0}'.format(len(self.variable_liststore)+1), 1.0, 'Level 0, Level 1')) + self.update_allocations() + + def variable_delete_button(self, widget, data=None): + if self.variable_treeview.get_cursor()[0]: + row = self.variable_treeview.get_cursor()[0][0] + self.variable_liststore.remove(self.variable_liststore.get_iter(row)) + for idx in range(len(self.allocations)): + self.allocations[idx]['levels'].pop(row) + self.update_allocations() + + def update_allocations(self): + n = len(self.allocations_treeview.get_columns()) + while n: + n = self.allocations_treeview.remove_column(self.allocations_treeview.get_column(n-1)) + widgets = self.combo_vbox.get_children() + for widget in widgets: + widget.destroy() + table = gtk.Table(3, len(self.variable_liststore)+1) + min_group_old_index = self.min_group_combo.get_active() + if min_group_old_index < 0: + min_group_old_index = 0 + if (min_group_old_index + 1) > len(self.group_liststore): + min_group_old_index = 0 + self.min_group_combo.get_model().clear() + for group in self.group_liststore: + self.min_group_combo.append_text(group[0]) + if len(self.group_liststore): + self.min_group_combo.set_active(min_group_old_index) + self.variable_combos = [] + n = 0 + for variable in self.variable_liststore: + lbl = gtk.Label(variable[0]) + table.attach(lbl, 0, 1, n, n+1) + cbo = gtk.combo_box_new_text() + for level in map(str.strip, variable[2].split(',')): + cbo.append_text(level) + self.variable_combos.append(cbo) + table.attach(cbo, 1, 2, n, n+1) + n += 1 + self.combo_vbox.pack_start(table, False, False) + types = ((str,) * (len(self.variable_liststore) + 2)) + liststore = gtk.ListStore(*types) + + tvcolumn = gtk.TreeViewColumn('UI') + self.allocations_treeview.append_column(tvcolumn) + cell = gtk.CellRendererText() + tvcolumn.pack_start(cell, True) + tvcolumn.add_attribute(cell, 'text', 0) + tvcolumn.set_resizable(True) + tvcolumn.set_expand(True) + + tvcolumn = gtk.TreeViewColumn('Group') + self.allocations_treeview.append_column(tvcolumn) + cell = gtk.CellRendererText() + tvcolumn.pack_start(cell, True) + tvcolumn.add_attribute(cell, 'text', 1) + tvcolumn.set_resizable(True) + tvcolumn.set_expand(True) + + n = 1 + for variable in self.variable_liststore: + n += 1 + tvcolumn = gtk.TreeViewColumn(variable[0]) + self.allocations_treeview.append_column(tvcolumn) + cell = gtk.CellRendererText() + tvcolumn.pack_start(cell, True) + tvcolumn.add_attribute(cell, 'text', n) + tvcolumn.set_resizable(True) + tvcolumn.set_expand(True) + self.allocations_treeview.set_model(liststore) + variable_models = [cbo.get_model() for cbo in self.variable_combos] + for row, record in enumerate(self.allocations): + liststore.append() + liststore[row][0] = record['UI'] + liststore[row][1] = self.group_liststore[record['allocation']][0] + for col, variable_model in enumerate(variable_models): + liststore[row][col+2] = variable_model[record['levels'][col]][0] + self.window.show_all() + + def get_minimize_case(self, new_case): + model = Model() + model.groups = range(len(self.group_liststore)) + model.variables = [range(len(self.variable_liststore[row][2].split(','))) for row in range(len(self.variable_liststore))] + model.variables_weight = [self.variable_liststore[row][1] for row in range(len(self.variable_liststore))] + model.allocation_ratio = [self.group_liststore[row][1] for row in range(len(self.group_liststore))] + model.allocations = self.allocations + model.prob_method = self.get_prob_method() + model.distance_measure = self.get_distance_measure() + model.high_prob = self.high_prob_spin.get_value() + model.min_group = self.min_group_combo.get_active() + m = Minim(model) + m.build_probs(model.high_prob, model.min_group) + m.build_freq_table() + if self.initial_freq_table: + self.add_to_initial(m.freq_table) + return m.enroll(new_case, m.freq_table) + + def add_to_initial(self, freq_table): + for row, group in enumerate(freq_table): + for v, variable in enumerate(group): + for l, level in enumerate(variable): + freq_table[row][v][l] += self.initial_freq_table[row][v][l] + + def allocations_undo_button(self, widget, data=None): + model = self.allocations_treeview.get_model() + if model == None or len(model) == 0: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: No subject allocated!") + if self.trial_file_name: + self.want_trial_unlock() + return False + msg = "Deallocation may introduce errors in randomization!\nAre you sure you want to undo the last allocation?" + dialog = gtk.MessageDialog(self.window, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_QUESTION, buttons=gtk.BUTTONS_YES_NO, message_format = msg) + dialog.set_title("Undo Allocation!") + if dialog.run() == gtk.RESPONSE_YES: + row = len(model)-1 + self.ui_pool.append(model[row][0]) + path = (row,) + iter = model.get_iter(path) + model.remove(iter) + self.allocations.pop() + self.save_trial(self.trial_file_name) + dialog.destroy() + + def allocations_add_button(self, widget, data=None): + model = self.allocations_treeview.get_model() + if not model: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Groups and prognostic factors must be defined first!") + return False + for cbo in self.variable_combos: + if cbo.get_active() == -1: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, 'Error: Some factor levels have not been selected for this case!') + return False + if not self.ui_pool: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, 'Error: Either this trial is finished or has not been saved!') + return False + model.append() + ui = self.ui_pool.pop() + new_case = {'levels': [], 'allocation': -1, 'UI': ui} + row = len(model)-1 + model[row][0] = ui + for col, cbo in enumerate(self.variable_combos): + model[row][col+2] = cbo.get_active_text() + new_case['levels'].append(cbo.get_active()) + m_group = self.get_minimize_case(new_case) + new_case['allocation'] = m_group + model[row][1] = self.group_liststore[m_group][0] + self.allocations.append(new_case) + self.save_trial(self.trial_file_name) + self.report_allocation(model) + if len(self.ui_pool) == 0: + self.end_trial() + + def report_allocation(self, model): + column = self.allocations_treeview.get_columns() + row = len(model)-1 + ret = [] + for col, column in enumerate(column): + ret.append(column.get_title() + ': ' + model[row][col]) + + msg = "New case allocated\n" + '\n'.join(ret) + dialog = gtk.MessageDialog(self.window, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_OK, message_format = msg) + dialog.set_title("New Allocation!") + dialog.run() + dialog.destroy() + + def end_trial(self): + msg = "{0} cases have been minimized!\nDo you like to extend the sample size".format(len(self.allocations)) + dialog = gtk.MessageDialog(self.window, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_QUESTION, buttons=gtk.BUTTONS_YES_NO, message_format = msg) + dialog.set_title("Trial finished!") + if dialog.run() == gtk.RESPONSE_YES: + extra_sample = "" + while not extra_sample.isdigit(): + extra_sample = functions.simple_dialog("Extra Sample", self.window) + ss = len(self.allocations)+int(extra_sample) + self.build_ui_pool(range(len(self.allocations), ss)) + model = self.allocations_treeview.get_model() + for row in range(len(model)): + model[row][0] = model[row][0].zfill(len(str(ss))) + else: + self.ui_pool = None + dialog.destroy() + + def refresh_freq_table(self): + model = Model() + model.groups = range(len(self.group_liststore)) + model.variables = [range(len(self.variable_liststore[row][2].split(','))) for row in range(len(self.variable_liststore))] + model.variables_weight = [self.variable_liststore[row][1] for row in range(len(self.variable_liststore))] + model.allocation_ratio = [self.group_liststore[row][1] for row in range(len(self.group_liststore))] + model.allocations = self.allocations + m = Minim(model) + m.build_freq_table() + if self.initial_freq_table: + self.add_to_initial(m.freq_table) + if not len(m.freq_table): + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: No allocation!") + return False + n = len(self.freq_table_treeview.get_columns()) + while n: + n = self.freq_table_treeview.remove_column(self.freq_table_treeview.get_column(n-1)) + self.initial_table_vbox.hide() + # following for test only + # m.freq_table = [[[18, 25], [6, 3, 3, 4, 3, 6, 4, 5, 5, 4]], [[39, 45], [12, 8, 7, 7, 7, 9, 6, 12, 11, 5]], [[55, 68], [17, 12, 10, 14, 10, 13, 8, 16, 15, 8]]] + cols = 0 + column_names = [] + for variable in self.variable_liststore: + column_names.extend([level for level in map(str.strip, variable[2].split(','))]) + column_names = ['Group'] + column_names + ['Total'] + for var in m.freq_table[0]: + cols += len(var) + col_types = [str] + [int] * (cols + 1) + liststore = gtk.ListStore(*col_types) + for n in range(len(column_names)): + tvcolumn = gtk.TreeViewColumn(column_names[n]) + self.freq_table_treeview.append_column(tvcolumn) + cell = gtk.CellRendererText() + #cell.set_property('editable', True) + #cell.connect("edited", edit_handler, n) + tvcolumn.pack_start(cell, True) + tvcolumn.add_attribute(cell, 'text', n) + tvcolumn.set_resizable(True) + tvcolumn.set_expand(True) + self.freq_table_treeview.set_model(liststore) + for row, group in enumerate(m.freq_table): + liststore.append() + liststore[row][0] = self.group_liststore[row][0] + col = 1 + for variable in group: + for level in variable: + liststore[row][col] = level + col += 1 + liststore[row][col] = sum(variable) + liststore.append() + liststore[len(m.freq_table)][0] = "Total" + total = 0 + for c in range(1, col): + col_total = sum([liststore[row][c] for row in range(len(m.freq_table))]) + total += col_total + liststore[len(m.freq_table)][c] = col_total + liststore[len(m.freq_table)][c+1] = total / len(self.variable_liststore) + if self.freq_table_enable_edit_button.get_label() == "Save as Initial Table": + self.freq_table_enable_edit() + self.window.show_all() + + def notebook_switch_page(self, notebook, page, page_num, data=None): + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, self.notbook_tabs[page_num]) + if page_num < 4: return + self.refresh_freq_table() + self.balance_table_refresh() + + def license_button_clicked(self, widget, data=None): + self.display_about_dialog() + + def display_about_dialog(self): + dialog = gtk.AboutDialog() + dialog.set_name("MinimPy Program") + dialog.set_version("0.1") + dialog.set_copyright("Copyright (c) 2010-2011 Mahmoud Saghaei") + dialog.set_license("Distributed under the GNU GPL v3.\nFor full terms refer to http://www.gnu.org/copyleft/gpl.html.") + dialog.set_website("http://minimpy.sourceforge.net") + dialog.set_authors(["Mahmoud Saghaei"]) + dialog.set_logo(self.pixbuf) + dialog.run() + dialog.destroy() + return False + + dialog = gtk.MessageDialog(self.window, flags = gtk.DIALOG_MODAL, type = +gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_OK, message_format = "XKnight game\nCopyright (c) 2008-2009 Mahmoud Saghaei\nDistributed under the GNU GPL v3.\nFor full terms refer to http://www.gnu.org/copyleft/gpl.html.") + dialog.set_title("About XKnight Game!") + dialog.run() + dialog.destroy() + + def trial_properties_cell_edited(self, cell, row, new_text, col): + self.trial_properties_liststore[row][col] = new_text + + def trial_properties_add_button(self, widget, data=None): + self.trial_properties_liststore.append(('Property Name', 'Property Value')) + + def trial_properties_delete_button(self, widget, data=None): + if self.trial_properties_treeview.get_cursor()[0]: + row = self.trial_properties_treeview.get_cursor()[0][0] + self.trial_properties_liststore.remove(self.trial_properties_liststore.get_iter(row)) + + def __init__(self): + self.trial_file_name = None + self.notbook_tabs = [] + self.ui_pool = None + self.initial_freq_table = False + self.allocations = [] + self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) + self.window.set_title("Minimization Program") + self.window.connect("delete_event", self.delete_event) + self.window.set_border_width(2) + self.window.set_size_request(750, 400) + self.notebook = gtk.Notebook() + self.notebook.set_tab_pos(gtk.POS_LEFT) + self.notebook.popup_enable() + self.notebook.connect("switch-page", self.notebook_switch_page) + img = gtk.Image() + img.set_from_file('logo.png') + img.show() + self.pixbuf = img.get_pixbuf() + + win_vbox = gtk.VBox(False) + win_vbox.pack_start(self.notebook, True, True) + + self.statusbar = gtk.Statusbar() + win_vbox.pack_start(self.statusbar, False, False, 0) + self.sb_context_id = self.statusbar.get_context_id("Statusbar") + + vbx = gtk.VBox(False) + hbx = gtk.HBox(False) + label = gtk.Label("Trial Title") + hbx.pack_start(label, False, False) + self.trial_title_entry = gtk.Entry() + hbx.pack_start(self.trial_title_entry, True, True) + + label = gtk.Label("Sample Size") + hbx.pack_start(label, False, False) + adj = gtk.Adjustment(value=30, lower=5, upper=1000000, step_incr=1, page_incr=10) + self.trial_sample_size_spin = gtk.SpinButton(adj) + hbx.pack_start(self.trial_sample_size_spin, False, False) + vbx.pack_start(hbx, False, False) + + hbx = gtk.HBox(False) + label = gtk.Label("Description") + hbx.pack_start(label, False, False) + vbx.pack_start(hbx, False, False) + sep = gtk.HSeparator() + vbx.pack_start(sep, False, False) + hbx = gtk.HBox(False) + sep = gtk.VSeparator() + hbx.pack_start(sep, False, False) + self.trial_description_text = gtk.TextView() + hbx.pack_start(self.trial_description_text, True, True) + sep = gtk.VSeparator() + hbx.pack_start(sep, False, False) + vbx.pack_start(hbx, True, True) + sep = gtk.HSeparator() + vbx.pack_start(sep, False, False) + + hbox = gtk.HBox(False) + vbx.pack_start(hbox, True, True) + label = gtk.Label("Probability Method") + vbox = gtk.VBox(False) + vbox.pack_start(label, False, False) + radio = gtk.RadioButton(None, label="Biased Coin Minimization") + vbox.pack_start(radio, False, False) + radio = gtk.RadioButton(radio, label="Naive Minimization") + vbox.pack_start(radio, False, False) + # this method returns the radios in revese order + self.prob_method_radios = radio.get_group() + # so we need to invert the returned list + self.prob_method_radios.reverse() + + hb = gtk.HBox(False) + lbl = gtk.Label("Min Group") + hb.pack_start(lbl, False, False) + self.min_group_combo = gtk.combo_box_new_text() + hb.pack_start(self.min_group_combo, False, False) + vbox.pack_start(hb, False, False) + + hb = gtk.HBox(False) + lbl = gtk.Label("High Probability") + hb.pack_start(lbl, False, False) + adj = gtk.Adjustment(value=0.7, lower=0.1, upper=1.0, step_incr=0.01, page_incr=0.1) + self.high_prob_spin = gtk.SpinButton(adj, digits=2) + hb.pack_start(self.high_prob_spin, False, False) + vbox.pack_start(hb, False, False) + hbox.pack_start(vbox, False, False) + sep = gtk.VSeparator() + hbox.pack_start(sep, False, False) + + label = gtk.Label("Distance Measure") + vbox = gtk.VBox(False) + vbox.pack_start(label, False, False) + radio = gtk.RadioButton(None, label="Marginal Balance") + vbox.pack_start(radio, False, False) + radio = gtk.RadioButton(radio, label="Range") + vbox.pack_start(radio, False, False) + radio = gtk.RadioButton(radio, label="Standard Deviation") + vbox.pack_start(radio, False, False) + radio = gtk.RadioButton(radio, label="Variance") + vbox.pack_start(radio, False, False) + hbox.pack_start(vbox, False, False) + self.distance_measure_radios = radio.get_group() + self.distance_measure_radios.reverse() + sep = gtk.VSeparator() + hbox.pack_start(sep, False, False) + + vbox = gtk.VBox(False) + lbl = gtk.Label("Trial Properties") + vbox.pack_start(lbl, False, False) + hb = gtk.HBox(False) + self.trial_properties_liststore, self.trial_properties_treeview = functions.make_treeview( + (str, str), ['Name', 'Value'], + editable=True, edit_handler=self.trial_properties_cell_edited) + hb.pack_start(self.trial_properties_treeview, True, True) + vbuttonbox = gtk.VButtonBox() + vbuttonbox.set_layout(gtk.BUTTONBOX_START) + button = gtk.Button(None, gtk.STOCK_ADD) + button.connect("clicked", self.trial_properties_add_button) + vbuttonbox.pack_start(button, False, False) + button = gtk.Button(None, gtk.STOCK_DELETE) + button.connect("clicked", self.trial_properties_delete_button) + vbuttonbox.pack_start(button, False, False) + hb.pack_start(vbuttonbox, False, False) + vbox.pack_start(hb, False, False) + + hbox.pack_start(vbox, True, True) + sep = gtk.VSeparator() + hbox.pack_start(sep, False, False) + + sep = gtk.HSeparator() + vbx.pack_start(sep, False, False) + + hbuttonbox = gtk.HButtonBox() + hbuttonbox.set_layout(gtk.BUTTONBOX_START) + + self.trial_load_button = gtk.Button(None, gtk.STOCK_OPEN) + self.trial_load_button.connect("clicked", self.load_trial_clicked) + hbuttonbox.pack_start(self.trial_load_button, False, False) + + self.trial_save_button = gtk.Button(None, gtk.STOCK_SAVE) + self.trial_save_button.connect("clicked", self.save_trial_clicked) + hbuttonbox.pack_start(self.trial_save_button, False, False) + + vbx.pack_start(hbuttonbox, False, False) + + lbl = gtk.Label("Settings") + self.notbook_tabs.append("Settings: Define and save a new trial or load a previous trial") + self.notebook.append_page(vbx, lbl) + + hbox = gtk.HBox(False) + self.group_liststore, self.group_treeview = functions.make_treeview( + (str, int), ['Group Name', 'Allocation Ratio'], + editable=True, edit_handler=self.group_cell_edited) + hbox.pack_start(self.group_treeview, True, True) + vbuttonbox = gtk.VButtonBox() + vbuttonbox.set_layout(gtk.BUTTONBOX_START) + button = gtk.Button(None, gtk.STOCK_ADD) + button.connect("clicked", self.group_add_button) + vbuttonbox.pack_start(button, False, False) + button = gtk.Button(None, gtk.STOCK_DELETE) + button.connect("clicked", self.group_delete_button) + vbuttonbox.pack_start(button, False, False) + hbox.pack_start(vbuttonbox, False, False) + lbl = gtk.Label('Groups') + self.notbook_tabs.append("Groups: Define trial groups and their allocation ratios") + self.group_hbox = hbox + self.notebook.append_page(hbox, lbl) + + hbox = gtk.HBox(False) + self.variable_liststore, self.variable_treeview = functions.make_treeview( + (str, float, str), ['Variable Name', 'Weight', 'Levels'], + editable=True, edit_handler=self.variable_cell_edited) + hbox.pack_start(self.variable_treeview, True, True) + vbuttonbox = gtk.VButtonBox() + vbuttonbox.set_layout(gtk.BUTTONBOX_START) + button = gtk.Button(None, gtk.STOCK_ADD) + button.connect("clicked", self.variable_add_button) + vbuttonbox.pack_start(button, False, False) + button = gtk.Button(None, gtk.STOCK_DELETE) + button.connect("clicked", self.variable_delete_button) + vbuttonbox.pack_start(button, False, False) + hbox.pack_start(vbuttonbox, False, False) + lbl = gtk.Label('Variables') + self.notbook_tabs.append("Variables: Define trial prognostic factors, their weights and levels") + self.variable_hbox = hbox + self.notebook.append_page(hbox, lbl) + + hbox = gtk.HBox(False) + vbox = gtk.VBox(False) + + self.allocations_treeview = gtk.TreeView() + hbox.pack_start(self.allocations_treeview, True, True) + + vbuttonbox = gtk.VButtonBox() + vbuttonbox.set_layout(gtk.BUTTONBOX_START) + button = gtk.Button(None, gtk.STOCK_ADD) + button.connect("clicked", self.allocations_add_button) + vbuttonbox.pack_start(button, False, False) + button = gtk.Button(None, gtk.STOCK_UNDO) + button.connect("clicked", self.allocations_undo_button) + vbuttonbox.pack_start(button, False, False) + vbox.pack_start(vbuttonbox, False, False) + self.combo_vbox = gtk.VBox(False) + vbox.pack_start(self.combo_vbox, False, False) + hbox.pack_start(vbox, False, False) + + lbl = gtk.Label('Allocations') + self.notbook_tabs.append('Allocations: Allocate subjects to treatments. To use minimization select "Minimize" as group name') + self.notebook.append_page(hbox, lbl) + + vbox = gtk.VBox(False) + self.freq_table_treeview = gtk.TreeView() + vbox.pack_start(self.freq_table_treeview, False, False) + self.initial_table_vbox = gtk.VBox(False) + self.freq_table_enable_edit_button = gtk.Button("Start Edit") + self.freq_table_enable_edit_button.connect("clicked", self.freq_table_start_edit_clicked) + self.initial_table_vbox.pack_start(self.freq_table_enable_edit_button, False, False) + button = gtk.Button("Delete Initial Table") + button.connect("clicked", self.freq_table_delete_initial_clicked) + self.initial_table_vbox.pack_start(button, False, False) + vbox.pack_start(self.initial_table_vbox, False, False) + lbl = gtk.Label('Table') + self.notbook_tabs.append("Table: Displays frequency table for different levels of prognostic factors") + self.notebook.append_page(vbox, lbl) + + hbox = gtk.HBox(True) + treestore = gtk.TreeStore(str, float, float, float, float) + self.balance_table_treeview = gtk.TreeView(treestore) + col_names = ['Variable/Level', 'Marginal Balance', 'Range', 'Variance', 'SD'] + for i in range(5): + cell = gtk.CellRendererText() + column = gtk.TreeViewColumn(col_names[i], cell, text=i) + self.balance_table_treeview.append_column(column) + hbox.pack_start(self.balance_table_treeview, True, True) + lbl = gtk.Label('Balance') + self.notbook_tabs.append("Balance: Displays current trial balance as four different balance measures") + self.notebook.append_page(hbox, lbl) + + hbox = gtk.HBox(True) + self.about_text = gtk.TextView() + self.about_text.set_wrap_mode(gtk.WRAP_WORD) + self.about_text.set_editable(False) + self.about_text.set_cursor_visible(False) + self.about_text.set_left_margin(20) + self.about_text.set_right_margin(20) + about_text = """ + + +*************************** MinimPy 0.1 *********************************** +Copyright (c) 2010 Mahmoud Saghaei +http://www.saghaei.com +MinimPy is a desktop minimization program for sequential randomization of subject to treatment groups in a clinical trial. +With this program you can define a new minimization model specifying the probability method used for assigning subject to treatment groups, distance measure which is the imbalance score at a the time of allocation considering the levels of prognostic factor for the a new subject which going to be allocated. Main features of MinimPy include total control over choice of probability method, distance measure, defining an initial minimization preload, adding a new method of probability assignment as biased coin minimization and another as marginal balance which has been shown to be superior to other distance measures. + """ + functions.set_text_buffer(self.about_text, about_text) + hbox.pack_start(self.about_text) + button = gtk.Button(None, gtk.STOCK_INFO) + button.connect("clicked", self.license_button_clicked) + functions.textview_add_widget(self.about_text, 0, button) + self.notbook_tabs.append("ABout: Displays information about MinimPy and the developers") + lbl = gtk.Label('ABout') + self.notebook.append_page(hbox, lbl) + self.notebook.set_show_tabs(True) + + self.window.add(win_vbox) + self.window.show_all() + self.initial_table_vbox.hide() + + def balance_table_refresh(self): + liststore = self.freq_table_treeview.get_model() + if not liststore: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: No allocation!") + return False + table = [] + for row in range(len(liststore)-1): + table.append([]) + for col in range(1, len(liststore[0])-1): + table[row].append(liststore[row][col]) + balance = self.get_trial_balances(table) + treestore = self.balance_table_treeview.get_model() + treestore.clear() + variables = [range(len(self.variable_liststore[row][2].split(','))) for row in range(len(self.variable_liststore))] + row = 0 + for idx, variable in enumerate(variables): + var_total = [0] * 4 + level_rows = [] + for level in variable: + for i in range(4): + var_total[i] += balance[row][i] + level_rows.append(balance[row]) + row += 1 + var_total = [self.variable_liststore[idx][0]] + [var_total[i] / len(variable) for i in range(4)] + variable_node = treestore.append(None, var_total) + level_names = map(str.strip, self.variable_liststore[idx][2].split(',')) + for level, level_row in enumerate(level_rows): + treestore.append(variable_node, [level_names[level]] + level_row) + treestore.append(None, ['Mean'] + balance[row]) + treestore.append(None, ['Max'] + balance[row+1]) + self.window.show_all() + + def get_trial_balances(self, table): + model = Model() + m = Minim(model) + levels = [[] for col in table[0]] + balances = [[] for col in table[0]] + [[], []] + for row in table: + for col, value in enumerate(row): + levels[col].append(value) + for row, level_count in enumerate(levels): + allocation_ratio = [self.group_liststore[r][1] for r in range(len(self.group_liststore))] + adj_count = [(1.0 * level_count[i]) / allocation_ratio[i] for i in range(len(level_count))] + balances[row].append(m.get_marginal_balance(adj_count)) + balances[row].append(max(adj_count) - min(adj_count)) + balances[row].append(m.get_variance(adj_count)) + balances[row].append(m.get_standard_deviation(adj_count)) + for col in range(4): + balances[len(levels)].append(1.0 * sum([balances[row][col] for row in range(len(levels))]) / len(levels)) + balances[len(levels)+1].append(max([balances[row][col] for row in range(len(levels))])) + return balances + + def freq_table_disable_edit(self): + cols = self.freq_table_treeview.get_columns() + for n, col in enumerate(cols): + cells = col.get_cell_renderers() + for cell in cells: + cell.set_property('editable', False) + + def freq_table_enable_edit(self): + cols = self.freq_table_treeview.get_columns() + for n, col in enumerate(cols): + cells = col.get_cell_renderers() + for cell in cells: + cell.set_property('editable', True) + cell.connect("edited", self.freq_table_treeview_edit_handler, n, len(cols)) + + def freq_table_start_edit_clicked(self, button, data=False): + if button.get_label() == "Start Edit": + self.freq_table_enable_edit() + button.set_label("Save as Initial Table") + else: + groups = range(len(self.group_liststore)) + variables = [range(len(self.variable_liststore[row][2].split(','))) for row in range(len(self.variable_liststore))] + initial_freq_model = self.freq_table_treeview.get_model() + table = [[[0 for l in v] for v in variables] for g in groups] + for row, group in enumerate(table): + col = 1 + for v, variable in enumerate(group): + for l, level in enumerate(variable): + table[row][v][l] = initial_freq_model[row][col] + col += 1 + self.initial_freq_table = table + button.set_label("Start Edit") + + def freq_table_treeview_edit_handler(self, cell, row, new_text, col, cols): + model = self.freq_table_treeview.get_model() + if col == 0: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: This cell can not be changed!") + return False + if not new_text.isdigit(): + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Only interger values allowed!") + return False + model[row][col] = int(new_text) + + def freq_table_delete_initial_clicked(self, button, data=None): + self.initial_freq_table = False + self.freq_table_disable_edit() + self.freq_table_enable_edit_button.set_label("Start Edit") + + def load_trial_clicked(self, button, data=None): + file_name = self.select_file("Select file", gtk.FILE_CHOOSER_ACTION_OPEN) + if not file_name: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Trial load canceled!") + return False + self.trial_file_name = self.load_trial(file_name) + + def save_trial_clicked(self, button, data=None): + if not self.trial_is_valid(): + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: This trial is not ready to save! Please check the requirements") + return False + file_name = self.select_file("Enter name of the file", gtk.FILE_CHOOSER_ACTION_SAVE) + if not file_name: + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, "Error: Trial save canceled!") + return False + self.build_ui_pool() + self.trial_file_name = self.save_trial(file_name) + + def load_trial(self, file_name, lock=True): + trial_state = self.trial_sample_size_spin.get_property("sensitive") + temp_file = self.save_trial() + try: + fp = open(file_name, 'rb') + data = pickle.load(fp) + fp.close() + self.ui_pool = data['ui_pool'] + self.trial_title_entry.set_text(data['trial_title']) + self.trial_sample_size_spin.set_value(data['sample_size']) + functions.set_text_buffer(self.trial_description_text, data['trial_description']) + self.set_trial_properties(data['trial_properties']) + self.high_prob_spin.set_value(data['high_prob']) + self.initial_freq_table = data['initial_freq_table'] + self.prob_method_radios[data['prob_method']].set_active(True) + self.distance_measure_radios[data['distance_measure']].set_active(True) + self.allocations = data['allocations'] + self.set_groups_data(data['groups']) + self.set_variables_data(data['variables']) + self.update_allocations() + if len(self.group_liststore): + self.min_group_combo.set_active(data['min_group']) + if lock: + self.lock_trial() + return file_name + except Exception as ex: + self.lock_trial(trial_state) + self.load_trial(file_name=temp_file, lock=False) + functions.error_dialog(self.window, 'An error occured while loading the trial!\nThe selected file may not be valid\n' + repr(ex) + '\nTrial restored to its previous state', 'Trial load failed!') + return False + + def set_groups_data(self, groups): + self.group_liststore.clear() + for group in groups: + self.group_liststore.append((group['name'], group['allocation_ratio'])) + + def set_variables_data(self, variables): + self.variable_liststore.clear() + for variable in variables: + self.variable_liststore.append((variable['name'], variable['weight'], variable['levels'])) + + def build_ui_pool(self, lst=None): + if not lst: + ss = self.trial_sample_size_spin.get_value_as_int() + lst = range(ss) + random.shuffle(lst) + self.ui_pool = map(lambda x: x.zfill(len(str(max(lst)))), map(str, lst)) + + def get_trial_properties(self): + table = [['', ''] for row in range(len(self.trial_properties_liststore))] + for row in range(len(table)): + for col in range(len(table[0])): + table[row][col] = self.trial_properties_liststore[row][col] + return table + + def set_trial_properties(self, table): + self.trial_properties_liststore.clear() + for row in range(len(table)): + self.trial_properties_liststore.append(table[row]) + + def trial_is_valid(self): + if not self.trial_title_entry.get_text(): + functions.error_dialog(self.window, "Please specify the trial title first", "Trial title") + self.notebook.set_current_page(0) + self.window.set_focus(self.trial_title_entry) + return False + if not functions.get_text_buffer(self.trial_description_text): + functions.error_dialog(self.window, "Please enter a description for this trial first", "Trial description") + self.notebook.set_current_page(0) + self.window.set_focus(self.trial_description_text) + return False + if len(self.group_liststore) < 2: + functions.error_dialog(self.window, "At least two groups must be defined for the trial", "Trial groups") + self.notebook.set_current_page(1) + self.window.set_focus(self.group_treeview) + return False + if len(self.variable_liststore) < 1: + functions.error_dialog(self.window, "At least one prognostic factor (variable) must be defined for the trial", "Trial variables") + self.notebook.set_current_page(2) + self.window.set_focus(self.variable_treeview) + return False + msg = "Are you sure you want to save the trial?\nOnce you saved a trial no change in trial settings are allowed!\nTrial details:\n" + self.get_trial_info() + dialog = gtk.MessageDialog(self.window, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_QUESTION, buttons=gtk.BUTTONS_YES_NO, message_format = msg) + dialog.set_title("Trial Save!") + if dialog.run() == gtk.RESPONSE_YES: + dialog.destroy() + return True + dialog.destroy() + return False + + def want_trial_unlock(self): + msg = "Do you want to unlock the trial!\nUnlocking the trial make changes of trial setting possible!\nTrial file will be released.\nYou have to save the trial again!" + dialog = gtk.MessageDialog(self.window, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_QUESTION, buttons=gtk.BUTTONS_YES_NO, message_format = msg) + dialog.set_title("Unlock Trial!") + if dialog.run() == gtk.RESPONSE_YES: + self.lock_trial(True) + self.ui_pool = None + self.trial_file_name = None + dialog.destroy() + + def lock_trial(self, state=False): + self.trial_load_button.set_property("sensitive", state) + self.trial_save_button.set_property("sensitive", state) + self.trial_sample_size_spin.set_property("sensitive", state) + for radio in self.prob_method_radios: + radio.set_property("sensitive", state) + self.min_group_combo.set_property("sensitive", state) + self.high_prob_spin.set_property("sensitive", state) + for radio in self.distance_measure_radios: + radio.set_property("sensitive", state) + for child in self.group_hbox.get_children(): + child.set_property("sensitive", state) + for child in self.variable_hbox.get_children(): + child.set_property("sensitive", state) + for child in self.initial_table_vbox.get_children(): + child.set_property("sensitive", state) + self.statusbar.pop(self.sb_context_id) + self.statusbar.push(self.sb_context_id, ("Trial lock!", "Trial unlocked!")[state]) + + def get_trial_info(self): + ret = [] + ret.append("Title: " + self.trial_title_entry.get_text()) + ret.append("Sample Size: " + str(self.trial_sample_size_spin.get_value_as_int())) + ret.append("Description: " + functions.get_text_buffer(self.trial_description_text)) + ret.append("Probability Method: " + self.get_prob_method_name()) + ret.append("Distance Measure: " + self.get_distance_measure_name()) + ret.append("High Probability: " + str(self.high_prob_spin.get_value())) + ret.append("Groups: " + str(self.get_groups_data())) + ret.append("Variables: " + str(self.get_variables_data())) + return '\n'.join(ret) + + def save_trial(self, file_name=None): + if file_name: + # do not lock if this is a temporary save + self.lock_trial() + else: + file_name = tempfile.mkstemp()[1] + try: + data = {} + data['ui_pool'] = self.ui_pool + data['trial_title'] = self.trial_title_entry.get_text() + data['sample_size'] = self.trial_sample_size_spin.get_value_as_int() + data['trial_description'] = functions.get_text_buffer(self.trial_description_text) + data['trial_properties'] = self.get_trial_properties() + data['high_prob'] = self.high_prob_spin.get_value() + data['min_group'] = self.min_group_combo.get_active() + data['initial_freq_table'] = self.initial_freq_table + data['prob_method'] = self.get_prob_method() + data['distance_measure'] = self.get_distance_measure() + data['allocations'] = self.allocations + data['groups'] = self.get_groups_data() + data['variables'] = self.get_variables_data() + fp = open(file_name, 'wb') + pickle.dump(data, fp) + fp.close() + # useful if temp save + return file_name + except Exception as ex: + functions.error_dialog(self.window, "An unknown error occured during trial save!\n" + repr(ex), "Trial save error!") + return False + + def get_distance_measure_name(self): + for distance_measure_radio in self.distance_measure_radios: + if distance_measure_radio.get_active(): + return distance_measure_radio.get_label() + return "Unknown" + + def get_distance_measure(self): + for idx, distance_measure_radio in enumerate(self.distance_measure_radios): + if distance_measure_radio.get_active(): + return idx + return 0 + + def get_prob_method_name(self): + for prob_method_radio in self.prob_method_radios: + if prob_method_radio.get_active(): + return prob_method_radio.get_label() + return "Unknown" + + def get_prob_method(self): + for idx, prob_method_radio in enumerate(self.prob_method_radios): + if prob_method_radio.get_active(): + return idx + return 0 + + def get_variables_data(self): + variables = [] + for row in self.variable_liststore: + variable = {} + variable['name'] = row[0] + variable['weight'] = row[1] + variable['levels'] = row[2] + variables.append(variable) + return variables + + def get_groups_data(self): + groups = [] + for row in self.group_liststore: + group = {} + group['name'] = row[0] + group['allocation_ratio'] = row[1] + groups.append(group) + return groups + + def select_file(self, title, action): + """ + A generic method returning file name + """ + stock = {gtk.FILE_CHOOSER_ACTION_OPEN: gtk.STOCK_OPEN, gtk.FILE_CHOOSER_ACTION_SAVE: gtk.STOCK_SAVE} + buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, stock[action], gtk.RESPONSE_OK) + fdialog = gtk.FileChooserDialog(title, self.window, action, buttons) + if action == gtk.FILE_CHOOSER_ACTION_SAVE: + fdialog.set_do_overwrite_confirmation(True) + fdialog.set_default_response(gtk.RESPONSE_OK) + response = fdialog.run() + if response == gtk.RESPONSE_OK: + file_name = fdialog.get_filename() + else: + file_name = None + fdialog.destroy() + return file_name + +def main(): + gtk.main() + return 0 + +if __name__ == "__main__": + ModelInteface() + main() +