示例#1
0
    def add_worksheet(self, name=None):
        """
        Add a new worksheet to the Excel workbook.

        Args:
            name: The worksheet name. Defaults to 'Sheet1', etc.

        Returns:
            Reference to a worksheet object.

        """
        sheet_index = len(self.worksheets_objs)
        name = self._check_sheetname(name)

        # Initialisation data to pass to the worksheet.
        init_data = {
            "name": name,
            "index": sheet_index,
            "str_table": self.str_table,
            "worksheet_meta": self.worksheet_meta,
            "optimization": self.optimization,
            "tmpdir": self.tmpdir,
            "date_1904": self.date_1904,
        }

        worksheet = Worksheet()
        worksheet._initialize(init_data)

        self.worksheets_objs.append(worksheet)
        self.sheetnames.append(name)

        return worksheet
示例#2
0
    def add_worksheet(self, name=None):
        """
        Add a new worksheet to the Excel workbook.

        Args:
            name: The worksheet name. Defaults to 'Sheet1', etc.

        Returns:
            Reference to a worksheet object.

        """
        sheet_index = len(self.worksheets_objs)
        name = self._check_sheetname(name)

        # Encode any string options passed by the user.
        name = encode_utf8(name)

        # Initialisation data to pass to the worksheet.
        init_data = {
            'name': name,
            'index': sheet_index,
            'str_table': self.str_table,
            'worksheet_meta': self.worksheet_meta,
            'optimization': self.optimization,
            'tmpdir': self.tmpdir,
            'date_1904': self.date_1904,
        }

        worksheet = Worksheet()
        worksheet._initialize(init_data)

        self.worksheets_objs.append(worksheet)
        self.sheetnames.append(name)

        return worksheet
示例#3
0
    def _write_excel_rows(rows: list, workbook: Workbook,
                          worksheet: Worksheet) -> int:
        excel_longest_word = ''

        for i, row in enumerate(rows, 1):
            row_format = None

            if i == 1:
                row_format = workbook.add_format({
                    'bold': True,
                    'bg_color': '#cccccc',
                })
            elif i % 2 == 0:
                row_format = workbook.add_format({
                    'bg_color': '#f1f1f1',
                })

            range_cells = 'A%s:I10' % i

            row_longest_word = find_longest_word(row)
            if len(row_longest_word) > len(excel_longest_word):
                excel_longest_word = row_longest_word

            worksheet.write_row(range_cells, row, row_format)
            self.update_state(state='PROGRESS',
                              meta={
                                  'current': i,
                                  'total': self.total_progress,
                                  'status': 'In progress...',
                              })

        return len(excel_longest_word)
示例#4
0
def adjust_column_and_row_sizes(worksheet: Worksheet, rows: List[Tuple[str,
                                                                       ...]],
                                num_columns: int) -> None:
    """
    Rows height:
    - Title row is thicker than data row
    - blank separator row is thinner than data row
    Columns width:
    - Each column width is wider enough all the text in cells it contains

    :param worksheet: worksheet we operate on
    :param rows: list of tuples where each tuple represents a row in worksheet
    :param num_columns: number of columns in worksheet
    :return:
    """
    num_rows = len(rows)

    # adjust row sizes
    column_max_sizes = [0] * num_columns
    worksheet.set_row(0, 30)
    for i in range(num_rows):
        if rows[i][0] != " ":
            worksheet.set_row(i + 1, 20)
        else:
            worksheet.set_row(i + 1, 10)
        for j in range(num_columns):
            column_max_sizes[j] = max(column_max_sizes[j], len(rows[i][j]) + 5)

    # adjust column sizes
    for j in range(num_columns):
        worksheet.set_column(j, j, column_max_sizes[j])
    worksheet.set_column(num_columns, num_columns, 20)
示例#5
0
def set_column_autowidth(worksheet: Worksheet, column: int):
    """
    Set the width automatically on a column in the `Worksheet`.
    !!! Make sure you run this function AFTER having all cells filled in
    the worksheet!
    """
    maxwidth = get_column_width(worksheet=worksheet, column=column)
    if maxwidth is None:
        return
    worksheet.set_column(first_col=column, last_col=column, width=maxwidth)
