harnice 0.3.0__py3-none-any.whl

harnice/products/system.py

@@ -0,0 +1,125 @@
+import runpy
+import os
+from harnice import fileio, state, cli
+from harnice.lists import post_harness_instances_list, instances_list, library_history
+
+default_desc = "SYSTEM, SCOPE, etc."
+
+system_feature_tree_utils_default = """from harnice import fileio
+from harnice.utils import system_utils, feature_tree_utils
+from harnice.lists import instances_list, manifest, channel_map, circuits_list, disconnect_map
+
+#===========================================================================
+#                   KICAD PROCESSING
+#===========================================================================
+feature_tree_utils.run_macro("kicad_sch_to_pdf", "system_artifacts", "https://github.com/harnice/harnice", artifact_id="blockdiagram-1")
+feature_tree_utils.run_macro("kicad_pro_to_bom", "system_builder", "https://github.com/harnice/harnice", artifact_id="bom-1")
+
+#===========================================================================
+#                   COLLECT AND PULL DEVICES FROM LIBRARY
+#===========================================================================
+system_utils.make_instances_from_bom()
+
+#===========================================================================
+#                   CHANNEL MAPPING
+#===========================================================================
+feature_tree_utils.run_macro("kicad_pro_to_system_connector_list", "system_builder", "https://github.com/harnice/harnice", artifact_id="system-connector-list-1")
+manifest.new()
+channel_map.new()
+
+#add manual channel map commands here. key=(from_device_refdes, from_device_channel_id)
+#channel_map.map(("MIC3", "out1"), ("PREAMP1", "in2"))
+
+#map channels to other compatible channels by sorting alphabetically then mapping compatibles
+feature_tree_utils.run_macro("basic_channel_mapper", "system_builder", "https://github.com/harnice/harnice", artifact_id="channel-mapper-1")
+
+#if mapped channels must connect via disconnects, add the list of disconnects to the channel map
+system_utils.add_chains_to_channel_map()
+
+#map channels that must pass through disconnects to available channels inside disconnects
+disconnect_map.new()
+
+#add manual disconnect map commands here
+#disconnect_map.already_assigned_disconnects_set_append(('X1', 'ch0'))
+
+#map channels passing through disconnects to available channels inside disconnects
+feature_tree_utils.run_macro("disconnect_mapper", "system_builder", "https://github.com/harnice/harnice", artifact_id="disconnect-mapper-1")
+feature_tree_utils.ensure_requirements_met()
+
+#process channel and disconnect maps to make a list of every circuit in your system
+circuits_list.new()
+
+#===========================================================================
+#                   INSTANCES LIST
+#===========================================================================
+system_utils.make_instances_for_connectors_cavities_nodes_channels_circuits()
+
+#assign mating connectors
+#for instance in fileio.read_tsv("instances list"):
+    #if instance.get("item_type") == "connector":
+        #if instance.get("this_instance_mating_device_connector_mpn") == "XLR3M":
+            #instances_list.modify(instance.get("instance_name"),{
+                #"mpn":"D38999_26ZA98PN",
+                #"lib_repo":"https://github.com/harnice/harnice"
+            #})
+
+#===========================================================================
+#                   SYSTEM DESIGN CHECKS
+#===========================================================================
+connector_list = fileio.read_tsv("system connector list")
+circuits_list = fileio.read_tsv("circuits list")
+
+#check for circuits with no connectors
+system_utils.find_connector_with_no_circuit(connector_list, circuits_list)
+"""
+
+
+def file_structure():
+    return {
+        f"{state.partnumber('pn-rev')}-feature_tree.py": "feature tree",
+        f"{state.partnumber('pn-rev')}-instances_list.tsv": "instances list",
+        f"{state.partnumber('pn-rev')}-library_import_history.tsv": "library history",
+        "instance_data": {},
+        "features_for_relatives": {},
+        "harnesses": {},
+        "lists": {
+            f"{state.partnumber('pn-rev')}-bom.tsv": "bom",
+            f"{state.partnumber('pn-rev')}-circuits_list.tsv": "circuits list",
+            f"{state.partnumber('pn-rev')}-post_harness_instances_list.tsv": "post harness instances list",
+            f"{state.partnumber('pn-rev')}-harness_manifest.tsv": "harness manifest",
+            f"{state.partnumber('pn-rev')}-system_connector_list.tsv": "system connector list",
+            f"{state.partnumber('pn-rev')}-mapped_channels_set.tsv": "mapped channels set",
+            f"{state.partnumber('pn-rev')}-mapped_disconnect_channels_set.tsv": "mapped disconnects set",
+            f"{state.partnumber('pn-rev')}-mapped_a_channels_through_disconnects_set.tsv": "mapped A-side channels through disconnects set",
+        },
+        "maps": {
+            f"{state.partnumber('pn-rev')}-channel_map.tsv": "channel map",
+            f"{state.partnumber('pn-rev')}-disconnect_map.tsv": "disconnect map",
+        },
+    }
+
+
+def generate_structure():
+    os.makedirs(fileio.dirpath("instance_data"), exist_ok=True)
+    os.makedirs(fileio.dirpath("features_for_relatives"), exist_ok=True)
+    os.makedirs(fileio.dirpath("harnesses"), exist_ok=True)
+    os.makedirs(fileio.dirpath("lists"), exist_ok=True)
+    os.makedirs(fileio.dirpath("maps"), exist_ok=True)
+    pass
+
+
+def render():
+    state.set_net(None)
+
+    if not os.path.exists(fileio.path("feature tree")):
+        with open(fileio.path("feature tree"), "w", encoding="utf-8") as f:
+            f.write(system_feature_tree_utils_default)
+
+    library_history.new()
+    instances_list.new()
+    cli.print_import_status_headers()
+    runpy.run_path(fileio.path("feature tree"))
+
+    post_harness_instances_list.rebuild()
+
+    print("\nSystem rendered successfully!\n")

