bed9f43d04
- Add Conduit and ConduitConnector classes in DataClasses.py - Extend parsing in wireviz.py for conduits/conduit-connectors/conduit-connections - Add rendering logic in Harness.py (dotted style, port colors) - Update BOM in wv_bom.py - Add example ex16.yml Refs #485
354 lines
13 KiB
Python
354 lines
13 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from dataclasses import asdict
|
|
from itertools import groupby
|
|
from typing import Any, Dict, List, Optional, Tuple, Union
|
|
|
|
from wireviz.DataClasses import AdditionalComponent, Cable, Color, Connector
|
|
from wireviz.wv_colors import translate_color
|
|
from wireviz.wv_gv_html import html_bgcolor_attr, html_line_breaks
|
|
from wireviz.wv_helper import clean_whitespace
|
|
|
|
BOM_COLUMNS_ALWAYS = ("id", "description", "qty", "unit", "designators")
|
|
BOM_COLUMNS_OPTIONAL = ("pn", "manufacturer", "mpn", "supplier", "spn")
|
|
BOM_COLUMNS_IN_KEY = ("description", "unit") + BOM_COLUMNS_OPTIONAL
|
|
|
|
HEADER_PN = "P/N"
|
|
HEADER_MPN = "MPN"
|
|
HEADER_SPN = "SPN"
|
|
|
|
BOMKey = Tuple[str, ...]
|
|
BOMColumn = str # = Literal[*BOM_COLUMNS_ALWAYS, *BOM_COLUMNS_OPTIONAL]
|
|
BOMEntry = Dict[BOMColumn, Union[str, int, float, List[str], None]]
|
|
|
|
|
|
def optional_fields(part: Union[Connector, Cable, AdditionalComponent]) -> BOMEntry:
|
|
"""Return part field values for the optional BOM columns as a dict."""
|
|
part = asdict(part)
|
|
return {field: part.get(field) for field in BOM_COLUMNS_OPTIONAL}
|
|
|
|
|
|
def get_additional_component_table(
|
|
harness: "Harness", component: Union[Connector, Cable]
|
|
) -> List[str]:
|
|
"""Return a list of diagram node table row strings with additional components."""
|
|
rows = []
|
|
if component.additional_components:
|
|
rows.append(["Additional components"])
|
|
# Ignore components that have qty 0
|
|
for part in [
|
|
part
|
|
for part in component.additional_components
|
|
if component.get_qty_multiplier(part.qty_multiplier)
|
|
]:
|
|
common_args = {
|
|
"qty": part.qty * component.get_qty_multiplier(part.qty_multiplier),
|
|
"unit": part.unit,
|
|
"bgcolor": part.bgcolor,
|
|
}
|
|
if harness.options.mini_bom_mode:
|
|
id = get_bom_index(
|
|
harness.bom(),
|
|
bom_entry_key({**asdict(part), "description": part.description}),
|
|
)
|
|
rows.append(
|
|
component_table_entry(
|
|
f"#{id} ({part.type.rstrip()})", **common_args
|
|
)
|
|
)
|
|
else:
|
|
rows.append(
|
|
component_table_entry(
|
|
part.description, **common_args, **optional_fields(part)
|
|
)
|
|
)
|
|
return rows
|
|
|
|
|
|
def get_additional_component_bom(component: Union[Connector, Cable]) -> List[BOMEntry]:
|
|
"""Return a list of BOM entries with additional components."""
|
|
bom_entries = []
|
|
# Ignore components that have qty 0
|
|
for part in [
|
|
part
|
|
for part in component.additional_components
|
|
if component.get_qty_multiplier(part.qty_multiplier)
|
|
]:
|
|
bom_entries.append(
|
|
{
|
|
"description": part.description,
|
|
"qty": part.qty * component.get_qty_multiplier(part.qty_multiplier),
|
|
"unit": part.unit,
|
|
"designators": component.name if component.show_name else None,
|
|
**optional_fields(part),
|
|
}
|
|
)
|
|
return bom_entries
|
|
|
|
|
|
def bom_entry_key(entry: BOMEntry) -> BOMKey:
|
|
"""Return a tuple of string values from the dict that must be equal to join BOM entries."""
|
|
if "key" not in entry:
|
|
entry["key"] = tuple(
|
|
clean_whitespace(make_str(entry.get(c))) for c in BOM_COLUMNS_IN_KEY
|
|
)
|
|
return entry["key"]
|
|
|
|
|
|
def generate_bom(harness: "Harness") -> List[BOMEntry]:
|
|
"""Return a list of BOM entries generated from the harness."""
|
|
from wireviz.Harness import Harness # Local import to avoid circular imports
|
|
|
|
bom_entries = []
|
|
# connectors
|
|
for connector in harness.connectors.values():
|
|
if not connector.ignore_in_bom:
|
|
description = (
|
|
"Connector"
|
|
+ (f", {connector.type}" if connector.type else "")
|
|
+ (f", {connector.subtype}" if connector.subtype else "")
|
|
+ (f", {connector.pincount} pins" if connector.show_pincount else "")
|
|
+ (
|
|
f", {translate_color(connector.color, harness.options.color_mode)}"
|
|
if connector.color
|
|
else ""
|
|
)
|
|
)
|
|
bom_entries.append(
|
|
{
|
|
"description": description,
|
|
"designators": connector.name if connector.show_name else None,
|
|
**optional_fields(connector),
|
|
}
|
|
)
|
|
|
|
# add connectors aditional components to bom
|
|
bom_entries.extend(get_additional_component_bom(connector))
|
|
|
|
# cables
|
|
# TODO: If category can have other non-empty values than 'bundle', maybe it should be part of description?
|
|
for cable in harness.cables.values():
|
|
if not cable.ignore_in_bom:
|
|
if cable.category != "bundle":
|
|
# process cable as a single entity
|
|
description = (
|
|
"Cable"
|
|
+ (f", {cable.type}" if cable.type else "")
|
|
+ (f", {cable.wirecount}")
|
|
+ (
|
|
f" x {cable.gauge} {cable.gauge_unit}"
|
|
if cable.gauge
|
|
else " wires"
|
|
)
|
|
+ (" shielded" if cable.shield else "")
|
|
+ (
|
|
f", {translate_color(cable.color, harness.options.color_mode)}"
|
|
if cable.color
|
|
else ""
|
|
)
|
|
)
|
|
bom_entries.append(
|
|
{
|
|
"description": description,
|
|
"qty": cable.length,
|
|
"unit": cable.length_unit,
|
|
"designators": cable.name if cable.show_name else None,
|
|
**optional_fields(cable),
|
|
}
|
|
)
|
|
else:
|
|
# add each wire from the bundle to the bom
|
|
for index, color in enumerate(cable.colors):
|
|
description = (
|
|
"Wire"
|
|
+ (f", {cable.type}" if cable.type else "")
|
|
+ (f", {cable.gauge} {cable.gauge_unit}" if cable.gauge else "")
|
|
+ (
|
|
f", {translate_color(color, harness.options.color_mode)}"
|
|
if color
|
|
else ""
|
|
)
|
|
)
|
|
bom_entries.append(
|
|
{
|
|
"description": description,
|
|
"qty": cable.length,
|
|
"unit": cable.length_unit,
|
|
"designators": cable.name if cable.show_name else None,
|
|
**{
|
|
k: index_if_list(v, index)
|
|
for k, v in optional_fields(cable).items()
|
|
},
|
|
}
|
|
)
|
|
|
|
# add cable/bundles aditional components to bom
|
|
bom_entries.extend(get_additional_component_bom(cable))
|
|
|
|
# conduits
|
|
for conduit in harness.conduits.values():
|
|
if not conduit.ignore_in_bom:
|
|
description = (
|
|
"Conduit"
|
|
+ (f", {conduit.type}" if conduit.type else "")
|
|
+ (f", {conduit.gauge} {conduit.gauge_unit}" if conduit.gauge else "")
|
|
+ (
|
|
f", {conduit.length} {conduit.length_unit}"
|
|
if conduit.length > 0
|
|
else ""
|
|
)
|
|
+ (
|
|
f", {translate_color(conduit.color, harness.options.color_mode)}"
|
|
if conduit.color
|
|
else ""
|
|
)
|
|
)
|
|
bom_entries.append(
|
|
{
|
|
"description": description,
|
|
"qty": conduit.length,
|
|
"unit": conduit.length_unit,
|
|
"designators": conduit.name if conduit.show_name else None,
|
|
**optional_fields(conduit),
|
|
}
|
|
)
|
|
|
|
# add conduits aditional components to bom
|
|
bom_entries.extend(get_additional_component_bom(conduit))
|
|
|
|
# conduit connectors
|
|
for conduit_connector in harness.conduit_connectors.values():
|
|
if not conduit_connector.ignore_in_bom:
|
|
description = "Conduit Connector" + (
|
|
f", {conduit_connector.type}" if conduit_connector.type else ""
|
|
)
|
|
bom_entries.append(
|
|
{
|
|
"description": description,
|
|
"designators": (
|
|
conduit_connector.name if conduit_connector.show_name else None
|
|
),
|
|
**optional_fields(conduit_connector),
|
|
}
|
|
)
|
|
|
|
# add conduit connectors aditional components to bom
|
|
bom_entries.extend(get_additional_component_bom(conduit_connector))
|
|
|
|
# add harness aditional components to bom directly, as they both are List[BOMEntry]
|
|
bom_entries.extend(harness.additional_bom_items)
|
|
|
|
# remove line breaks if present and cleanup any resulting whitespace issues
|
|
bom_entries = [
|
|
{k: clean_whitespace(v) for k, v in entry.items()} for entry in bom_entries
|
|
]
|
|
|
|
# deduplicate bom
|
|
bom = []
|
|
for _, group in groupby(sorted(bom_entries, key=bom_entry_key), key=bom_entry_key):
|
|
group_entries = list(group)
|
|
designators = sum(
|
|
(make_list(entry.get("designators")) for entry in group_entries), []
|
|
)
|
|
total_qty = sum(entry.get("qty", 1) for entry in group_entries)
|
|
bom.append(
|
|
{
|
|
**group_entries[0],
|
|
"qty": (
|
|
int(total_qty)
|
|
if float(total_qty).is_integer()
|
|
else round(total_qty, 3)
|
|
),
|
|
"designators": sorted(set(designators)),
|
|
}
|
|
)
|
|
|
|
# add an incrementing id to each bom entry
|
|
return [{**entry, "id": index} for index, entry in enumerate(bom, 1)]
|
|
|
|
|
|
def get_bom_index(bom: List[BOMEntry], target: BOMKey) -> int:
|
|
"""Return id of BOM entry or raise exception if not found."""
|
|
for entry in bom:
|
|
if bom_entry_key(entry) == target:
|
|
return entry["id"]
|
|
raise Exception("Internal error: No BOM entry found matching: " + "|".join(target))
|
|
|
|
|
|
def bom_list(bom: List[BOMEntry]) -> List[List[str]]:
|
|
"""Return list of BOM rows as lists of column strings with headings in top row."""
|
|
keys = list(BOM_COLUMNS_ALWAYS) # Always include this fixed set of BOM columns.
|
|
for fieldname in BOM_COLUMNS_OPTIONAL:
|
|
# Include only those optional BOM columns that are in use.
|
|
if any(entry.get(fieldname) for entry in bom):
|
|
keys.append(fieldname)
|
|
# Custom mapping from internal name to BOM column headers.
|
|
# Headers not specified here are generated by capitilising the internal name.
|
|
bom_headings = {
|
|
"pn": HEADER_PN,
|
|
"mpn": HEADER_MPN,
|
|
"spn": HEADER_SPN,
|
|
}
|
|
return [
|
|
[bom_headings.get(k, k.capitalize()) for k in keys]
|
|
] + [ # Create header row with key names
|
|
[make_str(entry.get(k)) for k in keys] for entry in bom
|
|
] # Create string list for each entry row
|
|
|
|
|
|
def component_table_entry(
|
|
type: str,
|
|
qty: Union[int, float],
|
|
unit: Optional[str] = None,
|
|
bgcolor: Optional[Color] = None,
|
|
pn: Optional[str] = None,
|
|
manufacturer: Optional[str] = None,
|
|
mpn: Optional[str] = None,
|
|
supplier: Optional[str] = None,
|
|
spn: Optional[str] = None,
|
|
) -> str:
|
|
"""Return a diagram node table row string with an additional component."""
|
|
part_number_list = [
|
|
pn_info_string(HEADER_PN, None, pn),
|
|
pn_info_string(HEADER_MPN, manufacturer, mpn),
|
|
pn_info_string(HEADER_SPN, supplier, spn),
|
|
]
|
|
output = (
|
|
f"{qty}"
|
|
+ (f" {unit}" if unit else "")
|
|
+ f" x {type}"
|
|
+ ("<br/>" if any(part_number_list) else "")
|
|
+ (", ".join([pn for pn in part_number_list if pn]))
|
|
)
|
|
# format the above output as left aligned text in a single visible cell
|
|
# indent is set to two to match the indent in the generated html table
|
|
return f"""<table border="0" cellspacing="0" cellpadding="3" cellborder="1"{html_bgcolor_attr(bgcolor)}><tr>
|
|
<td align="left" balign="left">{html_line_breaks(output)}</td>
|
|
</tr></table>"""
|
|
|
|
|
|
def pn_info_string(
|
|
header: str, name: Optional[str], number: Optional[str]
|
|
) -> Optional[str]:
|
|
"""Return the company name and/or the part number in one single string or None otherwise."""
|
|
number = str(number).strip() if number is not None else ""
|
|
if name or number:
|
|
return f'{name if name else header}{": " + number if number else ""}'
|
|
else:
|
|
return None
|
|
|
|
|
|
def index_if_list(value: Any, index: int) -> Any:
|
|
"""Return the value indexed if it is a list, or simply the value otherwise."""
|
|
return value[index] if isinstance(value, list) else value
|
|
|
|
|
|
def make_list(value: Any) -> list:
|
|
"""Return value if a list, empty list if None, or single element list otherwise."""
|
|
return value if isinstance(value, list) else [] if value is None else [value]
|
|
|
|
|
|
def make_str(value: Any) -> str:
|
|
"""Return comma separated elements if a list, empty string if None, or value as a string otherwise."""
|
|
return ", ".join(str(element) for element in make_list(value))
|