示例#6
0
def size_cells(
    ws: xlsxWorksheet,
    col_widths: List[Tuple[int, int, int]],
    row_heights: List[Tuple[int, int]],
) -> None:

    for row, height in [(0, BORDER_CELLS_SPAN_CHAR_UNITS)] + row_heights:
        ws.set_row_pixels(row, height=height)
    for col_i, col_f, width in [(0, 0, BORDER_CELLS_SPAN_CHAR_UNITS)
                                ] + col_widths:
        ws.set_column_pixels(col_i, col_f, width=width)
 def adjust_rows_height(cls,
                        df: pd.DataFrame,
                        wb: Workbook,
                        worksheet: Worksheet):
     bold_fmt = wb.add_format({'bold': True})
     worksheet.set_row(0, cell_format=bold_fmt)
     for idx, row in df.iterrows():
         height = max([1 + sum([1 for ch in str(c or '') if ch == '\n'])
                       for c in row])
         height = min(height, cls.MAX_ROW_HEIGHT)
         worksheet.set_row(idx + 1, height * worksheet.default_row_height)
示例#8
0
    def _set_columns_width(workbook: Workbook, worksheet: Worksheet, columns,
                           fields: List[str]):
        cell_format_text_wrap = workbook.add_format()
        cell_format_text_wrap.set_text_wrap()

        for idx, field in enumerate(fields, start=0):
            if columns[field][MAX_WIDTH_KEY] > MAX_WIDTH:
                worksheet.set_column(idx, idx, MAX_WIDTH,
                                     cell_format_text_wrap)
            else:
                worksheet.set_column(idx, idx, columns[field][MAX_WIDTH_KEY])
示例#9
0
def write_conditional_blank_color_if_dependency_fails(
    worksheet: Worksheet,
    row_index: int,
    column_index: int,
    question: Dict[str, Any],
    full_question_path: Tuple[str, ...],
    question_to_cell: Dict[Tuple[str, ...], str],
    bool_options: Dict[str, str],
    black_format: Format,
) -> None:
    index = -1
    criterias = []
    q = question
    while "dependsOn" in q:
        compare, value = q["dependsOn"]["compare"], q["dependsOn"]["value"]
        new_question_path = full_question_path[:index]
        dependent_cell_name = question_to_cell[(
            new_question_path[0],
            *list(map(lambda x: x[0], list(new_question_path[1:-1]))),
            new_question_path[-1][1],
        )]
        comparison_value = (f'"{bool_options["Yes"]}"' if value is True else
                            '"{boolOptions["No"]}"' if value is False else
                            f"{value}" if isinstance(value, int)
                            or isinstance(value, float) else f'"{value}"')
        opposite_compare = ("<>" if compare == "=" else "=" if compare == "<>"
                            else ">" if compare == "<=" else "<=" if compare ==
                            ">" else ">=" if compare == "<" else "<")
        criterias.append('AND(${0}{1}{2},${0}<>"")'.format(
            dependent_cell_name, opposite_compare, comparison_value))
        index = index - 1
        q = q["dependsOn"]
    if len(criterias) > 1:
        final_criteria = "=OR("
        for i, criteria in enumerate(criterias):
            if i == 0:
                final_criteria = final_criteria + criteria
            else:
                final_criteria = final_criteria + "," + criteria
        final_criteria = final_criteria + ")"
    else:
        final_criteria = "=" + criterias[0]
    worksheet.conditional_format(
        row_index,
        column_index,
        row_index,
        column_index,
        {
            "type": "formula",
            "criteria": final_criteria,
            "format": black_format
        },
    )
def MergeColumnCells(work_book: Workbook, work_sheet: Worksheet, row: int,
                     column_start: int, column_end: int, text: str) -> None:

    # Output :- A1, B2, etc
    column_row_lambda = lambda x: NumToExcelAlpha(x) + str(row + 1)

    # Sample : 'A1:D1'
    merge_range_string = ':'.join(
        map(column_row_lambda, [column_start, column_end]))

    work_sheet.merge_range(merge_range_string, text,
                           GetDefaultCellFormat(work_book))
