graphify-vault 0.6.0__tar.gz → 0.6.2__tar.gz

{graphify_vault-0.6.0 → graphify_vault-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphify_vault
-Version: 0.6.0
+Version: 0.6.2
 Summary: Fork of github.com/safishamsi/graphify with GRAPHIFY_WORKSPACE path resolution for distributed graph artifacts, same-label node merging, incremental build fixes, and local knowledge vault capabilities
 License: MIT License
         

{graphify_vault-0.6.0 → graphify_vault-0.6.2}/graphify/__main__.py

@@ -251,7 +251,7 @@ def _agent_mcp_rule(mcp_name: str, platform_name: str) -> str:
         + f"This project uses the `{mcp_name}` MCP server as an external knowledge source.\n\n"
         + "Rules:\n"
         + "- For relevant architecture, API usage, implementation, or troubleshooting questions, query the knowledge graph before answering.\n"
-        + "- Start with `query_graph` using `depth=3` and `token_budget=3000`.\n"
+        + "- Start with `query_graph` using `depth=3`.\n"
         + "- Treat graph results as retrieval context, not as the final answer.\n"
         + "- Read the referenced source files and line ranges when detailed evidence is needed.\n"
         + "- If retrieval is incomplete, retry with alternate terminology instead of guessing.\n"
@@ -1292,7 +1292,7 @@ def main() -> None:
         print("    --graph <path>          path to graph.json (default graphify-out/graph.json)")
         print('  query "<question>"       BFS traversal of graph.json for a question')
         print("    --dfs                   use depth-first instead of breadth-first")
-        print("    --budget N              cap output at N tokens (default 2000)")
+        print("    --max-degree N          filter hub nodes (default 0 = unlimited)")
         print("    --graph <path>          path to graph.json (default graphify-out/graph.json)")
         print("  save-result             save a Q&A result to graphify-out/memory/ for graph feedback loop")
         print("    --question Q            the question asked")
@@ -1487,7 +1487,7 @@ def main() -> None:
     elif cmd == "query":
         if len(sys.argv) < 3:
             print(
-                'Usage: graphify query "<question>" [--dfs] [--json] [--budget N] [--max-degree N] [--sort-by degree|relevance] [--query-variant TEXT ...] [--leaf-depth N] [--graph path]',
+                'Usage: graphify query "<question>" [--dfs] [--json] [--max-degree N] [--sort-by degree|relevance] [--query-variant TEXT ...] [--leaf-depth N] [--graph path]',
                 file=sys.stderr,
             )
             sys.exit(1)
@@ -1505,21 +1505,7 @@ def main() -> None:
         args = sys.argv[3:]
         i = 0
         while i < len(args):
-            if args[i] == "--budget" and i + 1 < len(args):
-                try:
-                    budget = int(args[i + 1])
-                except ValueError:
-                    print("error: --budget must be an integer", file=sys.stderr)
-                    sys.exit(1)
-                i += 2
-            elif args[i].startswith("--budget="):
-                try:
-                    budget = int(args[i].split("=", 1)[1])
-                except ValueError:
-                    print("error: --budget must be an integer", file=sys.stderr)
-                    sys.exit(1)
-                i += 1
-            elif args[i] == "--max-degree" and i + 1 < len(args):
+            if args[i] == "--max-degree" and i + 1 < len(args):
                 try:
                     max_degree = int(args[i + 1])
                 except ValueError:
@@ -2089,7 +2075,14 @@ def main() -> None:
             print(f"  {result.total_files} files analyzed, {flagged} flagged, avg health={result.avg_health:.2f}")
 
     elif cmd == "feedback":
-        from graphify.feedback import analyze_daily_log, clear_feedback, load_feedback
+        from graphify.feedback import (
+            analyze_daily_log,
+            clear_feedback,
+            disable_ranking,
+            enable_ranking,
+            load_feedback,
+            ranking_enabled,
+        )
 
         graph_dir = Path("graphify-out")
         node_id = None
@@ -2105,40 +2098,68 @@ def main() -> None:
             elif a == "--workspace" and i + 1 < len(args):
                 graph_dir = Path(args[i + 1]) / "graphify-out"
                 i += 2
-            elif a == "--node" and i + 1 < len(args):
+            elif a in ("--node", "--file") and i + 1 < len(args):
                 node_id = args[i + 1]
                 i += 2
-            elif a == "--list":
+            elif a in ("--list", "list"):
                 action = "list"
                 i += 1
-            elif a == "--clear":
+            elif a in ("--clear", "clear"):
                 action = "clear"
                 i += 1
-            elif a == "--analyze":
+            elif a in ("--analyze", "analyze"):
                 action = "analyze"
                 i += 1
+            elif a in ("--enable", "enable"):
+                action = "enable"
+                i += 1
+            elif a in ("--disable", "disable"):
+                action = "disable"
+                i += 1
+            elif a in ("--status", "status"):
+                action = "status"
+                i += 1
             else:
                 i += 1
 
-        if action == "list":
+        if action == "enable":
+            enable_ranking(graph_dir)
+            print(f"Ranking feedback enabled: {graph_dir}")
+        elif action == "disable":
+            disable_ranking(graph_dir)
+            print(f"Ranking feedback disabled: {graph_dir}")
+        elif action == "status":
+            enabled = ranking_enabled(graph_dir)
+            fb = load_feedback(graph_dir)
+            fb_path = graph_dir / "feedback.json"
+            print(f"Ranking feedback: {'enabled' if enabled else 'disabled'}")
+            print(f"Config:          {graph_dir / '.feedback_ranking'}")
+            print(f"Feedback file:   {fb_path} ({len(fb)} files)")
+            print(f"Env override:    {os.environ.get('GRAPHIFY_FEEDBACK_RANKING') or 'not set'}")
+        elif action == "list":
             fb = load_feedback(graph_dir)
             if not fb:
                 print("No feedback recorded.")
             else:
                 for nid, score in sorted(fb.items(), key=lambda x: x[1]):
-                    print(f"  {nid}: {score:+.1f}")
-                print(f"  ({len(fb)} nodes with feedback)")
+                    print(f"  {nid}: {score:+.2f}")
+                print(f"  ({len(fb)} files with feedback)")
         elif action == "clear":
             clear_feedback(graph_dir)
             print("Feedback cleared.")
         elif action == "analyze":
+            from datetime import datetime
+
             from graphify.query_log import _LOG_DIR
 
+            today = f"query_{datetime.now().strftime('%Y-%m-%d')}"
             total = 0
             for log_file in sorted(_LOG_DIR.glob("query_*.jsonl")):
-                n = analyze_daily_log(log_file, graph_dir)
+                # Today's log is still growing: analyze it now but do not
+                # write the marker, so tomorrow's run sees the complete day.
+                n = analyze_daily_log(log_file, graph_dir, write_marker=log_file.stem != today)
                 if n > 0:
-                    print(f"  {log_file.name}: updated {n} node(s)")
+                    print(f"  {log_file.name}: updated {n} file(s)")
                 total += n
             if total == 0:
                 print("No feedback updates from query logs.")
@@ -2146,15 +2167,15 @@ def main() -> None:
                 fb = load_feedback(graph_dir)
                 neg = {k: v for k, v in fb.items() if v < 0}
                 pos = {k: v for k, v in fb.items() if v > 0}
-                print(f"  Total: {total} node(s) updated ({len(neg)} noise, {len(pos)} core)")
+                print(f"  Total: {total} file(s) updated ({len(neg)} noise, {len(pos)} core)")
                 if neg:
                     top_neg = sorted(neg.items(), key=lambda x: x[1])[:5]
-                    print("  Top noise nodes:")
+                    print("  Top noise files:")
                     for nid, score in top_neg:
                         print(f"    {nid}: {score:+.2f}")
                 if pos:
                     top_pos = sorted(pos.items(), key=lambda x: -x[1])[:5]
-                    print("  Top core nodes:")
+                    print("  Top core files:")
                     for nid, score in top_pos:
                         print(f"    {nid}: {score:+.2f}")
         elif node_id:
@@ -2162,13 +2183,16 @@ def main() -> None:
             score = fb.get(node_id, 0.0)
             from graphify.feedback import feedback_multiplier
 
-            print(f"  {node_id}: score={score:+.1f}  multiplier={feedback_multiplier(score):.2f}")
+            print(f"  {node_id}: score={score:+.2f}  multiplier={feedback_multiplier(score):.2f}")
         else:
-            print("Usage: graphify feedback [--list | --clear | --analyze | --node <id>]")
-            print("  --list              list all nodes with feedback")
+            print("Usage: graphify feedback [status | enable | disable | --list | --clear | --analyze | --file <path>]")
+            print("  status              show whether feedback affects ranking")
+            print("  enable              let feedback adjust ranking (off by default)")
+            print("  disable             keep collecting feedback without affecting ranking")
+            print("  --list              list all files with feedback")
             print("  --clear             clear all feedback")
             print("  --analyze           analyze query logs and update feedback")
-            print("  --node <id>         show feedback for a specific node")
+            print("  --file <path>       show feedback for a specific source file")
             print("  --graph <path>      graphify-out directory (default: ./graphify-out)")
             print("  --workspace <path>  workspace root (uses <path>/graphify-out)")
 

{graphify_vault-0.6.0 → graphify_vault-0.6.2}/graphify/build_cmd.py

@@ -627,6 +627,15 @@ def run_build(args: list[str] | None = None) -> None:
 
     communities = cluster(G)
 
+    if not opts.no_simplify:
+        from graphify.simplify import post_cluster_cleanup
+
+        post_cluster_cleanup(G)
+        # Remove stale node references from communities after pruning
+        node_set = set(G.nodes())
+        communities = {cid: [n for n in members if n in node_set] for cid, members in communities.items()}
+        communities = {cid: members for cid, members in communities.items() if members}
+
     cohesion = score_all(G, communities)
     gods = god_nodes(G)
     surprises = surprising_connections(G, communities)
@@ -863,6 +872,15 @@ def run_build(args: list[str] | None = None) -> None:
 
     communities = cluster(G)
 
+    if not opts.no_simplify:
+        from graphify.simplify import post_cluster_cleanup
+
+        post_cluster_cleanup(G)
+        # Remove stale node references from communities after pruning
+        node_set = set(G.nodes())
+        communities = {cid: [n for n in members if n in node_set] for cid, members in communities.items()}
+        communities = {cid: members for cid, members in communities.items() if members}
+
     cohesion = score_all(G, communities)
     gods = god_nodes(G)
     surprises = surprising_connections(G, communities)

graphify_vault-0.6.2/graphify/feedback.py

@@ -0,0 +1,343 @@
+"""File-level reputation feedback — automatic quality signal from query logs.
+
+Design:
+
+* **Unit = source file.**  The query output and the rerank funnel are
+  file-level (one merged entry per document), so node-level reputation was
+  measuring a unit that no longer exists in the output.
+* **Signal = rank-weighted exposure.**  A file returned at rank ``r``
+  contributes ``3**-(r-1)``: consistently appearing near the top means the
+  file answers questions, only appearing in the tail means it is noise.
+* **Strength = ±20%.**  Ranking already selects by concept coverage, so
+  feedback breaks ties instead of overriding relevance.
+* **Time = 30-day half-life.**  Old behaviour fades instead of accumulating
+  forever; the decay is applied lazily from ``_meta.updated``.
+
+Compatibility is by **field**, not by a version number: the file-level data
+lives in ``files`` and the legacy node-level ``scores`` field is ignored.  A
+reader works with both old and new files, and malformed data degrades to
+"no feedback" instead of raising.  Writers only emit ``files``; an older
+process still running would overwrite the file with its own ``scores``, so
+upgrade every process before enabling this format.
+
+The previous signal (``seed / recall`` ratio per node) is intentionally not
+migrated: seeds are lexical matches while the ranking now selects by
+coverage, so a correct answer source is often not a seed.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import threading
+from collections import defaultdict
+from datetime import date, datetime
+from pathlib import Path
+
+_fb_cache: dict = {}
+
+_SCHEMA = "file-reputation"
+_RANKING_CONFIG = ".feedback_ranking"
+_HALF_LIFE_DAYS = 30.0
+_RANK_DECAY = 1.0 / 3.0
+_MIN_SAMPLE = 3  # appearances before a file earns a score
+_MIN_QUESTIONS = 2  # distinct questions before a file earns a score
+_BLEND = 0.3  # weight of the new estimate vs the stored score
+_MULTIPLIER_RANGE = 0.2  # score ±1 maps to multiplier 1 ± 0.2
+
+
+def canonical_source_key(source_file: str, workspace: Path | str) -> str:
+    """Return a workspace-relative POSIX key for feedback storage/lookup.
+
+    ``_resolve_source_file`` returns absolute paths in some processes and
+    relative paths in others, so the same document used to be stored under
+    two keys and each half saw only part of the evidence.  Normalising at
+    write, load and lookup keeps one key per document.
+    """
+    if not source_file:
+        return ""
+    path = Path(source_file)
+    if not path.is_absolute():
+        return path.as_posix()
+    try:
+        return path.resolve().relative_to(Path(workspace).resolve()).as_posix()
+    except (ValueError, OSError):
+        return path.as_posix()
+
+
+def load_feedback(graph_dir: Path) -> dict[str, float]:
+    """Load file reputation, applying the 30-day half-life lazily.
+
+    Compatibility is by field, not by version number: the file-level data
+    lives in ``files``; the legacy node-level ``scores`` field is ignored.
+    A reader therefore works with both old and new files, and a missing or
+    malformed field degrades to "no feedback" instead of an error.
+
+    The cache is keyed by the file's mtime so a CLI ``feedback --analyze``
+    becomes visible to a running MCP server without waiting for the next day.
+    """
+    fb_path = graph_dir / "feedback.json"
+    key = str(graph_dir)
+    today = datetime.now().strftime("%Y-%m-%d")
+    try:
+        mtime = fb_path.stat().st_mtime
+    except OSError:
+        mtime = None
+
+    cached = _fb_cache.get(key)
+    if cached and cached["date"] == today and cached["mtime"] == mtime:
+        return cached["data"]
+
+    scores: dict[str, float] = {}
+    if mtime is not None:
+        try:
+            data = json.loads(fb_path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            data = {}
+        files = data.get("files") if isinstance(data, dict) else None
+        if isinstance(files, dict):
+            grouped: dict[str, list[float]] = {}
+            for name, value in files.items():
+                try:
+                    score = float(value)
+                except (TypeError, ValueError):
+                    continue
+                canonical = canonical_source_key(str(name), graph_dir.parent)
+                grouped.setdefault(canonical, []).append(score)
+            # Absolute and relative keys can describe the same document;
+            # average their evidence instead of letting one shadow the other.
+            scores = {name: sum(values) / len(values) for name, values in grouped.items() if name}
+            updated = (data.get("_meta") or {}).get("updated")
+            if updated:
+                try:
+                    days = (date.fromisoformat(today) - date.fromisoformat(updated)).days
+                except (TypeError, ValueError):
+                    days = 0
+                if days > 0:
+                    factor = 0.5 ** (days / _HALF_LIFE_DAYS)
+                    scores = {k: v * factor for k, v in scores.items() if abs(v * factor) >= 0.01}
+
+    _fb_cache[key] = {"date": today, "mtime": mtime, "data": scores}
+    return scores
+
+
+def save_feedback(graph_dir: Path, feedback: dict[str, float]) -> None:
+    """Write the file-level reputation atomically.
+
+    Only ``files`` is written; the legacy ``scores`` field is dropped.  An
+    older process still running would overwrite the whole file with its own
+    ``scores`` payload, so upgrade every process before enabling v2.
+    """
+    fb_path = graph_dir / "feedback.json"
+    graph_dir.mkdir(parents=True, exist_ok=True)
+    data = {
+        "_meta": {
+            "schema": _SCHEMA,
+            "updated": datetime.now().strftime("%Y-%m-%d"),
+        },
+        "files": feedback,
+    }
+    temp_path = fb_path.with_suffix(".json.tmp")
+    temp_path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    os.replace(temp_path, fb_path)
+    _fb_cache.pop(str(graph_dir), None)
+
+
+def ranking_enabled(graph_dir: Path | None = None) -> bool:
+    """Whether reputation may influence ranking.
+
+    Default is OFF.  Rank-exposure reputation is derived from the ranking it
+    then adjusts, so it can only reinforce the current order; in practice it
+    also demotes broad overview documents that are frequently returned but
+    rarely first.  Collection and analysis keep running.
+
+    Resolution order:
+      1. ``GRAPHIFY_FEEDBACK_RANKING`` env (1/0, for temporary experiments)
+      2. ``<graphify-out>/.feedback_ranking`` (written by ``gv feedback enable``)
+      3. disabled
+    """
+    env = os.environ.get("GRAPHIFY_FEEDBACK_RANKING")
+    if env is not None:
+        return env.strip().lower() in ("1", "true", "yes", "on")
+    if graph_dir is not None:
+        config = graph_dir / _RANKING_CONFIG
+        try:
+            return config.read_text(encoding="utf-8").strip().lower() in ("1", "true", "yes", "on")
+        except OSError:
+            return False
+    return False
+
+
+def enable_ranking(graph_dir: Path) -> None:
+    graph_dir.mkdir(parents=True, exist_ok=True)
+    (graph_dir / _RANKING_CONFIG).write_text("1", encoding="utf-8")
+
+
+def disable_ranking(graph_dir: Path) -> None:
+    graph_dir.mkdir(parents=True, exist_ok=True)
+    (graph_dir / _RANKING_CONFIG).write_text("0", encoding="utf-8")
+
+
+def feedback_multiplier(score: float) -> float:
+    """Map a reputation score in [-1, 1] to a multiplier in [0.8, 1.2]."""
+    lower = 1.0 - _MULTIPLIER_RANGE
+    upper = 1.0 + _MULTIPLIER_RANGE
+    return max(lower, min(upper, 1.0 + score * _MULTIPLIER_RANGE))
+
+
+def clear_feedback(graph_dir: Path) -> None:
+    fb_path = graph_dir / "feedback.json"
+    if fb_path.exists():
+        fb_path.unlink()
+    _fb_cache.pop(str(graph_dir), None)
+    # ``.feedback_analyzed`` (no date suffix) is the legacy marker name.
+    for marker in graph_dir.glob(".feedback_analyzed*"):
+        marker.unlink()
+
+
+def _rank_weight(rank: int) -> float:
+    """Weight of a result at 1-based ``rank``: 1, 1/3, 1/9, ..."""
+    return _RANK_DECAY ** (rank - 1)
+
+
+def _result_files(record: dict) -> list[str]:
+    """Ordered source files for one log record.
+
+    New logs carry a structured ``results`` list.  Older logs only have the
+    rendered text, which cannot be parsed reliably, so they contribute no
+    ranking signal.
+    """
+    files: list[str] = []
+    for item in record.get("results") or []:
+        if isinstance(item, dict):
+            source = str(item.get("source_file") or "")
+            if source:
+                files.append(source)
+    return files
+
+
+def analyze_daily_log(log_path: Path, graph_dir: Path, *, write_marker: bool = True) -> int:
+    """Update file reputation from one query log.
+
+    Returns the number of files whose stored score changed.  A marker file
+    makes the analysis idempotent per log.  ``write_marker=False`` is used
+    for today's still-growing log: it can be analyzed now and again later.
+    """
+    if not log_path.exists():
+        return 0
+
+    marker = graph_dir / f".feedback_analyzed_{log_path.stem}"
+    if marker.exists():
+        return 0
+
+    workspace_filter = os.path.normpath(str(graph_dir.parent))
+    weighted: dict[str, float] = defaultdict(float)
+    appearances: dict[str, int] = defaultdict(int)
+    questions: dict[str, set[str]] = defaultdict(set)
+    total_weight = 0.0
+    total_results = 0
+
+    with log_path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            # An empty workspace cannot be attributed to a graph; skipping
+            # is safer than mixing several workspaces into one reputation.
+            # Normalise both sides: GRAPHIFY_WORKSPACE is often exported with
+            # a trailing slash, which an exact string compare would reject.
+            record_workspace = os.path.normpath(str(record.get("workspace", ""))) if record.get("workspace") else ""
+            if not record_workspace or record_workspace != workspace_filter:
+                continue
+            question = str(record.get("question", ""))
+            for rank, source in enumerate(_result_files(record)[:20], 1):
+                key = canonical_source_key(source, graph_dir.parent)
+                if not key:
+                    continue
+                weight = _rank_weight(rank)
+                weighted[key] += weight
+                appearances[key] += 1
+                questions[key].add(question)
+                total_weight += weight
+                total_results += 1
+
+    if total_results == 0:
+        # Logs written before structured results existed can never contribute;
+        # mark them so every future query does not rescan the whole history.
+        if write_marker:
+            try:
+                marker.write_text("1", encoding="utf-8")
+            except OSError:
+                pass
+        return 0
+
+    mean_weight = total_weight / total_results
+    feedback = load_feedback(graph_dir)
+    updated = 0
+
+    for source, count in appearances.items():
+        if count < _MIN_SAMPLE or len(questions[source]) < _MIN_QUESTIONS:
+            continue
+        file_mean = weighted[source] / count
+        # Relative position against how an average result is ranked: 0 means
+        # the file sits at the graph-wide average, +1 means twice as high.
+        relative = (file_mean - mean_weight) / max(mean_weight, 1e-9)
+        estimate = max(-1.0, min(1.0, relative))
+        # Small samples are pulled toward zero; confidence reaches 0.5 at
+        # the minimum sample size and approaches 1 as evidence accumulates.
+        confidence = count / (count + _MIN_SAMPLE)
+        estimate *= confidence
+
+        old = feedback.get(source, 0.0)
+        new = max(-1.0, min(1.0, old * (1.0 - _BLEND) + estimate * _BLEND))
+        if abs(new - old) >= 0.01:
+            feedback[source] = round(new, 3)
+            updated += 1
+
+    if updated:
+        save_feedback(graph_dir, feedback)
+
+    if write_marker:
+        try:
+            marker.write_text("1", encoding="utf-8")
+        except OSError:
+            pass
+
+    return updated
+
+
+def _analyze_unmarked_logs(graph_dir: Path, log_dir: Path) -> int:
+    """Analyze every past log that has no marker, oldest first."""
+    today = f"query_{datetime.now().strftime('%Y-%m-%d')}"
+    updated = 0
+    for log_path in sorted(log_dir.glob("query_*.jsonl")):
+        if log_path.stem == today:
+            continue  # today's log is still being written
+        updated += analyze_daily_log(log_path, graph_dir)
+    return updated
+
+
+def _maybe_run_daily_analysis(graph_dir: Path, log_dir: Path, on_complete=None) -> None:
+    """Run feedback analysis in the background.
+
+    The previous version only looked at *yesterday*; a day the server did
+    not run meant that log was never analyzed.  Scanning unmarked logs makes
+    the feedback loop self-healing.
+    """
+
+    def _run():
+        try:
+            updated = _analyze_unmarked_logs(graph_dir, log_dir)
+            if updated > 0:
+                print(f"[feedback] updated {updated} file(s) from query logs", file=sys.stderr)
+            if on_complete:
+                on_complete()
+        except Exception as exc:  # noqa: BLE001 - background thread must not die silently
+            print(f"[feedback] analysis failed: {exc}", file=sys.stderr)
+
+    threading.Thread(target=_run, daemon=True).start()

{graphify_vault-0.6.0 → graphify_vault-0.6.2}/graphify/query_log.py

@@ -43,6 +43,7 @@ def write_entry(
     workspace: str,
     seed_ids: list[str] | None = None,
     result_node_ids: list[str] | None = None,
+    results: list[dict] | None = None,
     *,
     auto_rotate: bool = True,
 ) -> None:
@@ -51,6 +52,11 @@ def write_entry(
     auto_rotate: if True (default), spawn a background thread to compress
     old logs and clean up.  Set to False when the caller manages rotation
     ordering (e.g. MCP server runs feedback analysis before rotation).
+
+    results: ordered structured entries ``{source_file, start_line,
+    end_line, item_ranges, node_ids}``.  Feedback analysis needs the rank
+    order and the files, which cannot be recovered reliably from the
+    rendered text.
     """
     if not is_enabled():
         return
@@ -80,6 +86,8 @@ def write_entry(
         record["seed_ids"] = seed_ids
     if result_node_ids is not None:
         record["result_node_ids"] = result_node_ids
+    if results is not None:
+        record["results"] = results
 
     try:
         with log_file.open("a", encoding="utf-8") as f: