From 305089fcf653de44e9baf4ad57cd5be5e46a7daa Mon Sep 17 00:00:00 2001 From: Lars Date: Tue, 9 Sep 2025 11:27:18 +0200 Subject: [PATCH] app/core/note_payload.py aktualisiert --- app/core/note_payload.py | 76 ++++++++++++++++++++++++++++------------ 1 file changed, 53 insertions(+), 23 deletions(-) diff --git a/app/core/note_payload.py b/app/core/note_payload.py index 59c6a63..6a94e6b 100644 --- a/app/core/note_payload.py +++ b/app/core/note_payload.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- """ Modul: app/core/note_payload.py -Version: 1.3.1 +Version: 1.4.0 Datum: 2025-09-09 Kurzbeschreibung @@ -12,15 +12,14 @@ Idempotenz wird der vollständige Body unter ``fulltext`` persistiert und der Dateipfad relativ zum Vault gespeichert. Das erlaubt eine verlustfreie Rekonstruktion im Export (erst ``fulltext``, sonst Chunks). -Wesentliche Features --------------------- -- Hash-Strategie via ENV ``MINDNET_HASH_MODE``: - * ``body`` (Default) - * ``frontmatter`` - * ``body+frontmatter`` -- Persistenter Volltext im Note-Payload: ``fulltext`` -- Pfad-Relativierung (``path``) gegen ``vault_root`` -- Optionale Note-Level-Wikilinks (Fallback-Refs) +Hash-Steuerung +-------------- +- Modus: ``body`` (Default) | ``frontmatter`` | ``body+frontmatter`` + * per Funktionsparameter ``hash_mode`` (prio 1) + * oder ENV ``MINDNET_HASH_MODE`` (prio 2) +- Normalisierung: ``canonical`` (Default) | ``none`` + * per Funktionsparameter ``hash_normalize`` (prio 1) + * oder ENV ``MINDNET_HASH_NORMALIZE`` (prio 2) Beispiele (CLI – Sichtprüfung) ------------------------------ @@ -35,7 +34,6 @@ import os from typing import Any, Dict, Optional try: - # In deinem Parser heißen die Funktionen read_markdown / extract_wikilinks from app.core.parser import read_markdown, extract_wikilinks except Exception: # pragma: no cover from .parser import read_markdown, extract_wikilinks # type: ignore @@ -49,18 +47,39 @@ def _canon_frontmatter(fm: Dict[str, Any]) -> str: """Kanonische, stabile JSON-Serialisierung der Frontmatter für Hashbildung.""" return json.dumps(fm or {}, ensure_ascii=False, separators=(",", ":"), sort_keys=True) +def _normalize_body(body: str, mode: str) -> str: + """Normalisiert den Body für reproduzierbare Hashes (oder nicht).""" + if mode == "none": + return body if body is not None else "" + # canonical: \r\n→\n, trailing spaces, mehrfach-blankzeilen trimmen + text = (body or "").replace("\r\n", "\n").replace("\r", "\n") + # trailing whitespace am Zeilenende entfernen + text = "\n".join(line.rstrip() for line in text.split("\n")) + # keine aggressivere Logik (keine inhaltliche Änderung) + return text -def compute_hash(*, body: Optional[str], frontmatter: Optional[Dict[str, Any]], mode: Optional[str] = None) -> str: +def compute_hash( + *, + body: Optional[str], + frontmatter: Optional[Dict[str, Any]], + mode: Optional[str] = None, + normalize: Optional[str] = None, +) -> str: """ - Berechnet einen Hex-Hash gemäß ``mode``. + Berechnet einen Hex-Hash gemäß ``mode`` und ``normalize``. mode: - "body" (Default) - "frontmatter" - "body+frontmatter" + normalize: + - "canonical" (Default) + - "none" """ mode = (mode or os.environ.get("MINDNET_HASH_MODE", "body")).strip().lower() - body = body or "" + normalize = (normalize or os.environ.get("MINDNET_HASH_NORMALIZE", "canonical")).strip().lower() + + body = _normalize_body(body or "", normalize) fm_s = _canon_frontmatter(frontmatter or {}) h = hashlib.sha256() @@ -79,7 +98,13 @@ def compute_hash(*, body: Optional[str], frontmatter: Optional[Dict[str, Any]], # Kernfunktion # --------------------------------------------------------------------------- -def make_note_payload(parsed: Any, vault_root: Optional[str] = None) -> Dict[str, Any]: +def make_note_payload( + parsed: Any, + vault_root: Optional[str] = None, + *, + hash_mode: Optional[str] = None, + hash_normalize: Optional[str] = None, +) -> Dict[str, Any]: """ Erzeugt den Payload für eine geparste Note. @@ -89,6 +114,10 @@ def make_note_payload(parsed: Any, vault_root: Optional[str] = None) -> Dict[str Objekt mit Attributen/Keys ``frontmatter``, ``body``, ``path``. vault_root : Optional[str] Vault-Wurzel (für Pfad-Relativierung). Wenn ``None``, wird ``path`` unverändert übernommen. + hash_mode : Optional[str] + "body" | "frontmatter" | "body+frontmatter" (überschreibt ENV). + hash_normalize : Optional[str] + "canonical" | "none" (überschreibt ENV). Returns ------- @@ -105,8 +134,8 @@ def make_note_payload(parsed: Any, vault_root: Optional[str] = None) -> Dict[str body = getattr(parsed, "body", None) or (parsed.get("body") if isinstance(parsed, dict) else "") or "" path = getattr(parsed, "path", None) or (parsed.get("path") if isinstance(parsed, dict) else "") or "" - # Hash gem. Modus bilden (Default: body) - hash_fulltext = compute_hash(body=body, frontmatter=fm, mode=None) + # Hash gem. Modus bilden + hash_fulltext = compute_hash(body=body, frontmatter=fm, mode=hash_mode, normalize=hash_normalize) # Pfad relativieren rel_path = path @@ -116,8 +145,7 @@ def make_note_payload(parsed: Any, vault_root: Optional[str] = None) -> Dict[str rel = rel.replace("\\", "/").lstrip("/") # normalisieren rel_path = rel except Exception: - # fail-safe, Pfad ist nicht kritisch für Hash/ID - pass + pass # Pfad nicht kritisch für Hash/ID # Optionale Note-Level-Wikilinks (Fallback, wenn Chunks nicht geliefert werden) note_level_refs = list(dict.fromkeys(extract_wikilinks(body))) if body else [] @@ -132,13 +160,12 @@ def make_note_payload(parsed: Any, vault_root: Optional[str] = None) -> Dict[str "path": rel_path or fm.get("path"), "tags": fm.get("tags"), "hash_fulltext": hash_fulltext, - # --- WICHTIG: Volltext persistieren --- + # Volltext persistieren (verlustfreie Rekonstruktion) "fulltext": body, - # --- Optionaler Fallback für Edge-Ableitung --- + # Fallback-Refs auf Note-Ebene "references": note_level_refs, } - # Bekannte optionale Frontmatter-Felder durchreichen for k in ("area", "project", "source", "lang", "slug"): if k in fm: payload[k] = fm[k] @@ -155,10 +182,13 @@ def _cli() -> None: ap.add_argument("--from-file", dest="src", required=True, help="Pfad zur Markdown-Datei") ap.add_argument("--vault-root", dest="vault_root", default=None, help="Vault-Wurzel zur Pfad-Relativierung") ap.add_argument("--print", dest="do_print", action="store_true", help="Payload auf stdout ausgeben") + ap.add_argument("--hash-mode", choices=["body", "frontmatter", "body+frontmatter"], default=None) + ap.add_argument("--hash-normalize", choices=["canonical", "none"], default=None) args = ap.parse_args() parsed = read_markdown(args.src) - payload = make_note_payload(parsed, vault_root=args.vault_root) + payload = make_note_payload(parsed, vault_root=args.vault_root, + hash_mode=args.hash_mode, hash_normalize=args.hash_normalize) if args.do_print: print(json.dumps(payload, ensure_ascii=False, indent=2))