示例#11
0
def make_sheet_banded(worksheet: Worksheet, df: pd.DataFrame):
    col_vals = df.columns.values
    xl_cols_dict = [{'header': col} for col in df.columns.values]
    last_col_letter = excel_columns()[len(col_vals) - 1]
    xl_last_data_row = df.shape[0] + 1  # plus 1 is because data starts at row 2
    table_style = {
        'banded_rows': True,
        'header_row': True,
        'columns': xl_cols_dict,
        'style': 'Table Style Light 16'
    }

    worksheet.add_table(f'A1:{last_col_letter}{xl_last_data_row}', table_style)
 def adjust_columns_width(cls,
                          df: pd.DataFrame,
                          wb: Workbook,
                          worksheet: Worksheet):
     # wrap_format = wb.add_format({'shrink': True})
     for idx, col in enumerate(df):
         series = df[col]
         max_len = max((
             series.astype(str).map(len).max(),  # len of largest item
             len(str(series.name))  # len of column name/header
         )) + 1  # adding a little extra space
         max_len = min(max_len, cls.MAX_COL_WIDTH)
         worksheet.set_column(idx, idx, max_len)
示例#13
0
    def _add_sheet(self, name, is_chartsheet):
        # Utility for shared code in add_worksheet() and add_chartsheet().

        sheet_index = len(self.worksheets_objs)
        name = self._check_sheetname(name, is_chartsheet)

        # Initialisation data to pass to the worksheet.
        init_data = {
            'name': name,
            'index': sheet_index,
            'str_table': self.str_table,
            'worksheet_meta': self.worksheet_meta,
            'optimization': self.optimization,
            'tmpdir': self.tmpdir,
            'date_1904': self.date_1904,
            'strings_to_numbers': self.strings_to_numbers,
            'strings_to_formulas': self.strings_to_formulas,
            'strings_to_urls': self.strings_to_urls,
            'default_date_format': self.default_date_format,
            'default_url_format': self.default_url_format,
            'excel2003_style': self.excel2003_style,
        }

        if is_chartsheet:
            worksheet = Chartsheet()
        else:
            worksheet = Worksheet()

        worksheet._initialize(init_data)

        self.worksheets_objs.append(worksheet)
        self.sheetnames.append(name)

        return worksheet
def DetailsWriter(work_book: Workbook, work_sheet: Worksheet,
                  excel_sheet_number: int, row: int,
                  details_list: list) -> int:
    ''' Function to write details under respective headers in the excel table 
        Returns a list of count of characters in every cells for the respective row
    '''

    # Use the required empty value
    empty_cell_value = 'NIL'
    format_dict = {
        'align': 'center',
        'valign': 'vcenter',
        'fg_color': '#add8e6',
        'border': 1
    }

    cell_format = work_book.add_format(format_dict)

    column_width = []

    for column, value in enumerate(details_list):
        temp_cell_format = None

        # Check :- is None / empty
        if not value:
            value, temp_cell_format = empty_cell_value, cell_format

        # If value is a list
        elif isinstance(value, list):
            # If the type of list elements is non-object type
            if len(value) == 0 or not isinstance(value[0], dict):
                value = str(value)

            # Type of list elements is object type
            # TODO :: Nested List need to be handled i.e, [[1,2],[3,4]] , flattening the list might be applicable
            else:
                # Set the new Sheet name to the value
                value = ExcelFileWriter(work_book, excel_sheet_number + 1,
                                        value)

        work_sheet.write(row, column, value)

        column_width.append(len(str(value)))

    return column_width
def MergeRowCells(work_book: Workbook, work_sheet: Worksheet, column: int,
                  row_start: int, row_end: int, text: str) -> None:

    if not text:
        return

    cell_format = GetDefaultCellFormat(work_book)

    # If the cell is in the last row of headers, no need for merging cells
    if row_start + 1 == row_end:
        work_sheet.write(row_start, column, text, cell_format)
        return

    # Sample : 'A1:D1'
    merge_range_string = NumToExcelAlpha(column) + str(
        row_start + 1) + ':' + NumToExcelAlpha(column) + str(row_end)

    work_sheet.merge_range(merge_range_string, text, cell_format)
