From 6751926ac2d6b60b8f755eec86a4b865a23dbf86 Mon Sep 17 00:00:00 2001
From: admin <admin@vecmocon.com>
Date: Tue, 14 Jul 2026 13:19:37 +0000
Subject: [PATCH] schlib_write: write full template+SOP param set (--typeid),
 fill ComponentDescription from template Description; docs updated

---
 SKILL.md                        |   8 +++-
 assets/CHANGELOG.xlsx           | Bin 5533 -> 5536 bytes
 references/schlib_parameters.md |  35 +++++++++++------
 scripts/schlib_write.py         |  65 +++++++++++++++++++++++++++++---
 4 files changed, 89 insertions(+), 19 deletions(-)

diff --git a/SKILL.md b/SKILL.md
index 65cc783..ec1a679 100644
--- a/SKILL.md
+++ b/SKILL.md
@@ -340,10 +340,14 @@ Leave any genuinely-unknown field blank — the SOP hides blank parameters, so a
 empty until filled. The full method for the second-source search is in
 `references/schlib_parameters.md`.
 
-Collect the values into a `params.json` and write them into the symbol:
+Write the **full parameter set** — the typeid template's engineering columns **plus** the SOP
+params above (see `references/schlib_parameters.md`). Collect your filled values into a
+`params.json` and pass `--typeid` so the writer guarantees every template column is present
+(blank where the datasheet is silent):
 
 ```bash
-python scripts/schlib_write.py --schlib <in>.SchLib --params params.json --out <stage>/<tag>/<sym>.SchLib
+python scripts/schlib_write.py --schlib <in>.SchLib --params params.json \
+    --out <stage>/<tag>/<sym>.SchLib --typeid <TYPEID>
 ```
 
 Deliver the resulting `.SchLib`; the engineer opens it in Altium once to confirm it loads, then
