attribution_report/main.py

from attribution import AttributionReport

__author__ = 'tsouza'
import Tkinter as tk
from ttk import Progressbar
import tkFileDialog
import tkMessageBox
from utils import get_dropbox_dir, ThreadedTask
import Queue


class AttributeGUI(tk.Tk):
    def __init__(self):
        tk.Tk.__init__(self)
        self.salesforce_filename = None
        self.deposit_filename = None
        self.output_directoryname = None

        self.defaults = {
            'sf_label': u"<SalesForce Export File...>",
            'dp_label': u"<Deposit Export File...>",
            'output_label': u"<Output directory...>"
        }
        self.initGUI()
        self.reset()

    def reset(self):
        self.report = AttributionReport(months=6, footer_length=6)  # TODO MAKE MONTHS A DROPDOWN
        self.input_frame.sf_label_var.set(self.defaults['sf_label'])
        self.input_frame.dp_label_var.set(self.defaults['dp_label'])
        self.output_frame.output_label_var.set(self.defaults['output_label'])
        self.run_frame.run_button.config(text="Run")
        self._check_ready_to_run()

    def initGUI(self):
        self.title('Attribution Report')
        self.grid()
        self.minsize(width=300, height=200)

        # Input
        self.input_frame = self.setup_input_frame()
        self.input_frame.grid(row=0, column=0)
        self.rowconfigure(0, weight=0)

        # Output
        self.output_frame = self.setup_output_frame()
        self.output_frame.grid(row=1, column=0)
        self.rowconfigure(1, weight=0)

        # Run
        self.run_frame = self.setup_run_frame()
        self.run_frame.grid(row=2, column=0)
        self.rowconfigure(2, weight=0)

        # Progress bar
        self.progress_bar = Progressbar(self, mode="indeterminate")
        self.progress_bar.grid(column=0, row=3)

        self.update()

        self.minsize(self.winfo_width(), self.winfo_height())
        self.resizable(True, False)

    #  ___ ___    _   __  __ ___ ___
    # | __| _ \  /_\ |  \/  | __/ __|
    # | _||   / / _ \| |\/| | _|\__ \
    # |_| |_|_\/_/ \_\_|  |_|___|___/
    def setup_input_frame(self):
        input_frame = tk.LabelFrame(text="Input Files")
        input_frame.grid()
        row = 0
        input_frame.sf_button = tk.Button(input_frame, text=u"Browse", command=self.callback_sf_browse_click)
        input_frame.sf_button.grid(column=0, row=row)
        input_frame.sf_label_var = tk.StringVar()
        input_frame.sf_label = tk.Label(input_frame,
                                        textvariable=input_frame.sf_label_var,
                                        anchor="w")
        input_frame.sf_label.grid(column=1, row=row, sticky='nsew')
        input_frame.sf_label_var.set(self.defaults['sf_label'])

        row += 1

        input_frame.dp_button = tk.Button(input_frame, text=u"Browse", command=self.callback_dp_browse_click)
        input_frame.dp_button.grid(column=0, row=row)
        input_frame.dp_label_var = tk.StringVar()
        input_frame.dp_label = tk.Label(input_frame,
                                        textvariable=input_frame.dp_label_var,
                                        anchor="w")
        input_frame.dp_label.grid(column=1, row=row, sticky='nsew')
        input_frame.dp_label_var.set(self.defaults['dp_label'])
        input_frame.grid_columnconfigure(1, weight=1)
        return input_frame

    def setup_output_frame(self):
        output_frame = tk.LabelFrame(text="Output Directory")
        output_frame.grid()

        row = 0
        output_frame.output_button = tk.Button(output_frame, text=u"Browse", command=self.callback_output_browse_click)
        output_frame.output_button.grid(column=0, row=row)
        output_frame.output_label_var = tk.StringVar()
        output_frame.sf_label = tk.Label(output_frame,
                                         textvariable=output_frame.output_label_var,
                                         anchor="w")

        output_frame.sf_label.grid(column=1, row=row, sticky='nsew')
        output_frame.output_label_var.set(self.defaults['output_label'])
        output_frame.grid_columnconfigure(0, weight=1)
        return output_frame

    def setup_run_frame(self):
        run_frame = tk.LabelFrame(text="Output Directory")
        run_frame.grid()
        row = 0
        run_frame.run_button = tk.Button(run_frame, text=u"Run", command=self.callback_run_click)
        run_frame.run_button.grid(column=0, row=row)

        run_frame.grid_columnconfigure(0, weight=1)
        return run_frame

    #   ___   _   _    _    ___   _   ___ _  _____
    #  / __| /_\ | |  | |  | _ ) /_\ / __| |/ / __|
    # | (__ / _ \| |__| |__| _ \/ _ \ (__| ' <\__ \
    #  \___/_/ \_\____|____|___/_/ \_\___|_|\_\___/
    def callback_sf_browse_click(self):
        self.salesforce_filename = tkFileDialog.askopenfilename(
            title="Salesforce Export File",
            initialdir=get_dropbox_dir(),
            filetypes=(
                ("Excel", "*.csv"),
                ("Excel", "*.xls"),
                ("Excel", "*.xlsx"),
            )
        )
        if self.salesforce_filename:
            df_parse_successful = self.report.set_dataframe_sf(self.salesforce_filename)
            if df_parse_successful:
                self.input_frame.sf_label_var.set(self.salesforce_filename)
            else:
                self.input_frame.sf_label_var.set(self.defaults['sf_label'])
                tkMessageBox.showerror(
                    "Column Mismatch",
                    ("At a minimum, the Salesforce file must have the following columns:\n\n"
                     "{0}\n\n"
                     "Please re-run and select a proper file.".format(", ".join(self.report.REQUIRED_SF_COLUMNS))
                     )
                )
        self._check_ready_to_run()

    def callback_dp_browse_click(self):
        self.deposit_filename = tkFileDialog.askopenfilename(
            title="Deposit Data Export File",
            initialdir=get_dropbox_dir(),
            filetypes=(
                ("Excel", "*.csv"),
                ("Excel", "*.xls"),
                ("Excel", "*.xlsx"),
            )
        )
        if self.deposit_filename:
            df_parse_successful = self.report.set_dataframe_deposit(self.deposit_filename)
            if df_parse_successful:
                self.input_frame.dp_label_var.set(self.deposit_filename)
            else:
                self.input_frame.dp_label_var.set(self.defaults['dp_label'])
                tkMessageBox.showerror(
                    "Column Mismatch",
                    "At a minimum, the Deposit Data file must have the following columns:\n\n"
                    "{0}\n\n"
                    "Please re-run and select a proper file.".format(
                        ",\n".join(self.report.REQUIRED_DP_COLUMNS)))
        self._check_ready_to_run()

    def callback_output_browse_click(self):
        self.output_directoryname = tkFileDialog.askdirectory(
            initialdir=get_dropbox_dir(),
        )
        if self.output_directoryname:
            self.report.set_output_dir(self.output_directoryname)
            self.output_frame.output_label_var.set(self.output_directoryname)
        self._check_ready_to_run()

    def callback_run_click(self):
        """
            When you click run, the progress bar and button notify you that something is happening.
            This then starts a thread that sets the report Running and report Saving.
        """
        self.progress_bar.start()
        self.run_frame.run_button.config(text="Running...")
        self.queue = Queue.Queue()
        ThreadedTask(self.queue, self.report).start()
        self.after(100, self._process_queue)

    def _check_ready_to_run(self):
        """
            Disables and re-enables the Run button when criteria is met.
        """
        if self.report.salesforce_df is not None \
                and self.report.deposit_df is not None \
                and self.report.output_dir:
            self.run_frame.run_button.config(state=tk.NORMAL)
        else:
            self.run_frame.run_button.config(state=tk.DISABLED)
        self.update()

    def _process_queue(self):
        """
            Multi-threading the running stuff so that the UI doesn't lock.
        """
        try:
            self.queue.get(0)
            # Show result of the task if needed
            self.progress_bar.stop()
            self.reset()
        except Queue.Empty:
            self.after(100, self._process_queue)


def main():
    app = AttributeGUI()
    app.mainloop()


if __name__ == "__main__":
    main()