示例#16
0
def write_form_description_as_cell_comment(
    worksheet: Worksheet,
    form_names: List[str],
    question_index_to_row_index: Dict[int, int],
    form_name_to_description: Dict[str, str],
) -> None:
    # add form description as comment to column and make every other form
    # appear in different color
    last_form_name = ""
    i = 1
    for form_name in form_names:
        if form_name != last_form_name:
            last_form_name = form_name
            if form_name in form_name_to_description:
                worksheet.write_comment(
                    question_index_to_row_index[i + 1],
                    0,
                    form_name_to_description[form_name],
                )
        i = i + 1
示例#17
0
    def __init__(self, worksheet: Worksheet, headers=None, header_format=None):
        if headers is None:
            raise Exception("Invalid headers. List expected!")

        if worksheet is None:
            raise Exception("Invalid worksheet")

        self._headers = headers

        self._header_length = [len(header) for header in headers]

        self._worksheet = worksheet

        for i, header in enumerate(headers):
            if header_format is not None:
                worksheet.write(0, i, header, header_format)
            else:
                worksheet.write(0, i, header)

        self._next_row = 1
示例#18
0
文件: RE.py 项目: shennjia/weblte
    def write(self, frame:Worksheet):
        """
        show re on target cell::frame in xlsx
        update the content of value a and format based on the re type
        :param frame:
        :return:
        """

        #  -normal         default
        #  -crs            Cell-specific Reference Signal (CRS)
        #  -mbsfnrs        MBSFN reference signal
        #  -pbch           PBCH
        #  -uepdsch_dmrs   UE-specific Reference Signal (DM-RS) associated with PDSCH
        #  -edpdcch_dmrs   DeModulation Reference Signal (DM-RS) associated with EPDCCH
        #  -pcs            Positioning Reference Signal (PRS)
        #  -csi_rs         SI Reference Signal (CSI-RS)


        #only normal cp is supported in current release 2016.1.8
        # in future,offset shall derived from an accumulated way or a lookup  table
        frame.write(self.k+self.n__s*7, self.l+self.n__s*7, self.a, self.reFormat)
示例#19
0
 def write_data(self, sheet: Worksheet, year_list):
     sheet.write_column(1, 0, asset_sheet_content_zh)
     col = 1
     for year in year_list:
         sheet.write(0, col, str(year) + self.date)
         sheet.write_column(1, col, self.get_sheet(year).data_list)
         col += 1
示例#20
0
 def write_row_col(sheet:Worksheet, row:int, col:int, dataL:list, cellFormat, writeRow:bool):
     # if cellFormat is a list, assign cellFormat to the corresponding data, 
     # else assign the same cellFormat to all data
     broadcast = (not isinstance(cellFormat, list))
     if not broadcast:
         if len(dataL) != len(cellFormat):
             raise ValueError("The length of data and formats should be the same")
             
     for i in range(len(dataL)):
         if writeRow:
             # row not changed, col increases with i
             tmpRow = row
             tmpCol = col+i
         else:
             # row increases with i, col not changed
             tmpRow = row+i
             tmpCol = col
             
         # write as number in default, otherwise as string
         try:
             sheet.write_number(tmpRow, tmpCol, float(dataL[i]), cellFormat if broadcast else cellFormat[i])
         except (TypeError, ValueError):
             sheet.write_string(tmpRow, tmpCol, dataL[i], cellFormat if broadcast else cellFormat[i])
