#! /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()