MinimPy Code

#! /usr/bin/env python
# -*- coding: utf-8 -*-

import sys
import os

from printclass import PrintClass

try:
    import pygtk
    pygtk.require("2.0")
except:
    print("pygtk Not Availible")
    sys.exit(1)
try:
    import gtk
except:
    print("GTK Not Availible")
    sys.exit(1)

class Export(object):
    def delete_event(self, widget, event):
        self.window.destroy()

    def export_varnames_chk(self, chk, data=None):
        self.export_firstrow_var = not self.export_firstrow_var

    def export_arrangement_toggled(self, radio, data=None):
        if radio.get_active():
            self.export_arrange = radio.get_label()

    def export_separator_toggled(self, radio, custom=None):
        if radio.get_active():
            if radio.get_label() != self._('custom'):
                self.export_separator = radio.get_label()[-2]
            else:
                if len(custom.get_text()):
                    self.export_separator = custom.get_text()

    def export_items_chk (self, chk, export_item):
        self.export_items[export_item] = not self.export_items[export_item]

    def __init__(self, parent):
        self._ = parent._
        self.parent = parent
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_title(self._("export_win_title"))
        self.window.connect("delete_event", self.delete_event)
        self.window.set_border_width(10)
        self.window.set_transient_for(parent.window)
        self.window.set_modal(True)
        vb = gtk.VBox(False)
        sep = gtk.HSeparator()
        vb.pack_start(sep, False, False)
        lbl = gtk.Label(self._("field_arrangement"))
        vb.pack_start(lbl, False, False)
        hb = gtk.HBox(True)
        self.export_arrange = self._('delimited')
        radio = gtk.RadioButton(label=self._('delimited'))
        radio.set_active(True)
        radio.connect("toggled", self.export_arrangement_toggled)
        hb.pack_start(radio, False, False)
        radio = gtk.RadioButton(radio, label=self._('fixed_width'))
        radio.connect("toggled", self.export_arrangement_toggled)
        hb.pack_start(radio, False, False)
        self.export_firstrow_var = False
        chk = gtk.CheckButton(self._("first_row_names"))
        chk.set_active(self.export_firstrow_var)
        chk.connect("toggled", self.export_varnames_chk)
        hb.pack_start(chk, False, False)

        vb.pack_start(hb, True, False)
        sep = gtk.HSeparator()
        vb.pack_start(sep, False, False)
        
        lbl = gtk.Label(self._("field_separator"))
        vb.pack_start(lbl, False, False)

        table = gtk.Table()
        self.export_separator = ','
        radio = gtk.RadioButton(label=self._("space"))
        radio.connect("toggled", self.export_separator_toggled)
        table.attach(radio, 0, 1, 0, 1)
        radio = gtk.RadioButton(radio, label=self._("tab"))
        radio.connect("toggled", self.export_separator_toggled)
        table.attach(radio, 1, 2, 0, 1)
        radio = gtk.RadioButton(radio, label=self._("colon"))
        radio.connect("toggled", self.export_separator_toggled)
        table.attach(radio, 2, 3, 0, 1)
        radio = gtk.RadioButton(radio, label=self._("comma"))
        radio.set_active(True)
        radio.connect("toggled", self.export_separator_toggled)
        table.attach(radio, 3, 4, 0, 1)
        radio = gtk.RadioButton(radio, label=self._("hyphen"))
        radio.connect("toggled", self.export_separator_toggled)
        table.attach(radio, 0, 1, 1, 2)
        radio = gtk.RadioButton(radio, label=self._("pipe"))
        radio.connect("toggled", self.export_separator_toggled)
        table.attach(radio, 1, 2, 1, 2)
        radio = gtk.RadioButton(radio, label=self._("semicolon"))
        radio.connect("toggled", self.export_separator_toggled)
        table.attach(radio, 2, 3, 1, 2)
        radio = gtk.RadioButton(radio, label=self._("slash"))
        radio.connect("toggled", self.export_separator_toggled)
        table.attach(radio, 3, 4, 1, 2)
        radio = gtk.RadioButton(radio, label=self._("bang"))
        radio.connect("toggled", self.export_separator_toggled)
        table.attach(radio, 0, 1, 2, 3)
        hb = gtk.HBox(False)
        radio = gtk.RadioButton(radio, label=self._("custom"))
        hb.pack_start(radio, False, False)
        entry = gtk.Entry(max=1)
        radio.connect("toggled", self.export_separator_toggled, entry)
        hb.pack_start(entry, False, False)
        table.attach(hb, 2, 3, 2, 3)
        self.export_delimited_table = table

        vb.pack_start(table, True, False)

        sep = gtk.HSeparator()
        vb.pack_start(sep, False, False)
        lbl = gtk.Label(self._("choose_export_items"))
        vb.pack_start(lbl, False, False)
        self.export_items = [True, False, False, False, False]
        hb = gtk.HBox(True)
        labels = (self._("allocations_tab"), self._("settings_tab"), self._("spss_syntax"),
                self._("frequency_table"), self._("balance_table"))
        for idx, lbl in enumerate(labels):
            chk = gtk.CheckButton(lbl)
            chk.set_active(self.export_items[idx])
            chk.connect("toggled", self.export_items_chk, idx)
            hb.pack_start(chk, False, False)
            if idx == 0: # Allocations
                self.allocations_options = gtk.combo_box_new_text()
                self.allocations_options.append_text(self._('values'))
                self.allocations_options.append_text(self._('labels'))
                hb.pack_start(self.allocations_options, False, False)
                self.allocations_options.set_active(0)
        vb.pack_start(hb, True, False)
        sep = gtk.HSeparator()
        vb.pack_start(sep, False, False)

        hbuttonbox = gtk.HButtonBox()
        button = gtk.Button(None, gtk.STOCK_EXPORT)
        button.connect("clicked", self.export_data, 'save')
        hbuttonbox.pack_start(button, False, False)
        button = gtk.Button(None, gtk.STOCK_PRINT)
        button.connect("clicked", self.export_data, 'print')
        hbuttonbox.pack_start(button, False, False)
        button = gtk.Button(None, gtk.STOCK_CLOSE)
        button.connect("clicked", self.close_window)
        hbuttonbox.pack_start(button, False, False)
        vb.pack_start(hbuttonbox, True, True)
        self.window.add(vb)
        self.window.show_all()

    def get_general_out_put_data(self):
        out_put_data = []
        firstcase = 1
        if self.export_items[1]: # Settings
            out_put_data.append('')
            out_put_data.append(self._('settings_tab'))
            out_put_data.append(self.parent.get_trial_info())
            firstcase += out_put_data[-1].count('\n') + 1
        if self.export_items[0]: # Allocations
            # in case we need raw pure data to import
            if len(out_put_data):
                out_put_data.append('')
                out_put_data.append(self._('allocations_tab'))
            # [{'allocation': 1, 'levels': [0, 0, 0], 'UI': '24'}, {'allocation': 1, 'levels': [1, 1, 0], 'UI': '21'}]
            if self.export_firstrow_var:
                firstcase += 1
                first_row = ['"seq"', '"ui"', '"group"']
                for row in self.parent.variable_liststore:
                    first_row.append(row[0])
                out_put_data.append(self.export_separator.join(first_row))
            columns = self.parent.allocations_treeview.get_columns()
            col_headers = [column.get_title() for column in columns]
            if len(col_headers):
                out_put_data.append(self.export_separator.join(col_headers))
            n = 0
            model = self.parent.allocations_treeview.get_model()
            for idx, case in enumerate(self.parent.allocations):
                if self.allocations_options.get_active() == 0: # Values
                    row = [str(n), case['UI'], str(case['allocation'])] + [str(level) for level in case['levels']]
                else:
                    row = [str(model[idx][i]) for i in range(len(model[idx]))]
                    #row = [str(n), case['UI'], str(case['allocation'])] + [str(level) for level in case['levels']]
                if self.export_arrange == self._('delimited'):
                    out_put_data.append(self.export_separator.join(row))
                elif self.export_arrange == self._('fixed_width'):
                    out_put_data.append(
                    "{0:<8}{1:<8}{2:<2}".format(*row[:3]) + ''.join(['{0:<2}'.format(x) for x in row[3:]]))
                n += 1
        if self.export_items[3]: # Freq Table
            out_put_data.append('')
            out_put_data.append(self._('frequency_table'))
            if self.parent.freq_table_enable_edit_button.get_label() != self._("button_save_as_initial_table"):
                # refresh the table
                self.parent.refresh_freq_table()
            columns = self.parent.freq_table_treeview.get_columns()
            col_headers = [column.get_title() for column in columns]
            if len(col_headers):
                out_put_data.append(self.export_separator.join(col_headers))
            model = self.parent.freq_table_treeview.get_model()
            for r in range(len(model)):
                row = [str(model[r][i]) for i in range(len(model[r]))]
                out_put_data.append(self.export_separator.join(row))
        if self.export_items[4]: # Balance Table
            out_put_data.append('')
            out_put_data.append(self._('balance_table'))
            if self.parent.freq_table_enable_edit_button.get_label() != self._("button_save_as_initial_table"):
                # if not already refresh the freq table
                if not self.export_items[3]:
                    # refresh the table
                    self.parent.refresh_freq_table()
                # and the balance table
                self.parent.balance_table_refresh()
            columns = self.parent.balance_table_treeview.get_columns()
            col_headers = [column.get_title() for column in columns]
            if len(col_headers):
                out_put_data.append(self.export_separator.join(col_headers))
            self.parent.balance_table_treeview.expand_all()
            model = self.parent.balance_table_treeview.get_model()
            for r in range(len(self.parent.variable_liststore)):
                row = [str(model[(r,)][i]) for i in range(len(model[(r,)]))]
                out_put_data.append(self.export_separator.join(row))
                for L in range(len(self.parent.variable_liststore[r][2].split(','))):
                    row = [str(model[(r, L)][j]) for j in range(len(model[(r, L)]))]
                    out_put_data.append(self.export_separator.join(row))
            row = [str(model[len(model)-2][i]) for i in range(len(model[len(model)-2]))]
            out_put_data.append(self.export_separator.join(row))
            row = [str(model[len(model)-1][i]) for i in range(len(model[len(model)-1]))]
            out_put_data.append(self.export_separator.join(row))
        return out_put_data, firstcase

    def get_spss_output_data(self, dat_file_name, firstcase):
        if self.export_arrange == self._('delimited'):
            input_file = os.path.join(os.path.dirname(sys.argv[0]), 'data', 'delimited.dat')
            input_data = open(input_file).read()
            input_data = input_data.replace('$$filename$$', dat_file_name)
            input_data = input_data.replace('$$delimiters$$', self.export_separator)
            input_data = input_data.replace('$$firstcase$$', str(firstcase))
            for row in self.parent.variable_liststore:
                input_data += '{0} F2.0\n'.format(row[0])
            input_data += '.'
        elif self.export_arrange == self._('fixed_width'):
            input_file = os.path.join(os.path.dirname(sys.argv[0]), 'data', 'fixcase.dat')
            input_data = open(input_file).read()
            input_data = input_data.replace('$$filename$$', dat_file_name)
            input_data = input_data.replace('$$firstcase$$', str(firstcase))
            n = 18
            for row in self.parent.variable_liststore:
                input_data += '{0} {1}-{2} F2.0\n'.format(row[0], n, n+1)
                n += 2
            input_data += '.'
        return input_data

    def save_export(self, out_put_data, firstcase):
        folder_name = self.parent.select_file(self._("select_folder"), gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
        if not folder_name:
            return False
        sps_file_name = os.path.join(folder_name, "export.sps")
        dat_file_name = os.path.join(folder_name, "export.dat")
        if len(out_put_data):
            output_data_file = open(dat_file_name, 'w')
            output_data_file.write('\n'.join(out_put_data))
            output_data_file.flush()
            output_data_file.close()
        if self.export_items[2]: # SPSS Syntax
            spss_output_data = self.get_spss_output_data(dat_file_name, firstcase)
            output_file = open(sps_file_name, 'w')
            output_file.write(spss_output_data)
            output_file.flush()
            output_file.close()
        return True

    def print_export(self, text):
        action = gtk.PRINT_OPERATION_ACTION_PRINT_DIALOG
        return PrintClass(action, '\n'.join(text))

    def export_data(self, button, data=None):
        out_put_data, firstcase = self.get_general_out_put_data()
        if data == 'save':
            if not self.save_export(out_put_data, firstcase): return
        elif data == 'print':
            if not self.print_export(out_put_data): return
        msg = self._("data_exported")
        dialog = gtk.MessageDialog(self.window, flags = gtk.DIALOG_MODAL, type = gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_OK, message_format = msg)
        dialog.set_title(self._("export"))
        dialog.run()
        dialog.destroy()

    def close_window(self, widget, data=None):
        self.window.destroy()