示例#21
0
    def add_worksheet(self, name=None):
        """
        Add a new worksheet to the Excel workbook.

        Args:
            name: The worksheet name. Defaults to 'Sheet1', etc.

        Returns:
            Reference to a worksheet object.

        """
        sheet_index = len(self.worksheets_objs)
        name = self._check_sheetname(name)

        # Initialisation data to pass to the worksheet.
        init_data = {
            'name': name,
            'index': sheet_index,
            'str_table': self.str_table,
            'worksheet_meta': self.worksheet_meta,
            'optimization': self.optimization,
            'tmpdir': self.tmpdir,
            'date_1904': self.date_1904,
            'strings_to_numbers': self.strings_to_numbers,
            'strings_to_formulas': self.strings_to_formulas,
            'strings_to_urls': self.strings_to_urls,
            'default_date_format': self.default_date_format,
            'default_url_format': self.default_url_format,
        }

        worksheet = Worksheet()
        worksheet._initialize(init_data)

        self.worksheets_objs.append(worksheet)
        self.sheetnames.append(name)

        return worksheet
示例#22
0
    def add_worksheet(self, name=None):
        """
        Add a new worksheet to the Excel workbook.

        Args:
            name: The worksheet name. Defaults to 'Sheet1', etc.

        Returns:
            Reference to a worksheet object.

        """
        sheet_index = len(self.worksheets_objs)
        name = self._check_sheetname(name)

        # Initialisation data to pass to the worksheet.
        init_data = {
            'name': name,
            'index': sheet_index,
            'str_table': self.str_table,
            'worksheet_meta': self.worksheet_meta,
            'optimization': self.optimization,
            'tmpdir': self.tmpdir,
            'date_1904': self.date_1904,
            'strings_to_numbers': self.strings_to_numbers,
            'strings_to_formulas': self.strings_to_formulas,
            'strings_to_urls': self.strings_to_urls,
            'default_date_format': self.default_date_format,
            'default_url_format': self.default_url_format,
        }

        worksheet = Worksheet()
        worksheet._initialize(init_data)

        self.worksheets_objs.append(worksheet)
        self.sheetnames.append(name)

        return worksheet
示例#23
0
 def write_data(self, sheet: Worksheet, merge_format):
     """
     write the indicator data to the indicator sheet
     :param sheet: indicator sheet which is a xlsxwriter.Worksheet instance
     """
     col = 1
     for year in self.year_list:
         year_data = self.year2data[year]
         sheet.write_column(6, col, year_data.data_list)
         col += 1
     avg_col = 1 + len(self.year_list)  # “行业平均”数据所在列
     ratio_col = 1 + avg_col  # “比率”数据所在列
     sub_score_col = 1 + ratio_col  # “分项能力”得分所在列
     sheet.write_column(6, avg_col, self.avg_data)
     sheet.write_column(6, ratio_col, self.ratio)
     sheet.merge_range("%s:%s" % (xl_rowcol_to_cell(6, sub_score_col), xl_rowcol_to_cell(11, sub_score_col)),
                       self.score, merge_format)
示例#24
0
def write_column_titles(
    worksheet: Worksheet,
    num_columns: int,
    title_format: Format,
    translations: Dict[str, str],
) -> None:
    worksheet.write("A1", translations.get("Form", "Form"), title_format)
    for i in range(1, num_columns - 1):
        worksheet.write_blank(f"{xl_col_to_name(i)}1", "", title_format)
    worksheet.write(
        f"{xl_col_to_name(num_columns - 1)}1",
        translations.get("Question", "Question"),
        title_format,
    )
    worksheet.write(
        f"{xl_col_to_name(num_columns)}1",
        translations.get("Answer", "Answer"),
        title_format,
    )
示例#25
0
    async def _store_hotel(self,
                           sheet: Worksheet,
                           row: int,
                           parsed_columns: List[HotelField],
                           hotel: HotelContentRow) -> None:

        parsed_header: HotelField
        # 由 Columns 尋訪,並找出資料欄位
        for col, header in enumerate(parsed_columns):
            if header is HotelField.Url:
                url = hotel[header]
                url = self._normializa_url(url)
                link_style = {"color": "blue", "underline": 1, "font_size": 12}
                link_format = self._workbook.add_format(link_style)
                sheet.write_url(row, col, url, link_format)
            elif header is HotelField.Rooms:
                number_style = {"font_size": 12}
                number_format = self._workbook.add_format(number_style)
                sheet.write_number(row, col, int(hotel[header]), number_format)
            else:
                # 如果資料為 None 改成空字串
                field_data = hotel[header] if hotel[header] else ""
                sheet.write_string(row, col, field_data)
