templates
/
KiBot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
KiBot/kibot/bom/xlsx_writer.py

812 lines
32 KiB
Python
Raw Blame History

# -*- coding: utf-8 -*-
# Copyright (c) 2020-2021 Salvador E. Tropea
# Copyright (c) 2020-2021 Instituto Nacional de Tecnología Industrial
# Copyright (c) 2016-2020 Oliver Henry Walters (@SchrodingersGat)
# License: MIT
# Project: KiBot (formerly KiPlot)
# Adapted from: https://github.com/SchrodingersGat/KiBoM
"""
XLSX Writer: Generates an XLSX BoM file.
"""
import io
import pprint
import os.path as op
import sys
from textwrap import wrap
from base64 import b64decode
from .columnlist import ColumnList
from .kibot_logo import KIBOT_LOGO
from .. import log
from ..misc import W_NOKICOST, W_UNKDIST, KICOST_ERROR, W_BADFIELD
from ..error import trace_dump
from ..__main__ import __version__
try:
from xlsxwriter import Workbook
XLSX_SUPPORT = True
except ModuleNotFoundError:
XLSX_SUPPORT = False
class Workbook():
pass
# KiCost support
try:
# Give priority to submodules
rel_path = '../../submodules/KiCost/'
if op.isfile(op.join(op.dirname(__file__), rel_path+'kicost/__init__.py')):
rel_path = op.abspath(op.join(op.dirname(__file__), rel_path))
if rel_path not in sys.path:
sys.path.insert(0, rel_path)
# Init the logger first
logger = log.get_logger(__name__)
from kicost.global_vars import set_logger, KiCostError
set_logger(logger)
from kicost import PartGroup
from kicost.kicost import query_part_info
from kicost.spreadsheet import create_worksheet, Spreadsheet
from kicost.distributors import (init_distributor_dict, set_distributors_logger, get_distributors_list,
get_dist_name_from_label, set_distributors_progress, is_valid_api,
configure_from_environment, configure_apis)
from kicost.edas import set_edas_logger
from kicost.config import load_config
# Progress mechanism: use the one declared in __main__ (TQDM)
from kicost.__main__ import ProgressConsole
set_distributors_progress(ProgressConsole)
KICOST_SUPPORT = True
except ModuleNotFoundError:
KICOST_SUPPORT = False
BG_GEN = "#E6FFEE" # "#C6DFCE"
BG_KICAD = "#FFE6B3" # "#DFC693"
BG_USER = "#E6F9FF" # "#C6D9DF"
BG_EMPTY = "#FF8080"
BG_GEN_L = "#F0FFF4"
BG_KICAD_L = "#FFF0BD"
BG_USER_L = "#F0FFFF"
BG_EMPTY_L = "#FF8A8A"
BG_COLORS = [[BG_GEN, BG_GEN_L], [BG_KICAD, BG_KICAD_L], [BG_USER, BG_USER_L], [BG_EMPTY, BG_EMPTY_L]]
GREY = "#dddddd"
GREY_L = "#f3f3f3"
HEAD_COLOR_R = "#982020"
HEAD_COLOR_G = "#009879"
HEAD_COLOR_B = "#0e4e8e"
DEFAULT_FMT = {'text_wrap': True, 'align': 'center_across', 'valign': 'vcenter'}
KICOST_COLUMNS = {'refs': ColumnList.COL_REFERENCE,
'desc': ColumnList.COL_DESCRIPTION,
'qty': ColumnList.COL_GRP_BUILD_QUANTITY}
SPECS_GENERATED = set((ColumnList.COL_REFERENCE_L, ColumnList.COL_ROW_NUMBER_L, 'sep'))
def bg_color(col):
""" Return a background color for a given column title """
col = col.lower()
# Auto-generated columns
if col in ColumnList.COLUMNS_GEN_L:
return 0
# KiCad protected columns
elif col in ColumnList.COLUMNS_PROTECTED_L:
return 1
# Additional user columns
return 2
def add_info(worksheet, column_widths, row, col_offset, formats, text, value):
worksheet.write_string(row, col_offset, text, formats[0])
if isinstance(value, (int, float)):
worksheet.write_number(row, col_offset+1, value, formats[1])
value = str(value)
else:
worksheet.write_string(row, col_offset+1, value, formats[1])
column_widths[col_offset] = max(len(text)+1, column_widths[col_offset])
column_widths[col_offset+1] = max(len(value), column_widths[col_offset+1])
return row + 1
def compute_head_size(cfg):
col_logo = 0 if cfg.xlsx.logo is None else 6
col_info = 1 if cfg.xlsx.title else 0
if not (cfg.xlsx.hide_pcb_info and cfg.xlsx.hide_stats_info):
col_info += 5
if len(cfg.aggregate) > 1:
col_info += 6*len(cfg.aggregate)
head_size = max(col_logo, col_info)
if head_size:
# To separate
head_size += 1
return head_size
def get_bg_color(style_name):
head_color = None
if style_name.startswith('modern-'):
if style_name.endswith('green'):
head_color = HEAD_COLOR_G
elif style_name.endswith('blue'):
head_color = HEAD_COLOR_B
else:
head_color = HEAD_COLOR_R
return head_color
def create_fmt_head(workbook, style_name):
fmt_head = workbook.add_format(DEFAULT_FMT)
fmt_head.set_bold()
if style_name.startswith('modern-'):
fmt_head.set_bg_color(get_bg_color(style_name))
fmt_head.set_font_color("#ffffff")
return fmt_head
def get_logo_data(logo):
if logo is not None:
if logo:
with open(logo, 'rb') as f:
image_data = f.read()
else:
image_data = b64decode(KIBOT_LOGO)
else:
image_data = None
return image_data
def create_fmt_title(workbook, title):
if not title:
return None
fmt_title = workbook.add_format(DEFAULT_FMT)
fmt_title.set_font_size(24)
fmt_title.set_bold()
fmt_title.set_font_name('Arial')
fmt_title.set_align('left')
return fmt_title
def create_fmt_subtitle(workbook):
fmt_title = workbook.add_format(DEFAULT_FMT)
fmt_title.set_font_size(18)
fmt_title.set_bold()
fmt_title.set_font_name('Arial')
fmt_title.set_align('left')
return fmt_title
def create_fmt_cols(workbook, col_colors):
""" Create the possible column formats """
fmt_cols = []
if col_colors:
for c in BG_COLORS:
fmts = [None, None]
fmts[0] = workbook.add_format(DEFAULT_FMT)
fmts[1] = workbook.add_format(DEFAULT_FMT)
fmts[0].set_bg_color(c[0])
fmts[1].set_bg_color(c[1])
fmt_cols.append(fmts)
else:
fmts = [None, None]
fmts[0] = workbook.add_format(DEFAULT_FMT)
fmts[1] = workbook.add_format(DEFAULT_FMT)
fmts[0].set_bg_color(GREY)
fmts[1].set_bg_color(GREY_L)
fmt_cols.append(fmts)
return fmt_cols
def create_col_fmt(col_fields, col_colors, fmt_cols):
""" Assign a color to each column """
col_fmt = []
if col_colors:
for c in col_fields:
col_fmt.append(fmt_cols[bg_color(c)])
else:
for c in col_fields:
col_fmt.append(fmt_cols[0])
# Empty color
col_fmt.append(fmt_cols[-1])
return col_fmt
def create_fmt_info(workbook, cfg):
""" Formats for the PCB and stats info """
if cfg.xlsx.hide_pcb_info and cfg.xlsx.hide_stats_info:
return None
# Data left justified
fmt_data = workbook.add_format({'align': 'left'})
fmt_name = workbook.add_format(DEFAULT_FMT)
fmt_name.set_bold()
fmt_name.set_align('left')
return [fmt_name, fmt_data]
def insert_logo(worksheet, image_data, scale):
""" Inserts the logo, returns how many columns we used """
if image_data:
# Note: OpenOffice doesn't support using images in the header for XLSXs
# worksheet.set_header('&L&[Picture]', {'image_left': 'logo.png', 'image_data_left': image_data})
options = {'image_data': io.BytesIO(image_data),
'x_scale': scale,
'y_scale': scale,
'object_position': 1,
'decorative': True}
worksheet.insert_image('A1', 'logo.png', options)
return 2
return 0
def create_color_ref(workbook, col_colors, hl_empty, fmt_cols, do_kicost, kicost_colors):
if not (col_colors or do_kicost):
return
row = 0
worksheet = workbook.add_worksheet('Colors')
worksheet.set_column(0, 0, 50)
if col_colors:
worksheet.write_string(0, 0, 'KiCad Fields (default)', fmt_cols[1][0])
worksheet.write_string(1, 0, 'Generated Fields', fmt_cols[0][0])
worksheet.write_string(2, 0, 'User Fields', fmt_cols[2][0])
if hl_empty:
worksheet.write_string(3, 0, 'Empty Fields', fmt_cols[3][0])
row = 5
if do_kicost:
worksheet.write_string(row, 0, 'Costs sheet')
for label, format in kicost_colors.items():
row += 1
worksheet.write_string(row, 0, label, format)
def get_spec(part, name):
if name[0] != '_':
return part.specs.get(name, ['', ''])
name = name[1:]
for k, v in part.dd.items():
val = v.extra_info.get(name, None)
if val:
return [name, val]
return ['', '']
def create_meta(workbook, name, columns, parts, fmt_head, fmt_cols, max_w, rename, levels, comments, join):
worksheet = workbook.add_worksheet(name)
col_w = []
row_h = 1
for c, col in enumerate(columns):
name = rename.get(col.lower(), col) if rename else col
worksheet.write_string(0, c, name, fmt_head)
text_l = max(len(col), 6)
if text_l > max_w:
h = len(wrap(col, max_w))
row_h = max(row_h, h)
text_l = max_w
col_w.append(text_l)
if row_h > 1:
worksheet.set_row(0, 15.0*row_h)
for r, part in enumerate(parts):
# Add the references as another spec
part.specs[ColumnList.COL_REFERENCE_L] = (ColumnList.COL_REFERENCE, part.collapsed_refs)
# Also add the row
part.specs[ColumnList.COL_ROW_NUMBER_L] = (ColumnList.COL_ROW_NUMBER, str(r+1))
row_h = 1
for c, col in enumerate(columns):
col_l = col.lower()
if col_l == 'sep':
col_w[c] = 0
continue
v = get_spec(part, col_l)
text = v[1]
# Append text from other fields
if join:
for j in join:
if j[0] == col_l:
for c_join in j[1:]:
v = part.specs.get(c_join, None)
if v:
text += ' ' + v[1]
text_l = len(text)
if not text_l:
continue
fmt_kind = 0 if col_l in SPECS_GENERATED else 2
worksheet.write_string(r+1, c, text, fmt_cols[fmt_kind][r % 2])
if text_l > col_w[c]:
if text_l > max_w:
h = len(wrap(text, max_w))
row_h = max(row_h, h)
text_l = max_w
col_w[c] = text_l
if row_h > 1:
worksheet.set_row(r+1, 15.0*row_h)
for i, width in enumerate(col_w):
ops = {'level': levels[i] if levels else 0}
if not width:
ops['hidden'] = 1
if comments and comments[i]:
worksheet.write_comment(0, i, comments[i])
worksheet.set_column(i, i, width, None, ops)
def adjust_widths(worksheet, column_widths, max_width, levels):
c_levels = len(levels)
for i, width in enumerate(column_widths):
if width > max_width:
width = max_width
if i < c_levels:
worksheet.set_column(i, i, width, None, {'level': levels[i]})
def adjust_heights(worksheet, rows, max_width, head_size):
for rn, r in enumerate(rows):
max_h = 1
for c in r:
if len(c) > max_width:
h = len(wrap(c, max_width))
max_h = max(h, max_h)
if max_h > 1:
worksheet.set_row(head_size+rn, 15.0*max_h)
def write_info(cfg, r_info_start, worksheet, column_widths, col1, fmt_info, fmt_subtitle, compact=False):
if len(cfg.aggregate) == 1:
# Only one project
rc = r_info_start
if not cfg.xlsx.hide_pcb_info:
prj = cfg.aggregate[0]
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Schematic:", prj.name)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Variant:", cfg.variant.name)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Revision:", prj.sch.revision)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Date:", prj.sch.date)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "KiCad Version:", cfg.kicad_version)
col1 += 2
rc = r_info_start
if not cfg.xlsx.hide_stats_info:
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Component Groups:", cfg.n_groups)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Component Count:", cfg.n_total)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Fitted Components:", cfg.n_fitted)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Number of PCBs:", cfg.number)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Total Components:", cfg.n_build)
else:
# Multiple projects
# Global stats
old_col1 = col1
rc = r_info_start
if not cfg.xlsx.hide_pcb_info:
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Variant:", cfg.variant.name)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "KiCad Version:", cfg.kicad_version)
col1 += 2
rc = r_info_start
if not cfg.xlsx.hide_stats_info:
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Component Groups:", cfg.n_groups)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Component Count:", cfg.n_total)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Fitted Components:", cfg.n_fitted)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Number of PCBs:", cfg.number)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Total Components:", cfg.n_build)
# Individual stats
# No need to waste space for a column with no data
r_info_start += 3 if cfg.xlsx.hide_stats_info and compact else 5
for prj in cfg.aggregate:
col1 = old_col1
worksheet.set_row(r_info_start, 24)
worksheet.merge_range(r_info_start, col1, r_info_start, len(column_widths)-1, prj.sch.title, fmt_subtitle)
r_info_start += 1
rc = r_info_start
if not cfg.xlsx.hide_pcb_info:
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Schematic:", prj.name)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Revision:", prj.sch.revision)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Date:", prj.sch.date)
if prj.sch.company:
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Company:", prj.sch.company)
if prj.ref_id:
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "ID:", prj.ref_id)
col1 += 2
rc = r_info_start
if not cfg.xlsx.hide_stats_info:
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Component Groups:", prj.comp_groups)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Component Count:", prj.comp_total)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Fitted Components:", prj.comp_fitted)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Number of PCBs:", prj.number)
rc = add_info(worksheet, column_widths, rc, col1, fmt_info, "Total Components:", prj.comp_build)
r_info_start += 5
def adapt_extra_cost_columns(cfg):
if not cfg.columns_ce:
return
user_fields = []
for i, col in enumerate(cfg.columns_ce):
data = {'field': col}
comment = cfg.column_comments_ce[i]
if comment:
data['comment'] = comment
level = cfg.column_levels_ce[i]
if level:
data['level'] = level
col = col.lower()
if col in cfg.column_rename_ce:
data['label'] = cfg.column_rename_ce[col]
user_fields.append(data)
Spreadsheet.USER_FIELDS = user_fields
def apply_join_requests(join, adapted, original):
if not join:
return
for key, val in original.items():
append = ''
for join_l in join:
# Each list is "target, source..." so we need at least 2 elements
elements = len(join_l)
target = join_l[0]
if elements > 1 and target == key:
# Append data from the other fields
for source in join_l[1:]:
v = original.get(source)
if v:
append += ' ' + v
if append:
if val is None:
val = ''
adapted[key] = val + append
def remove_unknown_distributors(distributors, available, silent):
new_distributors = []
for d in distributors:
d = d.lower()
if d not in available:
# Is the label of the column?
new_d = get_dist_name_from_label(d)
if new_d is not None:
d = new_d
if d not in available:
if not silent:
logger.warning(W_UNKDIST+'Unknown distributor `{}`'.format(d))
else:
new_distributors.append(d)
return new_distributors
def solve_distributors(cfg, silent=True):
# List of distributors to scrape
available = get_distributors_list()
include = remove_unknown_distributors(cfg.distributors, available, silent)
exclude = remove_unknown_distributors(cfg.no_distributors, available, silent)
# Default is to sort the entries
Spreadsheet.SORT_DISTRIBUTORS = True
if not include:
# All by default
dist_list = available
else:
# Requested to be included
dist_list = include
# Keep user sorting
Spreadsheet.SORT_DISTRIBUTORS = False
# Requested to be excluded
for d in exclude:
dist_list.remove(d)
Spreadsheet.DISTRIBUTORS = dist_list
return dist_list
def compute_qtys(cfg, g):
if len(cfg.aggregate) == 1:
return str(g.get_count())
return [str(g.get_count(sch.name)) for sch in cfg.aggregate]
def create_meta_sheets(workbook, used_parts, fmt_head, fmt_cols, cfg, ss):
if cfg.xlsx.specs:
meta_names = ['Specs', 'Specs (DNF)']
for ws in range(2):
spec_cols = {}
spec_cols_l = set()
parts = used_parts[ws]
for part in parts:
for name_l, v in part.specs.items():
spec_cols_l.add(name_l)
spec = v[0]
if spec in spec_cols:
spec_cols[spec] += 1
else:
spec_cols[spec] = 1
if len(spec_cols):
columns = cfg.xlsx.s_columns
if columns is None:
# Use all columns, sort them by relevance (most used) and alphabetically
c = len(parts)
columns = sorted(spec_cols, key=lambda k: (c - spec_cols[k], k))
columns.insert(0, ColumnList.COL_REFERENCE)
else:
# Inform about missing columns
for c in columns:
col = c.lower()
if ((col[0] == '_' and col[1:] not in ss.extra_info_display) or
(col[0] != '_' and col not in spec_cols_l and col not in SPECS_GENERATED)):
logger.warning(W_BADFIELD+'Invalid Specs column name `{}` {}'.format(c, col[1:]))
create_meta(workbook, meta_names[ws], columns, parts, fmt_head, fmt_cols, cfg.xlsx.max_col_width,
cfg.xlsx.s_rename, cfg.xlsx.s_levels, cfg.xlsx.s_comments, cfg.xlsx.s_join)
def _create_kicost_sheet(workbook, groups, image_data, fmt_title, fmt_info, fmt_subtitle, fmt_head, fmt_cols, cfg):
if not KICOST_SUPPORT:
logger.warning(W_NOKICOST, 'KiCost sheet requested but failed to load KiCost support')
return
if cfg.debug_level > 2:
logger.debug("Groups exported to KiCost:")
for g in groups:
logger.debug(pprint.pformat(g.__dict__))
logger.debug("-- Components")
for c in g.components:
logger.debug(pprint.pformat(c.__dict__))
# Force KiCost to use our logger
set_distributors_logger(logger)
set_edas_logger(logger)
# Load KiCost config (includes APIs config)
api_options = load_config()
# Environment with overwrite
configure_from_environment(api_options, True)
# Filter which APIs we want
for api in cfg.xlsx.kicost_api_disable:
if is_valid_api(api):
api_options[api]['enable'] = False
for api in cfg.xlsx.kicost_api_enable:
if is_valid_api(api):
api_options[api]['enable'] = True
# Configure the APIs
configure_apis(api_options)
# Start with a clean list of available distributors
init_distributor_dict()
# Create the projects information structure
prj_info = [{'title': p.name, 'company': p.sch.company, 'date': p.sch.date, 'qty': p.number} for p in cfg.aggregate]
# Create the worksheets
ws_names = ['Costs', 'Costs (DNF)']
Spreadsheet.PRJ_INFO_ROWS = 5 if len(cfg.aggregate) == 1 else 6
Spreadsheet.PRJ_INFO_START = 1 if len(cfg.aggregate) == 1 else 4
Spreadsheet.ADJUST_ROW_AND_COL_SIZE = True
Spreadsheet.MAX_COL_WIDTH = cfg.xlsx.max_col_width
Spreadsheet.PART_NSEQ_SEPRTR = cfg.ref_separator
if hasattr(Spreadsheet, 'SUPPRESS_DIST_DESC'):
Spreadsheet.SUPPRESS_DIST_DESC = not cfg.xlsx.kicost_dist_desc
# Keep our sorting
try:
Spreadsheet.SORT_GROUPS = False
except Exception:
pass
# Make the version less intrusive
Spreadsheet.WRK_FORMATS['about_msg']['font_size'] = 8
# Don 't add project info, we add our own data
Spreadsheet.INCLUDE_PRJ_INFO = False
# Move the date to the bottom, and make it less relevant
Spreadsheet.ADD_DATE_TOP = False
Spreadsheet.ADD_DATE_BOTTOM = True
Spreadsheet.WRK_FORMATS['proj_info_field']['font_size'] = 11
Spreadsheet.WRK_FORMATS['proj_info']['font_size'] = 11
Spreadsheet.DATE_FIELD_LABEL = 'Created:'
# Set the color for the global section (using the selected theme)
bg_color = get_bg_color(cfg.xlsx.style)
if bg_color:
Spreadsheet.WRK_FORMATS['global']['bg_color'] = bg_color
Spreadsheet.WRK_FORMATS['header']['bg_color'] = bg_color
Spreadsheet.WRK_FORMATS['header']['font_color'] = 'white'
Spreadsheet.WRK_FORMATS['global']['font_size'] = 12
Spreadsheet.WRK_FORMATS['header']['font_size'] = 11
# Avoid the use of the same color twice
Spreadsheet.WRK_FORMATS['order_too_much']['bg_color'] = '#FF4040'
Spreadsheet.WRK_FORMATS['order_min_qty']['bg_color'] = '#FF6060'
# Project quantity as the default quantity
Spreadsheet.DEFAULT_BUILD_QTY = cfg.number
# Add version information
Spreadsheet.ABOUT_MSG += ' + KiBot v'+__version__
# References using ranges
Spreadsheet.COLLAPSE_REFS = cfg.use_alt
# Pass any extra column
adapt_extra_cost_columns(cfg)
# Adapt the column names
for id, v in Spreadsheet.GLOBAL_COLUMNS.items():
if id in KICOST_COLUMNS:
# We use another name
new_id = KICOST_COLUMNS[id]
v['label'] = new_id
id = new_id.lower()
if id in cfg.column_rename:
v['label'] = cfg.column_rename[id]
used_parts = []
for ws in range(2):
# Second pass is DNF
dnf = ws == 1
# Should we generate the DNF?
if dnf and (not cfg.xlsx.generate_dnf or cfg.n_total == cfg.n_fitted):
break
# Create the parts structure from the groups
parts = []
for g in groups:
if (cfg.ignore_dnf and not g.is_fitted()) != dnf:
continue
part = PartGroup()
part.refs = [c.ref for c in g.components]
part.fields = g.fields
part.fields['manf#_qty'] = compute_qtys(cfg, g)
parts.append(part)
# Process any "join" request
apply_join_requests(cfg.join_ce, part.fields, g.fields)
# Distributors
dist_list = solve_distributors(cfg)
# Get the prices
query_part_info(parts, dist_list)
# Distributors again. During `query_part_info` user defined distributors could be added
solve_distributors(cfg, silent=False)
# Create a class to hold the spreadsheet parameters
ss = Spreadsheet(workbook, ws_names[ws], prj_info)
wks = ss.wks
# Page head
# Logo
col1 = insert_logo(wks, image_data, cfg.xlsx.logo_scale)
if col1:
col1 += 1
# PCB & Stats Info
if not (cfg.xlsx.hide_pcb_info and cfg.xlsx.hide_stats_info):
r_info_start = 1 if cfg.xlsx.title else 0
column_widths = [0]*5 # Column 1 to 5
old_stats = cfg.xlsx.hide_stats_info
cfg.xlsx.hide_stats_info = True
write_info(cfg, r_info_start, wks, column_widths, col1, fmt_info, fmt_subtitle, compact=True)
cfg.xlsx.hide_stats_info = old_stats
ss.col_widths[col1] = column_widths[col1]
ss.col_widths[col1+1] = column_widths[col1+1]
# Add a worksheet with costs to the spreadsheet
create_worksheet(ss, logger, parts)
# Title
if cfg.xlsx.title:
wks.set_row(0, 32)
wks.merge_range(0, col1, 0, ss.globals_width, cfg.xlsx.title, fmt_title)
used_parts.append(parts)
# Specs sheets
create_meta_sheets(workbook, used_parts, fmt_head, fmt_cols, cfg, ss)
colors = {}
colors['Best price'] = ss.wrk_formats['best_price']
colors['No manufacturer or distributor code'] = ss.wrk_formats['not_manf_codes']
colors['Not available'] = ss.wrk_formats['not_available']
colors['Purchase quantity is more than what is available'] = ss.wrk_formats['order_too_much']
colors['Minimum order quantity not respected'] = ss.wrk_formats['order_min_qty']
colors['Total available part quantity is less than needed'] = ss.wrk_formats['too_few_available']
colors['Total purchased part quantity is less than needed'] = ss.wrk_formats['too_few_purchased']
colors['This part is obsolete'] = ss.wrk_formats['part_format_obsolete']
colors['This part is listed but is not normally stocked'] = ss.wrk_formats['not_stocked']
return colors
def create_kicost_sheet(workbook, groups, image_data, fmt_title, fmt_info, fmt_subtitle, fmt_head, fmt_cols, cfg):
try:
return _create_kicost_sheet(workbook, groups, image_data, fmt_title, fmt_info, fmt_subtitle, fmt_head, fmt_cols, cfg)
except KiCostError as e:
trace_dump()
logger.error('KiCost error: `{}` ({})'.format(e.msg, e.id))
exit(KICOST_ERROR)
def write_xlsx(filename, groups, col_fields, head_names, cfg):
"""
Write BoM out to a XLSX file
filename = path to output file (must be a .csv, .txt or .tsv file)
groups = [list of ComponentGroup groups]
col_fields = [list of headings to search for data in the BoM file]
head_names = [list of headings to display in the BoM file]
cfg = BoMOptions object with all the configuration
"""
if not XLSX_SUPPORT:
logger.error('Python xlsxwriter module not installed (Debian: python3-xlsxwriter)')
return False
link_datasheet = -1
if cfg.xlsx.datasheet_as_link and cfg.xlsx.datasheet_as_link in col_fields:
link_datasheet = col_fields.index(cfg.xlsx.datasheet_as_link)
link_digikey = cfg.xlsx.digikey_link
hl_empty = cfg.xlsx.highlight_empty
workbook = Workbook(filename)
ws_names = ['BoM', 'DNF']
row_headings = head_names
# Leave space for the logo, title and info
head_size = compute_head_size(cfg)
# First rowe for the information
r_info_start = 1 if cfg.xlsx.title else 0
max_width = cfg.xlsx.max_col_width
# #######################
# Create all the formats
# #######################
# Headings
# Column names format
fmt_head = create_fmt_head(workbook, cfg.xlsx.style)
# Column formats
fmt_cols = create_fmt_cols(workbook, cfg.xlsx.col_colors)
col_fmt = create_col_fmt(col_fields, cfg.xlsx.col_colors, fmt_cols)
# Page head
# Logo
image_data = get_logo_data(cfg.xlsx.logo)
# Title
fmt_title = create_fmt_title(workbook, cfg.xlsx.title)
fmt_subtitle = create_fmt_subtitle(workbook)
# Info
fmt_info = create_fmt_info(workbook, cfg)
# #######################
# Fill the cells
# #######################
# Normal BoM & DNF
for ws in range(2):
# Second pass is DNF
dnf = ws == 1
# Should we generate the DNF?
if dnf and (not cfg.xlsx.generate_dnf or cfg.n_total == cfg.n_fitted):
break
worksheet = workbook.add_worksheet(ws_names[ws])
row_count = head_size
# Headings
# Create the head titles
column_widths = [0]*max(len(col_fields), 6)
rows = [row_headings]
for i in range(len(row_headings)):
# Title for this column
column_widths[i] = len(row_headings[i]) + 10
worksheet.write_string(row_count, i, row_headings[i], fmt_head)
if cfg.column_comments[i]:
worksheet.write_comment(row_count, i, cfg.column_comments[i])
# Body
row_count += 1
for i, group in enumerate(groups):
if (cfg.ignore_dnf and not group.is_fitted()) != dnf:
continue
# Get the data row
row = group.get_row(col_fields)
rows.append(row)
if link_datasheet != -1:
datasheet = group.get_field(ColumnList.COL_DATASHEET_L)
# Fill the row
for i in range(len(row)):
cell = row[i]
if hl_empty and (len(cell) == 0 or cell.strip() == "~"):
fmt = col_fmt[-1][row_count % 2]
else:
fmt = col_fmt[i][row_count % 2]
# Link this column to the datasheet?
if link_datasheet == i and datasheet.startswith('http'):
worksheet.write_url(row_count, i, datasheet, fmt, cell)
# A link to Digi-Key?
elif link_digikey and col_fields[i] in link_digikey:
url = 'http://search.digikey.com/scripts/DkSearch/dksus.dll?Detail&name=' + cell
worksheet.write_url(row_count, i, url, fmt, cell)
else:
worksheet.write_string(row_count, i, cell, fmt)
if len(cell) > column_widths[i] - 5:
column_widths[i] = len(cell) + 5
row_count += 1
# Page head
# Logo
col1 = insert_logo(worksheet, image_data, cfg.xlsx.logo_scale)
# Title
if cfg.xlsx.title:
worksheet.set_row(0, 32)
worksheet.merge_range(0, col1, 0, len(column_widths)-1, cfg.xlsx.title, fmt_title)
# PCB & Stats Info
if not (cfg.xlsx.hide_pcb_info and cfg.xlsx.hide_stats_info):
write_info(cfg, r_info_start, worksheet, column_widths, col1, fmt_info, fmt_subtitle)
# Adjust cols and rows
adjust_widths(worksheet, column_widths, max_width, cfg.column_levels)
adjust_heights(worksheet, rows, max_width, head_size)
worksheet.freeze_panes(head_size+1, 0)
worksheet.repeat_rows(head_size+1)
worksheet.set_landscape()
# Optionally add KiCost information
kicost_colors = None
if cfg.xlsx.kicost:
kicost_colors = create_kicost_sheet(workbook, groups, image_data, fmt_title, fmt_info, fmt_subtitle, fmt_head,
fmt_cols, cfg)
# Add a sheet for the color references
create_color_ref(workbook, cfg.xlsx.col_colors, hl_empty, fmt_cols, cfg.xlsx.kicost and KICOST_SUPPORT, kicost_colors)
workbook.close()
return True
Reference in New Issue View Git Blame Copy Permalink