harnice 0.3.0__py3-none-any.whl

harnice/lists/rev_history.py

@@ -0,0 +1,325 @@
+import os
+import csv
+import ast
+import importlib
+from harnice import fileio, state
+
+# === Global Columns Definition ===
+COLUMNS = [
+    "product", #documentation needed
+    "mfg", #documentation needed
+    "pn", #documentation needed
+    "desc", #documentation needed
+    "rev", #documentation needed
+    "status", #documentation needed
+    "releaseticket", #documentation needed
+    "library_repo", #documentation needed
+    "library_subpath", #documentation needed
+    "datestarted", #documentation needed
+    "datemodified", #documentation needed
+    "datereleased", #documentation needed
+    "git_hash_of_harnice_src", #documentation needed
+    "drawnby", #documentation needed
+    "checkedby", #documentation needed
+    "revisionupdates", #documentation needed
+    "affectedinstances", #documentation needed
+]
+
+
+def overwrite(content_dict):
+    PROTECTED_KEYS = [
+        "product",
+        "mfg",
+        "pn",
+        "rev",
+        "releaseticket",
+        "library_repo",
+        "library_subpath",
+        "datestarted",
+    ]
+    # 1) Ensure no unknown keys
+    for key in content_dict:
+        if key not in COLUMNS:
+            raise KeyError(
+                f"Harnice does not allow writing unknown key '{key}'. "
+                f"Valid columns: {', '.join(COLUMNS)}"
+            )
+
+    # 2) Ensure none of the protected keys are being modified
+    for key in PROTECTED_KEYS:
+        if key in content_dict:
+            raise KeyError(
+                f"Harnice does not allow overwriting '{key}' by script.\n"
+                f"Please edit the revision history manually."
+            )
+
+    # 3) Load or create revision history
+    path = fileio.path("revision history")
+    if not os.path.exists(path):
+        new()  # Creates a blank rev history with header
+
+    rows = fileio.read_tsv("revision history")
+
+    # 4) Determine which revision we are updating from state
+    target_rev = str(state.rev).strip()
+    if not target_rev:
+        raise RuntimeError("state.rev is not set. Did verify_revision_structure() run?")
+
+    # 5) Update matching row
+    found = False
+    for row in rows:
+        if str(row.get("rev", "")).strip() == target_rev:
+            found = True
+            for key, value in content_dict.items():
+                row[key] = value
+
+    if not found:
+        raise ValueError(f"No revision '{target_rev}' found in revision history.")
+
+    # 6) Write updated TSV
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=COLUMNS, delimiter="\t")
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def info(rev=None, path=None, field=None, all=False):
+    if path is None:
+        path = fileio.path("revision history")
+
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Revision history file not found at {path}")
+
+    if rev:
+        rev = str(rev)
+    else:
+        rev = state.partnumber("R")
+
+    with open(path, newline="", encoding="utf-8") as f:
+        reader = csv.DictReader(f, delimiter="\t")
+        rows = list(reader)
+
+    if all:
+        return rows
+
+    for row in rows:
+        if row.get("rev") == rev:
+
+            # ------------------------------------------------------
+            # Field requested
+            # ------------------------------------------------------
+            if field:
+                val = row.get(field)
+
+                if field == "affectedinstances":
+                    if not val or val.strip() == "":
+                        return []
+                    try:
+                        return ast.literal_eval(val)
+                    except Exception:
+                        # fallback: return empty list if malformed
+                        return []
+
+                # other fields unchanged
+                return val
+
+            # ------------------------------------------------------
+            # Entire row requested: parse affectedinstances only
+            # ------------------------------------------------------
+            full_row = dict(row)
+            ai = row.get("affectedinstances")
+            if ai and ai.strip() != "":
+                try:
+                    full_row["affectedinstances"] = ast.literal_eval(ai)
+                except Exception:
+                    full_row["affectedinstances"] = []
+            else:
+                full_row["affectedinstances"] = []
+
+            return full_row
+
+    raise ValueError(f"Revision {rev} not found in revision history at {path}")
+
+
+def initial_release_exists():
+    try:
+        for row in fileio.read_tsv("revision history"):
+            if str(row.get("revisionupdates", "")).strip() == "INITIAL RELEASE":
+                return True
+            else:
+                return False
+    except NameError:
+        return False
+
+
+def initial_release_desc():
+    for row in fileio.read_tsv("revision history"):
+        if row.get("revisionupdates") == "INITIAL RELEASE":
+            return row.get("desc")
+
+
+def update_datemodified():
+    target_rev = state.partnumber("R")
+
+    # Read all rows
+    with open(fileio.path("revision history"), newline="", encoding="utf-8") as f_in:
+        reader = csv.DictReader(f_in, delimiter="\t")
+        rows = list(reader)
+
+    # Modify matching row(s)
+    for row in rows:
+        if row.get("rev", "").strip() == target_rev:
+            row["datemodified"] = fileio.today()
+            row["drawnby"] = fileio.drawnby()["name"]
+            row["git_hash_of_harnice_src"] = fileio.get_git_hash_of_harnice_src()
+
+    # Write back
+    with open(
+        fileio.path("revision history"), "w", newline="", encoding="utf-8"
+    ) as f_out:
+        writer = csv.DictWriter(f_out, fieldnames=COLUMNS, delimiter="\t")
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def new():
+    columns = COLUMNS
+    from harnice.cli import select_product_type
+
+    global product
+    product = select_product_type()
+    with open(fileio.path("revision history"), "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=columns, delimiter="\t")
+        writer.writeheader()
+
+
+def append(next_rev=None):
+    from harnice import cli
+
+    global product
+
+    if not os.path.exists(fileio.path("revision history")):
+        new()
+    rows = fileio.read_tsv("revision history")
+    product_name = None
+    if rows:
+        for row in reversed(rows):
+            candidate = (row.get("product") or "").strip()
+            if candidate:
+                product_name = candidate
+                break
+    if not product_name:
+        product_name = globals().get("product")
+    if not product_name:
+        product_name = cli.select_product_type()
+    product = product_name
+
+    default_desc = ""
+    if product_name:
+        try:
+            product_module = importlib.import_module(f"harnice.products.{product_name}")
+        except ModuleNotFoundError:
+            product_module = None
+        else:
+            default_desc = getattr(product_module, "default_desc", "") or ""
+
+    desc = ""
+    if next_rev != 1:
+        # find the highest revision in the table
+        try:
+            highest_existing_rev = max(
+                int(row.get("rev", 0)) for row in rows if row.get("rev")
+            )
+        except ValueError:
+            highest_existing_rev = None
+
+        if next_rev != highest_existing_rev:
+            for row in rows:
+                if int(row.get("rev", 0)) == highest_existing_rev:
+                    desc = row.get("desc")
+                    if row.get("status") in [None, ""]:
+                        print(
+                            f"Your existing highest revision ({highest_existing_rev}) has no status. Do you want to obsolete it?"
+                        )
+                        obsolete_message = cli.prompt(
+                            "Type your message here, leave blank for 'OBSOLETE' message, or type 'n' to keep it blank.",
+                            default="OBSOLETE",
+                        )
+                        if obsolete_message == "n":
+                            obsolete_message = ""
+                        row["status"] = obsolete_message  # ← modified here
+                    break
+
+    if desc in [None, ""]:
+        desc = cli.prompt(
+            f"Enter a description of this {product_name}",
+            default=default_desc,
+        )
+
+    revisionupdates = "INITIAL RELEASE"
+    if initial_release_exists():
+        revisionupdates = ""
+    revisionupdates = cli.prompt(
+        "Enter a description for this revision", default=revisionupdates
+    )
+    while not revisionupdates or not revisionupdates.strip():
+        print("Revision updates can't be blank!")
+        revisionupdates = cli.prompt(
+            "Enter a description for this revision", default=None
+        )
+
+    # add lib_repo if filepath is found in library locations
+    library_repo = ""
+    library_subpath = ""
+    cwd = str(os.getcwd()).lower().strip("~")
+
+    for row in fileio.read_tsv("library locations", delimiter=","):
+        lib_local_path = str(row.get("local_path", "")).lower().strip("~")
+        if lib_local_path in cwd:
+            library_repo = row.get("repo_url")
+
+            # keep only the portion AFTER local_path
+            idx = cwd.find(lib_local_path)
+            remainder = cwd[idx + len(lib_local_path) :].lstrip("/")
+            parts = remainder.split("/")
+
+            # find the part number in the path
+            pn = str(state.partnumber("pn")).lower()
+            if pn in parts:
+                pn_index = parts.index(pn)
+                core_parts = parts[:pn_index]  # everything before pn
+            else:
+                core_parts = parts
+
+            # build library_subpath and product
+            if core_parts:
+                library_subpath = (
+                    "/".join(core_parts[1:]) + "/" if len(core_parts) > 1 else ""
+                )  # strip out the first element (product type)
+            else:
+                library_subpath = ""
+
+            break
+
+    ####
+
+    rows.append(
+        {
+            "product": product_name,
+            "pn": state.pn,
+            "rev": next_rev,
+            "desc": desc,
+            "status": "",
+            "library_repo": library_repo,
+            "library_subpath": library_subpath,
+            "datestarted": fileio.today(),
+            "datemodified": fileio.today(),
+            "revisionupdates": revisionupdates,
+        }
+    )
+
+    columns = COLUMNS
+    with open(fileio.path("revision history"), "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=columns, delimiter="\t")
+        writer.writeheader()
+        writer.writerows(rows)

harnice/lists/signals_list.py

@@ -0,0 +1,135 @@
+import csv
+import os
+from harnice import fileio
+
+list_type = None
+COLUMNS = []
+
+# Signals list column headers to match source of truth + compatibility change
+DEVICE_COLUMNS = [
+    "channel_id",  # Unique identifier for the channel.
+    "signal", # Name of the electrical function of that signal, as it pertains to its channel type defition. i.e. "positive"
+    "connector_name", # Unique identifier for the connector that this signal and channel is a part of.
+    "cavity", # Identifier of the pin, socket, stud, etc, that this signal is internally electrically routed to within its connector.
+    "connector_mpn", #MPN of the connector in this device (NOT the mating connector).
+    "channel_type",  #The channel type of this signal. \n{% include-markdown "fragments/channel_type_reference.md" %}
+    "config_variable", #Change header or add more headers as needed. Blank: row is true across all values of this field. Otherwise, row is only true when configuration matches the value of this field.
+]
+
+DISCONNECT_COLUMNS = [
+    "channel_id",  # Unique identifier for the channel.
+    "signal",# Name of the electrical function of that signal, as it pertains to its channel type defition. i.e. "positive"
+    "A_cavity", #Identifier of the pin, socket, stud, etc, that this signal is internally electrically routed to within that side of the connector.\n??? question "Why are A and B different here?"\n    Sometimes it's possible to have connectors that have cavities that may mate electrically, but have different names. For example, suppose two connectors physically mate, but are made by different manufacturers. One manufacturer used lowercase (a, b, c) to reference the cavities but the other used uppercase (A, B, C), or numbers (1, 2, 3), or colors (red, green, blue), etc.
+    "B_cavity" #Identifier of the pin, socket, stud, etc, that this signal is internally electrically routed to within that side of the connector.\n??? question "Why are A and B different here?"\n    Sometimes it's possible to have connectors that have cavities that may mate electrically, but have different names. For example, suppose two connectors physically mate, but are made by different manufacturers. One manufacturer used lowercase (a, b, c) to reference the cavities but the other used uppercase (A, B, C), or numbers (1, 2, 3), or colors (red, green, blue), etc.
+    "A_connector_mpn", #MPN of the connector of the harness on this side of the disconnect
+    "A_channel_type", #The channel type of this side of the discconect.\n??? question "Why are A and B different here?"\n    It's important to keep track of which side has which channel type so that you cannot accidentally flip pins and sockets, for example, by mapping the wrong channel type to the wrong pin gender. Careful validation should be done when mapping channels through disconnects to ensure the disconnects have channels that pass through them in the correct direction.
+    "B_connector_mpn",#MPN of the connector of the harness on this side of the disconnect
+    "B_channel_type", #The channel type of this side of the discconect.\n??? question "Why are A and B different here?"\n    It's important to keep track of which side has which channel type so that you cannot accidentally flip pins and sockets, for example, by mapping the wrong channel type to the wrong pin gender. Careful validation should be done when mapping channels through disconnects to ensure the disconnects have channels that pass through them in the correct direction.
+]
+
+
+def set_list_type(x):
+    global list_type
+    list_type = x
+
+    global COLUMNS
+    if list_type == "device":
+        COLUMNS = DEVICE_COLUMNS
+    elif list_type == "disconnect":
+        COLUMNS = DISCONNECT_COLUMNS
+
+
+def new():
+    """
+    Creates a new signals TSV file at fileio.path("signals list") with only the header row.
+    Overwrites any existing file.
+    """
+    signals_path = fileio.path("signals list")
+    os.makedirs(os.path.dirname(signals_path), exist_ok=True)
+
+    if os.path.exists(signals_path):
+        os.remove(signals_path)
+
+    with open(signals_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f, delimiter="\t")
+        writer.writerow(COLUMNS)
+
+
+def append(**kwargs):
+    """
+    Appends a new row to the signals TSV file.
+    Missing optional fields will be written as empty strings.
+    Raises ValueError if required fields are missing.
+
+    Required kwargs:
+        For 'device':
+            channel_id, signal, connector_name, cavity, connector_mpn, channel_type
+        For 'disconnect':
+            A_channel_id, A_signal, A_connector_name, A_cavity, A_connector_mpn, A_channel_type,
+            B_channel_id, B_signal, B_connector_name, B_cavity, B_connector_mpn, B_channel_type
+    """
+    signals_path = fileio.path("signals list")
+
+    # Create the signals list file if it doesn't exist
+    if not os.path.exists(signals_path):
+        new()
+
+    # --- Define required fields based on product type ---
+    if list_type == "device":
+        required = [
+            "channel_id",
+            "signal",
+            "connector_name",
+            "cavity",
+            "connector_mpn",
+            "channel_type",
+        ]
+    elif list_type == "disconnect":
+        required = [
+            "channel_id",
+            "signal",
+            "A_cavity",
+            "A_connector_mpn",
+            "A_channel_type",
+            "B_cavity",
+            "B_connector_mpn",
+            "B_channel_type",
+        ]
+    else:
+        required = []
+
+    # --- Check for missing required fields ---
+    missing = [key for key in required if not kwargs.get(key)]
+    if missing:
+        raise ValueError(
+            f"Missing required signal fields for '{list_type}': {', '.join(missing)}"
+        )
+
+    # --- Fill row in header order ---
+    row = [kwargs.get(col, "") for col in COLUMNS]
+
+    # --- Append to the signals list ---
+    with open(signals_path, "a", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f, delimiter="\t", lineterminator="\n")
+        writer.writerow(row)
+
+
+def cavity_of_signal(channel_id, signal, path_to_signals_list):
+    for row in fileio.read_tsv(path_to_signals_list):
+        if row.get("signal", "").strip() == signal.strip():
+            if row.get("channel_id", "").strip() == channel_id.strip():
+                return row.get("cavity", "").strip()
+    raise ValueError(
+        f"Signal {signal} of channel_id {channel_id} not found in {path_to_signals_list}"
+    )
+
+
+def connector_name_of_channel(channel_id, path_to_signals_list):
+    if not os.path.exists(path_to_signals_list):
+        raise FileNotFoundError(f"Signals list file not found: {path_to_signals_list}")
+
+    with open(path_to_signals_list, newline="", encoding="utf-8") as f:
+        reader = csv.DictReader(f, delimiter="\t")
+        for row in reader:
+            if row.get("channel_id", "").strip() == channel_id.strip():
+                return row.get("connector_name", "").strip()

harnice/products/__init__.py

@@ -0,0 +1 @@
+# Render package for harnice

harnice/products/cable.py

@@ -0,0 +1,152 @@
+import os
+import csv
+import json
+from harnice import fileio, state
+
+
+default_desc = "CABLE, FUNCTION, ATTRIBUTES, etc."
+
+
+def file_structure():
+    return {
+        f"{state.partnumber('pn-rev')}-attributes.json": "attributes",
+        f"{state.partnumber('pn-rev')}-conductor_list.tsv": "conductor list",
+    }
+
+
+def generate_structure():
+    pass
+
+
+def render():
+    # ========== Default JSON ==========
+    default_attributes = {
+        "jacket": {
+            "properties": {
+                "color": "gray",
+                "material": "pvc",
+                "od": "0.204in",
+                "thickness": "0.028in",
+            },
+            "shield": {
+                "properties": {"type": "foil", "coverage": "100%"},
+                "drain_wire": {
+                    "conductor": True,
+                    "properties": {"gauge": "20AWG", "construction": "7x28"},
+                    "appearance": {
+                        "outline_color": "gray",
+                        "slash_lines": {"direction": "RH", "color": "gray"},
+                    },
+                },
+                "pair_1": {
+                    "properties": {"twists": "12 per inch"},
+                    "black": {
+                        "conductor": True,
+                        "properties": {
+                            "insulation material": "polyethylene",
+                            "od": "0.017in",
+                            "gauge": "20AWG",
+                            "construction": "7x28",
+                            "material": "copper",
+                        },
+                        "appearance": {"base_color": "black"},
+                    },
+                    "white": {
+                        "conductor": True,
+                        "properties": {
+                            "insulation material": "polyethylene",
+                            "od": "0.017in",
+                            "gauge": "20AWG",
+                            "construction": "7x28",
+                            "material": "copper",
+                        },
+                        "appearance": {"base_color": "white", "outline_color": "black"},
+                    },
+                },
+            },
+        }
+    }
+
+    attributes_path = fileio.path("attributes")
+
+    # ========== Load or create attributes.json ==========
+    if os.path.exists(attributes_path):
+        try:
+            with open(attributes_path, "r", encoding="utf-8") as f:
+                attrs = json.load(f)
+        except Exception as e:
+            print(f"[WARNING] Could not load existing attributes.json: {e}")
+            attrs = default_attributes
+            with open(attributes_path, "w", encoding="utf-8") as f:
+                json.dump(attrs, f, indent=4)
+    else:
+        attrs = default_attributes
+        with open(attributes_path, "w", encoding="utf-8") as f:
+            json.dump(attrs, f, indent=4)
+
+    # ========== Traverse and build TSV ==========
+    rows = []
+    all_headers = {"appearance"}  # ensure it exists
+
+    def recurse(obj, parent_chain=None):
+        """Walk through nested dicts, recording conductor rows."""
+        if parent_chain is None:
+            parent_chain = []
+
+        if isinstance(obj, dict):
+            # Found conductor
+            if obj.get("conductor") is True:
+                props = obj.get("properties", {})
+                appearance = obj.get("appearance", {})
+
+                # Use previous parent chain to fill in context
+                container = parent_chain[-2] if len(parent_chain) >= 2 else ""
+                identifier = parent_chain[-1] if len(parent_chain) >= 1 else ""
+
+                row = {"container": container, "identifier": identifier}
+
+                for k, v in props.items():
+                    row[k] = v
+                    all_headers.add(k)
+
+                # Convert appearance to JSON string (compact)
+                row["appearance"] = (
+                    json.dumps(
+                        appearance, separators=(",", ":"), ensure_ascii=False
+                    ).replace('"', "'")
+                    if appearance
+                    else ""
+                )
+
+                rows.append(row)
+
+            # Continue traversing deeper
+            for k, v in obj.items():
+                if isinstance(v, (dict, list)):
+                    recurse(v, parent_chain + [k])
+
+        elif isinstance(obj, list):
+            for item in obj:
+                recurse(item, parent_chain)
+
+    recurse(attrs)
+
+    if not rows:
+        print("[WARNING] No conductor entries found.")
+        return
+
+    # Define header order
+    headers = ["container", "identifier"] + sorted(all_headers)
+
+    # Write to TSV
+    conductor_list_path = fileio.path("conductor list")
+    with open(conductor_list_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(
+            f, fieldnames=headers, delimiter="\t", lineterminator="\n"
+        )
+        writer.writeheader()
+        writer.writerows(rows)
+
+    print(
+        f"\ncable rendered successfully! wrote {len(rows)} rows to:\n{conductor_list_path}\n"
+    )

harnice/products/chtype.py

@@ -0,0 +1,80 @@
+import os
+import ast
+from harnice import fileio
+from harnice.utils import library_utils
+
+
+def file_structure():
+    return {}
+
+
+def generate_structure():
+    pass
+
+
+def path(channel_type):
+    """
+    Args:
+        channel_type: tuple like (chid, lib_repo) or string like "(5, '...')"
+    """
+    chid, lib_repo = parse(channel_type)
+    base_dir = library_utils.get_local_path(lib_repo)
+    return os.path.join(base_dir, "channel_types", "channel_types.tsv")
+
+
+def parse(val):
+    """Convert stored string into a tuple (chid:int, lib_repo:str)."""
+    if not val:
+        return None
+    if isinstance(val, tuple):
+        chid, lib_repo = val
+    else:
+        chid, lib_repo = ast.literal_eval(str(val))
+    return (int(chid), str(lib_repo).strip())
+
+
+def compatibles(channel_type):
+    """
+    Look up compatible channel_types for the given channel_type.
+    Splits the TSV field by commas and parses each entry into (chid, lib_repo).
+    """
+    channel_type_id, lib_repo = parse(channel_type)
+    for row in fileio.read_tsv(path((channel_type_id, lib_repo))):
+        if str(channel_type_id) != str(row.get("channel_type_id")):
+            continue
+
+        signals_str = row.get("compatible_channel_types", "").strip()
+        if not signals_str:
+            return []
+
+        values = [v.strip() for v in signals_str.split(";") if v.strip()]
+        parsed = []
+        for v in values:
+            parsed.append(parse(v))
+        return parsed
+
+    return []
+
+
+def is_or_is_compatible_with(channel_type):
+    output = []
+    output.append(parse(channel_type))
+    for compatible in compatibles(channel_type):
+        output.append(compatible)
+    return output
+
+
+# search channel_types.tsv
+def signals(channel_type):
+    chid, lib_repo = parse(channel_type)
+
+    ch_types_tsv_path = os.path.join(
+        library_utils.get_local_path(lib_repo), "channel_types", "channel_types.tsv"
+    )
+
+    for row in fileio.read_tsv(ch_types_tsv_path):
+        if str(row.get("channel_type_id", "")).strip() == str(chid):
+            return [
+                sig.strip() for sig in row.get("signals", "").split(",") if sig.strip()
+            ]
+    return []