示例#26
0
 def _write_end(self, worksheet: Worksheet):
     worksheet.write('A35', 'Konditionen:', self.fonts.tt)
     worksheet.write('B35', '', self.fonts.leer)
     worksheet.write('C35', 'netto', self.fonts.ttr)
     worksheet.write('A36', 'zahlbar bis:', self.fonts.tt)
     worksheet.write('B36', '', self.fonts.leer)
     worksheet.write('C36',
                     (datetime.date.today() +
                      datetime.timedelta(365 / 12)).strftime('%d.%m.%Y'),
                     self.fonts.ttr_rot)
     worksheet.write('A38', 'Herzlichen Dank für den geschätzten Auftrag',
                     self.fonts.d)
     worksheet.write('A40', 'Mit freundlichen Grüssen', self.fonts.d)
     worksheet.write('A41', 'Name des Betriebs', self.fonts.pr)
示例#27
0
 def _write_bill_header(self, worksheet: Worksheet):
     worksheet.write('A13', 'Rechnung', self.fonts.rechnung)
     worksheet.write('B13', '', self.fonts.dd)
     worksheet.write('C13', '', self.fonts.dd)
     worksheet.write('D13', '', self.fonts.dd)
示例#28
0
 def _write_postal_information(self, worksheet: Worksheet, bill: Bill):
     worksheet.write('A7', 'Kunde:', self.fonts.bg)
     worksheet.write('C7', bill.customer_name, self.fonts.d)
     worksheet.write('C8', bill.customer_address, self.fonts.d)
     worksheet.write('C9', bill.customer_zip_place, self.fonts.d)
示例#29
0
 def _write_bill_meta_info(self, worksheet: Worksheet, bill: Bill):
     worksheet.write('A16', 'Datum:', self.fonts.bg)
     t = time.strftime("%d.%m.%Y")
     worksheet.write('C16', t, self.fonts.d)
     worksheet.write('A18', 'Rechnungperiode:', self.fonts.d)
     worksheet.write('C18', bill.period_str, self.fonts.pr)
     worksheet.write('A19', 'Rechnungsnummer:', self.fonts.d)
     worksheet.write('C19', bill.get_bill_nbr_string(), self.fonts.pr)
示例#30
0
    def _write_table(self, worksheet: Worksheet, bill: Bill):
        worksheet.write('A21', 'Anzahl', self.fonts.tt)
        worksheet.write('B21', 'Beschreibung', self.fonts.tt)
        worksheet.write('C21', 'Preis', self.fonts.tt)
        worksheet.write('D21', 'Betrag', self.fonts.tt)
        worksheet.write('A22', '', self.fonts.leer)
        worksheet.write('B22', 'Eierlieferungen', self.fonts.tt),
        worksheet.write('C22', '', self.fonts.leer)
        worksheet.write('D22', '', self.fonts.leer)

        worksheet.write('A23', bill.nbr_of_eggs, self.fonts.anzahl)
        worksheet.write('B23', 'Stück', self.fonts.tt)
        worksheet.write('C23', Bill.price_per_egg, self.fonts.ttr)
        worksheet.write('D23', '=A23*C23', self.fonts.ttr)

        for x in range(23, 29):
            for y in range(0, 4):
                worksheet.write(x, y, '', self.fonts.leer)

        worksheet.write('C30', 'Total', self.fonts.bgu)
        worksheet.write('D30', '=SUM(D23:D29)', self.fonts.total)
