graphitect 0.2.0__py3-none-any.whl

graphify/extractors/zig.py

@@ -0,0 +1,181 @@
+"""Zig extractor (tree-sitter). Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from graphify.extractors.base import _file_stem, _make_id, _read_text
+
+
+def extract_zig(path: Path) -> dict:
+    """Extract functions, structs, enums, unions, and imports from a .zig file."""
+    try:
+        import tree_sitter_zig as tszig
+        from tree_sitter import Language, Parser
+    except ImportError:
+        return {"nodes": [], "edges": [], "error": "tree_sitter_zig not installed"}
+
+    try:
+        language = Language(tszig.language())
+        parser = Parser(language)
+        source = path.read_bytes()
+        tree = parser.parse(source)
+        root = tree.root_node
+    except Exception as e:
+        return {"nodes": [], "edges": [], "error": str(e)}
+
+    stem = _file_stem(path)
+    str_path = str(path)
+    nodes: list[dict] = []
+    edges: list[dict] = []
+    seen_ids: set[str] = set()
+    function_bodies: list[tuple[str, Any]] = []
+
+    def add_node(nid: str, label: str, line: int) -> None:
+        if nid not in seen_ids:
+            seen_ids.add(nid)
+            nodes.append({"id": nid, "label": label, "file_type": "code",
+                          "source_file": str_path, "source_location": f"L{line}"})
+
+    def add_edge(src: str, tgt: str, relation: str, line: int,
+                 confidence: str = "EXTRACTED", weight: float = 1.0,
+                 context: str | None = None) -> None:
+        edge = {"source": src, "target": tgt, "relation": relation,
+                "confidence": confidence, "source_file": str_path,
+                "source_location": f"L{line}", "weight": weight}
+        if context:
+            edge["context"] = context
+        edges.append(edge)
+
+    file_nid = _make_id(str(path))
+    add_node(file_nid, path.name, 1)
+
+    def _extract_import(node) -> None:
+        for child in node.children:
+            if child.type == "builtin_function":
+                bi = None
+                args = None
+                for c in child.children:
+                    if c.type == "builtin_identifier":
+                        bi = _read_text(c, source)
+                    elif c.type == "arguments":
+                        args = c
+                if bi in ("@import", "@cImport") and args:
+                    for arg in args.children:
+                        if arg.type in ("string_literal", "string"):
+                            raw = _read_text(arg, source).strip('"')
+                            module_name = raw.split("/")[-1].split(".")[0]
+                            if module_name:
+                                tgt_nid = _make_id(module_name)
+                                add_edge(file_nid, tgt_nid, "imports_from",
+                                         node.start_point[0] + 1)
+                            return
+            elif child.type == "field_expression":
+                _extract_import(child)
+                return
+
+    def walk(node, parent_struct_nid: str | None = None) -> None:
+        t = node.type
+
+        if t == "function_declaration":
+            name_node = node.child_by_field_name("name")
+            if name_node:
+                func_name = _read_text(name_node, source)
+                line = node.start_point[0] + 1
+                if parent_struct_nid:
+                    func_nid = _make_id(parent_struct_nid, func_name)
+                    add_node(func_nid, f".{func_name}()", line)
+                    add_edge(parent_struct_nid, func_nid, "method", line)
+                else:
+                    func_nid = _make_id(stem, func_name)
+                    add_node(func_nid, f"{func_name}()", line)
+                    add_edge(file_nid, func_nid, "contains", line)
+                body = node.child_by_field_name("body")
+                if body:
+                    function_bodies.append((func_nid, body))
+            return
+
+        if t == "variable_declaration":
+            name_node = None
+            value_node = None
+            for child in node.children:
+                if child.type == "identifier":
+                    name_node = child
+                elif child.type in ("struct_declaration", "enum_declaration",
+                                    "union_declaration", "builtin_function",
+                                    "field_expression"):
+                    value_node = child
+
+            if value_node and value_node.type == "struct_declaration":
+                if name_node:
+                    struct_name = _read_text(name_node, source)
+                    line = node.start_point[0] + 1
+                    struct_nid = _make_id(stem, struct_name)
+                    add_node(struct_nid, struct_name, line)
+                    add_edge(file_nid, struct_nid, "contains", line)
+                    for child in value_node.children:
+                        walk(child, parent_struct_nid=struct_nid)
+                return
+
+            if value_node and value_node.type in ("enum_declaration", "union_declaration"):
+                if name_node:
+                    type_name = _read_text(name_node, source)
+                    line = node.start_point[0] + 1
+                    type_nid = _make_id(stem, type_name)
+                    add_node(type_nid, type_name, line)
+                    add_edge(file_nid, type_nid, "contains", line)
+                    # Zig enums and tagged unions can declare methods just like
+                    # structs (`pub fn ...` inside the container). Recurse so those
+                    # methods — and the calls made from their bodies — are captured
+                    # rather than dropped along with the whole method layer.
+                    for child in value_node.children:
+                        walk(child, parent_struct_nid=type_nid)
+                return
+
+            if value_node and value_node.type in ("builtin_function", "field_expression"):
+                _extract_import(node)
+            return
+
+        for child in node.children:
+            walk(child, parent_struct_nid)
+
+    walk(root)
+
+    seen_call_pairs: set[tuple[str, str]] = set()
+    raw_calls: list[dict] = []
+
+    def walk_calls(node, caller_nid: str) -> None:
+        if node.type == "function_declaration":
+            return
+        if node.type == "call_expression":
+            fn = node.child_by_field_name("function")
+            if fn:
+                fn_text = _read_text(fn, source)
+                callee = fn_text.split(".")[-1]
+                is_member_call = "." in fn_text
+                tgt_nid = next((n["id"] for n in nodes if n["label"] in
+                                (f"{callee}()", f".{callee}()")), None)
+                if tgt_nid and tgt_nid != caller_nid:
+                    pair = (caller_nid, tgt_nid)
+                    if pair not in seen_call_pairs:
+                        seen_call_pairs.add(pair)
+                        add_edge(caller_nid, tgt_nid, "calls",
+                                 node.start_point[0] + 1,
+                                 confidence="EXTRACTED", weight=1.0)
+                elif callee:
+                    raw_calls.append({
+                        "caller_nid": caller_nid,
+                        "callee": callee,
+                        "is_member_call": is_member_call,
+                        "source_file": str_path,
+                        "source_location": f"L{node.start_point[0] + 1}",
+                    })
+        for child in node.children:
+            walk_calls(child, caller_nid)
+
+    for caller_nid, body_node in function_bodies:
+        walk_calls(body_node, caller_nid)
+
+    clean_edges = [e for e in edges if e["source"] in seen_ids and
+                   (e["target"] in seen_ids or e["relation"] == "imports_from")]
+    return {"nodes": nodes, "edges": clean_edges, "raw_calls": raw_calls}

graphify/file_slice.py

@@ -0,0 +1,246 @@
+"""Intra-file slicing for oversized text documents (#1369).
+
+The extraction packer (`_pack_chunks_by_tokens`) treats each file as atomic and
+`_read_files` caps every file at ``_FILE_CHAR_CAP`` characters, so a document
+larger than that cap had everything past the cap silently dropped — the model
+never saw it, and nothing in the adaptive-retry path could recover it ("a single
+file larger than the budget ... packing can't shrink one big file").
+
+This module splits an oversized *splittable text* document (Markdown, plain
+text, reStructuredText) into contiguous ``FileSlice`` units at heading /
+paragraph / line boundaries so the whole file gets extracted across several
+units. Every slice of a file reports the **parent file path** as its source, so
+the resulting nodes are never fragmented per-slice — they merge by source_file
+exactly as if the file had been extracted in one pass.
+
+Only plain-text documents are sliced: code files need whole-symbol context, and
+PDFs/images are read through their own extractors and have no char-offset model.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+# Plain-text document types where boundary-based slicing is meaningful and where
+# `_file_to_text` is a straight ``read_text`` (so a char range matches the bytes
+# the model is shown). Deliberately excludes code (.py, .ts, ...) and binary
+# docs (.pdf) — those are never sliced.
+#
+# This set has to keep pace with ``detect.DOC_EXTENSIONS``: anything classified
+# as a document reaches the semantic pass, and anything the pass sees that is
+# NOT listed here is silently cut at ``_FILE_CHAR_CAP`` by ``_read_files``. The
+# two lists drifted as DOC_EXTENSIONS grew — .qmd, .skill, .html, .yaml and .yml
+# were documents that never got sliced, so a 38k-character one reached the model
+# as its first 20k with no warning and no partial marker (#2900).
+# ``tests/test_oversized_document_slicing.py`` pins the relationship so a future
+# addition to DOC_EXTENSIONS fails loudly instead of quietly losing content.
+_SPLITTABLE_TEXT_SUFFIXES = frozenset({
+    ".md", ".mdx", ".markdown", ".txt", ".rst",
+    ".qmd", ".skill", ".html", ".yaml", ".yml",
+})
+
+# Document types whose BYTES are not what the model is shown. `llm._file_to_text`
+# routes these through a converter, so a character range has to be taken over the
+# converted text, never over the file. Kept separate from the set above because
+# they are splittable for a different reason and via a different reader.
+_CONVERTED_TEXT_SUFFIXES = frozenset({".pdf"})
+
+
+def _pdf_text(path: Path) -> str:
+    """Extracted text of a PDF — the same string `llm._file_to_text` builds.
+
+    Imported lazily from ``detect`` so this module keeps no import-time
+    dependency on the extraction stack (``llm`` imports *this* module, so the
+    reverse direction would be a cycle).
+    """
+    from graphify.detect import extract_pdf_text
+    return extract_pdf_text(path)
+
+
+# Slicing a PDF means extracting its text, and the slicing pass asks for the same
+# file several times: once to measure it, then once per slice as the prompt is
+# built. Memoised on (path, size, mtime_ns) so a corpus of papers is parsed once
+# rather than once per slice, and so a file rewritten mid-run is re-read instead
+# of served a stale body. Bounded: the entries are whole documents, and a large
+# corpus should not pin all of them in memory.
+_CONVERTED_TEXT_CACHE: "dict[tuple, str]" = {}
+_CONVERTED_TEXT_CACHE_MAX = 64
+
+
+def unit_source_text(path: Path) -> str:
+    """The text a unit contributes to the prompt, whatever its container.
+
+    Plain-text files are read directly; converted types (PDF) go through their
+    converter. Both `expand_oversized_files` and `read_slice_text` use this, so
+    the offsets a slice carries always index the same string the model sees.
+    """
+    if path.suffix.lower() not in _CONVERTED_TEXT_SUFFIXES:
+        return path.read_text(encoding="utf-8", errors="replace")
+    try:
+        st = path.stat()
+        key = (str(path), st.st_size, st.st_mtime_ns)
+    except OSError:
+        return _pdf_text(path)
+    hit = _CONVERTED_TEXT_CACHE.get(key)
+    if hit is not None:
+        return hit
+    text = _pdf_text(path)
+    if len(_CONVERTED_TEXT_CACHE) >= _CONVERTED_TEXT_CACHE_MAX:
+        _CONVERTED_TEXT_CACHE.clear()
+    _CONVERTED_TEXT_CACHE[key] = text
+    return text
+
+# Boundary preferences, strongest first. A Markdown heading (``\n#``) keeps a
+# section with its title; a blank line keeps a paragraph intact; a bare newline
+# avoids cutting mid-line. If none is found in the window we hard-cut.
+_BOUNDARY_SEPARATORS = ("\n#", "\n\n", "\n")
+
+
+@dataclass(frozen=True)
+class FileSlice:
+    """A contiguous ``[start, end)`` character range of a splittable text file.
+
+    ``index``/``total`` are for logging only. ``path`` is the real file on disk;
+    the slice always reports ``path`` as its source so slices don't fragment the
+    graph.
+    """
+
+    path: Path
+    start: int
+    end: int
+    index: int
+    total: int
+
+
+# A unit of extraction work: either a whole file (``Path``) or one slice of one.
+Unit = "Path | FileSlice"
+
+
+def unit_path(unit: "Path | FileSlice") -> Path:
+    """The on-disk path a unit belongs to (the parent file for a slice)."""
+    return unit.path if isinstance(unit, FileSlice) else unit
+
+
+def is_splittable_text(path: Path) -> bool:
+    """True for document types that may be sliced.
+
+    Covers plain text read straight off disk and converted types (PDF) whose
+    text is produced by a converter. Both are sliceable because
+    :func:`unit_source_text` gives the slicing pass the same string the prompt
+    will carry; what disqualifies a type is having no text at all (an image) or
+    text the reader cannot address by character offset.
+    """
+    suffix = path.suffix.lower()
+    return suffix in _SPLITTABLE_TEXT_SUFFIXES or suffix in _CONVERTED_TEXT_SUFFIXES
+
+
+def _best_cut(text: str, start: int, end: int) -> int:
+    """Return a cut index in ``(start, end]`` at the strongest nearby boundary.
+
+    Searches the window ``text[start:end]`` for the latest heading, then blank
+    line, then newline, and returns the index just *after* it (a heading cuts
+    just *before* the ``#`` so the heading leads the next slice). Falls back to a
+    hard cut at ``end`` when the window has no usable boundary, which still makes
+    forward progress because ``end > start``.
+    """
+    window = text[start:end]
+    for sep in _BOUNDARY_SEPARATORS:
+        idx = window.rfind(sep)
+        if idx > 0:  # a boundary strictly inside the window (non-empty prev slice)
+            if sep == "\n#":
+                return start + idx + 1  # keep the newline with the previous slice
+            return start + idx + len(sep)
+    return end
+
+
+def slice_boundaries(text: str, max_chars: int) -> list[tuple[int, int]]:
+    """Contiguous ``(start, end)`` ranges covering all of ``text``, each ≤ max_chars.
+
+    Ranges are gap-free and non-overlapping, so concatenating the slices
+    reproduces ``text`` exactly — no content is dropped.
+    """
+    n = len(text)
+    if n <= max_chars:
+        return [(0, n)]
+    bounds: list[tuple[int, int]] = []
+    pos = 0
+    while pos < n:
+        hard = min(pos + max_chars, n)
+        end = _best_cut(text, pos, hard) if hard < n else n
+        if end <= pos:  # defensive: never stall
+            end = hard
+        bounds.append((pos, end))
+        pos = end
+    return bounds
+
+
+def expand_oversized_files(
+    files: list[Path], max_chars: int
+) -> list["Path | FileSlice"]:
+    """Replace each oversized splittable-text file with a list of ``FileSlice``s.
+
+    Files at or below ``max_chars`` (and all non-splittable files) pass through
+    unchanged as ``Path``, so behaviour is identical for everything that already
+    fit. Unreadable files pass through untouched (the reader handles the error).
+    """
+    out: list["Path | FileSlice"] = []
+    for f in files:
+        if not is_splittable_text(f):
+            out.append(f)
+            continue
+        try:
+            # The CONVERTED text for a PDF, so the boundaries below index the
+            # same string read_slice_text will later slice and the prompt will
+            # carry — not the container's bytes (#2906).
+            text = unit_source_text(f)
+        except OSError:
+            out.append(f)
+            continue
+        if len(text) <= max_chars:
+            out.append(f)
+            continue
+        ranges = slice_boundaries(text, max_chars)
+        total = len(ranges)
+        for i, (s, e) in enumerate(ranges):
+            out.append(FileSlice(path=f, start=s, end=e, index=i, total=total))
+    return out
+
+
+def read_slice_text(fs: FileSlice) -> str:
+    """Read just this slice's characters from its parent file.
+
+    Goes through :func:`unit_source_text`, so a PDF slice indexes the extracted
+    text rather than the container's bytes — the offsets `expand_oversized_files`
+    computed and the string the prompt carries are then the same string (#2906).
+    """
+    return unit_source_text(fs.path)[fs.start:fs.end]
+
+
+def bisect_slice(fs: FileSlice) -> tuple[FileSlice, FileSlice] | None:
+    """Split a slice into two halves at a newline near its midpoint, or None.
+
+    Used by the adaptive-retry path when a single slice still overflows the
+    model's output: halving it produces a smaller response. Returns None when the
+    slice is already too small to split meaningfully.
+    """
+    if fs.end - fs.start <= 1:
+        return None
+    # Index the SAME string the slice offsets were computed against and the
+    # prompt carries: for a PDF that is the extracted text via unit_source_text,
+    # not the raw container bytes. Reading the container here (the old behavior)
+    # searched for the newline cut in binary coordinates, so a compressed PDF
+    # slice could cut mid-line or past the text end (#2906). Any converter/read
+    # failure means we cannot split, so fall back to None (treated as atomic).
+    try:
+        text = unit_source_text(fs.path)
+    except Exception:
+        return None
+    mid = (fs.start + fs.end) // 2
+    nl = text.find("\n", mid, fs.end)
+    cut = nl + 1 if (nl != -1 and fs.start < nl + 1 < fs.end) else mid
+    if not (fs.start < cut < fs.end):
+        return None
+    left = FileSlice(fs.path, fs.start, cut, fs.index, fs.total)
+    right = FileSlice(fs.path, cut, fs.end, fs.index, fs.total)
+    return left, right

graphify/global_graph.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+import json
+import hashlib
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+import networkx as nx
+from networkx.readwrite import json_graph as _jg
+
+_GLOBAL_DIR = Path.home() / ".graphify"
+_GLOBAL_GRAPH = _GLOBAL_DIR / "global-graph.json"
+_GLOBAL_MANIFEST = _GLOBAL_DIR / "global-manifest.json"
+
+
+def _load_manifest() -> dict:
+    if _GLOBAL_MANIFEST.exists():
+        try:
+            return json.loads(_GLOBAL_MANIFEST.read_text(encoding="utf-8"))
+        except Exception as exc:
+            # Don't silently wipe the user's manifest on a parse error: that
+            # deletes every tracked repo. Back the bad file up and surface the
+            # error so the user can recover or report it.
+            backup = _GLOBAL_MANIFEST.with_suffix(
+                _GLOBAL_MANIFEST.suffix + f".corrupt.{int(datetime.now(timezone.utc).timestamp())}"
+            )
+            try:
+                _GLOBAL_MANIFEST.rename(backup)
+                print(
+                    f"[graphify global] manifest at {_GLOBAL_MANIFEST} failed to parse ({exc}); "
+                    f"moved to {backup} and starting fresh. Restore from the backup if this was "
+                    f"unexpected.",
+                    file=sys.stderr,
+                )
+            except Exception as rename_exc:
+                print(
+                    f"[graphify global] manifest at {_GLOBAL_MANIFEST} failed to parse ({exc}) "
+                    f"and could not be backed up ({rename_exc}). Starting fresh.",
+                    file=sys.stderr,
+                )
+    return {"version": 1, "repos": {}}
+
+
+def _save_manifest(manifest: dict) -> None:
+    _GLOBAL_DIR.mkdir(parents=True, exist_ok=True)
+    from graphify.paths import write_json_atomic
+    write_json_atomic(_GLOBAL_MANIFEST, manifest, indent=2)
+
+
+def _load_global_graph() -> nx.Graph:
+    if _GLOBAL_GRAPH.exists():
+        from graphify.security import check_graph_file_size_cap
+        check_graph_file_size_cap(_GLOBAL_GRAPH)
+        data = json.loads(_GLOBAL_GRAPH.read_text(encoding="utf-8"))
+        if "links" not in data and "edges" in data:
+            data = dict(data, links=data["edges"])
+        try:
+            return _jg.node_link_graph(data, edges="links")
+        except TypeError:
+            return _jg.node_link_graph(data)
+    return nx.Graph()
+
+
+def _save_global_graph(G: nx.Graph) -> None:
+    _GLOBAL_DIR.mkdir(parents=True, exist_ok=True)
+    try:
+        data = _jg.node_link_data(G, edges="links")
+    except TypeError:
+        data = _jg.node_link_data(G)
+    from graphify.paths import write_json_atomic
+    write_json_atomic(_GLOBAL_GRAPH, data, indent=2)
+
+
+def _file_hash(path: Path) -> str:
+    h = hashlib.sha256()
+    h.update(path.read_bytes())
+    return h.hexdigest()[:16]
+
+
+def global_add(source_path: Path, repo_tag: str) -> dict:
+    """Add or update a project graph in the global graph.
+
+    Returns a summary dict with keys: repo_tag, nodes_added, nodes_removed, skipped,
+    cross_repo_calls.
+    Skipped=True means the source graph hasn't changed since last add.
+    """
+    from graphify.build import prefix_graph_for_global, prune_repo_from_graph
+
+    if not source_path.exists():
+        raise FileNotFoundError(f"graph not found: {source_path}")
+
+    manifest = _load_manifest()
+    src_hash = _file_hash(source_path)
+
+    existing = manifest["repos"].get(repo_tag, {})
+    existing_path = existing.get("source_path", "")
+    if existing_path and existing_path != str(source_path.resolve()):
+        print(
+            f"[graphify global] warning: repo tag '{repo_tag}' previously pointed to "
+            f"{existing_path!r}, now updating to {str(source_path.resolve())!r}. "
+            f"Use --as <tag> to give it a different name.",
+            file=sys.stderr,
+        )
+    if existing.get("source_hash") == src_hash:
+        return {"repo_tag": repo_tag, "nodes_added": 0, "nodes_removed": 0, "skipped": True,
+                "cross_repo_calls": 0}
+
+    # Load source graph
+    from graphify.security import check_graph_file_size_cap
+    check_graph_file_size_cap(source_path)
+    data = json.loads(source_path.read_text(encoding="utf-8"))
+    if "links" not in data and "edges" in data:
+        data = dict(data, links=data["edges"])
+    try:
+        src_G = _jg.node_link_graph(data, edges="links")
+    except TypeError:
+        src_G = _jg.node_link_graph(data)
+
+    # Prefix IDs for cross-project isolation
+    prefixed = prefix_graph_for_global(src_G, repo_tag)
+
+    # Load global graph and prune stale nodes for this repo
+    G = _load_global_graph()
+    removed = prune_repo_from_graph(G, repo_tag)
+
+    # Merge external-library nodes (no source_file) by label to avoid duplication
+    external_labels = {
+        d.get("label", ""): n
+        for n, d in G.nodes(data=True)
+        if not d.get("source_file") and d.get("label")
+    }
+    # Map each deduplicated external onto the existing global node so that
+    # edges incident to it can be rewired instead of dropped.
+    remap = {}
+    for node, data in prefixed.nodes(data=True):
+        if not data.get("source_file") and data.get("label") in external_labels:
+            remap[node] = external_labels[data["label"]]
+
+    # Compose: add prefixed nodes (except deduplicated externals) into global graph
+    for node, data in prefixed.nodes(data=True):
+        if node not in remap:
+            G.add_node(node, **data)
+    for u, v, data in prefixed.edges(data=True):
+        u = remap.get(u, u)
+        v = remap.get(v, v)
+        if u != v:  # don't introduce self-loops via remapping
+            G.add_edge(u, v, **data)
+
+    added = prefixed.number_of_nodes() - len(remap)
+    # A member call parked on a caller node (#3152) may be answered by a repo
+    # already in the global graph, or by this one for a repo added earlier. The
+    # pass recomputes its own output, so adding repos one at a time lands where a
+    # single merge-graphs of the same inputs would.
+    from graphify.cross_repo_calls import link_cross_repo_member_calls
+
+    cross_repo_calls = link_cross_repo_member_calls(G)
+    _save_global_graph(G)
+
+    manifest["repos"][repo_tag] = {
+        "added_at": datetime.now(timezone.utc).isoformat(),
+        "source_path": str(source_path.resolve()),
+        "node_count": added,
+        "edge_count": prefixed.number_of_edges(),
+        "source_hash": src_hash,
+    }
+    _save_manifest(manifest)
+
+    return {"repo_tag": repo_tag, "nodes_added": added, "nodes_removed": removed,
+            "skipped": False, "cross_repo_calls": cross_repo_calls}
+
+
+def global_remove(repo_tag: str) -> int:
+    """Remove all nodes for repo_tag from the global graph. Returns count removed."""
+    from graphify.build import prune_repo_from_graph
+
+    manifest = _load_manifest()
+    if repo_tag not in manifest["repos"]:
+        raise KeyError(f"repo '{repo_tag}' not in global graph")
+
+    G = _load_global_graph()
+    removed = prune_repo_from_graph(G, repo_tag)
+    _save_global_graph(G)
+
+    del manifest["repos"][repo_tag]
+    _save_manifest(manifest)
+    return removed
+
+
+def global_list() -> dict:
+    """Return the manifest repos dict."""
+    return _load_manifest().get("repos", {})
+
+
+def global_path() -> Path:
+    return _GLOBAL_GRAPH