| """A small YAML emitter for rule files and alertmanager.yml that keeps comments and per-generation style. |
| |
| Dict keys named "_comment" (a string or a list of lines) are written as `# ...` lines above the mapping they |
| belong to and dropped from the data. `strip()` returns the data without them; `emit()` output is checked to |
| load back to exactly that data. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| import re |
|
|
| import yaml |
|
|
| _PLAIN_BAD = re.compile(r"^[\s\-?:,\[\]{}#&*!|>'\"%@`]|: |\s#|[\s]$|^$") |
| _RESERVED = {"true", "false", "yes", "no", "on", "off", "null", "~", "y", "n"} |
|
|
|
|
| def strip(obj): |
| if isinstance(obj, dict): |
| return {k: strip(v) for k, v in obj.items() if k != "_comment"} |
| if isinstance(obj, list): |
| return [strip(v) for v in obj] |
| return obj |
|
|
|
|
| def _scalar(v, quote_dur: bool = False) -> str: |
| if isinstance(v, bool): |
| return "true" if v else "false" |
| if v is None: |
| return "null" |
| if isinstance(v, (int, float)): |
| return repr(v) if isinstance(v, float) else str(v) |
| s = str(v) |
| if quote_dur and re.fullmatch(r"\d+[smhdw]", s): |
| return json.dumps(s) |
| if (_PLAIN_BAD.search(s) or s.lower() in _RESERVED or re.fullmatch(r"[-+.\d][\d_.eE+-]*", s) |
| or "\n" in s or "\t" in s or "\\" in s or not s.isascii()): |
| return json.dumps(s, ensure_ascii=False) |
| return s |
|
|
|
|
| class Style: |
| """quote_dur: durations as "5m"; block_expr: `expr: |` for expressions longer than `block_at` chars; |
| squote: single-quoted strings where that reads naturally (older files).""" |
|
|
| def __init__(self, quote_dur=False, block_expr=False, block_at=70, flow_labels=False): |
| self.quote_dur, self.block_expr, self.block_at, self.flow_labels = quote_dur, block_expr, block_at, flow_labels |
|
|
|
|
| def _comments(v, pad: str) -> list[str]: |
| if not v: |
| return [] |
| lines = [v] if isinstance(v, str) else list(v) |
| return [f"{pad}# {ln}".rstrip() for ln in lines] |
|
|
|
|
| def _emit(obj, indent: int, style: Style, out: list[str], key_ctx: str = "") -> None: |
| pad = " " * indent |
| if isinstance(obj, dict): |
| out += _comments(obj.get("_comment"), pad) |
| for k, v in obj.items(): |
| if k == "_comment": |
| continue |
| _emit_kv(k, v, indent, style, out) |
| return |
| raise TypeError("top level must be a mapping") |
|
|
|
|
| def _flow_map(d: dict) -> str: |
| return "{" + ", ".join(f"{k}: {_scalar(v)}" for k, v in d.items()) + "}" |
|
|
|
|
| def _emit_kv(k, v, indent: int, style: Style, out: list[str]) -> None: |
| pad = " " * indent |
| if isinstance(v, dict): |
| if not v: |
| out.append(f"{pad}{k}: {{}}") |
| return |
| if style.flow_labels and k in ("labels",) and all(not isinstance(x, (dict, list)) for x in v.values()): |
| out.append(f"{pad}{k}: {_flow_map(v)}") |
| return |
| out.append(f"{pad}{k}:") |
| _emit(v, indent + 2, style, out) |
| return |
| if isinstance(v, list): |
| if not v: |
| out.append(f"{pad}{k}: []") |
| return |
| if all(not isinstance(x, (dict, list)) for x in v) and k in ("group_by", "equal"): |
| out.append(f"{pad}{k}: [{', '.join(_scalar(x) for x in v)}]") |
| return |
| out.append(f"{pad}{k}:") |
| for item in v: |
| if isinstance(item, dict): |
| out += _comments(item.get("_comment"), pad) |
| keys = [x for x in item if x != "_comment"] |
| if not keys: |
| out.append(f"{pad}- {{}}") |
| continue |
| first = [] |
| _emit_kv(keys[0], item[keys[0]], indent + 2, style, first) |
| first[0] = f"{pad}- " + first[0][indent + 2:] |
| out += first |
| for kk in keys[1:]: |
| _emit_kv(kk, item[kk], indent + 2, style, out) |
| else: |
| out.append(f"{pad}- {_scalar(item)}") |
| return |
| if k == "expr" and isinstance(v, str) and style.block_expr and len(v) > style.block_at: |
| out.append(f"{pad}{k}: |") |
| for ln in _wrap_expr(v): |
| out.append(f"{pad} {ln}") |
| return |
| out.append(f"{pad}{k}: {_scalar(v, quote_dur=style.quote_dur and k in ('for', 'keep_firing_for', 'interval'))}") |
|
|
|
|
| def _wrap_expr(expr: str) -> list[str]: |
| """Break a long binary expression before its top-level operators, the way people format PromQL.""" |
| if "\n" in expr: |
| return expr.splitlines() |
| parts, depth, cur, i = [], 0, "", 0 |
| ops = (" / ", " and ", " or ", " unless ", " > ", " < ") |
| while i < len(expr): |
| c = expr[i] |
| if c in "([{": |
| depth += 1 |
| elif c in ")]}": |
| depth -= 1 |
| hit = next((o for o in ops if depth == 0 and expr.startswith(o, i)), None) |
| if hit in (" / ", " and ", " or ", " unless ") and cur.strip(): |
| parts.append(cur.rstrip()) |
| cur = hit.strip() + " " |
| i += len(hit) |
| continue |
| cur += c |
| i += 1 |
| parts.append(cur.rstrip()) |
| out = [] |
| for p in parts: |
| if out and p.startswith(("> ", "< ")): |
| out[-1] += " " + p |
| else: |
| out.append(p) |
| return out |
|
|
|
|
| def emit(doc: dict, style: Style | None = None, header: list[str] | None = None) -> str: |
| style = style or Style() |
| out = [f"# {h}".rstrip() for h in (header or [])] |
| _emit(doc, 0, style, out) |
| text = "\n".join(out) + "\n" |
| back = yaml.safe_load(text) |
| want = strip(doc) |
| if style.block_expr: |
| back = _norm_block(back) |
| want = _norm_block(want) |
| if back != want: |
| raise AssertionError("YAML emitter round trip failed") |
| return text |
|
|
|
|
| def _norm_block(obj): |
| if isinstance(obj, dict): |
| return {k: (re.sub(r"\s+", " ", v).strip() if k == "expr" and isinstance(v, str) else _norm_block(v)) |
| for k, v in obj.items()} |
| if isinstance(obj, list): |
| return [_norm_block(x) for x in obj] |
| return obj |
|
|