diff --git a/assets/CHANGELOG.xlsx b/assets/CHANGELOG.xlsx
index 2681c608d321c632053431f15e90f6bfab908c65..2f57f6685b1df084108aaef1648ecf4b1913f4e6 100644
GIT binary patch
delta 1420
zcmbQMy+E5Mz?+#xgn@y9gP|yEBF{n2qO5l@c??}!eonlmRll5fk)F7K`h*E9SRRR~
z-V?jHB{1pAySJIAuQfhkv^e(f^UuvsPO)U}>hRylEpak&msHJVwai1)WILKzJf1bg
zEwAy}l3aY<b$w>dF<X}0dtc=iKB(c9^NjYDQcDmMQwpAHddcO=m7~J<X0giKB^e)H
z!<cg+*_+cvuVH0ok_BJAFRS<g7UdqhTG0!7M|S>FFMG#et=j%%TFCwHmGS3x7P2$0
z@8>`NdDqNr;g{DQ{Lr@aJl+spHt$c+y?a-``-tv|NUxd98ON;`-m0_yzS?#9I`PE&
zk=u*^AFc@P4(gJQ%-bh9pEZ<q|2wBzCggy47c(<vj<Ue!zl;`a;1F?(Kk?pevmM6^
z#`;-%js(_R>%CWAE!cUk{qK?Eb=}>oU!FN$%l%66o8dpH3wxNpN*jnry1fzmAXTgr
z+?M!MKyyNTtHx>9>!<Y2hV!(jM!1}m+LEU6>eSSL`C7e-cEStmMHc=~60Evt@KMz=
zx3JLo_bcIrtWU)snl7l^AKG$L^<cWY=rkLTypNvs2Y1a8o3-rsq>3{PUvG+3EM4-=
z=)S~t<7bnVKc753)4%QF&i<cb;@7?PKkI7Pe_qdcc5>LWsdpOHB#qlNU-8u*FIToJ
z)wgQtIwSg}IcP<{-5s8^l%>8JQ>U)f5n<mSpqqJtXMUgX(d>ed{15i8j>^}(+PY)M
zzoOT{>sg<Mzc;O4@N+@v-q%N;uRHecS>qxBH^;0K(!KBf$^w=<hs7)__sQWiU+sLR
z?`FyCY1gFQaSOcM7p&d!YyVmnQL$*HZG}wX?kdwG4<1~d>0Q)2tF3<*<8}ACWmSh;
z6lJW9-!R_a>wbLKtNE)qw>3On9Bx|hw4i&d#1`WNf45HgW>9E*e4~uxyg#g{ag{dv
z#QuLw3=EY*lMis)YnEJElFPN?(7xU8-|hZvxoy|WD~*?bcLhD=HO=33Wc`#Zdp5`E
zp<C4MT2I#Cv0&_<oX8_1sJ=SxmgEMRzgN}>3bi!$e(;*y$0MV{J=MHVo^S25Xs@D(
zb@zUYGg}>u<WoF-<%#a;y?T!xnf?0mFm3WVo{0M9$?uPbY*|`nDl+fw<MWnVHn8^=
z%DnRGcYb}$PvOFy*<WqTcmLAeA9q@=b=TWcuHKpdU$ibNpCp!J@Oj}3j)Z&D)!(n)
zS+1*|dz#;T&QxFD+)v`{ck)gMJ`Z);q%O-_7P5>r<kvmrsa>hYoKrG1?!~p(I}1mB
zjaPm7cgm951@+BV|LXpJ?OCq^f&ZB%9jq`o@ArT6=K4uh1^GUI@(bQRUB2PozVw)l
zX>&q#&S!pp#I@kA_NMFKUm5?uWw)I5<<6=ZQ#$LV>X%x+eqFI?S94HL*z%9!JB)P~
zzbsmlyisjA^V!RVtMnbyue<+dc(5}qU2Z$u;fT4>%vL&l9LE?AM~H|$ub-^RXU4lN
z>hbE{@)NIX8`i$eo}9xMDmj0y`@xTMxcvU--1>)-&nDmEd(KppwfQiAA|sHVtS0yv
z#N`(90&~NKZ4l+r<T=7-@}SZQoHf}P80M%mFbD%nE*NNFd_DQ2uo74eIKMJ8Fz9eI
zFi5}@0O^KCoykTb>U<z`kdjThh^{qAXnNOfnFBy&!obu7)CmU-j2HPB7~+dkbBgu#
zKxBY7Ba;X-tlXS@UPOj**W@=Mav)Feh{`a^PSzCFQ~(*7I-zosBqIaEd7x`hUCSgi
Mxkyx%%?B(B0BkC0g#Z8m

delta 1402
zcmZ8hdo<Gv9N%c0$4qOR;!dg?^BSF#EW0EbouQQ?Vn@v@$s-m@)0S{tP2m?(%5#k?
zd9B;YYm+<N6v?Jj*Q{%9+1$2fS6ve>-P7su{p0&R-#@<J&*yv}pGv!%cJKqfx@*uN
z5J(Rc9aISK(T@&NQtLmQj`+85%$C{Ds+-9^fh#Duwr0}Aa>8VU=N~RozCF=9cHtFx
zXWx=$zHQ3qTzv;?f0bs#KzOGab=13lG0!}=b4{+6MG-RmcoFpH5N-@3$L$P9D&AQ2
zilL7nn|c{o9eaIzOM_hv2T@mNi0d5LKEceg>S06Up3;1gBnOswl*Gg`uNye9^u0Gw
zKiXE7{amlbIj6907J2gMzo-^E9S<dpdkAJ^z4Q=5Tl`jWESBkIC!bCd4gp6WEzG6%
zDl*p(vZaxkiICDudrIyn0yD<^OU*NE$%|!L=QVbds@9rsS^=3cI4|*9)c<-8N@^Lk
z{KvJ>wq-B@`e`EU$ilz(wz=y~gPGM($0T$`O3epJ7^zxAb62-WCnsZxnj~pvdTs`r
z4|QtVy$F5mRf6n*boOBfuhN2DNCs0un;#{Q+-vpKV03BvCjPC^M$^3ZWJ?j(Cn9&4
zG;QHE%@58BbMj-5DWTNy$K6^|jK{p!8KanqL<}vJ{O*N+wxw}VD1&*h*@2sVTi(5O
z<M!Pd&X6#h`mV=>zB%^%)Bs~P`87a0t&Hdv3g?~;G7KLLe>}NcQ(Ju2GOd!_$EM}A
zdrH-k-2IYEh^j4g$YLd0QDaQFXnN!X$|owy)==2v7~pH>)XSBT)Mi-m4<E0jt6>%C
zc!#_Eajod2$GrF)(<o+FOrR=V{h*<x<7}mMmVbfSthcNKFc--SFr{*H)Q#RJinVPK
z&XRV{y_^LdQoBlIP`#9B=aDTe$&D`;h>^cX9X|Cg_GJ;Z=Jua834*!8iu#FdG`;>I
z_&GtEYNX|^mK&RiKQ=!dXhd}x5645_!cQ^r95+AeaFTgk0geg&c3Y?xgzJJ12qZ!R
z0z-Ej-m}_9+q#F{9V%sq#^u*`x#+^^A9)A=GTM>Y{#(=4Sa+C5X&}!^0t2k!JHa0S
z8XSv+HH5u1ZN@H&?jYA?UC4ju2V90@x1x#(msN<y*P%Yi!FP9Q*Xt5{jvzJ<il*>`
zT@I6zMD46R78rsDGc$n-VE~Vlx&wXdt*ps~*9^-~!YX{Oc+T`uHa#7`G3S=HK;(xF
zDzn>_DF*pv%Zlu3LXk<_Hcizvy<-!lI90=gG(0YT&^V~Pc;CMG+4ZpTgaPE6z&))n
zbEDLN+mHb5gj;c5)OP)=G1g&WS$t1a$Q;vBzF1P*RdbO^Tsps~VN1!~00TEaMuy7D
z2tNf6Ulx-UJ;nBFrXatl;$iy2tt8>~q{A()+$X?jU`J47Q`4Q}OZPG;hR^6J1RK<{
z(-MU~_FNsAqRZLPNRcI;GC$%y+I6Tud>;jNohu8FIu0d7zXuB<o(#Dr80EAO??X=q
zW7*&wNQ<@oP$*!Ja5icUku~I}4QMi0jdD7WhzK;bxVg7SU2Z^G?tiiL&EfzF;*Cyp
zP+Old4ZIQo8>DPCMXdArl!l;Ozo-#VfpWH3)u#VH69g*9fk3Dg-TG`Sumbo8wdKpV
z0v2ct*bdl%#vxYgzPgcEG=3GX42>lYAwZy`$x(51M~78^z!$88*8MDpO6q$j4&NCJ
z0$Hsbm+@z$mB<3$2UO^dt6hvSSg;vjkFnXbiV{_Dw#am)U|9EicFRa01!D;%f8zWf
D=CyYk

diff --git a/references/schlib_parameters.md b/references/schlib_parameters.md
index 9b53436..b84b496 100644
--- a/references/schlib_parameters.md
+++ b/references/schlib_parameters.md
@@ -93,24 +93,35 @@ symbol's Library Ref (from `altium_refs.py`); omit it to apply to every componen
 }
 ```
 
+## The full parameter set (template + SOP)
+
+Every `.SchLib` should carry the **complete** parameter set for its part: the **typeid
+template's engineering columns** (all columns of that typeid's `template.xlsx` sheet except the
+internal bookkeeping ones — the tag `MPN_make_type`, `Skill Version`, `Template Version`, and the
+four `Library/Footprint Ref/Path` columns) **plus** the mandatory SOP params above. So a CER
+(ceramic MLCC) symbol gets `Capacitance(uF)`, `Tolerance`, `Voltage(V)`,
+`Dielectric(temp. Coefficient)`, `Operating Temp(°C)`, `Max operating temp(°C)`, `Package`,
+`Description`, `Manufacturer` from the template, alongside `Value`, `Manufacturer Part`,
+`Process`, `Vecmocon Part Code`, `ROHS`, `Datasheet`, and the second-source fields. Fill each
+from the datasheet; leave blank what the datasheet doesn't state.
+
 ## Writing them into the symbol
 
-Write the parameters straight into the `.SchLib`, producing a new file:
+Write the parameters straight into the `.SchLib`, producing a new file. Pass `--typeid` so the
+writer guarantees the whole template column set is present (blank where you didn't supply a
+value) — this is what keeps every symbol's parameter set complete and consistent:
 
 ```bash
-python scripts/schlib_write.py --schlib <in>.SchLib --params params.json --out <out>.SchLib
+python scripts/schlib_write.py --schlib <in>.SchLib --params params.json --out <out>.SchLib --typeid <TYPEID>
 ```
 
-`params.json` may carry a `"remove"` list (defaults to `["Manufacturer_Name",
-"Manufacturer_Part_Number"]`); those Ultra-Librarian defaults are stripped and the SOP params
-added. The script targets the component named in `"component"` (its Library Ref / storage name),
-or every component if omitted, and self-checks the output re-opens as a valid OLE. Deliver the
-resulting `.SchLib`, and have the engineer open it in Altium once to confirm it loads, then Save
-to Server with a revision note per the SOP.
-
-Scope note: the direct writer keeps a component's `Data` under Altium's 4096-byte mini-stream
-threshold in the common case; a very large parameter set (or an extremely long datasheet URL)
-can push it past that, at which point fall back to the `altium_params.py` DXP-script path.
+`params.json` carries your filled values (and may include a `"remove"` list — defaults to
+`["Manufacturer_Name", "Manufacturer_Part_Number"]`, the Ultra-Librarian duplicates that get
+stripped). The script targets the component named in `"component"` (its Library Ref / storage
+name), or every component if omitted, and self-checks the output re-opens as a valid OLE. It
+handles any parameter-set size — small sets stay in Altium's mini-stream, larger ones are written
+as a regular stream automatically. Deliver the resulting `.SchLib`; have the engineer open it in
+Altium once to confirm it loads, then Save to Server with a revision note per the SOP.
 
 Fallback (apply from inside Altium):
 
diff --git a/scripts/schlib_write.py b/scripts/schlib_write.py
index ffc952b..4730cd6 100644
--- a/scripts/schlib_write.py
+++ b/scripts/schlib_write.py
@@ -29,7 +29,7 @@ IMPORTANT: this writes Altium's own binary format from outside Altium. It is val
 re-open as a well-formed OLE with every other stream byte-identical, but ALWAYS open the result
 in Altium once to confirm it loads before relying on it.
 """
-import argparse, json, struct, sys, hashlib
+import argparse, json, os, struct, sys, hashlib
 import olefile
 
 FREESECT=0xFFFFFFFF; ENDOFCHAIN=0xFFFFFFFE; FATSECT=0xFFFFFFFD
@@ -42,6 +42,26 @@ def le32(b,o): return struct.unpack('<I',b[o:o+4])[0]
 def pad(b,n): return b+b'\x00'*((-len(b))%n)
 
 
+# ----------------------------------------------------------------- typeid template columns
+
+# Template columns that are internal library bookkeeping, NOT symbol parameters.
+NON_PARAM_COLS = {"MPN_make_type", "Skill Version", "Template Version",
+                  "Library Ref", "Library Path", "Footprint Ref", "Footprint Path"}
+
+
+def template_param_names(template_path, typeid):
+    """The symbol-parameter columns for a typeid = every column on that typeid's template sheet
+    EXCEPT the internal bookkeeping ones (the tag, the two version columns, and the four design
+    Ref/Path columns). These are the engineering parameters that belong on the symbol."""
+    import openpyxl
+    wb = openpyxl.load_workbook(template_path, read_only=True)
+    if typeid not in wb.sheetnames:
+        raise SystemExit(f"no template sheet for typeid '{typeid}'")
+    ws = wb[typeid]
+    return [ws.cell(1, c).value for c in range(1, ws.max_column + 1)
+            if ws.cell(1, c).value and ws.cell(1, c).value not in NON_PARAM_COLS]
+
+
 # ----------------------------------------------------------------- read the container
 
 def read_container(path):
@@ -118,16 +138,34 @@ def _rec_name(block):
     return t.split('|Name=')[1].split('|')[0] if '|Name=' in t else None
 
 
+def _patch_field(block, field, value):
+    """Replace |field=...| inside a length-prefixed text record, re-framing its 4-byte length.
+    Used to set the component's ComponentDescription in the RECORD=1 header."""
+    import re
+    text = block[4:-1].decode('latin-1')
+    if f"|{field}=" in text:
+        text = re.sub(rf"\|{re.escape(field)}=[^|]*", f"|{field}={value}", text, count=1)
+    elif text.startswith("|RECORD="):
+        text = text + f"|{field}={value}"
+    payload = text.encode('latin-1') + b'\x00'
+    return struct.pack('<I', len(payload)) + payload
+
+
 def edit_data(data, params, remove):
     """Return a new Data stream: drop `remove` params, drop any SOP-name params (re-added
-    fresh), keep everything else, then append the SOP params. Pins/graphics/tail untouched."""
+    fresh), keep everything else, then append the SOP params. Also mirror the `Description`
+    parameter into the component's ComponentDescription field (the Altium 'Description' shown in
+    the component properties). Pins/graphics/tail untouched."""
     leading, tail = _leading_text_records(data)
     sop_names=set(params)
+    desc = params.get("Description")
     kept=[]
     for blk in leading:
         nm=_rec_name(blk)
         if nm is not None and (nm in remove or nm in sop_names):
             continue                                   # drop UL duplicates + stale SOP copies
+        if desc is not None and blk[4:-1].startswith(b"|RECORD=1|"):
+            blk = _patch_field(blk, "ComponentDescription", desc)   # component Description field
         kept.append(blk)
     added=[_param_record(20+i, nm, val) for i,(nm,val) in enumerate(params.items())]
     return b''.join(kept)+b''.join(added)+tail
@@ -211,10 +249,20 @@ def rebuild(entries, content):
 
 # ----------------------------------------------------------------- driver
 
-def write_params(schlib, params_json, out):
+def write_params(schlib, params_json, out, typeid=None, template=None):
     component=params_json.get("component") or None
-    fields=params_json.get("parameters", {}) or {}
+    fields=dict(params_json.get("parameters", {}) or {})
     remove=params_json.get("remove", DEFAULT_REMOVE)
+
+    # If a typeid+template are given, guarantee the FULL template parameter set is written:
+    # every engineering column for that typeid becomes a symbol parameter (value from the
+    # params if provided, else blank). This is what makes every .SchLib carry the complete,
+    # consistent parameter set the template defines — not just whatever was hand-listed.
+    typeid = typeid or params_json.get("typeid")
+    template = template or params_json.get("template")
+    if typeid and template:
+        for name in template_param_names(template, typeid):
+            fields.setdefault(name, "")
     entries, paths, content = read_container(schlib)
 
     # target Data stream sid(s): a stream named 'Data' whose parent storage == component (or all)
@@ -253,8 +301,15 @@ def main():
     ap.add_argument("--schlib", required=True)
     ap.add_argument("--params", required=True)
     ap.add_argument("--out", required=True)
+    ap.add_argument("--typeid", help="component typeid; with --template, writes that typeid's "
+                                     "full template parameter set (blank where not provided)")
+    ap.add_argument("--template", help="path to template.xlsx (defaults to the skill's)")
     a=ap.parse_args()
-    write_params(a.schlib, json.load(open(a.params, encoding="utf-8")), a.out)
+    template = a.template
+    if a.typeid and not template:
+        template = os.path.join(os.path.dirname(__file__), "..", "assets", "template", "template.xlsx")
+    write_params(a.schlib, json.load(open(a.params, encoding="utf-8")), a.out,
+                 typeid=a.typeid, template=template)
 
 
 if __name__ == "__main__":