harnice/products/tblock.py

@@ -0,0 +1,270 @@
+import os
+import json
+import xml.etree.ElementTree as ET
+from xml.dom import minidom
+from harnice import fileio, cli, state
+
+
+default_desc = "TITLEBLOCK, PAPER SIZE, DESIGN"
+
+
+def file_structure():
+    return {
+        f"{state.partnumber('pn-rev')}-params.json": "params",
+        f"{state.partnumber('pn-rev')}-drawing.svg": "drawing",
+        f"{state.partnumber('pn-rev')}-attributes.json": "attributes",
+    }
+
+
+def generate_structure():
+    pass
+
+
+def render():
+    if (
+        cli.prompt(
+            "Warning: rendering a titleblock may clear user edits to its svg. Proceed?",
+            default="yes",
+        )
+        != "yes"
+    ):
+        exit()
+
+    # === Default Parameters ===
+    params = {
+        "page_size": [11 * 96, 8.5 * 96],
+        "outer_margin": 20,
+        "inner_margin": 40,
+        "tick_spacing": 96,
+        "tb_origin_offset": [398, 48],
+        "row_heights": [24, 24],
+        "column_widths": [[264, 50, 84], [73, 126, 139, 60]],
+        "label_offset": [2, 7],
+        "key_offset_y": 16,
+        "cell_texts": [
+            [
+                ("DESCRIPTION", "tblock-key-desc"),
+                ("REV", "tblock-key-rev"),
+                ("PAGE DESC", "tblock-key-pagedesc"),
+            ],
+            [
+                ("SCALE", "tblock-key-scale"),
+                ("PART NUMBER", "tblock-key-pn"),
+                ("DRAWN BY", "tblock-key-drawnby"),
+                ("SHEET", "tblock-key-sheet"),
+            ],
+        ],
+    }
+
+    # === If param file doesn't exist, create it ===
+    if not os.path.exists(fileio.path("params")):
+        with open(fileio.path("params"), "w", encoding="utf-8") as f:
+            json.dump(params, f, indent=2)
+        # if it does exist, ignore it
+
+    # === Load parameters from JSON ===
+    with open(fileio.path("params"), "r", encoding="utf-8") as f:
+        p = json.load(f)
+
+    width, height = p["page_size"]
+    svg = ET.Element(
+        "svg",
+        {
+            "xmlns": "http://www.w3.org/2000/svg",
+            "version": "1.1",
+            "width": str(width),
+            "height": str(height),
+        },
+    )
+
+    contents_group = ET.SubElement(svg, "g", {"id": "tblock-contents-start"})
+
+    def add_rect(parent, x, y, w, h, stroke="black", fill="none", stroke_width=1):
+        ET.SubElement(
+            parent,
+            "rect",
+            {
+                "x": str(x),
+                "y": str(y),
+                "width": str(w),
+                "height": str(h),
+                "fill": fill,
+                "stroke": stroke,
+                "stroke-width": str(stroke_width),
+            },
+        )
+
+    def add_text(parent, x, y, text, size=8, anchor="start", bold=False, id=None):
+        style = f"font-size:{size}px;font-family:Arial"
+        if bold:
+            style += ";font-weight:bold"
+        attrs = {
+            "x": str(x),
+            "y": str(y),
+            "style": style,
+            "text-anchor": anchor,
+        }
+        if id:
+            attrs["id"] = id
+        ET.SubElement(parent, "text", attrs).text = text
+
+    # === Border Group ===
+    border_group = ET.SubElement(contents_group, "g", {"id": "border"})
+
+    x_ticks = int((width - 2 * p["inner_margin"]) // p["tick_spacing"])
+    for i in range(x_ticks):
+        x0 = p["inner_margin"] + i * p["tick_spacing"]
+        x_center = x0 + p["tick_spacing"] / 2
+        ET.SubElement(
+            border_group,
+            "line",
+            {
+                "x1": str(x0),
+                "y1": str(p["outer_margin"]),
+                "x2": str(x0),
+                "y2": str(height - p["outer_margin"]),
+                "stroke": "black",
+                "stroke-width": "0.5",
+            },
+        )
+        label_y_top = (p["outer_margin"] + p["inner_margin"]) / 2
+        label_y_bot = height - label_y_top
+        add_text(border_group, x_center, label_y_top, str(i + 1), anchor="middle")
+        add_text(border_group, x_center, label_y_bot, str(i + 1), anchor="middle")
+
+    x_end = p["inner_margin"] + x_ticks * p["tick_spacing"]
+    ET.SubElement(
+        border_group,
+        "line",
+        {
+            "x1": str(x_end),
+            "y1": str(p["outer_margin"]),
+            "x2": str(x_end),
+            "y2": str(height - p["outer_margin"]),
+            "stroke": "black",
+            "stroke-width": "0.5",
+        },
+    )
+
+    y_ticks = int((height - 2 * p["inner_margin"]) // p["tick_spacing"])
+    for j in range(y_ticks):
+        y0 = p["inner_margin"] + j * p["tick_spacing"]
+        y_center = y0 + p["tick_spacing"] / 2
+        ET.SubElement(
+            border_group,
+            "line",
+            {
+                "x1": str(p["outer_margin"]),
+                "y1": str(y0),
+                "x2": str(width - p["outer_margin"]),
+                "y2": str(y0),
+                "stroke": "black",
+                "stroke-width": "0.5",
+            },
+        )
+        label = chr(ord("A") + j)
+        label_x_left = (p["outer_margin"] + p["inner_margin"]) / 2
+        label_x_right = width - label_x_left
+        add_text(border_group, label_x_left, y_center + 4, label, anchor="middle")
+        add_text(border_group, label_x_right, y_center + 4, label, anchor="middle")
+
+    y_end = p["inner_margin"] + y_ticks * p["tick_spacing"]
+    ET.SubElement(
+        border_group,
+        "line",
+        {
+            "x1": str(p["outer_margin"]),
+            "y1": str(y_end),
+            "x2": str(width - p["outer_margin"]),
+            "y2": str(y_end),
+            "stroke": "black",
+            "stroke-width": "0.5",
+        },
+    )
+
+    add_rect(
+        border_group,
+        p["outer_margin"],
+        p["outer_margin"],
+        width - 2 * p["outer_margin"],
+        height - 2 * p["outer_margin"],
+    )
+    add_rect(
+        border_group,
+        p["inner_margin"],
+        p["inner_margin"],
+        width - 2 * p["inner_margin"],
+        height - 2 * p["inner_margin"],
+        stroke="black",
+        fill="white",
+        stroke_width=1,
+    )
+
+    # === Logo Group ===
+    tb_origin_x = width - p["inner_margin"] - p["tb_origin_offset"][0]
+    tb_origin_y = height - p["inner_margin"] - p["tb_origin_offset"][1]
+    logo_width = 1.25 * 96
+    logo_height = sum(p["row_heights"])
+    logo_group = ET.SubElement(contents_group, "g", {"id": "logo"})
+    add_rect(logo_group, tb_origin_x - logo_width, tb_origin_y, logo_width, logo_height)
+
+    # === Titleblock Cell Groups ===
+    y_cursor = tb_origin_y
+    for row_idx, row_height in enumerate(p["row_heights"]):
+        row_cols = p["column_widths"][row_idx]
+        row_cells = p["cell_texts"][row_idx]
+        x_cursor = tb_origin_x
+        for col_idx, col_width in enumerate(row_cols):
+            label, key_id = row_cells[col_idx]
+            group_id = (
+                label.lower().replace(" ", "-")
+                if label
+                else f"cell-r{row_idx}-c{col_idx}"
+            )
+            cell_group = ET.SubElement(contents_group, "g", {"id": group_id})
+            add_rect(cell_group, x_cursor, y_cursor, col_width, row_height)
+
+            if label:
+                add_text(
+                    cell_group,
+                    x_cursor + p["label_offset"][0],
+                    y_cursor + p["label_offset"][1],
+                    label,
+                    size=7,
+                    bold=True,
+                )
+            if key_id:
+                center_x = x_cursor + col_width / 2
+                add_text(
+                    cell_group,
+                    center_x,
+                    y_cursor + p["key_offset_y"],
+                    key_id,
+                    size=7,
+                    anchor="middle",
+                    id=key_id,
+                )
+
+            x_cursor += col_width
+        y_cursor += row_height
+
+    ET.SubElement(svg, "g", {"id": "tblock-contents-end"})
+    rough_string = ET.tostring(svg, encoding="utf-8")
+    pretty = minidom.parseString(rough_string).toprettyxml(indent="  ")
+    with open(fileio.path("drawing"), "w", encoding="utf-8") as f:
+        f.write(pretty)
+
+    # === Write attributes file ===
+    periphery_json = {
+        "page_size_in": [
+            round(p["page_size"][0] / 96, 3),
+            round(p["page_size"][1] / 96, 3),
+        ],
+    }
+
+    with open(fileio.path("attributes"), "w", encoding="utf-8") as f:
+        json.dump(periphery_json, f, indent=2)
+
+    print()
+    print(f"Titleblock '{state.partnumber('pn')}' updated")
+    print()

harnice/state.py

@@ -0,0 +1,57 @@
+import re
+
+
+# not initializing these variables so that a NameError is raised if they are not set
+def set_pn(x):
+    global pn
+    pn = x
+
+
+def set_rev(x):
+    global rev
+    rev = x
+
+
+def set_net(x):
+    global net
+    net = x
+
+
+def set_file_structure(x):
+    global file_structure
+    file_structure = x
+
+
+def partnumber(format):
+    # Returns part numbers in various formats based on the current working directory
+
+    # given a part number "pppppp-revR"
+
+    # format options:
+    # "pn-rev"    returns "pppppp-revR"
+    # "pn"        returns "pppppp"
+    # "rev"       returns "revR"
+    # "R"         returns "R"
+
+    pn_rev = f"{pn}-rev{rev}"
+
+    if format == "pn-rev":
+        return pn_rev
+
+    elif format == "pn":
+        match = re.search(r"-rev", pn_rev)
+        if match:
+            return pn_rev[: match.start()]
+
+    elif format == "rev":
+        match = re.search(r"-rev", pn_rev)
+        if match:
+            return pn_rev[match.start() + 1 :]
+
+    elif format == "R":
+        match = re.search(r"-rev", pn_rev)
+        if match:
+            return pn_rev[match.start() + 4 :]
+
+    else:
+        raise ValueError("Function 'partnumber' not presented with a valid format")

harnice/utils/appearance.py

@@ -0,0 +1,51 @@
+import ast
+import webcolors
+
+"""
+Appearance guide:
+    color lookup: https://www.w3.org/TR/SVG11/types.html#ColorKeywords
+    add the following dictionary-formatted string to a field in the instances list
+
+
+format: design your macros to be able to parse this, define your cables to conform to this
+    {"base_color":"","parallelstripe":["",""],"perpstripe":[], "twisted":None}
+
+    
+"""
+
+
+def parse(val):
+    """
+    Parse appearance dictionary, converting color names and shorthand hex to full hex.
+    No validation or safeguards.
+    """
+    if not val:
+        return None
+
+    data = val if isinstance(val, dict) else ast.literal_eval(str(val))
+    result = {}
+
+    for key, value in data.items():
+        # lists → normalize each element
+        if isinstance(value, list):
+            parsed = []
+            for c in value:
+                c = c.strip().lower()
+                if c.startswith("#") and len(c) == 4:
+                    c = "#" + "".join(ch * 2 for ch in c[1:])
+                if not c.startswith("#"):
+                    c = webcolors.name_to_hex(c)
+                parsed.append(c)
+            result[key] = parsed
+        # single string → normalize directly
+        elif isinstance(value, str):
+            c = value.strip().lower()
+            if c.startswith("#") and len(c) == 4:
+                c = "#" + "".join(ch * 2 for ch in c[1:])
+            if not c.startswith("#"):
+                c = webcolors.name_to_hex(c)
+            result[key] = c
+        else:
+            result[key] = value
+
+    return result