def months_stat(self, q_months, year):
        q_df = self.period_calc(q_months, year)
        sum_q = self.period_stat(q_months, year)

        wb = Workbook()

        sh = Sheet.add("Summary", wkb = wb)

        row_flag = write_to_excel(q_df, sh = sh)
        row_flag = write_to_excel(sum_q, sh = sh, row_flag = row_flag)

        sh = Sheet.add("Master", wkb = wb)
        row_flag = write_to_excel(self.active_on_the_day(t_month_end(q_months[-1], year))                                  .data.pipe(ready_excel), 
                                sh = sh)
        
        sh1 = Sheet.add("Aggregate", wkb = wb)
        row_flag = write_to_excel('New Leases During the Period', sh = sh1)
        new_leases_list = self.new_analysis(t_month_start(q_months[0], year), t_month_end(q_months[-1], year))                           .data.pipe(ready_excel)
        row_flag = write_to_excel(new_leases_list, sh = sh1, row_flag = row_flag)

        row_flag = write_to_excel('Expired During the Period', sh = sh1, row_flag = row_flag)
        
        expired_leases_list = self.old_analysis(t_month_start(q_months[0], year), t_month_end(q_months[-1], year))                                   .data.pipe(ready_excel)
        row_flag = write_to_excel(expired_leases_list, sh = sh1, row_flag = row_flag)     
        
        r_expired_leases_list, r_new_leases_list, period_rate = self.renewal_a(q_months, year)
        
        sh1 = Sheet.add("Renewal", wkb = wb)
        row_flag = write_to_excel('Renewed Leases During the Period', sh = sh1)
        row_flag = write_to_excel('Original Leases', sh = sh1, row_flag = row_flag)

        row_flag = write_to_excel(r_expired_leases_list.pipe(ready_excel), sh = sh1, row_flag = row_flag)

        row_flag = write_to_excel('Renewed Leases', sh = sh1, row_flag = row_flag)    
        row_flag = write_to_excel(r_new_leases_list.pipe(ready_excel), sh = sh1, row_flag = row_flag)

        row_flag = write_to_excel('Weighted Average Reversion Rate', sh = sh1, row_flag = row_flag)
        row_flag = write_to_excel(period_rate, sh = sh1, row_flag = row_flag)
        
        quarter = q_months[-1]//3

        for tower in range(1,3):    
            sh_new = Sheet.add("Tower {tower} {year} Q{quarter}".format(tower = tower, year = year, quarter = quarter), wkb = wb)
            row_flag = write_to_excel('Tower {tower} New Leases During the Period'.format(tower = tower), sh = sh_new)   
            new_leases_list_T = new_leases_list.loc[new_leases_list['BLDG'] == tower].copy()
            row_flag = write_to_excel(new_leases_list_T, sh = sh_new, row_flag = row_flag)

            row_flag = write_to_excel('Tower {tower} Expired Leases During the Period'.format(tower = tower), sh = sh_new, row_flag = row_flag)
            expired_leases_list_T = expired_leases_list.loc[expired_leases_list['BLDG'] == tower].copy()
            row_flag = write_to_excel(expired_leases_list_T, sh = sh_new, row_flag = row_flag)

        Sheet('Sheet1').delete()
        wb.save("Operating Statistics Q{quarter} {year}".format(quarter = quarter, year = year))
        #wb.close()        

        return "OK"

def xlo(df, filename=None):
    """ show pandas dataframe or series in excel sheet
        uses xlwings which allows writing to open file
    """
    if not filename:    
        filename = "_temp.xlsx"
    if not os.path.isfile(filename):
        wb = Workbook()
        Sheet("Sheet2").delete()
        Sheet("Sheet3").delete()
    else:
        wb = Workbook(filename)
        Sheet.add()
    Range("A1").value = df
    wb.save(filename)

def df_write(df, range_name, ws=None):
    """Write a dataframe to a cell.

    df_write(df, range_name, ws=None)
    """
    ws = Sheet.active() if ws is None else ws
    Range(ws.name, range_name, index=False).value = df # without pd indices

def clearcontents_ws(ws=None):
    """Clear entire worksheet, ex: clearcontents_ws(ws=worksheetobj).

    clearcontents_ws(ws=None)
    """
    ws = Sheet.active() if ws is None else ws
    ws.clear_contents()

def clearcontents(range_name, ws=None):
    """Clear a table started in a range cell, ex: clearcontents('a1').

    clearcontents(range_name, ws=None)
    """
    ws = Sheet.active() if ws is None else ws
    Range(ws.name, range_name).table.clear_contents()

def clear_ws(ws=None):
    """Clear a table started in a range cell, ex: clearcontents('a1').

    clear_ws(ws=None)
    """
    ws = Sheet.active() if ws is None else ws
    ws.clear()

    def __init__(self, sheet="log"):
        """ create sheet and setup format """
        logging.Handler.__init__(self)
        try:
            self.caller = Workbook.caller()
        except:
            self.caller = None
            return
        
        # create sheet if it does not exist
        self.sheet = sheet
        if sheet not in [s.name for s in Sheet.all()]:
            Sheet.add(sheet)
        Sheet(sheet).clear()

        self.row = 0

