o Always sorting index.xml for better git diffs.

o Normalizing more Digikey facts.
o When creating distributor search lists, create a new plain <part> with
  containing only the part numbers.

1 files changed, 150 insertions, 0 deletions

diff --git a/src/ee/digikey/normalize_facts.py b/src/ee/digikey/normalize_facts.py
new file mode 100644
index 0000000..1ddf78c
--- /dev/null
+++ b/src/ee/digikey/normalize_facts.py
@@ -0,0 +1,150 @@
+import re
+from pathlib import Path
+from typing import List, Tuple, Union
+
+from ee import EeVal, EeException
+from ee.part import PartDb, load_db, save_db
+from ee.xml import bomFile, uris
+
+__all__ = ["normalize_facts"]
+
+
+# TODO: this should be moved to a generic normalizer
+def handle_tolerance(tolerance: bomFile.Fact, capacitance: bomFile.Fact) -> List[bomFile.Fact]:
+    cap_value = float(EeVal.parse(capacitance.valueProp))
+
+    s = tolerance.valueProp
+    print("tolerance: {}".format(s))
+    is_plus_minus = s.startswith("±")
+    s = s[1:] if is_plus_minus else s
+
+    is_percent = s.endswith("%")
+
+    is_farad = s.endswith("F")
+
+    print("tolerance={}, is_plus_minus={}, is_farad={}, is_percent={}".format(
+        tolerance.valueProp, is_plus_minus, is_farad, is_percent))
+    print("capacitance={}".format(EeVal.parse(capacitance.valueProp)))
+
+    low_pct = low_value = None
+    high_pct = high_value = None
+    facts = []  # type: List[Tuple[str, str, Union[str, EeVal]]]
+
+    if is_farad:
+        s = s[0:-1] if is_farad else s
+
+        try:
+            farad = EeVal.parse(s)
+        except EeException:
+            farad = None
+
+    elif is_percent:
+        s = s[0:-1]
+        pct_value = int(s)
+
+        if is_plus_minus:
+            low_pct = high_pct = str(pct_value)
+            pct = float(pct_value) / 100
+            low_value = EeVal(value=cap_value * (1 - pct), exp=1, unit="F")
+            high_value = EeVal(value=cap_value * (1 + pct), exp=1, unit="F")
+    else:
+        raise EeException("bad combination")
+
+    if low_pct:
+        facts.append(("tolerance-percent-lower", "Tolerance, lower (%)", low_pct))
+    if high_pct:
+        facts.append(("tolerance-percent-upper", "Tolerance, upper (%)", high_pct))
+    if low_value:
+        facts.append(("tolerance-lower", "Tolerance, lower", low_value))
+    if high_value:
+        facts.append(("tolerance-upper", "Tolerance, upper", high_value))
+
+    if low_pct and low_pct == high_pct:
+        facts.append(("tolerance-percent", "Tolerance (±%)", low_pct))
+
+    return [bomFile.Fact(key=uris.make_fact_key(key), label=label, value=str(value)) for key, label, value in facts]
+
+
+_operating_temperature_re = re.compile("-([0-9]+)°C ~ ([0-9])+°C")
+_height_seated_re = re.compile("([0-9]+\\.[0-9]+)\" \\(([0-9]+\\.[0-9]+)mm\\)")
+_land_size_re = re.compile("([0-9]+\\.[0-9]+)\" L x ([0-9]+\\.[0-9]+)\" W "
+                           "\\(([0-9]+\\.[0-9]+)mm x ([0-9]+\\.[0-9]+)mm\\)")  # 0.260" L x 0.260" W (6.60mm x 6.60mm)
+
+
+def normalize_facts(in_dir: Path, out_dir: Path):
+    print("in: {}, out: {}".format(in_dir, out_dir))
+
+    in_db = load_db(in_dir)
+    out_parts = PartDb()
+
+    for part in in_db.iterparts():  # type: bomFile.Part
+        fact_list: bomFile.FactList = part.factsProp
+        if fact_list is None:
+            continue
+
+        in_facts: List[bomFile.Fact] = fact_list.factProp
+        out_facts = []
+
+        for f in in_facts:
+            key = uris.parse_digikey_fact_key(f.keyProp)
+
+            out_fact = None
+
+            value = f.valueProp
+
+            if value == "-":
+                continue
+
+            try:
+                if key == 3:
+                    out_fact = bomFile.Fact(key=uris.make_fact_key("tolerance"), label="Tolerance", value=value)
+                elif key == 252:
+                    m = _operating_temperature_re.match(value)
+                    if m:
+                        mn = m.group(1)
+                        mx = m.group(2)
+
+                        out_facts.extend([
+                            bomFile.Fact(key=uris.make_fact_key("temperature-min"), label="Min temperature", value=mn),
+                            bomFile.Fact(key=uris.make_fact_key("temperature-max"), label="Max temperature", value=mx)])
+                elif key == 1500:
+                    m = _height_seated_re.match(value)
+
+                    if m:
+                        out_fact = bomFile.Fact(key=uris.make_fact_key("part-height"), label="Height", value=m.group(2))
+                    else:
+                        print("{}: bad str: '{}'".format(key, value))
+                elif key == 884:
+                    m = _land_size_re.match(value)
+
+                    if m:
+                        out_facts.extend([
+                            bomFile.Fact(key=uris.make_fact_key("land-size-x"),
+                                         label="Land size, X",
+                                         value=m.group(3)),
+                            bomFile.Fact(key=uris.make_fact_key("land-size-y"),
+                                         label="Land size, Y",
+                                         value=m.group(4))])
+                elif key == 2049:
+                    val = EeVal.parse(value)
+                    out_fact = bomFile.Fact(key=uris.make_fact_key("capacitance"), label="Capacitance", value=str(val))
+                elif key == 2079:
+                    val = EeVal.parse(value)
+                    out_fact = bomFile.Fact(key=uris.make_fact_key("voltage-rating"), label="Voltage rating",
+                                            value=str(val))
+                else:
+                    pass  # fact ignored
+            except EeException:
+                pass
+
+            if out_fact:
+                out_facts.append(out_fact)
+
+        if len(out_facts) == 0:
+            continue
+
+        part.factsProp.factProp = out_facts
+        out_parts.add_entry(part, True)
+
+    print("Saving {} work parts".format(out_parts.size()))
+    save_db(out_dir, out_parts)