def pivot(self, depend_names=None, row_names=[], col_names=[], page_names=[], function='Mean'): """Build a pivot table. Arguments: depend_names (str): name of the dependent variable row_names, col_names, page_names (lists of str): name of the independent variables function (str): available functions: N,Sum, Mean, Median, Standard Deviation, Variance (default Mean) """ if not depend_names: try: self.dial_pivot except: self.dial_pivot = cogstat_dialogs.pivot_dialog(names=self.active_data.data_frame.columns) else: self.dial_pivot.init_vars(names=self.active_data.data_frame.columns) if self.dial_pivot.exec_(): row_names, col_names, page_names, depend_names, function = self.dial_pivot.read_parameters() else: return self._busy_signal(True) self.analysis_results.append(GuiResultPackage()) if not depend_names or not (row_names or col_names or page_names): # TODO this check should go to the dialog text_result = cs_util.reformat_output('<default>%s %s'%(_('Pivot table.'), _('The dependent variable and at least one grouping variable should be given.'))) else: try: text_result = self.active_data.pivot(depend_names, row_names, col_names, page_names, function) except: text_result = cs_util.reformat_output(broken_analysis % _('Pivot table.')) traceback.print_exc() self.analysis_results[-1].add_output(text_result) self._print_to_output_pane() self._busy_signal(False)
def compare_variables(self, var_names=None): """Compare variables. Arguments: var_names (list): variable names """ if not var_names: try: self.dial_comp_var except: self.dial_comp_var = cogstat_dialogs.compare_vars_dialog(names=self.active_data.data_frame.columns) else: self.dial_comp_var.init_vars(names=self.active_data.data_frame.columns) if self.dial_comp_var.exec_(): var_names = self.dial_comp_var.read_parameters() # TODO check if settings are appropriate else: return self._busy_signal(True) self.analysis_results.append(GuiResultPackage()) self.analysis_results[-1].add_command('self.compare_variables()') # TODO if len(var_names) < 2: text_result = cs_util.reformat_output('<default>%s %s'%(_('Compare variables.'), _(u'At least two variables should be set.'))) self.analysis_results[-1].add_output(text_result) else: try: result_list = self.active_data.compare_variables(var_names) for result in result_list: # TODO is this a list of lists? Can we remove the loop? self.analysis_results[-1].add_output(result) except: self.analysis_results[-1].add_output(cs_util.reformat_output(broken_analysis % _('Compare variables.'))) traceback.print_exc() self._print_to_output_pane() self._busy_signal(False)
def print_data(self, brief=False, display_import_message=False): """Print the current data to the output. :param brief (bool): print only the first 10 rows :param display_import_message (bool): """ self.analysis_results.append(GuiResultPackage()) self.analysis_results[-1].add_command('self.print_data') # TODO commands will be used to rerun the analysis self.analysis_results[-1].add_output(self.active_data.print_data(brief=brief)) if self.active_data.import_message and display_import_message: self.analysis_results[-1].add_output(cs_util.reformat_output(self.active_data.import_message)) self._print_to_output_pane()
def print_versions(self): """Print the versions of the software components CogStat uses.""" # Intentionally not localized. self._busy_signal(True) text_output = cs_util.reformat_output(cs_util.print_versions()) self.analysis_results.append(GuiResultPackage()) self.analysis_results[-1].add_output(csc.heading_style_begin + _('System components') + csc.heading_style_end) self.analysis_results[-1].add_output(text_output) self._print_to_output_pane() self._busy_signal(False)
def explore_variable_pair(self, var_names=None): """Explore variable pairs. Arguments: var_names (list): variable names """ if not var_names: try: self.dial_var_pair except: self.dial_var_pair = cogstat_dialogs.explore_var_pairs_dialog(names=self.active_data.data_frame.columns) else: self.dial_var_pair.init_vars(names=self.active_data.data_frame.columns) if self.dial_var_pair.exec_(): var_names = self.dial_var_pair.read_parameters() else: return self._busy_signal(True) if len(var_names) < 2: # TODO this check should go to the appropriate dialog self.analysis_results.append(GuiResultPackage()) text_result = cs_util.reformat_output('<default> %s %s'%(_('Explore variable pair.'), _(u'At least two variables should be set.'))) self.analysis_results[-1].add_output(text_result) else: try: for x in var_names: pass_diag = False for y in var_names: if pass_diag: self.analysis_results.append(GuiResultPackage()) self.analysis_results[-1].add_command('self.explore_variable_pair') # TODO result_list = self.active_data.explore_variable_pair(x, y) self.analysis_results[-1].add_output(result_list) self._print_to_output_pane() if x == y: pass_diag = True except: self.analysis_results[-1].add_output(cs_util.reformat_output(broken_analysis % _('Explore variable pair.'))) traceback.print_exc() self._print_to_output_pane() self._busy_signal(False)
def compare_groups(self, var_names=None, groups=None): """Compare groups. Arguments: var_names (list): dependent variable names groups (list): grouping variable names """ if not var_names: try: self.dial_comp_grp except: self.dial_comp_grp = cogstat_dialogs.compare_groups_dialog(names=self.active_data.data_frame.columns) else: self.dial_comp_grp.init_vars(names=self.active_data.data_frame.columns) if self.dial_comp_grp.exec_(): var_names, groups = self.dial_comp_grp.read_parameters() # TODO check if settings are appropriate else: return self._busy_signal(True) if not var_names or not groups: self.analysis_results.append(GuiResultPackage()) self.analysis_results[-1].add_command('self.compare_groups()') # TODO text_result = cs_util.reformat_output('<default>%s %s' % (_('Compare groups.'), _(u'Both the dependent and the grouping variables should be set.'))) self.analysis_results[-1].add_output(text_result) else: for var_name in var_names: try: self.analysis_results.append(GuiResultPackage()) self.analysis_results[-1].add_command('self.compare_groups()') # TODO result_list = self.active_data.compare_groups(var_name, groups[0]) self.analysis_results[-1].add_output(result_list) self._print_to_output_pane() except: self.analysis_results[-1].add_output(cs_util.reformat_output(broken_analysis % _('Compare groups.'))) traceback.print_exc() self._print_to_output_pane() self._busy_signal(False)
def explore_variable(self, var_names=None, freq=True, dist=True, descr=True, norm=True, loc_test=True, loc_test_value=0): """Computes various properties of variables. Arguments: var_names (list): variable names freq (bool): compute frequencies (default True) dist (bool): compute distribution (default True) descr (bool): compute descriptive statistics (default True) norm (bool): check normality (default True) loc_test (bool): test location (e.g. t-test) (default True) loc_test_value (numeric): test location against this value (default 0.0) """ if not var_names: try: self.dial_var_prop except: self.dial_var_prop = cogstat_dialogs.explore_var_dialog(names=self.active_data.data_frame.columns) else: # TODO is it not necessary anymore? For all dialogs self.dial_var_prop.init_vars(names=self.active_data.data_frame.columns) if self.dial_var_prop.exec_(): var_names, freq, dist, descr, norm, loc_test, loc_test_value = self.dial_var_prop.read_parameters() else: return self._busy_signal(True) try: for var_name in var_names: self.analysis_results.append(GuiResultPackage()) self.analysis_results[-1].add_command('self.explore_variable()') # TODO result = self.active_data.explore_variable(var_name, frequencies=freq, distribution=dist, descriptives=descr, normality=norm, central_test=loc_test, central_value=loc_test_value) self.analysis_results[-1].add_output(result) self._print_to_output_pane() except: self.analysis_results[-1].add_output(cs_util.reformat_output(broken_analysis % _('Explore variable.'))) traceback.print_exc() self._print_to_output_pane() self._busy_signal(False)
def _open_data(self, data): """ Core of the import process. """ self._busy_signal(True) try: self.active_data = cogstat.CogStatData(data=data) if self.active_data.import_source == _('Import failed'): QtGui.QMessageBox.warning(self, _('Import error'), _('Data could not be loaded.'), QtGui.QMessageBox.Ok) self._show_data_menus(False) else: self._show_data_menus() self.statusBar().showMessage((_('Data loaded from clipboard: ') if data else _('Data loaded from file: ')) + _('%s variables and %s cases.') % (len(self.active_data.data_frame.columns), len(self.active_data.data_frame.index))) self.print_data(brief=True, display_import_message=True) except: self.analysis_results.append(GuiResultPackage()) self.analysis_results[-1].add_command('self._open_data()') # TODO self.analysis_results[-1].add_output(cs_util.reformat_output(broken_analysis % _('Open data.'))) traceback.print_exc() self._print_to_output_pane() self._busy_signal(False)
def _convert_output(self, outputs): """ Convert output either to the GUI or to the IPython Notebook :param outputs: list of the output items :return: converted output, list of items """ def _figure_to_qimage(figure): """Convert matplotlib figure to pyqt qImage. """ figure.canvas.draw() size_x, size_y = figure.get_size_inches()*rcParams['figure.dpi'] if LooseVersion(csc.versions['matplotlib']) < LooseVersion('1.2'): string_buffer = figure.canvas.buffer_rgba(0, 0) else: string_buffer = figure.canvas.buffer_rgba() return QtGui.QImage(string_buffer, size_x, size_y, QtGui.QImage.Format_ARGB32).copy() # this should be a copy, otherwise closing the matplotlib figures would damage the qImages on the GUI if output_type in ['ipnb', 'gui']: # convert custom notation to html new_output = [] for i, output in enumerate(outputs): if isinstance(output, Figure): # For gui convert matplotlib to qImage new_output.append(output if output_type == 'ipnb' else _figure_to_qimage(output)) elif isinstance(output, basestring): new_output.append(cs_util.reformat_output(output)) elif isinstance(output, list): # flat list new_output.extend(self._convert_output(output)) elif output is None: pass # drop None-s from outputs else: # No other types are expected logging.error('Output includes wrong type: %s' % type(output)) return new_output else: return outputs