示例#31
0
def add_cell_validation(
    worksheet: Worksheet,
    row_index: int,
    column_index: int,
    full_question_path: Tuple[str, ...],
    question: Dict[str, Any],
    question_to_cell: Dict[Tuple[str, ...], str],
    bool_options: Dict[str, str],
    date_format: Format,
    black_format: Format,
) -> None:
    type = question["questionType"]
    has_options = "options" in question
    if type == "BOOL":
        worksheet.data_validation(
            row_index,
            column_index,
            row_index,
            column_index,
            {
                "validate": "list",
                "source": list(bool_options.values())
            },
        )
    elif has_options:
        options = question["options"]
        if "multiOptions" in question and question["multiOptions"]:
            s = set(options)
            multi_options = sum(
                map(lambda r: sorted(list(combinations(s, r))),
                    range(1,
                          len(s) + 1)),
                [],
            )
            options = [
                ";".join(multi_option) for multi_option in multi_options
            ]
        worksheet.data_validation(
            row_index,
            column_index,
            row_index,
            column_index,
            {
                "validate": "list",
                "source": options
            },
        )
    elif type == "INTEGER":
        worksheet.data_validation(
            row_index,
            column_index,
            row_index,
            column_index,
            {
                "validate": "integer",
                "criteria": ">",
                "value": -(2**32)
            },
        )
    elif type == "FLOAT":
        worksheet.data_validation(
            row_index,
            column_index,
            row_index,
            column_index,
            {
                "validate": "decimal",
                "criteria": ">",
                "value": -(2**32)
            },
        )
    elif type == "DATE":
        worksheet.write_datetime(
            row_index,
            column_index,
            datetime.strptime("01/01/1970", "%d/%m/%Y"),
            date_format,
        )
    if "questionDescription" in question:
        worksheet.write_comment(row_index, column_index,
                                question["questionDescription"])
    if "dependsOn" in question:
        write_conditional_blank_color_if_dependency_fails(
            worksheet,
            row_index,
            column_index,
            question,
            full_question_path,
            question_to_cell,
            bool_options,
            black_format,
        )
示例#32
0
    def write_xlsx(self, sheet: Worksheet, father):
        graph1 = bar_and_plot(
            category=self.year_list,
            bar_param=[[
                father.profit_data.get_sheet(year).data["selling_expenses"]
                for year in self.year_list
            ], "销售费用"],
            plot_param=[[
                self.get_indicator(year).data["sales_expense_rate"]
                for year in self.year_list
            ], "销售费用率"])
        sheet.insert_image(0, 0, "", {"image_data": graph1})

        graph2 = bar_and_plot(
            category=self.year_list,
            bar_param=[[
                father.profit_data.get_sheet(year).data["management_fees"]
                for year in self.year_list
            ], "管理费用"],
            plot_param=[[
                self.get_indicator(year).data["management_fee_rate"]
                for year in self.year_list
            ], "管理费用率"])
        sheet.insert_image(20, 0, "", {"image_data": graph2})

        graph3 = bar_and_plot(
            category=self.year_list,
            bar_param=[[
                (father.profit_data.get_sheet(year).data["management_fees"] +
                 father.profit_data.get_sheet(year).data["selling_expenses"])
                for year in self.year_list
            ], "销售费用+管理费用"],
            plot_param=[[
                self.get_indicator(year).data["sales_management_fee_rate"]
                for year in self.year_list
            ], "销售管理费用率"])
        sheet.insert_image(40, 0, "", {"image_data": graph3})

        graph4 = bar_and_plot(
            category=self.year_list,
            bar_param=[[
                (father.profit_data.get_sheet(year).data["management_fees"] +
                 father.profit_data.get_sheet(year).data["selling_expenses"] +
                 father.profit_data.get_sheet(year).data["financial_expenses"])
                for year in self.year_list
            ], "期间费用"],
            plot_param=[[
                self.get_indicator(year).data["period_expense_rate"]
                for year in self.year_list
            ], "期间费用率"])
        sheet.insert_image(60, 0, "", {"image_data": graph4})

        graph5 = bar_and_plot(
            category=self.year_list,
            bar_param=[[
                father.balance_data.get_sheet(year).data["total_assets"]
                for year in self.year_list
            ], "资产总计"],
            plot_param=[[
                self.get_indicator(year).data["asset_turnover_days"]
                for year in self.year_list
            ], "资产周转天数"],
            use_percent=False)
        sheet.insert_image(80, 0, "", {"image_data": graph5})

        graph6 = bar_and_plot(
            category=self.year_list,
            bar_param=[[
                father.balance_data.get_sheet(year).data["accounts_receivable"]
                for year in self.year_list
            ], "应收账款"],
            plot_param=[[
                self.get_indicator(
                    year).data["accounts_receivable_turnover_days"]
                for year in self.year_list
            ], "应收账款周转天数"],
            use_percent=False)
        sheet.insert_image(100, 0, "", {"image_data": graph6})

        graph7 = bar_and_plot(
            category=self.year_list,
            bar_param=[[
                father.balance_data.get_sheet(year).data["stock"]
                for year in self.year_list
            ], "存货"],
            plot_param=[[
                self.get_indicator(year).data["inventory_turnover_days"]
                for year in self.year_list
            ], "存货周转天数"],
            use_percent=False)
        sheet.insert_image(120, 0, "", {"image_data": graph7})

        graph8 = img_draw(category=self.year_list,
                          plot_params=[[[
                              self.get_indicator(year).data["business_cycle"]
                              for year in self.year_list
                          ], "营业周期", 1]],
                          use_percent=False)
        sheet.insert_image(140, 0, "", {"image_data": graph8})

        graph9 = img_draw(
            category=self.year_list,
            plot_params=[[[
                self.get_indicator(year).data["repayment_rate_of_sales"]
                for year in self.year_list
            ], "销售回款率", 1]])
        sheet.insert_image(160, 0, "", {"image_data": graph9})
