Map NE, S, M, and L motor delays

Author: SiboVG

scripts/build_database.py

@@ -20,6 +20,11 @@
 
 _DELAY_SUFFIX_RE = re.compile(r'-(\d+|[pP])$')
 _SIMPLIFY_CN_RE = re.compile(r'^[0-9]*[ -]*([A-Z][0-9]+)')
+_TEXTUAL_DELAY_VALUE_MAP = {
+    'S': 6.0,
+    'M': 10.0,
+    'L': 14.0,
+}
 
 
 def ensure_curve_starts_at_zero(points):
@@ -37,6 +42,28 @@ def curve_signature(points):
     return tuple((round(time_s, 6), round(thrust_n, 6)) for time_s, thrust_n in points)
 
 
+def normalize_delay_token(token):
+    """Canonicalize known textual delay tokens."""
+    normalized = str(token).strip()
+    upper = normalized.upper()
+    if upper in ('P', 'PLUGGED', 'NE'):
+        return 'P'
+    return upper
+
+
+def delay_token_to_seconds(token):
+    """Map known textual delay tokens to representative numeric values."""
+    normalized = normalize_delay_token(token)
+    if normalized in _TEXTUAL_DELAY_VALUE_MAP:
+        return _TEXTUAL_DELAY_VALUE_MAP[normalized]
+    return float(normalized)
+
+
+def normalize_delay_field(raw_value):
+    """Convert a raw delay field into canonical comma-separated form."""
+    return merge_delays(raw_value)
+
+
 def parse_delays(delays):
     """Normalize delay representations into a unique ordered list."""
     if delays is None:
@@ -59,7 +86,7 @@ def parse_delays(delays):
         token = part.strip()
         if not token:
             continue
-        normalized = 'P' if token.upper() == 'P' else token
+        normalized = normalize_delay_token(token)
         if normalized not in seen:
             tokens.append(normalized)
             seen.add(normalized)
@@ -80,13 +107,16 @@ def merge_delays(*delay_values):
     if not merged:
         return None
 
-    numeric = sorted(
-        (token for token in merged if token != 'P'),
-        key=lambda token: (float(token), token),
-    )
-    if 'P' in seen:
-        numeric.append('P')
-    return ','.join(numeric)
+    numeric = []
+    textual = []
+    for token in merged:
+        try:
+            numeric.append((delay_token_to_seconds(token), token))
+        except ValueError:
+            textual.append(token)
+
+    ordered_numeric = [token for _, token in sorted(numeric, key=lambda item: (item[0], item[1]))]
+    return ','.join(ordered_numeric + textual)
 
 
 def normalize_designation(designation):
@@ -416,13 +446,7 @@ def parse_rasp(filepath):
 
                 try:
                     delays_raw = parts[3]
-                    if delays_raw.upper() == 'P':
-                        delays = 'P'
-                    elif delays_raw.strip() == '':
-                        delays = None
-                    else:
-                        delay_parts = [d.strip() for d in re.split(r'[-,]+', delays_raw) if d.strip()]
-                        delays = ','.join(delay_parts) if delay_parts else None
+                    delays = normalize_delay_field(delays_raw)
 
                     # RASP weights are in kg, convert to grams for DB consistency
                     prop_weight_kg = float(parts[4])
@@ -490,13 +514,7 @@ def parse_rse(filepath):
 
         # Extract Metadata
         delays_raw = engine.get('delays', '')
-        if delays_raw.upper() == 'P':
-            delays = 'P'
-        elif not delays_raw.strip():
-            delays = None
-        else:
-            delay_parts = [d.strip() for d in re.split(r'[-,]+', delays_raw) if d.strip()]
-            delays = ','.join(delay_parts) if delay_parts else None
+        delays = normalize_delay_field(delays_raw)
 
         designation = engine.get('code', 'Unknown')
         # Extract common name from designation (strip propellant suffix letters)
@@ -643,14 +661,7 @@ def try_header(parts):
             return None
         try:
             raw_delays = parts[3]
-            if raw_delays.upper() == 'P':
-                delays = 'P'
-            elif raw_delays.strip() == '':
-                delays = None
-            else:
-                # Normalize dash-separated to comma-separated
-                delay_parts = [d.strip() for d in re.split(r'[-,]+', raw_delays) if d.strip()]
-                delays = ','.join(delay_parts) if delay_parts else None
+            delays = normalize_delay_field(raw_delays)
             return {
                 'common_name': parts[0], 'designation': parts[0],
                 'diameter': float(parts[1]), 'length': float(parts[2]),
@@ -737,13 +748,7 @@ def parse_rse_all(filepath):
         tree = ET.parse(filepath)
         for engine in tree.getroot().findall(".//engine"):
             raw_delays = engine.get('delays', '')
-            if raw_delays.upper() == 'P':
-                delays = 'P'
-            elif raw_delays.strip() == '':
-                delays = None
-            else:
-                delay_parts = [d.strip() for d in re.split(r'[-,]+', raw_delays) if d.strip()]
-                delays = ','.join(delay_parts) if delay_parts else None
+            delays = normalize_delay_field(raw_delays)
             designation = engine.get('code', 'Unknown')
             cn_match = re.match(r'^([A-Z][0-9]+)', designation)
             meta = {

tests/test_build_database.py

@@ -215,6 +215,7 @@ def test_parse_rasp_delays_normalized(tmp_path):
         ("5-10-15", "5,10,15"),
         ("0", "0"),
         ("P", "P"),
+        ("NE", "P"),
         ("p", "P"),
         ("3", "3"),
     ]
@@ -236,7 +237,7 @@ def make_rse(delays_attr):
             "<eng-data t=\"0.4\" f=\"0.0\" /></data></engine>"
             "</engine-list></engine-database>"
         )
-    cases = [("5-10-15", "5,10,15"), ("0", "0"), ("P", "P"), ("6,10", "6,10")]
+    cases = [("5-10-15", "5,10,15"), ("0", "0"), ("P", "P"), ("NE", "P"), ("6,10", "6,10")]
     for raw, expected in cases:
         path = tmp_path / f"motor_{raw}.rse"
         path.write_text(make_rse(raw))
@@ -256,10 +257,20 @@ def test_calculate_thrust_stats():
 
 def test_merge_delays_combines_unique_values():
     assert build_db.merge_delays("0,5", "5-10", "P") == "0,5,10,P"
+    assert build_db.merge_delays("Plugged", "0-3-5-7") == "0,3,5,7,P"
+    assert build_db.merge_delays("S,M", "L", "P") == "S,M,L,P"
+    assert build_db.merge_delays("NE", "P") == "P"
     assert build_db.merge_delays(None, "", "0") == "0"
     assert build_db.merge_delays(None, "") is None
 
 
+def test_delay_token_to_seconds_maps_textual_delays():
+    assert build_db.delay_token_to_seconds("S") == pytest.approx(6.0)
+    assert build_db.delay_token_to_seconds("M") == pytest.approx(10.0)
+    assert build_db.delay_token_to_seconds("L") == pytest.approx(14.0)
+    assert build_db.delay_token_to_seconds("7") == pytest.approx(7.0)
+
+
 def test_extract_simfile_info_from_filename():
     mapping = {"abcdef123456abcdef123456": "motor-1"}
     sim_id, info = build_db.extract_simfile_info_from_filename(