graphify-sf 0.3.6__tar.gz → 0.3.7__tar.gz

{graphify_sf-0.3.6 → graphify_sf-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphify-sf
-Version: 0.3.6
+Version: 0.3.7
 Summary: Turn any Salesforce SFDX project into a queryable knowledge graph — fully offline, no org connection required.
 Author: Ray Kuo
 License-Expression: MIT

{graphify_sf-0.3.6 → graphify_sf-0.3.7}/graphify_sf/__main__.py

@@ -2328,4 +2328,14 @@ def main() -> None:
 
 
 if __name__ == "__main__":
+    # PyInstaller + multiprocessing: on macOS/Windows the default start method is
+    # "spawn", which re-executes this frozen binary with internal bootstrap args
+    # (e.g. `-B --multiprocessing-fork <fd>`). freeze_support() MUST run before our
+    # CLI argument parser sees argv — otherwise the parser rejects those args with
+    # "unknown command '-B'" and every pool worker dies, silently truncating the
+    # graph. freeze_support() detects the bootstrap argv, runs the worker, and
+    # exits; in a normal invocation it is a no-op.
+    import multiprocessing
+
+    multiprocessing.freeze_support()
     main()

{graphify_sf-0.3.6 → graphify_sf-0.3.7}/graphify_sf/extract/__init__.py

@@ -7,8 +7,10 @@ Two-pass pipeline:
 
 from __future__ import annotations
 
+import os
 import sys
 from concurrent.futures import ProcessPoolExecutor, as_completed
+from concurrent.futures.process import BrokenProcessPool
 from pathlib import Path
 
 from .agentforce import (
@@ -245,21 +247,48 @@ def extract(
 
     # Phase 1: Extract single files
     use_parallel = parallel and len(single_files) > 8
+    parallel_failed = False
     if use_parallel:
+        # Allow overriding the multiprocessing start method (mainly for testing the
+        # spawn re-exec path on Linux, where the default is fork). On macOS/Windows
+        # the OS default is already "spawn"; freeze_support() in __main__ makes that
+        # work for the frozen binary. Unset → use the platform default context.
+        import multiprocessing as _mp
+
+        _start = os.environ.get("GRAPHIFY_SF_MP_START")
+        _ctx = _mp.get_context(_start) if _start else None
         try:
-            with ProcessPoolExecutor(max_workers=max_workers) as executor:
+            with ProcessPoolExecutor(max_workers=max_workers, mp_context=_ctx) as executor:
                 futures = {executor.submit(_extract_file, p): p for p in single_files}
                 for fut in as_completed(futures):
                     try:
                         result = fut.result()
                         all_nodes.extend(result.get("nodes", []))
                         all_edges.extend(result.get("edges", []))
+                    except BrokenProcessPool:
+                        # The worker pool itself died (e.g. PyInstaller spawn
+                        # bootstrap incompatibility on macOS). Partial results are
+                        # unreliable — abort parallel and redo everything sequentially
+                        # rather than emit a silently-truncated graph.
+                        parallel_failed = True
+                        break
                     except Exception as exc:
+                        # A single file failed to parse — log and continue; this does
+                        # not indicate a pool-level failure.
                         p = futures[fut]
                         print(f"[graphify-sf] WARNING: {p}: {exc}", file=sys.stderr)
-        except Exception:
-            # Fall back to sequential if parallel fails (e.g. on Windows)
-            # Clear any partial results from completed futures to prevent duplicates
+        except (BrokenProcessPool, OSError):
+            # The executor could not be created / a worker crashed at pool level.
+            parallel_failed = True
+
+        if parallel_failed:
+            print(
+                "[graphify-sf] WARNING: parallel worker pool failed — "
+                "falling back to sequential extraction (graph will be complete, just slower)",
+                file=sys.stderr,
+            )
+            # Discard partial parallel results to prevent duplicates, then redo
+            # the full single-file extraction sequentially below.
             all_nodes.clear()
             all_edges.clear()
             use_parallel = False

{graphify_sf-0.3.6 → graphify_sf-0.3.7}/graphify_sf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphify-sf
-Version: 0.3.6
+Version: 0.3.7
 Summary: Turn any Salesforce SFDX project into a queryable knowledge graph — fully offline, no org connection required.
 Author: Ray Kuo
 License-Expression: MIT

{graphify_sf-0.3.6 → graphify_sf-0.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphify-sf"
-version = "0.3.6"
+version = "0.3.7"
 description = "Turn any Salesforce SFDX project into a queryable knowledge graph — fully offline, no org connection required."
 readme = "README.md"
 requires-python = ">=3.10"

{graphify_sf-0.3.6 → graphify_sf-0.3.7}/tests/test_extract_pipeline.py

@@ -187,3 +187,76 @@ def test_stub_node_exists_for_standard_object_after_extract(tmp_path):
 
     lead_node = next(n for n in extraction["nodes"] if n["id"] == "object_lead")
     assert lead_node.get("stub") is True
+
+
+# ---------------------------------------------------------------------------
+# Parallel worker-pool failure → sequential fallback (0.3.7 macOS spawn bug)
+# ---------------------------------------------------------------------------
+
+
+def _make_multi_object_tree(root):
+    """Create >8 single-file metadata entries so parallel extraction is used."""
+    objects = root / "force-app" / "main" / "default" / "objects"
+    for i in range(12):
+        obj = objects / f"Obj{i}__c"
+        (obj / "fields").mkdir(parents=True)
+        (obj / f"Obj{i}__c.object-meta.xml").write_text(
+            '<?xml version="1.0"?><CustomObject xmlns="http://soap.sforce.com/2006/04/metadata">'
+            f"<label>Obj{i}</label></CustomObject>"
+        )
+        (obj / "fields" / f"F{i}__c.field-meta.xml").write_text(
+            '<?xml version="1.0"?><CustomField xmlns="http://soap.sforce.com/2006/04/metadata">'
+            f"<fullName>F{i}__c</fullName><type>Text</type><label>F{i}</label></CustomField>"
+        )
+
+
+def test_parallel_pool_failure_falls_back_to_complete_sequential_graph(tmp_path, monkeypatch, capsys):
+    """If the worker pool dies (e.g. PyInstaller spawn bootstrap on macOS), extraction
+    must fall back to sequential and still produce the COMPLETE graph — never a
+    silently-truncated one. Regression for the 0.3.6 macOS bug."""
+    from concurrent.futures.process import BrokenProcessPool
+
+    from graphify_sf import extract as extract_mod
+    from graphify_sf.detect import detect
+    from graphify_sf.extract import extract
+
+    _make_multi_object_tree(tmp_path)
+    detection = detect(tmp_path)
+
+    # Baseline: what a healthy sequential run produces.
+    baseline = extract(detection, parallel=False)
+    baseline_ids = {n["id"] for n in baseline["nodes"]}
+    assert any(i.startswith("object_") for i in baseline_ids)
+    assert any(i.startswith("field_") for i in baseline_ids)
+
+    # Simulate a broken pool: the executor's futures all raise BrokenProcessPool.
+    class _BrokenExecutor:
+        def __init__(self, *a, **k):
+            pass
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *a):
+            return False
+
+        def submit(self, *a, **k):
+            class _F:
+                def result(self_inner):
+                    raise BrokenProcessPool("simulated worker crash")
+
+            return _F()
+
+    monkeypatch.setattr(extract_mod, "ProcessPoolExecutor", _BrokenExecutor)
+    # as_completed must just yield the futures back
+    monkeypatch.setattr(extract_mod, "as_completed", lambda futs: list(futs))
+
+    degraded = extract(detection, parallel=True)
+    degraded_ids = {n["id"] for n in degraded["nodes"]}
+
+    # The fallback graph must equal the healthy sequential graph — no truncation.
+    assert degraded_ids == baseline_ids, "pool failure must fall back to a COMPLETE graph"
+    # And it must be loud about it.
+    err = capsys.readouterr().err
+    assert "parallel worker pool failed" in err
+    assert "falling back to sequential" in err