示例#33
0
    def write_xlsx(self, sheet: Worksheet, father):
        graph1 = bar_and_plot(
            category=self.year_list,
            bar_param=[
                [father.cash_data.get_sheet(year).data["net_cash_op"] for year in self.year_list],
                "经营现金流"
            ],
            plot_param=[
                [self.get_indicator(year).data["operating_cash_growth_rate"] for year in self.year_list],
                "经营现金增长率"
            ]
        )
        sheet.insert_image(0, 0, "", {"image_data": graph1})

        graph2 = img_draw(
            category=self.year_list,
            plot_params=[
                [
                    [father.dev_data.get_indicator(year).data["sales_growth_rate"] for year in self.year_list],
                    "销售增长率",
                    1
                ],
                [
                    [self.get_indicator(year).data["operating_cash_growth_rate"] for year in self.year_list],
                    "经营现金增长率",
                    1
                ]
            ]
        )
        sheet.insert_image(20, 0, "", {"image_data": graph2})

        graph3 = bar_and_plot(
            category=self.year_list,
            bar_param=[
                [father.cash_data.get_sheet(year).data["final_cash"] for year in self.year_list],
                "期末现金流"
            ],
            plot_param=[
                [self.get_indicator(year).data["cash_flow_growth_rate"] for year in self.year_list],
                "现金流量增长率"
            ]
        )
        sheet.insert_image(40, 0, "", {"image_data": graph3})

        graph4 = bar_and_plot(
            category=self.year_list,
            bar_param=[
                [self.get_indicator(year).data["free_cash_ratio"] for year in self.year_list],
                "自由现金流"
            ],
            plot_param=[
                [self.get_indicator(year).data["sales_and_operating_cash_ratio"] for year in self.year_list],
                "销售自由现金比"
            ]
        )
        sheet.insert_image(60, 0, "", {"image_data": graph4})

        graph5 = img_draw(
            category=self.year_list,
            plot_params=[
                [
                    [self.get_indicator(year).data["sales_and_operating_cash_ratio"] for year in self.year_list],
                    "销售经营现金比",
                    1
                ]
            ]
        )
        sheet.insert_image(80, 0, "", {"image_data": graph5})

        graph6 = img_draw(
            category=self.year_list,
            plot_params=[
                [
                    [self.get_indicator(year).data["sales_cash_ratio"] for year in self.year_list],
                    "销售现金比",
                    1
                ]
            ]
        )
        sheet.insert_image(100, 0, "", {"image_data": graph6})