')
wirehtml.append(" | |
")
for i, (connection_color, wirelabel) in enumerate(
zip_longest(cable.colors, cable.wirelabels), 1
):
wirehtml.append(" ")
wirehtml.append(f" | ")
wirehtml.append(f" ")
wireinfo = []
if cable.show_wirenumbers:
wireinfo.append(str(i))
colorstr = wv_colors.translate_color(
connection_color, self.options.color_mode
)
if colorstr:
wireinfo.append(colorstr)
if cable.wirelabels:
wireinfo.append(wirelabel if wirelabel is not None else "")
wirehtml.append(f' {":".join(wireinfo)}')
wirehtml.append(f" | ")
wirehtml.append(f" | ")
wirehtml.append("
")
# fmt: off
bgcolors = ['#000000'] + get_color_hex(connection_color, pad=pad) + ['#000000']
wirehtml.append(f" ")
wirehtml.append(f' ')
wirehtml.append(' ')
for j, bgcolor in enumerate(bgcolors[::-1]): # Reverse to match the curved wires when more than 2 colors
wirehtml.append(f' | ')
wirehtml.append(" ")
wirehtml.append(" | ")
wirehtml.append("
")
# fmt: on
# for bundles, individual wires can have part information
if cable.category == "bundle":
# create a list of wire parameters
wireidentification = []
if isinstance(cable.pn, list):
wireidentification.append(
pn_info_string(
HEADER_PN, None, remove_links(cable.pn[i - 1])
)
)
manufacturer_info = pn_info_string(
HEADER_MPN,
(
cable.manufacturer[i - 1]
if isinstance(cable.manufacturer, list)
else None
),
cable.mpn[i - 1] if isinstance(cable.mpn, list) else None,
)
supplier_info = pn_info_string(
HEADER_SPN,
(
cable.supplier[i - 1]
if isinstance(cable.supplier, list)
else None
),
cable.spn[i - 1] if isinstance(cable.spn, list) else None,
)
if manufacturer_info:
wireidentification.append(html_line_breaks(manufacturer_info))
if supplier_info:
wireidentification.append(html_line_breaks(supplier_info))
# print parameters into a table row under the wire
if len(wireidentification) > 0:
# fmt: off
wirehtml.append(' ')
wirehtml.append(' ')
for attrib in wireidentification:
wirehtml.append(f" | {attrib} | ")
wirehtml.append("
")
wirehtml.append(" |
")
# fmt: on
if cable.shield:
wirehtml.append(" | |
") # spacer
wirehtml.append(" ")
wirehtml.append(" | ")
wirehtml.append(" Shield | ")
wirehtml.append(" | ")
wirehtml.append("
")
if isinstance(cable.shield, str):
# shield is shown with specified color and black borders
shield_color_hex = wv_colors.get_color_hex(cable.shield)[0]
attributes = (
f'height="6" bgcolor="{shield_color_hex}" border="2" sides="tb"'
)
else:
# shield is shown as a thin black wire
attributes = f'height="2" bgcolor="#000000" border="0"'
# fmt: off
wirehtml.append(f' |
')
# fmt: on
wirehtml.append(" | |
")
wirehtml.append("
")
html = [
row.replace("", "\n".join(wirehtml)) for row in html
]
# connections
for connection in cable.connections:
if isinstance(connection.via_port, int):
# check if it's an actual wire and not a shield
dot.attr(
"edge",
color=":".join(
["#000000"]
+ wv_colors.get_color_hex(
cable.colors[connection.via_port - 1], pad=pad
)
+ ["#000000"]
),
)
else: # it's a shield connection
# shield is shown with specified color and black borders, or as a thin black wire otherwise
dot.attr(
"edge",
color=(
":".join(["#000000", shield_color_hex, "#000000"])
if isinstance(cable.shield, str)
else "#000000"
),
)
if connection.from_pin is not None: # connect to left
from_connector = self.connectors[connection.from_name]
from_pin_index = from_connector.pins.index(connection.from_pin)
from_port_str = (
f":p{from_pin_index+1}r"
if from_connector.style != "simple"
else ""
)
code_left_1 = f"{connection.from_name}{from_port_str}:e"
code_left_2 = f"{cable.name}:w{connection.via_port}:w"
dot.edge(code_left_1, code_left_2)
if from_connector.show_name:
from_info = [
str(connection.from_name),
str(connection.from_pin),
]
if from_connector.pinlabels:
pinlabel = from_connector.pinlabels[from_pin_index]
if pinlabel != "":
from_info.append(pinlabel)
from_string = ":".join(from_info)
else:
from_string = ""
html = [
row.replace(f"", from_string)
for row in html
]
if connection.to_pin is not None: # connect to right
to_connector = self.connectors[connection.to_name]
to_pin_index = to_connector.pins.index(connection.to_pin)
to_port_str = (
f":p{to_pin_index+1}l" if to_connector.style != "simple" else ""
)
code_right_1 = f"{cable.name}:w{connection.via_port}:e"
code_right_2 = f"{connection.to_name}{to_port_str}:w"
dot.edge(code_right_1, code_right_2)
if to_connector.show_name:
to_info = [str(connection.to_name), str(connection.to_pin)]
if to_connector.pinlabels:
pinlabel = to_connector.pinlabels[to_pin_index]
if pinlabel != "":
to_info.append(pinlabel)
to_string = ":".join(to_info)
else:
to_string = ""
html = [
row.replace(f"", to_string)
for row in html
]
style, bgcolor = (
("filled,dashed", self.options.bgcolor_bundle)
if cable.category == "bundle"
else ("filled", self.options.bgcolor_cable)
)
html = "\n".join(html)
dot.node(
cable.name,
label=f"<\n{html}\n>",
shape="box",
style=style,
fillcolor=translate_color(bgcolor, "HEX"),
)
# mates
for mate in self.mates:
if mate.shape[-1] == ">":
dir = "both" if mate.shape[0] == "<" else "forward"
else:
dir = "back" if mate.shape[0] == "<" else "none"
if isinstance(mate, MatePin):
color = "#000000"
elif isinstance(mate, MateComponent):
color = "#000000:#000000"
else:
raise Exception(f"{mate} is an unknown mate")
from_connector = self.connectors[mate.from_name]
to_connector = self.connectors[mate.to_name]
if isinstance(mate, MatePin) and from_connector.style != "simple":
from_pin_index = from_connector.pins.index(mate.from_pin)
from_port_str = f":p{from_pin_index+1}r"
else: # MateComponent or style == 'simple'
from_port_str = ""
if isinstance(mate, MatePin) and to_connector.style != "simple":
to_pin_index = to_connector.pins.index(mate.to_pin)
to_port_str = f":p{to_pin_index+1}l"
else: # MateComponent or style == 'simple'
to_port_str = ""
code_from = f"{mate.from_name}{from_port_str}:e"
code_to = f"{mate.to_name}{to_port_str}:w"
dot.attr("edge", color=color, style="dashed", dir=dir)
dot.edge(code_from, code_to)
def typecheck(name: str, value: Any, expect: type) -> None:
if not isinstance(value, expect):
raise Exception(
f"Unexpected value type of {name}: Expected {expect}, got {type(value)}\n{value}"
)
# TODO?: Differ between override attributes and HTML?
if self.tweak.override is not None:
typecheck("tweak.override", self.tweak.override, dict)
for k, d in self.tweak.override.items():
typecheck(f"tweak.override.{k} key", k, str)
typecheck(f"tweak.override.{k} value", d, dict)
for a, v in d.items():
typecheck(f"tweak.override.{k}.{a} key", a, str)
typecheck(f"tweak.override.{k}.{a} value", v, (str, type(None)))
# Override generated attributes of selected entries matching tweak.override.
for i, entry in enumerate(dot.body):
if isinstance(entry, str):
# Find a possibly quoted keyword after leading TAB(s) and followed by [ ].
match = re.match(
r'^\t*(")?((?(1)[^"]|[^ "])+)(?(1)") \[.*\]$', entry, re.S
)
keyword = match and match[2]
if keyword in self.tweak.override.keys():
for attr, value in self.tweak.override[keyword].items():
if value is None:
entry, n_subs = re.subn(
f'( +)?{attr}=("[^"]*"|[^] ]*)(?(1)| *)', "", entry
)
if n_subs < 1:
print(
f"Harness.create_graph() warning: {attr} not found in {keyword}!"
)
elif n_subs > 1:
print(
f"Harness.create_graph() warning: {attr} removed {n_subs} times in {keyword}!"
)
continue
if len(value) == 0 or " " in value:
value = value.replace('"', r"\"")
value = f'"{value}"'
entry, n_subs = re.subn(
f'{attr}=("[^"]*"|[^] ]*)', f"{attr}={value}", entry
)
if n_subs < 1:
# If attr not found, then append it
entry = re.sub(r"\]$", f" {attr}={value}]", entry)
elif n_subs > 1:
print(
f"Harness.create_graph() warning: {attr} overridden {n_subs} times in {keyword}!"
)
dot.body[i] = entry
if self.tweak.append is not None:
if isinstance(self.tweak.append, list):
for i, element in enumerate(self.tweak.append, 1):
typecheck(f"tweak.append[{i}]", element, str)
dot.body.extend(self.tweak.append)
else:
typecheck("tweak.append", self.tweak.append, str)
dot.body.append(self.tweak.append)
# Tweak processing above must be the last before returning dot.
# Please don't insert any code that might change the dot contents
# after tweak processing.
return dot
# cache for the GraphViz Graph object
# do not access directly, use self.graph instead
_graph = None
@property
def graph(self):
if not self._graph: # no cached graph exists, generate one
self._graph = self.create_graph()
return self._graph # return cached graph
@property
def png(self):
from io import BytesIO
graph = self.graph
data = BytesIO()
data.write(graph.pipe(format="png"))
data.seek(0)
return data.read()
@property
def svg(self):
graph = self.graph
return embed_svg_images(graph.pipe(format="svg").decode("utf-8"), Path.cwd())
def output(
self,
filename: (str, Path),
view: bool = False,
cleanup: bool = True,
fmt: tuple = ("html", "png", "svg", "tsv"),
) -> None:
# graphical output
graph = self.graph
svg_already_exists = Path(
f"{filename}.svg"
).exists() # if SVG already exists, do not delete later
# graphical output
for f in fmt:
if f in ("png", "svg", "html"):
if f == "html": # if HTML format is specified,
f = "svg" # generate SVG for embedding into HTML
# SVG file will be renamed/deleted later
_filename = f"{filename}.tmp" if f == "svg" else filename
# TODO: prevent rendering SVG twice when both SVG and HTML are specified
graph.format = f
graph.render(filename=_filename, view=view, cleanup=cleanup)
# embed images into SVG output
if "svg" in fmt or "html" in fmt:
embed_svg_images_file(f"{filename}.tmp.svg")
# GraphViz output
if "gv" in fmt:
graph.save(filename=f"{filename}.gv")
# BOM output
bomlist = bom_list(self.bom())
if "tsv" in fmt:
open_file_write(f"{filename}.bom.tsv").write(tuplelist2tsv(bomlist))
if "csv" in fmt:
# TODO: implement CSV output (preferrably using CSV library)
print("CSV output is not yet supported")
# HTML output
if "html" in fmt:
generate_html_output(filename, bomlist, self.metadata, self.options)
# PDF output
if "pdf" in fmt:
# TODO: implement PDF output
print("PDF output is not yet supported")
# delete SVG if not needed
if "html" in fmt and not "svg" in fmt:
# SVG file was just needed to generate HTML
Path(f"{filename}.tmp.svg").unlink()
elif "svg" in fmt:
Path(f"{filename}.tmp.svg").replace(f"{filename}.svg")
def bom(self):
if not self._bom:
self._bom = generate_bom(self)
return self._bom