def df_read(range_name, ws=None):
    """Return dataframe from range name and Sheet.; ex: df = df_read('a1').

    df_read(range_name, ws=None)
    """
    ws = Sheet.active() if ws is None else ws
    data = Range(ws.name, range_name).table.value
    df = pd.DataFrame(data[1:], columns=data[0])
    return df

def list_read(range_name, ws=None):
    """Read a list vertially.

    list_read(range_name, value_list, ws=None)
    """
    ws = Sheet.active() if ws is None else ws
    # Range(range_name).options(transpose=True).value = value_list
    datalist = Range(ws.name, range_name).vertical.value
    return datalist

def list_write(range_name, value_list, ws=None):
    """Write a list vertially.

    list_write(range_name, value_list, ws=None)
    """
    ws = Sheet.active() if ws is None else ws
    # Turn list into a column
    value_column = [[e] for e in value_list]
    Range(ws.name, range_name).value = value_column

    def test_add_wkb(self):
        # test use of add with wkb argument

        # Connect to an alternative test file and make Sheet1 the active sheet
        xl_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'test_range_1.xlsx')
        wb_2nd = Workbook(xl_file, app_visible=False, app_target=APP_TARGET)

        n_before = [sh.name for sh in Sheet.all(wkb=wb_2nd)]
        Sheet.add(name="default", wkb=wb_2nd)
        Sheet.add(name="after1", after=1, wkb=wb_2nd)
        Sheet.add(name="before1", before=1, wkb=wb_2nd)
        n_after = [sh.name for sh in Sheet.all(wkb=wb_2nd)]
        
        n_before.append("default")
        n_before.insert(1, "after1")
        n_before.insert(0, "before1")
        
        assert_equal(n_before, n_after)
        wb_2nd.close()

    def insert_one_dataframe(self, df, cell_specification):
        """
        Populate the current workbook given a single
        :class=:`pandas.DataFrame` object.
        """
        if not len(df):
            return

        index = cell_specification.get('index', False)
        header = cell_specification.get('header', False)
        top_left_cell = cell_specification.get('top_left_cell', 'A0')
        
        logger.debug("insert %d by %d rows/cols dataframe "
                     "at cell '%s' in sheet '%s'",
                     len(df), len(df.columns),
                     str(top_left_cell), Sheet.active(self.wkb).name)
        
        Range(top_left_cell, index=index, header=header).value = df

def get_sheet_arrange():
    """
    To find sheet name "TX or RX" and "2.4G or 5G" and make a dict (name:sheet_pos)
    """
    sheet_names = [i.name.lower() for i in Sheet.all()]
    sheet_ref = {}
    for idx in range(len(sheet_names)):
        if "2.4ghz" in sheet_names[idx]:
            if "tx" in sheet_names[idx]:
                sheet_ref["TX2G"] = idx + 1
            elif "sensitivity" in sheet_names[idx]:
                sheet_ref["RX2G"] = idx + 1
        elif "5ghz" in sheet_names[idx]:
            if "tx" in sheet_names[idx]:
                sheet_ref["TX5G"] = idx + 1
            elif "sensitivity" in sheet_names[idx]:
                sheet_ref["RX5G"] = idx + 1
    return sheet_ref

    def insert_one_series(self, series, cell_specification):
        """
        Populate the current workbook given a single
        :class=:`pandas.Series` object.
        """
        if not len(series):
            return
        
        # contiguous cells
        #TODO: (use vertical and horizontal properties of xlwings)
        
        # non-contiguous user-defined cells
        for cs in cell_specification.get('cells', []):
            ws = cs.get('worksheet') or Sheet.active(self.wkb).name
            content = self.jinja_env.from_string(cs['content']).render(**series)
            
            logger.debug("insert content '%s' at cell '%s' in sheet '%s'",
                         content, cs['cell'], ws)

            Range(ws, cs['cell']).value = content

 def test_all(self):
     all_names = [i.name for i in Sheet.all()]
     assert_equal(all_names, ['Sheet1', 'Sheet2', 'Sheet3'])

 def test_count(self):
     count = Sheet.count()
     assert_equal(count, 3)

 def test_add_name_already_taken(self):
     Sheet.add('Sheet1')

 def test_add_named(self):
     Sheet.add('test', before=1)
     assert_equal(Sheet(1).name, 'test')

 def test_add_default(self):
     # TODO: test call without args properly
     Sheet.add()

    def test_add_after(self):
        Sheet.add(after=Sheet.count())
        assert_equal(Sheet(Sheet.count()).name, Sheet.active().name)

        Sheet.add(after=1)
        assert_equal(Sheet(2).name, Sheet.active().name)