@h2loop/autosar 1.9.0 → 1.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h2loop/autosar",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "AUTOSAR Classic pack for Hydron: ECUC read/edit-in-place/validate/diff on ARXML, config-to-code trace, generator and build runners",
   "type": "module",
   "private": false,

package/python/ecuc_engine/ecucjson.py

@@ -20,7 +20,7 @@ from typing import Optional
 from . import defs as D
 from .model import Elem, Project
 from .validate import _resolve_def
-from .values import int_forms, to_json
+from .values import derived, int_forms, to_json
 
 
 def key_of(e: Elem) -> str:
@@ -42,6 +42,10 @@ def value_info(project: Project, e: Elem, pv) -> dict:
     nums = int_forms(pd, pv.value, pv.is_ref, numerical, pv.def_dest)
     if nums:
         out.update(nums)
+    if pd is not None and pd.kind == "FLOAT":
+        dv = derived(pd.name, pv.value)
+        if dv:
+            out["means"] = dv
     return out
 
 
@@ -49,6 +53,8 @@ def _put(out: dict, name: str, items: list, multi: bool):
     one = lambda xs: xs if multi else xs[0]  # noqa: E731
     out[name] = one([x["value"] for x in items])
     out[f"@at:{name}"] = one([x["at"] for x in items])
+    if any("means" in x for x in items):
+        out[f"@means:{name}"] = one([x.get("means") for x in items])
     if any("hex" in x for x in items):
         out[f"@hex:{name}"] = one([x.get("hex") for x in items])
         if any("dec" in x and x["value"] != x["dec"] for x in items):

package/python/ecuc_engine/edit.py

@@ -24,7 +24,7 @@ from typing import Optional
 from . import defs as D
 from .model import CONTAINER_VALUE, Elem, Project
 from .validate import _resolve_def, validate
-from .values import check_value, expected_value_tag, from_json
+from .values import check_value, derived, expected_value_tag, from_json
 from .xmltree import Node, escape, line_indent
 
 CONTAINER_ORDER = ["DEFINITION-REF", "PARAMETER-VALUES", "REFERENCE-VALUES", "SUB-CONTAINERS", "VARIATION-POINT"]
@@ -412,6 +412,65 @@ def _unwrap_ref(v):
     return v
 
 
+def _kids(project: Project, path: str) -> dict:
+    """{SHORT-NAME: child path} of a value path ('' = package level: the module configurations)."""
+    out = {}
+    for e in project.find(path):
+        for c in e.children:
+            out[c.name] = c.path
+    return out
+
+
+def _child_def_names(project: Project, path: str) -> set:
+    """Container def names a container at ``path`` may hold (from its def, else from its present children)."""
+    names = set()
+    for e in project.find(path):
+        d = _resolve_def(project.defs, e.def_ref) if project.defs else None
+        if d is not None:
+            names |= {project.defs.by_path[x].name for x in d.containers if x in project.defs.by_path}
+        names |= {(c.def_ref or "").rsplit("/", 1)[-1] for c in e.children}
+    return names - {""}
+
+
+def canonical_path(project: Project, path: str):
+    """Rewrite the path dialects agents write into the value path, or None.
+
+    Handles container DEF names used as path segments ('.../GptChannelConfigSet/GptChannelConfiguration/
+    GptChannel_Delay' -> '.../GptChannelConfigSet/GptChannel_Delay') and a missing module segment
+    ('/ActiveEcuC/GptDriverConfiguration' -> '/ActiveEcuC/Gpt/GptDriverConfiguration'). Unresolvable trailing
+    segments are kept (a parameter name, or the container an add creates). Returns (path, dropped_def) where
+    dropped_def is a def name dropped at the END of the path (the def of the container an add should create)."""
+    segs = [s for s in path.strip().strip("/").split("/") if s]
+    if len(segs) < 2:
+        return None
+    mods = {e.name: e.path for es in project.by_path.values() for e in es if e.parent is None}
+    pkg = "/" + segs[0]
+    if not any(p.startswith(pkg + "/") for p in mods.values()):
+        return None
+    cur, i, dropped, changed = None, 1, None, False
+    rest: list = []
+    while i < len(segs):
+        s = segs[i]
+        kids = {n: p for n, p in mods.items() if p.startswith(pkg + "/")} if cur is None else _kids(project, cur)
+        if s in kids:
+            cur, dropped = kids[s], None
+        elif cur is None:
+            owners = [mp for mp in kids.values() if s in _kids(project, mp)]
+            if len(owners) != 1:
+                return None
+            cur, changed = _kids(project, owners[0])[s], True
+        elif s in _child_def_names(project, cur):
+            dropped, changed = s, True
+        else:
+            rest = segs[i:]
+            break
+        i += 1
+    if not changed or cur is None:
+        return None
+    out = cur + ("/" + "/".join(rest) if rest else "")
+    return out, (dropped if not rest else None)
+
+
 def normalize_ops(project: Project, ops, notes: list):
     """Accept the shapes agents use for ECUC edits (arxml_edit's keys, SHORT-NAME given separately, refs as objects,
     params added to a container that does not exist yet) and rewrite them into ecuc_edit's own; note each rewrite."""
