From 5bf5316af590120d00a49e845407eb9c0b7383e8 Mon Sep 17 00:00:00 2001 From: Lars Date: Tue, 9 Sep 2025 12:40:23 +0200 Subject: [PATCH] app/core/note_payload.py aktualisiert --- app/core/note_payload.py | 165 ++++++++++++++++++++++++++++++--------- 1 file changed, 130 insertions(+), 35 deletions(-) diff --git a/app/core/note_payload.py b/app/core/note_payload.py index 6a94e6b..94cb846 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.4.0 +Version: 1.5.1 Datum: 2025-09-09 Kurzbeschreibung @@ -12,18 +12,36 @@ 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). +Wichtig +------- +- **Nur Inhalte** gehen in den Hash: Weder Dateisystem-Zeitstempel (mtime/ctime) + noch sonstige FS-Metadaten werden berücksichtigt. +- Hash-Quelle: Parser-Body (Default) oder Rohdatei-Body (Frontmatter via Regex entfernt). + +Änderungen in v1.5.1 +-------------------- +- Neue Env-Var **MINDNET_HASH_COMPARE** als Synonym zu MINDNET_HASH_MODE. +- Akzeptiert komfortable Werte (case-insensitive): **Body**, **Frontmatter**, **Full**. + *Full* wird intern zu ``body+frontmatter`` normalisiert. +- CLI akzeptiert weiterhin ``--hash-mode``; Importer reicht diese Einstellung durch. + 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) +- Modus (welche Teile in den Hash einfließen): + * ``body`` (Default) + * ``frontmatter`` + * ``body+frontmatter`` (Synonym CLI/ENV: ``full``) + Quelle: + * Funktionsparameter ``hash_mode`` (höchste Priorität) + * Env ``MINDNET_HASH_MODE`` oder **``MINDNET_HASH_COMPARE``** (Fallback) + Normalisierung: + * ``canonical`` (Default) | ``none`` — via Param ``hash_normalize`` oder Env ``MINDNET_HASH_NORMALIZE`` + Quelle des Body-Textes: + * ``parsed`` (Default) | ``raw`` — via Param ``hash_source`` oder Env ``MINDNET_HASH_SOURCE`` -Beispiele (CLI – Sichtprüfung) ------------------------------- - python3 -m app.core.note_payload --from-file ./vault/demo.md --vault-root ./vault --print +CLI (Sichtprüfung) +------------------ + python3 -m app.core.note_payload --from-file ./vault/demo.md --vault-root ./vault --print --hash-source raw """ from __future__ import annotations @@ -31,16 +49,16 @@ import argparse import hashlib import json import os -from typing import Any, Dict, Optional +from typing import Any, Dict, Optional, Tuple try: - from app.core.parser import read_markdown, extract_wikilinks + from app.core.parser import read_markdown, extract_wikilinks, FRONTMATTER_RE except Exception: # pragma: no cover - from .parser import read_markdown, extract_wikilinks # type: ignore + from .parser import read_markdown, extract_wikilinks, FRONTMATTER_RE # type: ignore # --------------------------------------------------------------------------- -# Hashing +# Helpers # --------------------------------------------------------------------------- def _canon_frontmatter(fm: Dict[str, Any]) -> str: @@ -51,13 +69,62 @@ 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 + # canonical: \r\n→\n, trailing spaces entfernen 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 _resolve_hash_mode(explicit: Optional[str]) -> str: + """ + Normalisiert den Hash-Modus auf einen der Werte: + 'body' | 'frontmatter' | 'body+frontmatter' + Akzeptiert auch 'full' als Alias für 'body+frontmatter'. + Beachtet zusätzlich die Env-Variablen MINDNET_HASH_MODE und MINDNET_HASH_COMPARE. + """ + if explicit: + val = explicit.strip().lower() + else: + val = (os.environ.get("MINDNET_HASH_MODE") or os.environ.get("MINDNET_HASH_COMPARE") or "body").strip().lower() + if val in ("full", "fulltext", "body+frontmatter", "bodyplusfrontmatter"): + return "body+frontmatter" + if val in ("frontmatter", "fm"): + return "frontmatter" + # default & fallbacks + return "body" + +def _read_raw_body_from_file(file_path: Optional[str]) -> Tuple[str, Dict[str, Any]]: + """Liest die Rohdatei und extrahiert Body & Frontmatter ohne Parser-Logik. + + Rückgabe: + (body_text, frontmatter_dict) + """ + if not file_path or not os.path.exists(file_path): + return "", {} + try: + with open(file_path, "r", encoding="utf-8") as f: + raw = f.read() + except Exception: + return "", {} + # Frontmatter per Regex entfernen + m = FRONTMATTER_RE.match(raw) + fm = {} + if m: + fm_txt = m.group(1) + try: + import yaml # lazy + fm = yaml.safe_load(fm_txt) or {} + except Exception: + fm = {} + body = raw[m.end():] + else: + body = raw + return body, fm + + +# --------------------------------------------------------------------------- +# Hashing +# --------------------------------------------------------------------------- + def compute_hash( *, body: Optional[str], @@ -76,7 +143,7 @@ def compute_hash( - "canonical" (Default) - "none" """ - mode = (mode or os.environ.get("MINDNET_HASH_MODE", "body")).strip().lower() + mode = _resolve_hash_mode(mode) normalize = (normalize or os.environ.get("MINDNET_HASH_NORMALIZE", "canonical")).strip().lower() body = _normalize_body(body or "", normalize) @@ -104,6 +171,8 @@ def make_note_payload( *, hash_mode: Optional[str] = None, hash_normalize: Optional[str] = None, + hash_source: Optional[str] = None, + file_path: Optional[str] = None, ) -> Dict[str, Any]: """ Erzeugt den Payload für eine geparste Note. @@ -115,9 +184,13 @@ def make_note_payload( 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). + "body" | "frontmatter" | "body+frontmatter" | "full" (Alias; überschreibt ENV). hash_normalize : Optional[str] "canonical" | "none" (überschreibt ENV). + hash_source : Optional[str] + "parsed" (Default) oder "raw". Wenn "raw", wird der Body aus der Rohdatei gelesen. + file_path : Optional[str] + Pfad zur Markdown-Datei, erforderlich für ``hash_source=raw``. Returns ------- @@ -125,17 +198,30 @@ def make_note_payload( Qdrant-Payload für die Notes-Collection. """ # "Duck typing": dict oder Objekt akzeptieren - fm = ( - getattr(parsed, "frontmatter", None) - or getattr(parsed, "fm", None) - or getattr(parsed, "front_matter", None) - or (parsed.get("frontmatter") if isinstance(parsed, dict) else {}) - ) or {} - 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 "" + if isinstance(parsed, dict): + fm = parsed.get("frontmatter") or {} + body = parsed.get("body") or "" + path = parsed.get("path") or "" + else: + fm = getattr(parsed, "frontmatter", {}) or {} + body = getattr(parsed, "body", "") or "" + path = getattr(parsed, "path", "") or "" - # Hash gem. Modus bilden - hash_fulltext = compute_hash(body=body, frontmatter=fm, mode=hash_mode, normalize=hash_normalize) + # Hash-Quelle bestimmen + src = (hash_source or os.environ.get("MINDNET_HASH_SOURCE", "parsed")).strip().lower() + raw_body, raw_fm = ("", {}) + if src == "raw": + raw_body, raw_fm = _read_raw_body_from_file(file_path or path) + # Roh-FM ergänzen (nicht überschreiben) + if isinstance(raw_fm, dict) and raw_fm: + merged_fm = dict(fm) + for k, v in raw_fm.items(): + merged_fm.setdefault(k, v) + fm = merged_fm + + # Hash gemäß Modus/Quelle bilden + body_for_hash = raw_body if src == "raw" else body + hash_fulltext = compute_hash(body=body_for_hash, frontmatter=fm, mode=hash_mode, normalize=hash_normalize) # Pfad relativieren rel_path = path @@ -145,9 +231,9 @@ def make_note_payload( rel = rel.replace("\\", "/").lstrip("/") # normalisieren rel_path = rel except Exception: - pass # Pfad nicht kritisch für Hash/ID + pass # Pfad ist nicht kritisch für Hash/ID - # Optionale Note-Level-Wikilinks (Fallback, wenn Chunks nicht geliefert werden) + # Note-Level-Wikilinks (Fallback, wenn Chunks nicht geliefert werden) note_level_refs = list(dict.fromkeys(extract_wikilinks(body))) if body else [] payload: Dict[str, Any] = { @@ -160,16 +246,23 @@ def make_note_payload( "path": rel_path or fm.get("path"), "tags": fm.get("tags"), "hash_fulltext": hash_fulltext, - # Volltext persistieren (verlustfreie Rekonstruktion) + # Volltext persistieren (verlustfreie Rekonstruktion) – aus PARSED-Body "fulltext": body, # Fallback-Refs auf Note-Ebene "references": note_level_refs, } - for k in ("area", "project", "source", "lang", "slug"): + for k in ("area", "project", "source", "lang", "slug", "aliases"): if k in fm: payload[k] = fm[k] + # Optional: Roh-Body-Hash zusätzlich persistieren + if os.environ.get("MINDNET_HASH_STORE_RAW", "false").strip().lower() == "true" and src == "raw": + try: + payload["hash_raw_body"] = compute_hash(body=raw_body, frontmatter=fm, mode="body", normalize="none") + except Exception: + pass + return payload @@ -182,13 +275,15 @@ 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-mode", choices=["body", "frontmatter", "body+frontmatter", "full"], default=None) ap.add_argument("--hash-normalize", choices=["canonical", "none"], default=None) + ap.add_argument("--hash-source", choices=["parsed", "raw"], default=None) args = ap.parse_args() parsed = read_markdown(args.src) payload = make_note_payload(parsed, vault_root=args.vault_root, - hash_mode=args.hash_mode, hash_normalize=args.hash_normalize) + hash_mode=args.hash_mode, hash_normalize=args.hash_normalize, + hash_source=args.hash_source, file_path=args.src) if args.do_print: print(json.dumps(payload, ensure_ascii=False, indent=2))