@@ -428,6 +487,21 @@ def normalize_ops(project: Project, ops, notes: list):
         if "path" not in op and isinstance(op.get("parent_path"), str):
             op["path"] = op.pop("parent_path")
             notes.append(f"op {i}: 'parent_path' read as 'path'")
+        for rk in ("refs", "references", "reference_values"):
+            if isinstance(op.get(rk), dict):
+                rv = op.pop(rk)
+                op["values"] = {**(op.get("values") if isinstance(op.get("values"), dict) else {}), **rv}
+                notes.append(f"op {i}: '{rk}' merged into values")
+        pth = op.get("path")
+        if isinstance(pth, str) and pth.startswith("/") and not project.find(pth.rstrip("/")):
+            cp = canonical_path(project, pth)
+            if cp is not None:
+                op["path"], ddef = cp
+                notes.append(f"op {i}: path {pth} read as {op['path']}")
+                c = op.get("container")
+                if ddef and op.get("op") == "add" and isinstance(c, str) and ":" not in c:
+                    op["container"] = f"{ddef}:{c}"
+                    notes.append(f"op {i}: container {c!r} read as {op['container']!r}")
         sn = None
         for k in ("short_name", "name", "shortName"):
             if isinstance(op.get(k), str):
@@ -560,6 +634,16 @@ def edit(project: Project, ops: list, dry_run: bool = False, force: bool = False
     try:
         ops = normalize_ops(project, ops, ed.notes)
         ed.apply(ops, force=force)
+        for op in ops if isinstance(ops, list) else []:
+            if not isinstance(op, dict):
+                continue
+            vals = dict(op.get("values") or {}) if isinstance(op.get("values"), dict) else {}
+            if op.get("op") == "set" and "value" in op:
+                vals[op.get("param") or str(op.get("path", "")).rstrip("/").rsplit("/", 1)[-1]] = op["value"]
+            for k, v in vals.items():
+                dv = derived(str(k), v)
+                if dv:
+                    ed.notes.append(f"{k} = {v}: {dv}; check this matches the requirement")
     except EditError as e:
         return {"ok": False, "error": str(e), "written": False, "notes": ed.notes}
     changes = ed.diffs()

package/python/ecuc_engine/values.py

@@ -170,3 +170,26 @@ def int_forms(d: Optional[DefNode], raw: Optional[str], is_ref: bool, numerical:
     if v is None:
         return None
     return {"dec": v, "hex": hex_str(v)}
+
+
+def _si(x: float, unit: str) -> str:
+    for f, pre in ((1e9, "G"), (1e6, "M"), (1e3, "k"), (1, ""), (1e-3, "m"), (1e-6, "\u00b5"), (1e-9, "n"), (1e-12, "p")):
+        if abs(x) >= f:
+            return f"{x / f:.4g} {pre}{unit}"
+    return f"{x:.4g} {unit}"
+
+
+def derived(name: str, raw) -> Optional[str]:
+    """Human reading of a frequency / baud rate value, with its period: helps catch unit slips
+    (100 ns resolution is a 10 MHz tick, not 100 kHz). None when the param is not one of those."""
+    try:
+        v = float(str(raw).strip())
+    except (TypeError, ValueError):
+        return None
+    if v <= 0:
+        return None
+    if name.endswith("Frequency"):
+        return f"{_si(v, 'Hz')} = {_si(1 / v, 's')} per tick"
+    if name.endswith("BaudRate"):   # ECUC CAN/LIN baud rates are in kbit/s
+        return f"{_si(v * 1e3, 'bit/s')} = {_si(1 / (v * 1e3), 's')} per bit"
+    return None