Upload 739 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+snap-python/source/dev/examples/demo.graph.dat filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "snap-python/mcp_output/start_mcp.py"]

app.py

@@ -0,0 +1,45 @@
+from fastapi import FastAPI
+import os
+import sys
+
+mcp_plugin_path = os.path.join(os.path.dirname(__file__), "snap-python", "mcp_output", "mcp_plugin")
+sys.path.insert(0, mcp_plugin_path)
+
+app = FastAPI(
+    title="Snap-Python MCP Service",
+    description="Auto-generated MCP service for snap-python",
+    version="1.0.0"
+)
+
+@app.get("/")
+def root():
+    return {
+        "service": "Snap-Python MCP Service",
+        "version": "1.0.0",
+        "status": "running",
+        "transport": os.environ.get("MCP_TRANSPORT", "http")
+    }
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "service": "snap-python MCP"}
+
+@app.get("/tools")
+def list_tools():
+    try:
+        from mcp_service import create_app
+        mcp_app = create_app()
+        tools = []
+        for tool_name, tool_func in mcp_app.tools.items():
+            tools.append({
+                "name": tool_name,
+                "description": tool_func.__doc__ or "No description available"
+            })
+        return {"tools": tools}
+    except Exception as e:
+        return {"error": f"Failed to load tools: {str(e)}"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

port.json

@@ -0,0 +1,5 @@
+{
+  "repo": "snap-python",
+  "port": 7916,
+  "timestamp": 1773243382
+}

requirements.txt

@@ -0,0 +1,5 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+snapx package modules under source.snapx.snapx

run_docker.ps1

@@ -0,0 +1,26 @@
+cd $PSScriptRoot
+$ErrorActionPreference = "Stop"
+$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "snap-python" }
+$entryUrl  = if ($env:MCP_ENTRY_URL)  { $env:MCP_ENTRY_URL  } else { "http://localhost:7916/mcp" }
+$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "snap-python-mcp" }
+$mcpDir = Join-Path $env:USERPROFILE ".cursor"
+$mcpPath = Join-Path $mcpDir "mcp.json"
+if (!(Test-Path $mcpDir)) { New-Item -ItemType Directory -Path $mcpDir | Out-Null }
+$config = @{}
+if (Test-Path $mcpPath) {
+  try { $config = Get-Content $mcpPath -Raw | ConvertFrom-Json } catch { $config = @{} }
+}
+$serversOrdered = [ordered]@{}
+if ($config -and ($config.PSObject.Properties.Name -contains "mcpServers") -and $config.mcpServers) {
+  $existing = $config.mcpServers
+  if ($existing -is [pscustomobject]) {
+    foreach ($p in $existing.PSObject.Properties) { if ($p.Name -ne $entryName) { $serversOrdered[$p.Name] = $p.Value } }
+  } elseif ($existing -is [System.Collections.IDictionary]) {
+    foreach ($k in $existing.Keys) { if ($k -ne $entryName) { $serversOrdered[$k] = $existing[$k] } }
+  }
+}
+$serversOrdered[$entryName] = @{ url = $entryUrl }
+$config = @{ mcpServers = $serversOrdered }
+$config | ConvertTo-Json -Depth 10 | Set-Content -Path $mcpPath -Encoding UTF8
+docker build -t $imageName .
+docker run --rm -p 7916:7860 $imageName

run_docker.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+mcp_entry_name="${MCP_ENTRY_NAME:-snap-python}"
+mcp_entry_url="${MCP_ENTRY_URL:-http://localhost:7916/mcp}"
+mcp_dir="${HOME}/.cursor"
+mcp_path="${mcp_dir}/mcp.json"
+mkdir -p "${mcp_dir}"
+if command -v python3 >/dev/null 2>&1; then
+python3 - "${mcp_path}" "${mcp_entry_name}" "${mcp_entry_url}" <<'PY'
+import json, os, sys
+path, name, url = sys.argv[1:4]
+cfg = {"mcpServers": {}}
+if os.path.exists(path):
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            cfg = json.load(f)
+    except Exception:
+        cfg = {"mcpServers": {}}
+if not isinstance(cfg, dict):
+    cfg = {"mcpServers": {}}
+servers = cfg.get("mcpServers")
+if not isinstance(servers, dict):
+    servers = {}
+ordered = {}
+for k, v in servers.items():
+    if k != name:
+        ordered[k] = v
+ordered[name] = {"url": url}
+cfg = {"mcpServers": ordered}
+with open(path, "w", encoding="utf-8") as f:
+    json.dump(cfg, f, indent=2, ensure_ascii=False)
+PY
+elif command -v python >/dev/null 2>&1; then
+python - "${mcp_path}" "${mcp_entry_name}" "${mcp_entry_url}" <<'PY'
+import json, os, sys
+path, name, url = sys.argv[1:4]
+cfg = {"mcpServers": {}}
+if os.path.exists(path):
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            cfg = json.load(f)
+    except Exception:
+        cfg = {"mcpServers": {}}
+if not isinstance(cfg, dict):
+    cfg = {"mcpServers": {}}
+servers = cfg.get("mcpServers")
+if not isinstance(servers, dict):
+    servers = {}
+ordered = {}
+for k, v in servers.items():
+    if k != name:
+        ordered[k] = v
+ordered[name] = {"url": url}
+cfg = {"mcpServers": ordered}
+with open(path, "w", encoding="utf-8") as f:
+    json.dump(cfg, f, indent=2, ensure_ascii=False)
+PY
+elif command -v jq >/dev/null 2>&1; then
+  name="${mcp_entry_name}"; url="${mcp_entry_url}"
+  if [ -f "${mcp_path}" ]; then
+    tmp="$(mktemp)"
+    jq --arg name "$name" --arg url "$url" '
+      .mcpServers = (.mcpServers // {})
+      | .mcpServers as $s
+      | ($s | with_entries(select(.key != $name))) as $base
+      | .mcpServers = ($base + {($name): {"url": $url}})
+    ' "${mcp_path}" > "${tmp}" && mv "${tmp}" "${mcp_path}"
+  else
+    printf '{ "mcpServers": { "%s": { "url": "%s" } } }
+' "$name" "$url" > "${mcp_path}"
+  fi
+fi
+docker build -t snap-python-mcp .
+docker run --rm -p 7916:7860 snap-python-mcp

snap-python/mcp_output/README_MCP.md

@@ -0,0 +1,110 @@
+# snap-python MCP (Model Context Protocol) Service README
+
+## 1) Project Introduction
+
+This MCP (Model Context Protocol) service exposes graph analytics capabilities built on top of the `snap-python` repository (Stanford SNAP bindings + `snapx` Pythonic API).  
+It is designed for developer workflows where an LLM or client app needs to:
+
+- Create/load graphs
+- Run shortest path and connectivity analysis
+- Compute community/centrality metrics
+- Convert between Python data structures and graph objects
+
+Main usable layers:
+
+- `swig.snap` (high-performance SNAP bindings, broad algorithm coverage)
+- `snapx` (NetworkX-like API wrapping SNAP-style behavior)
+
+---
+
+## 2) Installation Method
+
+### Requirements
+
+- Python 3.x
+- `pip`
+- Build toolchain for native extension (C/C++ compiler, SWIG-compatible environment) for `swig.snap` usage
+- Optional: `networkx`, `numpy`, `scipy` for interoperability or specific algorithm paths
+
+### Install
+
+- Install from repository root:
+  - `pip install .`
+- Editable/dev install:
+  - `pip install -e .`
+
+If native build fails, you can still use pure Python `snapx` portions where applicable, but full SNAP performance/features require successful extension build.
+
+---
+
+## 3) Quick Start
+
+### Basic graph + shortest path (snapx-style)
+
+- Create graph with `snapx.classes.graph.Graph` or generators (`snapx.generators.classic.path_graph`)
+- Use unweighted/weighted shortest path modules:
+  - `snapx.algorithms.shortest_paths.unweighted.single_source_shortest_path`
+  - `snapx.algorithms.shortest_paths.weighted.dijkstra_path`
+
+### Core analysis functions (SNAP SWIG layer)
+
+Typical high-value functions available in `snap` include:
+
+- Connectivity: `GetWccs`, `GetSccs`, `IsConnected`, `GetMxWcc`
+- Path/BFS: `GetBfsTree`, `GetShortPath`, `GetBfsEffDiam`
+- Centrality: `GetDegreeCentr`, `GetClosenessCentr`, `GetBetweennessCentr`
+- Community: `CommunityCNM`, `CommunityGirvanNewman`
+- Generation: `GenRndGnm`, `GenPrefAttach`, `GenSmallWorld`, `GenRMat`
+
+---
+
+## 4) Available Tools and Endpoints List
+
+Recommended MCP (Model Context Protocol) service surface (developer-oriented grouping):
+
+- `graph.create`
+  - Create empty/path/basic graphs (snapx generators, SNAP constructors)
+- `graph.load`
+  - Load edge lists / persisted graphs (`LoadEdgeList`, `*_Load`)
+- `graph.convert`
+  - Convert dict-of-dicts and Python structures (`to_snapx_graph`, `from_dict_of_dicts`)
+- `analysis.connectivity`
+  - Components and connectedness (`connected_components`, `GetWccs`, `GetSccs`)
+- `analysis.shortest_path`
+  - Unweighted + Dijkstra + all-pairs (`single_source_shortest_path`, `dijkstra_path`, `johnson`)
+- `analysis.centrality`
+  - Degree/closeness/betweenness/eigenvector variants
+- `analysis.community`
+  - CNM and Girvan-Newman community detection
+- `analysis.stats`
+  - Degree distributions, triads, clustering, diameter/ANF estimates
+- `graph.relabel`
+  - Node relabel operations (`relabel_nodes`, integer relabeling)
+
+Note: Repository does not define a ready-made CLI endpoint set; expose these as MCP (Model Context Protocol) service methods in your host runtime.
+
+---
+
+## 5) Common Issues and Notes
+
+- Native build friction:
+  - Most installation issues come from missing compiler/SWIG toolchain.
+- Mixed API layers:
+  - `swig.snap` and `snapx` overlap conceptually; keep service contracts explicit about which backend each endpoint uses.
+- Performance:
+  - Prefer SWIG SNAP functions for large graphs and heavy analytics.
+- Compatibility:
+  - Some conversion paths may assume NetworkX-like inputs.
+- Testing/examples:
+  - Use `test/` and `examples/` as validation references for endpoint behavior and expected outputs.
+
+---
+
+## 6) Reference Links / Documentation
+
+- Repository: https://github.com/snap-stanford/snap-python
+- Root docs: `README.md`, `troubleshooting.md`, `RELEASE.txt`
+- SWIG notes: `swig/README.txt`
+- Docker/environment help: `docker/README.md`
+- Examples: `examples/`, `dev/examples/`
+- Tests: `test/`, `dev/test/`

snap-python/mcp_output/analysis.json

@@ -0,0 +1,2104 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/snap-stanford/snap-python",
+    "summary": "Imported via zip fallback, file count: 238",
+    "file_tree": {
+      "CREDITS.txt": {
+        "size": 1015
+      },
+      "README.md": {
+        "size": 4798
+      },
+      "RELEASE.txt": {
+        "size": 8899
+      },
+      "dev/examples/benchmark.py": {
+        "size": 13737
+      },
+      "dev/examples/convert.py": {
+        "size": 6243
+      },
+      "dev/examples/data/p2p-Gnutella08.txt": {
+        "size": 194493
+      },
+      "dev/examples/getstats.py": {
+        "size": 9553
+      },
+      "dev/examples/load.py": {
+        "size": 207
+      },
+      "dev/examples/plot_results.py": {
+        "size": 5349
+      },
+      "dev/examples/result3.txt": {
+        "size": 131
+      },
+      "dev/examples/results-madmax/BFS_all.txt": {
+        "size": 5183
+      },
+      "dev/examples/results-madmax/BFS_pref.txt": {
+        "size": 868
+      },
+      "dev/examples/results-madmax/BFS_prefdeg3.txt": {
+        "size": 866
+      },
+      "dev/examples/results-madmax/BFS_rmat.txt": {
+        "size": 864
+      },
+      "dev/examples/results-madmax/BFS_rmatdeg3.txt": {
+        "size": 861
+      },
+      "dev/examples/results-madmax/BFS_sw.txt": {
+        "size": 864
+      },
+      "dev/examples/results-madmax/BFS_swdeg3.txt": {
+        "size": 860
+      },
+      "dev/examples/results-madmax/triads_all.txt": {
+        "size": 5163
+      },
+      "dev/examples/results-madmax/triads_pref.txt": {
+        "size": 863
+      },
+      "dev/examples/results-madmax/triads_prefdeg3.txt": {
+        "size": 860
+      },
+      "dev/examples/results-madmax/triads_rmat.txt": {
+        "size": 862
+      },
+      "dev/examples/results-madmax/triads_rmatdeg3.txt": {
+        "size": 860
+      },
+      "dev/examples/results-madmax/triads_sw.txt": {
+        "size": 861
+      },
+      "dev/examples/results-madmax/triads_swdeg3.txt": {
+        "size": 857
+      },
+      "dev/examples/snapswig-check.py": {
+        "size": 1191
+      },
+      "dev/examples/tneanet-cpp.py": {
+        "size": 262
+      },
+      "dev/examples/tneanet.py": {
+        "size": 9117
+      },
+      "dev/examples/tnodei.py": {
+        "size": 76
+      },
+      "dev/examples/tungraph.py": {
+        "size": 2674
+      },
+      "dev/examples/vector_comp.py": {
+        "size": 1563
+      },
+      "dev/swig-r/snappy.py": {
+        "size": 1067
+      },
+      "dev/test/adjlist.py": {
+        "size": 2256
+      },
+      "dev/test/data/p2p-Gnutella08.txt": {
+        "size": 194493
+      },
+      "dev/test/genrnd.py": {
+        "size": 847
+      },
+      "dev/test/hash.py": {
+        "size": 2654
+      },
+      "dev/test/hkey.py": {
+        "size": 390
+      },
+      "dev/test/install-dir.py": {
+        "size": 542
+      },
+      "dev/test/memtest.py": {
+        "size": 471
+      },
+      "dev/test/printstat.py": {
+        "size": 472
+      },
+      "dev/test/readvec.py": {
+        "size": 428
+      },
+      "dev/test/results-sheridan/coeff.txt": {
+        "size": 24
+      },
+      "dev/test/results-sheridan/pref-CDD.txt": {
+        "size": 139
+      },
+      "dev/test/results-sheridan/pref-ClustCoef.txt": {
+        "size": 139
+      },
+      "dev/test/results-sheridan/pref-DD.txt": {
+        "size": 139
+      },
+      "dev/test/results-sheridan/pref-HOP.txt": {
+        "size": 139
+      },
+      "dev/test/results-sheridan/pref-SVal.txt": {
+        "size": 140
+      },
+      "dev/test/results-sheridan/pref-SVec.txt": {
+        "size": 139
+      },
+      "dev/test/results-sheridan/pref-Scc.txt": {
+        "size": 139
+      },
+      "dev/test/results-sheridan/pref-Wcc.txt": {
+        "size": 139
+      },
+      "dev/test/results-sheridan/pref-info.txt": {
+        "size": 139
+      },
+      "dev/test/results-sheridan/rmat-CDD.txt": {
+        "size": 140
+      },
+      "dev/test/results-sheridan/rmat-ClustCoef.txt": {
+        "size": 140
+      },
+      "dev/test/results-sheridan/rmat-DD.txt": {
+        "size": 140
+      },
+      "dev/test/results-sheridan/rmat-HOP.txt": {
+        "size": 140
+      },
+      "dev/test/results-sheridan/rmat-SVal.txt": {
+        "size": 140
+      },
+      "dev/test/results-sheridan/rmat-SVec.txt": {
+        "size": 140
+      },
+      "dev/test/results-sheridan/rmat-Scc.txt": {
+        "size": 140
+      },
+      "dev/test/results-sheridan/rmat-Wcc.txt": {
+        "size": 140
+      },
+      "dev/test/results-sheridan/rmat-info.txt": {
+        "size": 140
+      },
+      "dev/test/results-sheridan/sw-CDD.txt": {
+        "size": 208
+      },
+      "dev/test/results-sheridan/sw-ClustCoef.txt": {
+        "size": 208
+      },
+      "dev/test/results-sheridan/sw-DD.txt": {
+        "size": 208
+      },
+      "dev/test/results-sheridan/sw-HOP.txt": {
+        "size": 208
+      },
+      "dev/test/results-sheridan/sw-SVal.txt": {
+        "size": 187
+      },
+      "dev/test/results-sheridan/sw-SVec.txt": {
+        "size": 187
+      },
+      "dev/test/results-sheridan/sw-Scc.txt": {
+        "size": 208
+      },
+      "dev/test/results-sheridan/sw-Wcc.txt": {
+        "size": 208
+      },
+      "dev/test/results-sheridan/sw-info.txt": {
+        "size": 208
+      },
+      "dev/test/tungraph.py": {
+        "size": 2714
+      },
+      "dev/test/vec.py": {
+        "size": 1487
+      },
+      "doc/README-DOC.TXT": {
+        "size": 3253
+      },
+      "doc/guide.txt": {
+        "size": 653
+      },
+      "doc/source/conf.py": {
+        "size": 8055
+      },
+      "doc/todo.txt": {
+        "size": 567
+      },
+      "docker/README.md": {
+        "size": 11893
+      },
+      "docker/requirements.txt": {
+        "size": 138
+      },
+      "examples/benchmark.py": {
+        "size": 14022
+      },
+      "examples/data/p2p-Gnutella08.txt": {
+        "size": 194493
+      },
+      "examples/stackoverflow/doJoin.py": {
+        "size": 1516
+      },
+      "examples/stackoverflow/getAnswers.py": {
+        "size": 1438
+      },
+      "examples/stackoverflow/getQuestions.py": {
+        "size": 1675
+      },
+      "examples/stackoverflow/getStats.py": {
+        "size": 2111
+      },
+      "examples/stackoverflow/getTag.py": {
+        "size": 1599
+      },
+      "examples/tneanet.py": {
+        "size": 9115
+      },
+      "hellotest/setup.py": {
+        "size": 148
+      },
+      "setup.py": {
+        "size": 1596
+      },
+      "setup/setup.py": {
+        "size": 2613
+      },
+      "setup/snap.py": {
+        "size": 524313
+      },
+      "snapx/README.md": {
+        "size": 2732
+      },
+      "snapx/setup.py": {
+        "size": 293
+      },
+      "snapx/snapx/__init__.py": {
+        "size": 271
+      },
+      "snapx/snapx/algorithms/__init__.py": {
+        "size": 171
+      },
+      "snapx/snapx/algorithms/centrality/__init__.py": {
+        "size": 24
+      },
+      "snapx/snapx/algorithms/centrality/snap_cent.py": {
+        "size": 115
+      },
+      "snapx/snapx/algorithms/community/__init__.py": {
+        "size": 50
+      },
+      "snapx/snapx/algorithms/community/snap_cmty.py": {
+        "size": 368
+      },
+      "snapx/snapx/algorithms/components/__init__.py": {
+        "size": 26
+      },
+      "snapx/snapx/algorithms/components/components.py": {
+        "size": 3784
+      },
+      "snapx/snapx/algorithms/dag.py": {
+        "size": 28823
+      },
+      "snapx/snapx/algorithms/shortest_paths/__init__.py": {
+        "size": 112
+      },
+      "snapx/snapx/algorithms/shortest_paths/unweighted.py": {
+        "size": 14520
+      },
+      "snapx/snapx/algorithms/shortest_paths/weighted.py": {
+        "size": 72792
+      },
+      "snapx/snapx/classes/__init__.py": {
+        "size": 168
+      },
+      "snapx/snapx/classes/_nodeiter.py": {
+        "size": 2521
+      },
+      "snapx/snapx/classes/attrdict.py": {
+        "size": 7278
+      },
+      "snapx/snapx/classes/coreviews.py": {
+        "size": 7082
+      },
+      "snapx/snapx/classes/digraph.py": {
+        "size": 40018
+      },
+      "snapx/snapx/classes/filters.py": {
+        "size": 1756
+      },
+      "snapx/snapx/classes/function.py": {
+        "size": 9997
+      },
+      "snapx/snapx/classes/graph.py": {
+        "size": 51329
+      },
+      "snapx/snapx/classes/graphviews.py": {
+        "size": 4930
+      },
+      "snapx/snapx/classes/reportviews.py": {
+        "size": 7755
+      },
+      "snapx/snapx/classes/tests/__init__.py": {
+        "size": 12
+      },
+      "snapx/snapx/classes/tests/test_attrdict.py": {
+        "size": 3830
+      },
+      "snapx/snapx/classes/tests/test_coreviews.py": {
+        "size": 4165
+      },
+      "snapx/snapx/classes/tests/test_graph.py": {
+        "size": 26667
+      },
+      "snapx/snapx/classes/tests/test_reportviews.py": {
+        "size": 14382
+      },
+      "snapx/snapx/convert.py": {
+        "size": 8514
+      },
+      "snapx/snapx/exception.py": {
+        "size": 1082
+      },
+      "snapx/snapx/generators/__init__.py": {
+        "size": 74
+      },
+      "snapx/snapx/generators/classic.py": {
+        "size": 4037
+      },
+      "snapx/snapx/generators/ego.py": {
+        "size": 2150
+      },
+      "snapx/snapx/relabel.py": {
+        "size": 7699
+      },
+      "snapx/snapx/testing/__init__.py": {
+        "size": 35
+      },
+      "snapx/snapx/testing/utils.py": {
+        "size": 1780
+      },
+      "snapx/snapx/utils/__init__.py": {
+        "size": 68
+      },
+      "snapx/snapx/utils/decorator.py": {
+        "size": 17222
+      },
+      "snapx/snapx/utils/decorators.py": {
+        "size": 3454
+      },
+      "snapx/snapx/utils/misc.py": {
+        "size": 577
+      },
+      "swig/README.txt": {
+        "size": 3310
+      },
+      "swig/gen/NOTES.TXT": {
+        "size": 3315
+      },
+      "swig/gen/disp-custom.py": {
+        "size": 6928
+      },
+      "swig/gen/dispatch-pneanet.txt": {
+        "size": 2480
+      },
+      "swig/gen/dispatch-pngraph.txt": {
+        "size": 2480
+      },
+      "swig/gen/dispatch-pngraphmp.txt": {
+        "size": 2534
+      },
+      "swig/gen/dispatch-pungraph.txt": {
+        "size": 2599
+      },
+      "swig/gen/dispatch.txt": {
+        "size": 10093
+      },
+      "swig/gen/genClassFn/README.txt": {
+        "size": 1193
+      },
+      "swig/gen/genClassFn/archive/README.txt": {
+        "size": 698
+      },
+      "swig/gen/genClassFn/archive/classFn.txt": {
+        "size": 266
+      },
+      "swig/gen/genClassFn/archive/classFnDef.txt": {
+        "size": 2415
+      },
+      "swig/gen/genClassFn/archive/classFnExt.txt": {
+        "size": 7672
+      },
+      "swig/gen/genClassFn/archive/genClassFnExt.py": {
+        "size": 2702
+      },
+      "swig/gen/genClassFn/classFn.txt": {
+        "size": 1728
+      },
+      "swig/gen/genClassFn/genPyClassFn.py": {
+        "size": 589
+      },
+      "swig/gen/gendispatch.py": {
+        "size": 1874
+      },
+      "swig/gen/gentypes.py": {
+        "size": 823
+      },
+      "swig/gen/hashes.txt": {
+        "size": 616
+      },
+      "swig/gen/types.txt": {
+        "size": 2858
+      },
+      "swig/gen/vectors.txt": {
+        "size": 969
+      },
+      "swig/setup.py": {
+        "size": 2136
+      },
+      "swig/snap/__init__.py": {
+        "size": 509
+      },
+      "test/adjlist.py": {
+        "size": 2286
+      },
+      "test/attributes.py": {
+        "size": 1128
+      },
+      "test/attrtest.py": {
+        "size": 804
+      },
+      "test/bfs.py": {
+        "size": 1529
+      },
+      "test/bug-2015-130-GetRndNI.py": {
+        "size": 146
+      },
+      "test/bug-2015-18-attr.py": {
+        "size": 1074
+      },
+      "test/bug-20150706-pagerank.py": {
+        "size": 160
+      },
+      "test/bug-328-cnm.py": {
+        "size": 170
+      },
+      "test/bug-585-genrndpowerlaw.py": {
+        "size": 171
+      },
+      "test/bug-AddFltAttrN.py": {
+        "size": 492
+      },
+      "test/bug-attr-mem.py": {
+        "size": 3056
+      },
+      "test/cncom.py": {
+        "size": 1602
+      },
+      "test/cpm_communities.py": {
+        "size": 671
+      },
+      "test/data/cooccurrence.txt": {
+        "size": 222
+      },
+      "test/data/data-table.txt": {
+        "size": 89
+      },
+      "test/data/example-LoadConnListStr.txt": {
+        "size": 12
+      },
+      "test/data/final_sorted_edges.txt": {
+        "size": 524313
+      },
+      "test/data/p2p-Gnutella08.txt": {
+        "size": 194498
+      },
+      "test/data/test-509.txt": {
+        "size": 12
+      },
+      "test/delnode.py": {
+        "size": 1141
+      },
+      "test/demo-random.py": {
+        "size": 505
+      },
+      "test/except.py": {
+        "size": 497
+      },
+      "test/genrnd.py": {
+        "size": 863
+      },
+      "test/getidv.py": {
+        "size": 207
+      },
+      "test/gnuplot.py": {
+        "size": 139
+      },
+      "test/graphviz.py": {
+        "size": 315
+      },
+      "test/hash.py": {
+        "size": 2688
+      },
+      "test/hkey.py": {
+        "size": 407
+      },
+      "test/intro.py": {
+        "size": 3055
+      },
+      "test/make-graph.py": {
+        "size": 749
+      },
+      "test/make-tab.py": {
+        "size": 330
+      },
+      "test/net.py": {
+        "size": 9161
+      },
+      "test/ops.py": {
+        "size": 2989
+      },
+      "test/ops1.py": {
+        "size": 1078
+      },
+      "test/pagerank.py": {
+        "size": 490
+      },
+      "test/plotdeg.py": {
+        "size": 368
+      },
+      "test/printsnap.py": {
+        "size": 59
+      },
+      "test/printstat.py": {
+        "size": 511
+      },
+      "test/props.py": {
+        "size": 594
+      },
+      "test/quick_test.py": {
+        "size": 291
+      },
+      "test/readgraph.py": {
+        "size": 2682
+      },
+      "test/readvec.py": {
+        "size": 439
+      },
+      "test/rnd.py": {
+        "size": 330
+      },
+      "test/snap-test-pylayer.py": {
+        "size": 137859
+      },
+      "test/snap-test.py": {
+        "size": 138461
+      },
+      "test/table-test-avery.py": {
+        "size": 3128
+      },
+      "test/test-131-setiter.py": {
+        "size": 334
+      },
+      "test/test-2015-18a-attr.py": {
+        "size": 1365
+      },
+      "test/test-2015-298.py": {
+        "size": 576
+      },
+      "test/test-20160801-LoadConnListStr.py": {
+        "size": 407
+      },
+      "test/test-20180416-table.py": {
+        "size": 805
+      },
+      "test/test-346-getei.py": {
+        "size": 917
+      },
+      "test/test-356-getei.py": {
+        "size": 545
+      },
+      "test/test-374-addstrattrdate.py": {
+        "size": 330
+      },
+      "test/test-384-deledge.py": {
+        "size": 205
+      },
+      "test/test-509-load.py": {
+        "size": 390
+      },
+      "test/test-582-getnodewcc.py": {
+        "size": 209
+      },
+      "test/test-585-genrndpowerlaw.py": {
+        "size": 57
+      },
+      "test/test-613-getbfstree.py": {
+        "size": 453
+      },
+      "test/test-GetBetweennessCentr.py": {
+        "size": 1035
+      },
+      "test/test-GetClosenessCentr.py": {
+        "size": 614
+      },
+      "test/test-GetFarnessCentr.py": {
+        "size": 596
+      },
+      "test/test-THashKeyDatI.py": {
+        "size": 178
+      },
+      "test/test-emptystr.py": {
+        "size": 353
+      },
+      "test/test-girvan-newman.py": {
+        "size": 710
+      },
+      "test/test-gnuplot.py": {
+        "size": 121
+      },
+      "test/test-graphviz.py": {
+        "size": 109
+      },
+      "test/test-io.py": {
+        "size": 2464
+      },
+      "test/test-node2vec.py": {
+        "size": 224
+      },
+      "test/test-pajek.py": {
+        "size": 1466
+      },
+      "test/test-rewire.py": {
+        "size": 278
+      },
+      "test/test-table.py": {
+        "size": 1780
+      },
+      "test/test-tnodei.py": {
+        "size": 1866
+      },
+      "test/test-vec-ops.py": {
+        "size": 1235
+      },
+      "test/thash.py": {
+        "size": 923
+      },
+      "test/titer.py": {
+        "size": 6659
+      },
+      "test/tmany.py": {
+        "size": 4540
+      },
+      "test/tneanet.py": {
+        "size": 29824
+      },
+      "test/tnodei.py": {
+        "size": 955
+      },
+      "test/tpair.py": {
+        "size": 83
+      },
+      "test/tree.py": {
+        "size": 369
+      },
+      "test/tutorial.py": {
+        "size": 3825
+      },
+      "test/tvec.py": {
+        "size": 704
+      },
+      "test/vec.py": {
+        "size": 1511
+      },
+      "test/vector_comp.py": {
+        "size": 1568
+      },
+      "troubleshooting.md": {
+        "size": 1594
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.snapx.snapx",
+      "source.swig.snap"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": false,
+    "pyproject": false,
+    "setup_cfg": false,
+    "setup_py": true
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "setup",
+        "module": "setup",
+        "functions": [],
+        "classes": [
+          "SwigBuild",
+          "SwigExtension"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "swig",
+        "module": "setup",
+        "functions": [],
+        "classes": [
+          "PkgBuild",
+          "SwigExtension"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "swig.gen",
+        "module": "disp-custom",
+        "functions": [
+          "ConvertESubGraph",
+          "ConvertGraph",
+          "ConvertSubGraph",
+          "ToGraph",
+          "ToNetwork"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "ConvertGraph": [
+            "toutspec",
+            "tinspec"
+          ],
+          "ConvertSubGraph": [
+            "toutspec",
+            "tinspec"
+          ],
+          "ConvertESubGraph": [
+            "toutspec",
+            "tinspec"
+          ],
+          "ToNetwork": [
+            "tspec"
+          ],
+          "ToGraph": [
+            "tspec"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "swig.gen.genClassFn.archive",
+        "module": "genClassFnExt",
+        "functions": [
+          "genFuncCall",
+          "getFuncName",
+          "removeFirstParam",
+          "stripTypes"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "removeFirstParam": [
+            "funcDecl"
+          ],
+          "stripTypes": [
+            "decl"
+          ],
+          "genFuncCall": [
+            "funcDecl",
+            "funcName",
+            "graphType"
+          ],
+          "getFuncName": [
+            "funcDecl"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "setup",
+        "module": "snap",
+        "functions": [
+          "CalcAvgDiamPdf",
+          "CalcEffDiam",
+          "CalcEffDiamPdf",
+          "CmtyGirvanNewmanStep",
+          "CntDegNodes",
+          "CntEdgesToSet",
+          "CntInDegNodes",
+          "CntNonZNodes",
+          "CntOutDegNodes",
+          "CntSelfEdges",
+          "CntUniqBiDirEdges",
+          "CntUniqDirEdges",
+          "CntUniqUndirEdges",
+          "CommunityCNM",
+          "CommunityGirvanNewman",
+          "DrawGViz",
+          "ErrNotify",
+          "ExeStop",
+          "GVizDoLayout",
+          "GVizGetLayoutStr",
+          "GenConfModel",
+          "GenCopyModel",
+          "GenDegSeq",
+          "GenForestFire",
+          "GenGeoPrefAttach",
+          "GenPrefAttach",
+          "GenRMat",
+          "GenRMatEpinions",
+          "GenRewire",
+          "GenRndBipart",
+          "GenRndDegK",
+          "GenRndGnm",
+          "GenRndPowerLaw",
+          "GenSmallWorld",
+          "Get1CnCom",
+          "Get1CnComSzCnt",
+          "GetAnf",
+          "GetAnfEffDiam",
+          "GetArtPoints",
+          "GetBetweennessCentr",
+          "GetBfsEffDiam",
+          "GetBfsFullDiam",
+          "GetBfsTree",
+          "GetBiCon",
+          "GetBiConSzCnt",
+          "GetClosenessCentr",
+          "GetClustCf",
+          "GetCmnNbrs",
+          "GetDegCnt",
+          "GetDegSeqV",
+          "GetDegreeCentr",
+          "GetEdgeBridges",
+          "GetEdgesInOut",
+          "GetEigVals",
+          "GetEigVec",
+          "GetEigenVectorCentr",
+          "GetFarnessCentr",
+          "GetInDegCnt",
+          "GetInvParticipRat",
+          "GetInvParticipRatEig",
+          "GetModularity",
+          "GetMxBiCon",
+          "GetMxDegNId",
+          "GetMxInDegNId",
+          "GetMxOutDegNId",
+          "GetMxScc",
+          "GetMxWcc",
+          "GetMxWccSz",
+          "GetNodeClustCf",
+          "GetNodeInDegV",
+          "GetNodeOutDegV",
+          "GetNodeWcc",
+          "GetNodesAtHop",
+          "GetNodesAtHops",
+          "GetOutDegCnt",
+          "GetSccSzCnt",
+          "GetSccs",
+          "GetShortPath",
+          "GetSngVals",
+          "GetSngVec",
+          "GetSubGraph",
+          "GetSubTreeSz",
+          "GetTriadEdges",
+          "GetTriadParticip",
+          "GetTriads",
+          "GetWccSzCnt",
+          "GetWccs",
+          "InfoNotify",
+          "IsConnected",
+          "IsWeaklyConn",
+          "LoadDyNet",
+          "LoadDyNetGraphV",
+          "LoadEdgeList",
+          "MxDegree",
+          "MxSccSz",
+          "MxWccSz",
+          "NodesGTEDegree",
+          "PNEANet_New",
+          "PercentDegree",
+          "PercentMxScc",
+          "PercentMxWcc",
+          "PrintGraphStatTable",
+          "PyTFltV",
+          "PyToTIntV",
+          "SaveToErrLog",
+          "StatNotify",
+          "TBPGraph_GetSmallGraph",
+          "TBPGraph_Load",
+          "TBPGraph_New",
+          "TBigStrPool_Load",
+          "TBigStrPool_New",
+          "TBool_Get01Str",
+          "TBool_GetRnd",
+          "TBool_GetValFromStr",
+          "TBool_GetYNStr",
+          "TBool_GetYesNoStr",
+          "TBool_IsValStr",
+          "TChAIn_New",
+          "TChA_LoadTxt",
+          "TCh_GetHex",
+          "TCh_GetHexCh",
+          "TCh_GetNum",
+          "TCh_GetUc",
+          "TCh_GetUsFromYuAscii",
+          "TCh_IsAlNum",
+          "TCh_IsAlpha",
+          "TCh_IsHex",
+          "TCh_IsNum",
+          "TCh_IsUc",
+          "TCh_IsWs",
+          "TCnCom_Dump",
+          "TCnCom_SaveTxt",
+          "TCs_GetCsFromBf",
+          "TFIn_New",
+          "TFOut_New",
+          "TFfGGen_GenFFGraphs",
+          "TFile_Del",
+          "TFile_DelWc",
+          "TFile_Exists",
+          "TFile_GetUniqueFNm",
+          "TFile_Rename",
+          "TFltRect_Intersection",
+          "TFlt_Abs",
+          "TFlt_Eq6",
+          "TFlt_GetGigaStr",
+          "TFlt_GetInRng",
+          "TFlt_GetKiloStr",
+          "TFlt_GetMegaStr",
+          "TFlt_GetMn",
+          "TFlt_GetMx",
+          "TFlt_GetPrcStr",
+          "TFlt_GetRnd",
+          "TFlt_Round",
+          "TFlt_Sign",
+          "TForestFire_GenGraph",
+          "TGUtil_GetCCdf",
+          "TGUtil_GetCdf",
+          "TGUtil_GetPdf",
+          "TGUtil_MakeExpBins",
+          "TGUtil_Normalize",
+          "TIntIntVV_GetV",
+          "TIntIntVV_SwapI",
+          "TIntVToPy",
+          "TIntV_GetV",
+          "TIntV_SwapI",
+          "TInt_Abs",
+          "TInt_GetHexStr",
+          "TInt_GetInRng",
+          "TInt_GetKiloStr",
+          "TInt_GetMegaStr",
+          "TInt_GetMn",
+          "TInt_GetMx",
+          "TInt_GetRnd",
+          "TInt_IsEven",
+          "TInt_IsOdd",
+          "TInt_LoadFrugalInt",
+          "TInt_LoadFrugalIntV",
+          "TInt_SaveFrugalInt",
+          "TInt_SaveFrugalIntV",
+          "TInt_Sign",
+          "TInt_Swap",
+          "TInt_TestFrugalInt",
+          "TMIn_New",
+          "TMOut_New",
+          "TMemIn_New",
+          "TMemOut_New",
+          "TMem_LoadMem",
+          "TMem_New",
+          "TNEANet_Load",
+          "TNEANet_New",
+          "TNEGraph_Load",
+          "TNEGraph_New",
+          "TNGraph_GetSmallGraph",
+          "TNGraph_Load",
+          "TNGraph_New",
+          "TPairHashImpl1_GetHashCd",
+          "TPairHashImpl2_GetHashCd",
+          "TPrGraph",
+          "TRStr_CmpI",
+          "TRStr_GetNullRStr",
+          "TRnd_GetExpDevStep",
+          "TRnd_GetNrmDevStep",
+          "TRnd_GetUniDevStep",
+          "TRnd_LoadTxt",
+          "TStdIn_New",
+          "TStdOut_New",
+          "TStrHashF_DJB_GetPrimHashCd",
+          "TStrHashF_DJB_GetSecHashCd",
+          "TStrHashF_Md5_GetPrimHashCd",
+          "TStrHashF_Md5_GetSecHashCd",
+          "TStrHashF_OldGLib_GetPrimHashCd",
+          "TStrHashF_OldGLib_GetSecHashCd",
+          "TStrIn_New",
+          "TStrPool64_Load",
+          "TStrPool64_New",
+          "TStrPool_Load",
+          "TStrPool_New",
+          "TStrUtil_CountWords",
+          "TStrUtil_GetAddWIdV",
+          "TStrUtil_GetCleanStr",
+          "TStrUtil_GetCleanWrdStr",
+          "TStrUtil_GetDomNm",
+          "TStrUtil_GetDomNm2",
+          "TStrUtil_GetNormalizedUrl",
+          "TStrUtil_GetShorStr",
+          "TStrUtil_GetStdName",
+          "TStrUtil_GetStdNameV",
+          "TStrUtil_GetTmFromStr",
+          "TStrUtil_GetWIdV",
+          "TStrUtil_GetWebsiteNm",
+          "TStrUtil_GetXmlTagNmVal",
+          "TStrUtil_GetXmlTagNmVal2",
+          "TStrUtil_GetXmlTagVal",
+          "TStrUtil_IsLatinStr",
+          "TStrUtil_RemoveHtmlTags",
+          "TStrUtil_SplitLines",
+          "TStrUtil_SplitOnCh",
+          "TStrUtil_SplitSentences",
+          "TStrUtil_SplitWords",
+          "TStrUtil_StripEnd",
+          "TStrV_GetV",
+          "TStrV_SwapI",
+          "TStr_AddToFMid",
+          "TStr_Fmt",
+          "TStr_GetChStr",
+          "TStr_GetDChStr",
+          "TStr_GetFNmStr",
+          "TStr_GetNrAbsFPath",
+          "TStr_GetNrFExt",
+          "TStr_GetNrFMid",
+          "TStr_GetNrFNm",
+          "TStr_GetNrFPath",
+          "TStr_GetNrNumFExt",
+          "TStr_GetNullStr",
+          "TStr_GetNumFNm",
+          "TStr_GetSpaceStr",
+          "TStr_IsAbsFPath",
+          "TStr_LoadTxt",
+          "TStr_MkClone",
+          "TStr_PutFBase",
+          "TStr_PutFBaseIfEmpty",
+          "TStr_PutFExt",
+          "TStr_PutFExtIfEmpty",
+          "TUInt64_GetHexStr",
+          "TUInt64_GetKiloStr",
+          "TUInt64_GetMegaStr",
+          "TUInt_GetKiloStr",
+          "TUInt_GetMegaStr",
+          "TUInt_GetRnd",
+          "TUInt_GetStrFromIpUInt",
+          "TUInt_GetUIntFromIpStr",
+          "TUInt_IsIpStr",
+          "TUInt_IsIpv6Str",
+          "TUInt_JavaUIntToCppUInt",
+          "TUNGraph_GetSmallGraph",
+          "TUNGraph_Load",
+          "TUNGraph_New",
+          "WarnNotify",
+          "WrNotify",
+          "accept_array",
+          "count",
+          "print_array"
+        ],
+        "classes": [
+          "PNEANet",
+          "TArtPointVisitor",
+          "TAscFlt",
+          "TBPGraph",
+          "TBiConVisitor",
+          "TBigStrPool",
+          "TBool",
+          "TCRef",
+          "TCh",
+          "TChA",
+          "TChAIn",
+          "TChRet",
+          "TCnCom",
+          "TConv_Pt64Ints32",
+          "TCs",
+          "TDbStr",
+          "TFIn",
+          "TFOut",
+          "TFfGGen",
+          "TFile",
+          "TFlt",
+          "TFltRect",
+          "TForestFire",
+          "TGUtil",
+          "TInt",
+          "TIntH",
+          "TIntHI",
+          "TIntIntVH",
+          "TIntIntVV",
+          "TIntV",
+          "TLFlt",
+          "TLnRet",
+          "TMIn",
+          "TMOut",
+          "TMem",
+          "TMemIn",
+          "TMemOut",
+          "TNEANet",
+          "TNEANetAFltI",
+          "TNEANetAIntI",
+          "TNEANetAStrI",
+          "TNEANetEdgeI",
+          "TNEANetNodeI",
+          "TNEGraph",
+          "TNGraph",
+          "TNGraphEdgeI",
+          "TNGraphMtx",
+          "TNGraphNodeI",
+          "TPairHashImpl1",
+          "TPairHashImpl2",
+          "TRStr",
+          "TRnd",
+          "TSBase",
+          "TSFlt",
+          "TSIn",
+          "TSInOut",
+          "TSInt",
+          "TSOut",
+          "TSOutMnp",
+          "TSStr",
+          "TStdIn",
+          "TStdOut",
+          "TStr",
+          "TStrHashF_DJB",
+          "TStrHashF_Md5",
+          "TStrHashF_OldGLib",
+          "TStrIn",
+          "TStrPool",
+          "TStrPool64",
+          "TStrUtil",
+          "TStrV",
+          "TUCh",
+          "TUInt",
+          "TUInt64",
+          "TUNGraph",
+          "TUNGraphEdgeI",
+          "TUNGraphMtx",
+          "TUNGraphNodeI",
+          "TUndirFFire",
+          "TVoid"
+        ],
+        "function_signatures": {
+          "CalcEffDiam": [],
+          "CalcEffDiamPdf": [],
+          "CalcAvgDiamPdf": [],
+          "WrNotify": [],
+          "SaveToErrLog": [],
+          "InfoNotify": [],
+          "WarnNotify": [],
+          "ErrNotify": [],
+          "StatNotify": [],
+          "ExeStop": [],
+          "TPairHashImpl1_GetHashCd": [],
+          "TPairHashImpl2_GetHashCd": [],
+          "GetDegreeCentr": [],
+          "GetFarnessCentr": [],
+          "GetClosenessCentr": [],
+          "GetBetweennessCentr": [],
+          "GetEigenVectorCentr": [],
+          "CommunityGirvanNewman": [],
+          "CommunityCNM": [],
+          "CmtyGirvanNewmanStep": [],
+          "GetBiConSzCnt": [],
+          "GetBiCon": [],
+          "GetArtPoints": [],
+          "GetEdgeBridges": [],
+          "Get1CnComSzCnt": [],
+          "Get1CnCom": [],
+          "TCnCom_Dump": [],
+          "TCnCom_SaveTxt": [],
+          "TForestFire_GenGraph": [],
+          "TFfGGen_GenFFGraphs": [],
+          "TCs_GetCsFromBf": [],
+          "TStdIn_New": [],
+          "TStdOut_New": [],
+          "TFIn_New": [],
+          "TFOut_New": [],
+          "TMIn_New": [],
+          "TMOut_New": [
+            "MxBfL"
+          ],
+          "TFile_Exists": [],
+          "TFile_Del": [],
+          "TFile_DelWc": [],
+          "TFile_Rename": [],
+          "TFile_GetUniqueFNm": [],
+          "TUNGraph_New": [],
+          "TUNGraph_Load": [],
+          "TUNGraph_GetSmallGraph": [],
+          "TNGraph_New": [],
+          "TNGraph_Load": [],
+          "TNGraph_GetSmallGraph": [],
+          "TNEGraph_New": [],
+          "TNEGraph_Load": [],
+          "TBPGraph_New": [],
+          "TBPGraph_Load": [],
+          "TBPGraph_GetSmallGraph": [],
+          "GetSngVals": [],
+          "GetSngVec": [],
+          "GetEigVals": [],
+          "GetEigVec": [],
+          "GetInvParticipRat": [],
+          "GetInvParticipRatEig": [],
+          "LoadDyNet": [],
+          "LoadDyNetGraphV": [],
+          "GVizDoLayout": [],
+          "GVizGetLayoutStr": [],
+          "TBigStrPool_New": [],
+          "TBigStrPool_Load": [],
+          "TStrHashF_OldGLib_GetPrimHashCd": [],
+          "TStrHashF_OldGLib_GetSecHashCd": [],
+          "TStrHashF_Md5_GetPrimHashCd": [],
+          "TStrHashF_Md5_GetSecHashCd": [],
+          "TStrHashF_DJB_GetPrimHashCd": [],
+          "TStrHashF_DJB_GetSecHashCd": [],
+          "GenRndBipart": [],
+          "GenRndDegK": [],
+          "GenRndPowerLaw": [],
+          "GenDegSeq": [],
+          "GenPrefAttach": [],
+          "GenGeoPrefAttach": [],
+          "GenSmallWorld": [],
+          "GenForestFire": [],
+          "GenCopyModel": [],
+          "GenRMat": [],
+          "GenRMatEpinions": [],
+          "GenRewire": [],
+          "GenConfModel": [],
+          "GetSubGraph": [],
+          "TGUtil_GetCdf": [],
+          "TGUtil_GetCCdf": [],
+          "TGUtil_GetPdf": [],
+          "TGUtil_Normalize": [],
+          "TGUtil_MakeExpBins": [],
+          "TStrUtil_GetXmlTagVal": [],
+          "TStrUtil_GetXmlTagNmVal": [],
+          "TStrUtil_GetXmlTagNmVal2": [],
+          "TStrUtil_GetDomNm": [],
+          "TStrUtil_GetDomNm2": [],
+          "TStrUtil_GetWebsiteNm": [],
+          "TStrUtil_GetNormalizedUrl": [],
+          "TStrUtil_StripEnd": [],
+          "TStrUtil_GetShorStr": [],
+          "TStrUtil_GetCleanStr": [],
+          "TStrUtil_GetCleanWrdStr": [],
+          "TStrUtil_CountWords": [],
+          "TStrUtil_SplitWords": [],
+          "TStrUtil_SplitOnCh": [],
+          "TStrUtil_SplitLines": [],
+          "TStrUtil_SplitSentences": [],
+          "TStrUtil_RemoveHtmlTags": [],
+          "TStrUtil_IsLatinStr": [],
+          "TStrUtil_GetWIdV": [],
+          "TStrUtil_GetAddWIdV": [],
+          "TStrUtil_GetTmFromStr": [],
+          "TStrUtil_GetStdName": [],
+          "TStrUtil_GetStdNameV": [],
+          "TRnd_GetUniDevStep": [],
+          "TRnd_GetNrmDevStep": [],
+          "TRnd_GetExpDevStep": [],
+          "TRnd_LoadTxt": [],
+          "TMem_New": [],
+          "TMem_LoadMem": [],
+          "TMemIn_New": [],
+          "TMemOut_New": [],
+          "TChA_LoadTxt": [],
+          "TChAIn_New": [],
+          "TRStr_CmpI": [],
+          "TRStr_GetNullRStr": [],
+          "TStr_GetNrFPath": [],
+          "TStr_GetNrFMid": [],
+          "TStr_GetNrFExt": [],
+          "TStr_GetNrNumFExt": [],
+          "TStr_GetNrFNm": [],
+          "TStr_GetNrAbsFPath": [],
+          "TStr_IsAbsFPath": [],
+          "TStr_PutFExt": [],
+          "TStr_PutFExtIfEmpty": [],
+          "TStr_PutFBase": [],
+          "TStr_PutFBaseIfEmpty": [],
+          "TStr_AddToFMid": [],
+          "TStr_GetNumFNm": [],
+          "TStr_GetFNmStr": [],
+          "TStr_LoadTxt": [],
+          "TStr_GetChStr": [],
+          "TStr_GetDChStr": [],
+          "TStr_Fmt": [],
+          "TStr_GetSpaceStr": [],
+          "TStr_MkClone": [],
+          "TStr_GetNullStr": [],
+          "TStrIn_New": [],
+          "TStrPool_New": [],
+          "TStrPool_Load": [],
+          "TStrPool64_New": [
+            "MxBfL",
+            "GrowBy"
+          ],
+          "TStrPool64_Load": [],
+          "TBool_GetRnd": [],
+          "TBool_GetYNStr": [],
+          "TBool_GetYesNoStr": [],
+          "TBool_Get01Str": [],
+          "TBool_IsValStr": [],
+          "TBool_GetValFromStr": [],
+          "TCh_IsWs": [],
+          "TCh_IsAlpha": [],
+          "TCh_IsNum": [],
+          "TCh_IsAlNum": [],
+          "TCh_GetNum": [],
+          "TCh_IsHex": [],
+          "TCh_GetHex": [],
+          "TCh_GetHexCh": [],
+          "TCh_IsUc": [],
+          "TCh_GetUc": [],
+          "TCh_GetUsFromYuAscii": [],
+          "TInt_Abs": [],
+          "TInt_Sign": [],
+          "TInt_Swap": [],
+          "TInt_GetRnd": [
+            "Range"
+          ],
+          "TInt_IsOdd": [],
+          "TInt_IsEven": [],
+          "TInt_GetMn": [],
+          "TInt_GetMx": [],
+          "TInt_GetInRng": [],
+          "TInt_GetHexStr": [],
+          "TInt_GetKiloStr": [],
+          "TInt_GetMegaStr": [],
+          "TInt_SaveFrugalInt": [],
+          "TInt_LoadFrugalInt": [],
+          "TInt_TestFrugalInt": [],
+          "TInt_SaveFrugalIntV": [],
+          "TInt_LoadFrugalIntV": [],
+          "TUInt_GetRnd": [
+            "Range"
+          ],
+          "TUInt_GetKiloStr": [],
+          "TUInt_GetMegaStr": [],
+          "TUInt_JavaUIntToCppUInt": [],
+          "TUInt_IsIpStr": [],
+          "TUInt_GetUIntFromIpStr": [],
+          "TUInt_GetStrFromIpUInt": [],
+          "TUInt_IsIpv6Str": [],
+          "TUInt64_GetHexStr": [],
+          "TUInt64_GetKiloStr": [],
+          "TUInt64_GetMegaStr": [],
+          "TFlt_Abs": [],
+          "TFlt_Sign": [],
+          "TFlt_Round": [],
+          "TFlt_GetRnd": [],
+          "TFlt_Eq6": [],
+          "TFlt_GetMn": [],
+          "TFlt_GetMx": [],
+          "TFlt_GetInRng": [],
+          "TFlt_GetPrcStr": [],
+          "TFlt_GetKiloStr": [],
+          "TFlt_GetMegaStr": [],
+          "TFlt_GetGigaStr": [],
+          "TFltRect_Intersection": [],
+          "TIntV_SwapI": [],
+          "TIntV_GetV": [],
+          "TIntIntVV_SwapI": [],
+          "TIntIntVV_GetV": [],
+          "TStrV_SwapI": [],
+          "TStrV_GetV": [],
+          "TPrGraph": [],
+          "accept_array": [],
+          "print_array": [],
+          "PyTFltV": [],
+          "PyToTIntV": [],
+          "count": [],
+          "TIntVToPy": [],
+          "TNEANet_New": [],
+          "TNEANet_Load": [],
+          "PercentDegree": [],
+          "PercentMxWcc": [],
+          "PercentMxScc": [],
+          "LoadEdgeList": [],
+          "PrintGraphStatTable": [],
+          "GenRndGnm": [],
+          "NodesGTEDegree": [],
+          "MxDegree": [],
+          "MxSccSz": [],
+          "MxWccSz": [],
+          "PNEANet_New": [],
+          "GetNodeWcc": [],
+          "IsConnected": [],
+          "IsWeaklyConn": [],
+          "GetWccSzCnt": [],
+          "GetWccs": [],
+          "GetSccSzCnt": [],
+          "GetSccs": [],
+          "GetMxWccSz": [],
+          "GetMxWcc": [],
+          "GetMxScc": [],
+          "GetMxBiCon": [],
+          "CntInDegNodes": [],
+          "CntOutDegNodes": [],
+          "CntDegNodes": [],
+          "CntNonZNodes": [],
+          "CntEdgesToSet": [],
+          "GetMxDegNId": [],
+          "GetMxInDegNId": [],
+          "GetMxOutDegNId": [],
+          "GetInDegCnt": [],
+          "GetOutDegCnt": [],
+          "GetDegCnt": [],
+          "GetDegSeqV": [],
+          "GetNodeInDegV": [],
+          "GetNodeOutDegV": [],
+          "CntUniqUndirEdges": [],
+          "CntUniqDirEdges": [],
+          "CntUniqBiDirEdges": [],
+          "CntSelfEdges": [],
+          "GetBfsTree": [],
+          "GetSubTreeSz": [],
+          "GetNodesAtHop": [],
+          "GetNodesAtHops": [],
+          "GetShortPath": [],
+          "GetBfsFullDiam": [],
+          "GetBfsEffDiam": [],
+          "DrawGViz": [],
+          "GetClustCf": [],
+          "GetNodeClustCf": [],
+          "GetTriads": [],
+          "GetTriadEdges": [],
+          "GetTriadParticip": [],
+          "GetCmnNbrs": [],
+          "GetModularity": [],
+          "GetEdgesInOut": [],
+          "GetAnf": [],
+          "GetAnfEffDiam": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "dev.examples",
+        "module": "tneanet-cpp",
+        "functions": [
+          "main"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "main": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "dev.examples",
+        "module": "snapswig-check",
+        "functions": [
+          "BfsDfsTest",
+          "GVizTest",
+          "main"
+        ],
+        "classes": [
+          "GVizTests"
+        ],
+        "function_signatures": {
+          "GVizTest": [
+            "NNodes",
+            "NEdges"
+          ],
+          "BfsDfsTest": [
+            "NNodes",
+            "NEdges"
+          ],
+          "main": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx",
+        "module": "exception",
+        "functions": [],
+        "classes": [
+          "NodeNotFound",
+          "SnapXAlgorithmError",
+          "SnapXError",
+          "SnapXException",
+          "SnapXKeyError",
+          "SnapXNoPath",
+          "SnapXTypeError",
+          "SnapXUnfeasible"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx",
+        "module": "relabel",
+        "functions": [
+          "convert_node_labels_to_integers",
+          "relabel_nodes"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "relabel_nodes": [
+            "G",
+            "mapping",
+            "copy"
+          ],
+          "convert_node_labels_to_integers": [
+            "G",
+            "first_label",
+            "ordering",
+            "label_attribute"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx",
+        "module": "convert",
+        "functions": [
+          "from_dict_of_dicts",
+          "to_snapx_graph"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "to_snapx_graph": [
+            "data",
+            "create_using",
+            "multigraph_input"
+          ],
+          "from_dict_of_dicts": [
+            "d",
+            "create_using",
+            "multigraph_input"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.classes",
+        "module": "coreviews",
+        "functions": [],
+        "classes": [
+          "AdjacencyView",
+          "AtlasView",
+          "FilterAdjacency",
+          "FilterAtlas",
+          "FilterMultiAdjacency"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.classes",
+        "module": "graph",
+        "functions": [],
+        "classes": [
+          "Graph"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.classes",
+        "module": "attrdict",
+        "functions": [],
+        "classes": [
+          "AttributeDict"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.classes",
+        "module": "reportviews",
+        "functions": [],
+        "classes": [
+          "EdgeDataView",
+          "EdgeView",
+          "NodeDataView",
+          "NodeView",
+          "OutEdgeDataView",
+          "OutEdgeView"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.classes",
+        "module": "digraph",
+        "functions": [],
+        "classes": [
+          "DiGraph"
+        ],
+        "function_signatures": {},
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.classes",
+        "module": "filters",
+        "functions": [
+          "hide_diedges",
+          "hide_edges",
+          "hide_multidiedges",
+          "hide_multiedges",
+          "hide_nodes",
+          "no_filter",
+          "show_diedges",
+          "show_edges",
+          "show_multidiedges",
+          "show_multiedges"
+        ],
+        "classes": [
+          "show_nodes"
+        ],
+        "function_signatures": {
+          "no_filter": [],
+          "hide_nodes": [
+            "nodes"
+          ],
+          "hide_diedges": [
+            "edges"
+          ],
+          "hide_edges": [
+            "edges"
+          ],
+          "hide_multidiedges": [
+            "edges"
+          ],
+          "hide_multiedges": [
+            "edges"
+          ],
+          "show_diedges": [
+            "edges"
+          ],
+          "show_edges": [
+            "edges"
+          ],
+          "show_multidiedges": [
+            "edges"
+          ],
+          "show_multiedges": [
+            "edges"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.classes",
+        "module": "function",
+        "functions": [
+          "freeze",
+          "frozen",
+          "set_edge_attributes",
+          "set_node_attributes"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "set_node_attributes": [
+            "G",
+            "values",
+            "name"
+          ],
+          "set_edge_attributes": [
+            "G",
+            "values",
+            "name"
+          ],
+          "frozen": [],
+          "freeze": [
+            "G"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.classes",
+        "module": "graphviews",
+        "functions": [
+          "subgraph_view"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "subgraph_view": [
+            "G",
+            "filter_node",
+            "filter_edge"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.algorithms",
+        "module": "dag",
+        "functions": [
+          "topological_sort"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "topological_sort": [
+            "G"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.algorithms.centrality",
+        "module": "snap_cent",
+        "functions": [
+          "get_degree_centr"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "get_degree_centr": [
+            "graph",
+            "nid"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.algorithms.components",
+        "module": "components",
+        "functions": [
+          "connected_components",
+          "max_connected_component"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "connected_components": [
+            "G"
+          ],
+          "max_connected_component": [
+            "G"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.algorithms.shortest_paths",
+        "module": "weighted",
+        "functions": [
+          "all_pairs_dijkstra",
+          "all_pairs_dijkstra_path",
+          "all_pairs_dijkstra_path_length",
+          "bidirectional_dijkstra",
+          "dijkstra_path",
+          "dijkstra_path_length",
+          "dijkstra_predecessor_and_distance",
+          "johnson",
+          "multi_source_dijkstra",
+          "multi_source_dijkstra_path",
+          "multi_source_dijkstra_path_length",
+          "single_source_dijkstra",
+          "single_source_dijkstra_path",
+          "single_source_dijkstra_path_length"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "dijkstra_path": [
+            "G",
+            "source",
+            "target",
+            "weight"
+          ],
+          "dijkstra_path_length": [
+            "G",
+            "source",
+            "target",
+            "weight"
+          ],
+          "single_source_dijkstra_path": [
+            "G",
+            "source",
+            "cutoff",
+            "weight"
+          ],
+          "single_source_dijkstra_path_length": [
+            "G",
+            "source",
+            "cutoff",
+            "weight"
+          ],
+          "single_source_dijkstra": [
+            "G",
+            "source",
+            "target",
+            "cutoff",
+            "weight"
+          ],
+          "multi_source_dijkstra_path": [
+            "G",
+            "sources",
+            "cutoff",
+            "weight"
+          ],
+          "multi_source_dijkstra_path_length": [
+            "G",
+            "sources",
+            "cutoff",
+            "weight"
+          ],
+          "multi_source_dijkstra": [
+            "G",
+            "sources",
+            "target",
+            "cutoff",
+            "weight"
+          ],
+          "dijkstra_predecessor_and_distance": [
+            "G",
+            "source",
+            "cutoff",
+            "weight"
+          ],
+          "all_pairs_dijkstra": [
+            "G",
+            "cutoff",
+            "weight"
+          ],
+          "all_pairs_dijkstra_path_length": [
+            "G",
+            "cutoff",
+            "weight"
+          ],
+          "all_pairs_dijkstra_path": [
+            "G",
+            "cutoff",
+            "weight"
+          ],
+          "bidirectional_dijkstra": [
+            "G",
+            "source",
+            "target",
+            "weight"
+          ],
+          "johnson": [
+            "G",
+            "weight"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.algorithms.shortest_paths",
+        "module": "unweighted",
+        "functions": [
+          "all_pairs_shortest_path_length",
+          "bidirectional_shortest_path",
+          "single_source_shortest_path",
+          "single_source_shortest_path_length",
+          "single_target_shortest_path",
+          "single_target_shortest_path_length"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "single_source_shortest_path_length": [
+            "G",
+            "source",
+            "cutoff"
+          ],
+          "single_target_shortest_path_length": [
+            "G",
+            "target",
+            "cutoff"
+          ],
+          "all_pairs_shortest_path_length": [
+            "G",
+            "cutoff"
+          ],
+          "bidirectional_shortest_path": [
+            "G",
+            "source",
+            "target"
+          ],
+          "single_source_shortest_path": [
+            "G",
+            "source",
+            "cutoff"
+          ],
+          "single_target_shortest_path": [
+            "G",
+            "target",
+            "cutoff"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.algorithms.community",
+        "module": "snap_cmty",
+        "functions": [
+          "community_CNM",
+          "community_girvan_newman"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "community_CNM": [
+            "graph"
+          ],
+          "community_girvan_newman": [
+            "graph"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.utils",
+        "module": "misc",
+        "functions": [
+          "pairwise"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "pairwise": [
+            "iterable",
+            "cyclic"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.utils",
+        "module": "decorator",
+        "functions": [
+          "append",
+          "contextmanager",
+          "decorate",
+          "decorator",
+          "dispatch_on"
+        ],
+        "classes": [
+          "ContextManager",
+          "FunctionMaker"
+        ],
+        "function_signatures": {
+          "decorate": [
+            "func",
+            "caller",
+            "extras"
+          ],
+          "decorator": [
+            "caller",
+            "_func"
+          ],
+          "contextmanager": [
+            "func"
+          ],
+          "append": [
+            "a",
+            "vancestors"
+          ],
+          "dispatch_on": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.utils",
+        "module": "decorators",
+        "functions": [
+          "nodes_or_number",
+          "not_implemented_for"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "nodes_or_number": [
+            "which_args"
+          ],
+          "not_implemented_for": []
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.generators",
+        "module": "classic",
+        "functions": [
+          "empty_graph",
+          "path_graph"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "empty_graph": [
+            "n",
+            "create_using",
+            "default"
+          ],
+          "path_graph": [
+            "n",
+            "create_using"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      },
+      {
+        "package": "snapx.snapx.generators",
+        "module": "ego",
+        "functions": [
+          "ego_graph"
+        ],
+        "classes": [],
+        "function_signatures": {
+          "ego_graph": [
+            "G",
+            "n",
+            "radius",
+            "sample",
+            "traversal",
+            "copy_attr"
+          ]
+        },
+        "description": "Discovered via AST scan"
+      }
+    ],
+    "cli_commands": [],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "blackbox",
+      "confidence": 0.9
+    },
+    "dependencies": {
+      "required": [
+        "python (runtime)",
+        "snapx package modules under source.snapx.snapx"
+      ],
+      "optional": [
+        "networkx (for interoperability paths in convert layer, if used)",
+        "compiled SNAP/SWIG extension for source.swig.snap usage",
+        "numpy/scipy (only if specific algorithm paths request them indirectly)"
+      ]
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.82,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/snap-stanford/snap-python",
+    "repo_name": "snap-python",
+    "error": "DeepWiki analysis failed",
+    "model": "gpt-5.3-codex",
+    "source": "llm_direct_analysis",
+    "success": false
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-5.3-codex"
+  },
+  "risk": {
+    "import_feasibility": 0.82,
+    "intrusiveness_risk": "low",
+    "complexity": "medium"
+  }
+}

snap-python/mcp_output/diff_report.md

@@ -0,0 +1,133 @@
+# Difference Report — `snap-python`
+
+**Generated:** 2026-03-11 23:35:38  
+**Repository:** `snap-python`  
+**Project Type:** Python library  
+**Scope:** Basic functionality  
+**Change Intrusiveness:** None  
+**Workflow Status:** ✅ Success  
+**Test Status:** ❌ Failed  
+
+---
+
+## 1) Project Overview
+
+This change set introduces **8 new files** with **no modifications** to existing files.  
+The update appears to be an additive baseline increment for core/library scaffolding or initial feature enablement, with no direct refactors to current code paths.
+
+---
+
+## 2) Change Summary
+
+| Metric | Value |
+|---|---|
+| New files | 8 |
+| Modified files | 0 |
+| Deleted files | 0 (not reported) |
+| Intrusive changes | None |
+| CI/Workflow | Success |
+| Tests | Failed |
+
+### Interpretation
+- The delivery is structurally low-risk in terms of regressions to existing files.
+- However, **failed tests** indicate integration, environment, or quality-gate issues that currently block confidence in release readiness.
+
+---
+
+## 3) Difference Analysis
+
+## 3.1 Functional Delta
+- Since only new files were added, this likely introduces:
+  - new module(s), utility code, or packaging/config artifacts,
+  - potential test assets and/or docs scaffolding.
+- No existing behavior is explicitly rewritten, but runtime behavior can still change if imports, entry points, or package discovery now include new modules.
+
+## 3.2 Risk Profile
+- **Code churn risk:** Low (no modified files).
+- **Integration risk:** Medium (new files can alter dependency graph, import order, packaging metadata, or test discovery).
+- **Release risk:** Medium–High due to failed tests.
+
+---
+
+## 4) Technical Analysis
+
+## 4.1 CI vs Test Signal
+- **Workflow success + test failure** commonly means:
+  1. Pipeline execution succeeded technically (jobs ran to completion),
+  2. but quality gate failed at the test stage.
+
+## 4.2 Likely Failure Categories (for additive-only changes)
+- Missing/incorrect test fixtures for new modules.
+- Import path or package init issues (`__init__.py`, relative imports, namespace package behavior).
+- Dependency/version mismatch introduced by new files or metadata.
+- Pytest discovery picking up incomplete tests or placeholders.
+- Type/runtime assumptions not met in CI environment.
+
+## 4.3 Maintainability Impact
+- Additive changes improve extensibility if structured cleanly.
+- Without passing tests, maintainability confidence is reduced (uncertain behavior contract).
+
+---
+
+## 5) Recommendations & Improvements
+
+## 5.1 Immediate (Blocker Resolution)
+1. **Triage failing tests first**
+   - Identify exact failing test cases and stack traces.
+   - Classify as: test defect vs implementation defect vs environment defect.
+2. **Run focused local reproduction**
+   - Re-run with verbose output (`-vv`) and isolated target modules.
+3. **Validate packaging/import topology**
+   - Confirm module discovery and path correctness for all 8 new files.
+4. **Stabilize CI matrix**
+   - Verify Python version compatibility and dependency lock consistency.
+
+## 5.2 Quality Hardening
+- Add/expand unit tests for each new file’s primary behavior.
+- Include smoke tests for package import and minimal public API usage.
+- Enforce lint/type checks (if not already gated): `ruff/flake8`, `mypy/pyright`.
+- Add coverage threshold for newly introduced modules.
+
+## 5.3 Process Improvements
+- Require “tests pass” as mandatory merge gate.
+- Include a brief architectural note for newly added modules (purpose, ownership, API boundary).
+- Add changelog entry describing user-visible impact (if any).
+
+---
+
+## 6) Deployment Information
+
+**Deployment Readiness:** ❌ **Not ready for production release** (due to failed tests)
+
+### Pre-deployment checklist
+- [ ] All test suites pass in CI
+- [ ] New files validated for packaging/distribution inclusion
+- [ ] Dependency graph unchanged or reviewed
+- [ ] Versioning/changelog updated
+- [ ] Rollback strategy documented (if release proceeds)
+
+---
+
+## 7) Future Planning
+
+## 7.1 Short-term (next iteration)
+- Resolve current failures and re-run full CI.
+- Add regression tests specifically tied to new modules/files.
+- Confirm backward compatibility of public APIs.
+
+## 7.2 Mid-term
+- Establish module-level ownership and code health KPIs.
+- Introduce automated release notes based on file-level changes.
+- Add contract tests for library consumers (import + basic call flows).
+
+## 7.3 Long-term
+- Maintain a stable compatibility matrix across Python versions.
+- Implement semantic versioning discipline tied to API impact.
+- Improve observability of test failures (flaky test detection, trend dashboards).
+
+---
+
+## 8) Executive Conclusion
+
+The current diff is **additive and non-intrusive** (8 new files, 0 modified), which is favorable for controlled evolution of the library.  
+However, **failed tests are a hard release blocker**. Priority should be given to failure triage, import/packaging verification, and targeted test stabilization before deployment.

snap-python/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,383 @@
+import os
+import sys
+import importlib
+import importlib.util
+from typing import Any, Dict, Optional, Tuple
+
+source_path = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+    "source",
+)
+sys.path.insert(0, source_path)
+
+
+class Adapter:
+    """
+    Import-mode adapter for snap-python repository integration.
+
+    This adapter attempts to import repository-local modules discovered by analysis and
+    exposes callable wrappers with unified response dictionaries.
+
+    All public methods return:
+    {
+        "status": "success" | "error" | "fallback",
+        "mode": "import" | "fallback",
+        ...
+    }
+    """
+
+    # -------------------------------------------------------------------------
+    # Lifecycle and module management
+    # -------------------------------------------------------------------------
+    def __init__(self) -> None:
+        """
+        Initialize adapter in import mode and attempt best-effort module loading.
+        """
+        self.mode = "import"
+        self._modules: Dict[str, Any] = {}
+        self._import_errors: Dict[str, str] = {}
+        self._load_modules()
+
+    def _result(self, status: str, **kwargs: Any) -> Dict[str, Any]:
+        data = {"status": status, "mode": self.mode}
+        data.update(kwargs)
+        return data
+
+    def _safe_import(self, key: str, module_path: str) -> None:
+        try:
+            self._modules[key] = importlib.import_module(module_path)
+        except Exception as e:
+            self._modules[key] = None
+            self._import_errors[key] = (
+                f"Failed to import '{module_path}'. "
+                f"Ensure repository source is available under '{source_path}' and dependencies are installed. "
+                f"Details: {e}"
+            )
+
+    def _load_hyphen_module(self, key: str, relative_path: str) -> None:
+        abs_path = os.path.join(source_path, relative_path)
+        try:
+            if not os.path.exists(abs_path):
+                raise FileNotFoundError(
+                    f"Module file not found at '{abs_path}'. Check repository extraction path."
+                )
+            spec = importlib.util.spec_from_file_location(key, abs_path)
+            if spec is None or spec.loader is None:
+                raise ImportError(
+                    f"Could not create import spec for '{abs_path}'."
+                )
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            self._modules[key] = module
+        except Exception as e:
+            self._modules[key] = None
+            self._import_errors[key] = (
+                f"Failed to load module from '{abs_path}'. "
+                f"Verify file presence and Python compatibility. Details: {e}"
+            )
+
+    def _load_modules(self) -> None:
+        """
+        Load all discovered modules/classes/functions from analysis.
+        """
+        # Classes in setup modules
+        self._safe_import("setup_setup", "setup")
+        self._safe_import("swig_setup", "swig.setup")
+
+        # Functions in standard importable module
+        self._safe_import("genClassFnExt", "swig.gen.genClassFn.archive.genClassFnExt")
+
+        # Functions in modules with hyphenated filenames (manual load)
+        self._load_hyphen_module("disp_custom", os.path.join("swig", "gen", "disp-custom.py"))
+        self._load_hyphen_module("tneanet_cpp", os.path.join("dev", "examples", "tneanet-cpp.py"))
+        self._load_hyphen_module("snapswig_check", os.path.join("dev", "examples", "snapswig-check.py"))
+
+        if self._import_errors:
+            self.mode = "fallback"
+
+    def health_check(self) -> Dict[str, Any]:
+        """
+        Return adapter/module import status.
+
+        Returns:
+            dict: Unified status payload with loaded module keys and import errors.
+        """
+        loaded = [k for k, v in self._modules.items() if v is not None]
+        return self._result(
+            "success" if not self._import_errors else "fallback",
+            loaded_modules=loaded,
+            import_errors=self._import_errors,
+            guidance=(
+                "If imports failed, ensure the repository is present under the configured source path, "
+                "and install optional build/runtime dependencies for SWIG-based modules."
+            ),
+        )
+
+    # -------------------------------------------------------------------------
+    # Class instance creators
+    # -------------------------------------------------------------------------
+    def create_setup_swigbuild(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create instance of setup.SwigBuild.
+
+        Parameters:
+            *args: Positional arguments forwarded to setup.SwigBuild constructor.
+            **kwargs: Keyword arguments forwarded to setup.SwigBuild constructor.
+
+        Returns:
+            dict: status and created instance or actionable error.
+        """
+        module = self._modules.get("setup_setup")
+        if module is None or not hasattr(module, "SwigBuild"):
+            return self._result(
+                "fallback",
+                error="Class 'SwigBuild' in module 'setup' is unavailable.",
+                guidance="Ensure 'setup.py' is importable and supports runtime class instantiation.",
+            )
+        try:
+            instance = module.SwigBuild(*args, **kwargs)
+            return self._result("success", class_name="SwigBuild", instance=instance)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"Failed to instantiate setup.SwigBuild: {e}",
+                guidance="Check constructor arguments required by distutils/setuptools command classes.",
+            )
+
+    def create_setup_swigextension(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create instance of setup.SwigExtension.
+        """
+        module = self._modules.get("setup_setup")
+        if module is None or not hasattr(module, "SwigExtension"):
+            return self._result(
+                "fallback",
+                error="Class 'SwigExtension' in module 'setup' is unavailable.",
+                guidance="Ensure setup module loads successfully.",
+            )
+        try:
+            instance = module.SwigExtension(*args, **kwargs)
+            return self._result("success", class_name="SwigExtension", instance=instance)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"Failed to instantiate setup.SwigExtension: {e}",
+                guidance="Provide valid extension constructor parameters (name, sources, and config).",
+            )
+
+    def create_swig_setup_pkgbuild(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create instance of swig.setup.PkgBuild.
+        """
+        module = self._modules.get("swig_setup")
+        if module is None or not hasattr(module, "PkgBuild"):
+            return self._result(
+                "fallback",
+                error="Class 'PkgBuild' in module 'swig.setup' is unavailable.",
+                guidance="Ensure swig setup module is present and importable.",
+            )
+        try:
+            instance = module.PkgBuild(*args, **kwargs)
+            return self._result("success", class_name="PkgBuild", instance=instance)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"Failed to instantiate swig.setup.PkgBuild: {e}",
+                guidance="Verify arguments expected by build command classes.",
+            )
+
+    def create_swig_setup_swigextension(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Create instance of swig.setup.SwigExtension.
+        """
+        module = self._modules.get("swig_setup")
+        if module is None or not hasattr(module, "SwigExtension"):
+            return self._result(
+                "fallback",
+                error="Class 'SwigExtension' in module 'swig.setup' is unavailable.",
+                guidance="Ensure swig setup module import succeeds.",
+            )
+        try:
+            instance = module.SwigExtension(*args, **kwargs)
+            return self._result("success", class_name="SwigExtension", instance=instance)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"Failed to instantiate swig.setup.SwigExtension: {e}",
+                guidance="Pass valid extension initialization arguments.",
+            )
+
+    # -------------------------------------------------------------------------
+    # Function call wrappers
+    # -------------------------------------------------------------------------
+    def call_convert_esubgraph(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call swig.gen.disp-custom.ConvertESubGraph.
+
+        Parameters:
+            *args: Forwarded to ConvertESubGraph.
+            **kwargs: Forwarded to ConvertESubGraph.
+        """
+        module = self._modules.get("disp_custom")
+        if module is None or not hasattr(module, "ConvertESubGraph"):
+            return self._result(
+                "fallback",
+                error="Function 'ConvertESubGraph' is unavailable.",
+                guidance="Check swig/gen/disp-custom.py availability and compatibility.",
+            )
+        try:
+            result = module.ConvertESubGraph(*args, **kwargs)
+            return self._result("success", function="ConvertESubGraph", result=result)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"ConvertESubGraph execution failed: {e}",
+                guidance="Validate argument types and graph object compatibility.",
+            )
+
+    def call_convert_graph(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call swig.gen.disp-custom.ConvertGraph.
+        """
+        module = self._modules.get("disp_custom")
+        if module is None or not hasattr(module, "ConvertGraph"):
+            return self._result(
+                "fallback",
+                error="Function 'ConvertGraph' is unavailable.",
+                guidance="Check swig/gen/disp-custom.py load status.",
+            )
+        try:
+            result = module.ConvertGraph(*args, **kwargs)
+            return self._result("success", function="ConvertGraph", result=result)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"ConvertGraph execution failed: {e}",
+                guidance="Ensure provided graph parameters match expected SNAP/SWIG types.",
+            )
+
+    def call_convert_subgraph(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call swig.gen.disp-custom.ConvertSubGraph.
+        """
+        module = self._modules.get("disp_custom")
+        if module is None or not hasattr(module, "ConvertSubGraph"):
+            return self._result(
+                "fallback",
+                error="Function 'ConvertSubGraph' is unavailable.",
+                guidance="Check swig/gen/disp-custom.py and repository source path.",
+            )
+        try:
+            result = module.ConvertSubGraph(*args, **kwargs)
+            return self._result("success", function="ConvertSubGraph", result=result)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"ConvertSubGraph execution failed: {e}",
+                guidance="Review node/edge subset arguments and graph input types.",
+            )
+
+    def call_gen_func_call(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call swig.gen.genClassFn.archive.genClassFnExt.genFuncCall.
+        """
+        module = self._modules.get("genClassFnExt")
+        if module is None or not hasattr(module, "genFuncCall"):
+            return self._result(
+                "fallback",
+                error="Function 'genFuncCall' is unavailable.",
+                guidance="Ensure module swig.gen.genClassFn.archive.genClassFnExt imports correctly.",
+            )
+        try:
+            result = module.genFuncCall(*args, **kwargs)
+            return self._result("success", function="genFuncCall", result=result)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"genFuncCall execution failed: {e}",
+                guidance="Verify expected inputs for class/function generation utility.",
+            )
+
+    def call_get_func_name(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call swig.gen.genClassFn.archive.genClassFnExt.getFuncName.
+        """
+        module = self._modules.get("genClassFnExt")
+        if module is None or not hasattr(module, "getFuncName"):
+            return self._result(
+                "fallback",
+                error="Function 'getFuncName' is unavailable.",
+                guidance="Check import status for swig.gen.genClassFn.archive.genClassFnExt.",
+            )
+        try:
+            result = module.getFuncName(*args, **kwargs)
+            return self._result("success", function="getFuncName", result=result)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"getFuncName execution failed: {e}",
+                guidance="Provide input matching expected parser/line format.",
+            )
+
+    def call_remove_first_param(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call swig.gen.genClassFn.archive.genClassFnExt.removeFirstParam.
+        """
+        module = self._modules.get("genClassFnExt")
+        if module is None or not hasattr(module, "removeFirstParam"):
+            return self._result(
+                "fallback",
+                error="Function 'removeFirstParam' is unavailable.",
+                guidance="Ensure genClassFnExt module loaded without syntax/runtime issues.",
+            )
+        try:
+            result = module.removeFirstParam(*args, **kwargs)
+            return self._result("success", function="removeFirstParam", result=result)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"removeFirstParam execution failed: {e}",
+                guidance="Check parameter string structure before invoking this utility.",
+            )
+
+    def call_tneanet_cpp_main(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call dev.examples.tneanet-cpp.main.
+        """
+        module = self._modules.get("tneanet_cpp")
+        if module is None or not hasattr(module, "main"):
+            return self._result(
+                "fallback",
+                error="Function 'main' in tneanet-cpp is unavailable.",
+                guidance="Check file dev/examples/tneanet-cpp.py exists and is valid.",
+            )
+        try:
+            result = module.main(*args, **kwargs)
+            return self._result("success", function="tneanet_cpp.main", result=result)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"tneanet_cpp.main execution failed: {e}",
+                guidance="Confirm runtime prerequisites for example script are met.",
+            )
+
+    def call_snapswig_check_main(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call dev.examples.snapswig-check.main.
+        """
+        module = self._modules.get("snapswig_check")
+        if module is None or not hasattr(module, "main"):
+            return self._result(
+                "fallback",
+                error="Function 'main' in snapswig-check is unavailable.",
+                guidance="Check file dev/examples/snapswig-check.py exists and imports succeed.",
+            )
+        try:
+            result = module.main(*args, **kwargs)
+            return self._result("success", function="snapswig_check.main", result=result)
+        except Exception as e:
+            return self._result(
+                "error",
+                error=f"snapswig_check.main execution failed: {e}",
+                guidance="Ensure SWIG SNAP extension is built and importable before running checks.",
+            )

snap-python/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

snap-python/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,271 @@
+import os
+import sys
+
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+
+from setup import SwigExtension, SwigBuild
+from swig.setup import SwigExtension, PkgBuild
+from swig.gen.disp-custom import ConvertGraph, ConvertSubGraph, ConvertESubGraph
+from swig.gen.genClassFn.archive.genClassFnExt import removeFirstParam, genFuncCall, getFuncName
+from dev.examples.tneanet-cpp import main
+from dev.examples.snapswig-check import main
+
+mcp = FastMCP("unknown_service")
+
+
+@mcp.tool(name="swigbuild", description="SwigBuild class")
+def swigbuild(*args, **kwargs):
+    """SwigBuild class"""
+    try:
+        if SwigBuild is None:
+            return {"success": False, "result": None, "error": "Class SwigBuild is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = SwigBuild(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="swigextension", description="SwigExtension class")
+def swigextension(*args, **kwargs):
+    """SwigExtension class"""
+    try:
+        if SwigExtension is None:
+            return {"success": False, "result": None, "error": "Class SwigExtension is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = SwigExtension(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="pkgbuild", description="PkgBuild class")
+def pkgbuild(*args, **kwargs):
+    """PkgBuild class"""
+    try:
+        if PkgBuild is None:
+            return {"success": False, "result": None, "error": "Class PkgBuild is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = PkgBuild(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="swigextension", description="SwigExtension class")
+def swigextension(*args, **kwargs):
+    """SwigExtension class"""
+    try:
+        if SwigExtension is None:
+            return {"success": False, "result": None, "error": "Class SwigExtension is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = SwigExtension(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="ConvertESubGraph", description="Auto-wrapped function ConvertESubGraph")
+def ConvertESubGraph(payload: dict):
+    try:
+        if ConvertESubGraph is None:
+            return {"success": False, "result": None, "error": "Function ConvertESubGraph is not available"}
+        result = ConvertESubGraph(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="ConvertGraph", description="Auto-wrapped function ConvertGraph")
+def ConvertGraph(payload: dict):
+    try:
+        if ConvertGraph is None:
+            return {"success": False, "result": None, "error": "Function ConvertGraph is not available"}
+        result = ConvertGraph(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="ConvertSubGraph", description="Auto-wrapped function ConvertSubGraph")
+def ConvertSubGraph(payload: dict):
+    try:
+        if ConvertSubGraph is None:
+            return {"success": False, "result": None, "error": "Function ConvertSubGraph is not available"}
+        result = ConvertSubGraph(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="genFuncCall", description="Auto-wrapped function genFuncCall")
+def genFuncCall(payload: dict):
+    try:
+        if genFuncCall is None:
+            return {"success": False, "result": None, "error": "Function genFuncCall is not available"}
+        result = genFuncCall(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="getFuncName", description="Auto-wrapped function getFuncName")
+def getFuncName(payload: dict):
+    try:
+        if getFuncName is None:
+            return {"success": False, "result": None, "error": "Function getFuncName is not available"}
+        result = getFuncName(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="removeFirstParam", description="Auto-wrapped function removeFirstParam")
+def removeFirstParam(payload: dict):
+    try:
+        if removeFirstParam is None:
+            return {"success": False, "result": None, "error": "Function removeFirstParam is not available"}
+        result = removeFirstParam(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="main", description="Auto-wrapped function main")
+def main(payload: dict):
+    try:
+        if main is None:
+            return {"success": False, "result": None, "error": "Function main is not available"}
+        result = main(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="main", description="Auto-wrapped function main")
+def main(payload: dict):
+    try:
+        if main is None:
+            return {"success": False, "result": None, "error": "Function main is not available"}
+        result = main(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+
+def create_app():
+    """Create and return FastMCP application instance"""
+    return mcp
+
+if __name__ == "__main__":
+    mcp.run(transport="http", host="0.0.0.0", port=8000)

snap-python/mcp_output/requirements.txt

@@ -0,0 +1,5 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+snapx package modules under source.snapx.snapx

snap-python/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

snap-python/mcp_output/workflow_summary.json

@@ -0,0 +1,209 @@
+{
+  "repository": {
+    "name": "snap-python",
+    "url": "https://github.com/snap-stanford/snap-python",
+    "local_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/snap-python",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "medium",
+    "intrusiveness_risk": "low"
+  },
+  "execution": {
+    "start_time": 1773242722.183267,
+    "end_time": 1773243206.42227,
+    "duration": 484.23900389671326,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 2,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "source.snapx.snapx",
+        "source.swig.snap"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": false,
+      "pyproject": false,
+      "setup_cfg": false,
+      "setup_py": true
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.82,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/snap-stanford/snap-python",
+      "repo_name": "snap-python",
+      "error": "DeepWiki analysis failed",
+      "model": "gpt-5.3-codex",
+      "source": "llm_direct_analysis",
+      "success": false
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/snap-python/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "add a minimal CI pipeline (GitHub Actions) to build/install the SWIG extension and run both `test/` and `snapx/snapx/classes/tests/`",
+    "consolidate packaging into a single modern `pyproject.toml` (keep one `setup.py` path only) and define optional extras (e.g. `dev`",
+    "`docs`",
+    "`interop`)",
+    "add a top-level `requirements.txt` or lockfile for reproducible local/dev installs",
+    "deduplicate legacy `dev/` vs main `examples/` and `test/` trees to reduce maintenance drift",
+    "split the huge generated `setup/snap.py` into generated+checked artifacts with clear regeneration scripts and version pinning",
+    "standardize naming/style (many legacy test filenames and mixed conventions) and enforce with `ruff`/`black`/`isort`",
+    "introduce test markers for slow/integration/SWIG-dependent tests and publish baseline coverage",
+    "add smoke tests for key MCP endpoints and auto-generate endpoint docs from adapter metadata",
+    "improve README with a clear “pure Python snapx vs compiled SNAP/SWIG” architecture/install matrix",
+    "add typed public APIs for `snapx` (at least core graph/algorithms) and run `mypy` in CI",
+    "add benchmark automation comparing key algorithms across representative graph sizes and track regressions",
+    "add dependency/security scanning (Dependabot + pip-audit) and binary build checks across Python versions/platforms",
+    "add contributor docs for build toolchain prerequisites (SWIG/compiler) and a troubleshooting decision tree",
+    "remove or gate large test/example data files from source distribution where possible and fetch on demand",
+    "create a release checklist that validates wheel/sdist contents and MCP plugin compatibility before tagging"
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Workflow completed end-to-end with status=success across all planned nodes (download, analysis, env, generate, run, review, finalize).",
+      "Import-based adapter strategy was feasible (import_feasibility=0.82), enabling plugin startup without invasive code changes.",
+      "MCP plugin runtime checks passed (service_health=healthy, transport=stdio), confirming baseline service operability.",
+      "Low assessed intrusiveness risk reduced integration friction with legacy mixed codebase (snapx + SWIG layers)."
+    ],
+    "failure_reasons": [
+      "No hard workflow failure occurred.",
+      "Quality signal gap: original project tests were not executed successfully (passed=false with empty details), so behavioral equivalence is unverified.",
+      "DeepWiki enrichment failed, reducing external architectural/context confidence.",
+      "Telemetry incompleteness (0/unknown metrics for LOC, file size, CPU, memory, response time) limits objective performance validation."
+    ],
+    "overall_assessment": "good",
+    "node_performance": {
+      "download_time": "Repository ingest succeeded via zip fallback; effective for reliability, but likely slower/less metadata-rich than native clone.",
+      "analysis_time": "AST/module discovery covered a large surface (hundreds of functions/classes), indicating substantial analysis effort and likely primary time contributor.",
+      "generation_time": "Generation completed quickly enough to produce full plugin scaffold (entrypoint, adapter, service, docs, requirements) with no generation errors.",
+      "test_time": "MCP smoke/health checks passed, but project-level test execution was effectively absent; test stage is functionally incomplete for regression assurance."
+    },
+    "resource_usage": {
+      "memory_efficiency": "Unknown due to missing metrics; no OOM/failure signs, so operationally acceptable but not measurable.",
+      "cpu_efficiency": "Unknown due to missing CPU telemetry; long total runtime (~484s) suggests analysis/reflection overhead on large API surface.",
+      "disk_usage": "Generated artifact size reported as 0 (likely instrumentation issue); repository includes large files, so packaging/disk controls should be tightened."
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 74,
+    "architecture_score": 78,
+    "performance_score": 62,
+    "maintainability_score": 68,
+    "security_score": 85,
+    "scalability_score": 70
+  }
+}

snap-python/source/CREDITS.txt

@@ -0,0 +1,34 @@
+Snap.py is a Python interface for SNAP. SNAP is a general purpose, high
+performance system for analysis and manipulation of large networks. SNAP
+is written in C++ and optimized for maximum performance and compact graph
+representation. It easily scales to massive networks with hundreds of
+millions of nodes, and billions of edges.
+
+Snap.py provides performance benefits of SNAP, combined with flexibility
+of Python. Most of the SNAP functionality is available via Snap.py in Python.
+
+The following people contributed to the development of Snap.py (in
+alphabetical order):
+Ruth-Ann Armstrong
+Roger Chen
+Benoît Coste
+Carlos Hernandez
+Jihun Hong
+Farzaan Kaiyom
+Viswesh Krishna
+Daiki Kumazawa
+Jure Leskovec
+Stephen Macke
+Ben Pastel
+Karthik Ramachandran
+Sheila Ramaswamy
+Avery Rogers
+Nicholas Shelly
+Rok Sosic
+Ming Han Teh
+Cameron Tew
+Albert Zheng
+
+Special thanks go to the students in the 2013 class of CS224W at Stanford
+University, who helped with the initial version of the manuals and the beta
+releases of Snap.py.

snap-python/source/LICENSE

@@ -0,0 +1,24 @@
+* Copyright (c) 2007-2019, Jure Leskovec
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above copyright
+*       notice, this list of conditions and the following disclaimer in the
+*       documentation and/or other materials provided with the distribution.
+*     * Neither the name of Stanford University nor the names of its contributors
+*       may be used to endorse or promote products derived from this software
+*       without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

snap-python/source/MANIFEST.in

@@ -0,0 +1 @@
+include snap/__init__.py

snap-python/source/Makefile

@@ -0,0 +1,26 @@
+#
+#	Top level Python SNAP Makefile
+#
+
+.PHONY: swig test examples
+
+build: swig
+
+#all: swig-r swig-sw test examples
+all: swig test examples
+
+# run SWIG and create Python interface code
+swig:
+	make -C swig
+
+# run tests
+test:
+	make -C test
+
+examples:
+	make -C examples
+  
+clean:
+	make -C swig clean
+	make -C test clean
+	make -C examples clean

snap-python/source/Makefile.config

@@ -0,0 +1,174 @@
+#
+#	compilation parameters for SNAP Python
+#
+
+UNAME := $(shell uname)
+SETUP = setup.py
+
+ifeq ($(UNAME), Linux)
+  # Linux flags
+  SWIGFLAGS += -D_CMPWARN -D__stdcall -DSW_SNAPPY -D_OPENMP -DNONUMPY -DUSE_OPENMP -DGCC_ATOMIC
+  CXXFLAGS += -fPIC -D__STDC_LIMIT_MACROS -DSW_SNAPPY -fopenmp
+  MANIFEST = MANIFEST.nx
+  MANIFEST_IN = MANIFEST.in.nx
+  PYTHON = python
+  PYTHON3 = python3
+  # SNAP_PY is set externally for the manylinux1 environment
+  ifeq ($(SNAP_PY), 3.9)
+    IFLAGS3 = -I/opt/python/cp39-cp39/include/python3.9
+    LDFLAGS3 += -shared -fopenmp
+    PYTHON3 = /opt/python/cp39-cp39/bin/python3
+  else ifeq ($(SNAP_PY), 3.8)
+    IFLAGS3 = -I/opt/python/cp38-cp38/include/python3.8
+    LDFLAGS3 += -shared -fopenmp
+    PYTHON3 = /opt/python/cp38-cp38/bin/python3
+  else ifeq ($(SNAP_PY), 3.7)
+    IFLAGS3 = -I/opt/python/cp37-cp37m/include/python3.7m
+    LDFLAGS3 += -shared -fopenmp
+    PYTHON3 = /opt/python/cp37-cp37m/bin/python3
+  else ifeq ($(SNAP_PY), 3.6)
+    IFLAGS3 = -I/opt/python/cp36-cp36m/include/python3.6m
+    LDFLAGS3 += -shared -fopenmp
+    PYTHON3 = /opt/python/cp36-cp36m/bin/python3
+  else ifeq ($(SNAP_PY), 3.5)
+    IFLAGS3 = -I/opt/python/cp35-cp35m/include/python3.5m
+    LDFLAGS3 += -shared -fopenmp
+    PYTHON3 = /opt/python/cp35-cp35m/bin/python3
+  else ifeq ($(SNAP_PY), 2.7m)
+    IFLAGS = -I/opt/python/cp27-cp27m/include/python2.7
+    LDFLAGS += -shared -fopenmp
+    PYTHON = /opt/python/cp27-cp27m/bin/python2
+  else ifeq ($(SNAP_PY), 2.7mu)
+    IFLAGS = -I/opt/python/cp27-cp27mu/include/python2.7
+    LDFLAGS += -shared -fopenmp
+    PYTHON = /opt/python/cp27-cp27mu/bin/python2
+  else
+    IFLAGS ?= -I/usr/include/python2.6 -I/usr/include/python2.7 -I/usr/lib/python2.7/dist-packages/numpy/core/include
+    IFLAGS3 ?= -I/usr/local/include/python3.7m  -I/usr/include/python3.7m
+    IFLAGS3 += -I/usr/local/include/python3.6m  -I/usr/include/python3.6m
+    IFLAGS3 += -I/usr/local/include/python3.5m  -I/usr/include/python3.5m
+    LDFLAGS += -shared -fopenmp
+    LDFLAGS3 += -shared -fopenmp
+  endif
+else ifeq ($(UNAME), Darwin)
+  # OS X flags
+  CC = g++
+  SWIGFLAGS += -D_CMPWARN -D__stdcall -DSW_SNAPPY -DNONUMPY
+  CXXFLAGS = -std=c++98 -fwrapv -Wall -Wno-unknown-pragmas -O3 -DNDEBUG -DNOMP -DSW_SNAPPY
+  CXXFLAGS += -DSW_SNAPPY
+
+  MANIFEST = MANIFEST.mac
+  MANIFEST_IN = MANIFEST.in.nx
+  PYTHON = python
+  PYTHON3 = python3
+  IFLAGS = -I/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/usr/include
+  IFLAGS3 = $(IFLAGS)
+  LDFLAGS = -bundle -undefined dynamic_lookup
+  LDFLAGS += -L/usr/local/opt/readline/lib -L/usr/local/opt/openssl@1.1/lib
+  LDFLAGS3 = $(LDFLAGS)
+  # SNAP_PY is set externally for the python build environment
+  ifeq ($(SNAP_PY), 2.7)
+    PYPATH = /Users/rok/.pyenv/versions/2.7.18
+    CXXFLAGS += -fno-strict-aliasing
+    IFLAGS += -I$(PYPATH)/include/python2.7
+    LDFLAGS += -L$(PYPATH)/lib
+  else ifeq ($(SNAP_PY), 3.5)
+    PYPATH = /Users/rok/.pyenv/versions/3.5.10
+    IFLAGS3 += -I$(PYPATH)/include/python3.5m
+    LDFLAGS3 += -L$(PYPATH)/lib
+  else ifeq ($(SNAP_PY), 3.6)
+    PYPATH = /Users/rok/.pyenv/versions/3.6.12
+    IFLAGS3 += -I$(PYPATH)/include/python3.6m
+    LDFLAGS3 += -L$(PYPATH)/lib
+  else ifeq ($(SNAP_PY), 3.7)
+    PYPATH = /Users/rok/.pyenv/versions/3.7.9
+    IFLAGS3 += -I$(PYPATH)/include/python3.7m
+    LDFLAGS3 += -L$(PYPATH)/lib
+  else ifeq ($(SNAP_PY), 3.8)
+    PYPATH = /Users/rok/.pyenv/versions/3.8.6
+    IFLAGS3 += -I$(PYPATH)/include/python3.8
+    LDFLAGS3 += -L$(PYPATH)/lib
+  else ifeq ($(SNAP_PY), 3.9)
+    PYPATH = /Users/rok/.pyenv/versions/3.9.0
+    IFLAGS3 += -I$(PYPATH)/include/python3.9
+    LDFLAGS3 += -L$(PYPATH)/lib
+  else
+
+    # the build environment is not specified, try to figure out the parameters
+    PY_CONDA3 := $(shell which python3 | grep conda3)
+    PY_BREW   := $(shell which python3 | grep local)
+
+    IFLAGS := $(shell python-config --includes)
+    IFLAGS3 := $(shell python3-config --includes)
+    LDFLAGS := $(shell python-config --ldflags) -dynamiclib -headerpad_max_install_names
+    LDFLAGS3 := $(shell python3-config --ldflags) -dynamiclib -headerpad_max_install_names
+    CLANG := $(shell g++ -v 2>&1 | grep clang | cut -d " " -f 2)
+    ifeq ($(CLANG), LLVM)
+      CXXFLAGS += -DNOMP
+      CXXOPENMP =
+    else ifeq ($(CLANG), clang)
+      CXXFLAGS += -DNOMP
+      CXXOPENMP =
+    else
+      #SWIGFLAGS += -DGCC_ATOMIC
+      CXXFLAGS += -fopenmp
+      LDFLAGS += -fopenmp
+      #CXXOPENMP += -fopenmp
+    endif
+    ifneq ($(PY_CONDA3), )
+      CC = x86_64-apple-darwin13.4.0-clang
+      CXXFLAGS  = -std=c++98 -Wall -Wno-unknown-pragmas -O3
+      CXXFLAGS += -fPIC -flto -mmacosx-version-min=10.9
+      CXXFLAGS += -DNDEBUG -DSW_SNAPPY -DNOMP
+      CXXFLAGS += -isystem $(CONDA_PREFIX)/include
+      IFLAGS3   = -I$(CONDA_PREFIX)/include/python3.7m
+      LDFLAGS3  = -bundle -undefined dynamic_lookup -flto -arch x86_64 -mmacosx-version-min=10.9
+      LDFLAGS3 += -isystem $(CONDA_PREFIX)/include
+      LDFLAGS3 += -L$(CONDA_PREFIX)/lib
+      LIBS      =
+    endif
+
+    ifneq ($(PY_BREW), )
+      CC = clang
+      CXXFLAGS  = -std=c++98 -Wall -Wno-unknown-pragmas -O3
+      CXXFLAGS += -dynamic
+      CXXFLAGS += -DNDEBUG -DSW_SNAPPY -DNOMP
+      CXXFLAGS += -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk
+      IFLAGS3   = -I/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/usr/include
+      IFLAGS3  += -I/Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk/System/Library/Frameworks/Tk.framework/Versions/8.5/Headers
+      IFLAGS3  += -I/usr/local/include
+      IFLAGS3  += -I/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7/include/python3.7m
+      LDFLAGS3  = -bundle -undefined dynamic_lookup -flto
+      LDFLAGS3 += -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX10.14.sdk
+      LDFLAGS3 += -L/usr/local/lib
+      LIBS      =
+    endif
+  endif
+
+else ifeq ($(shell uname -o), Cygwin)
+  # Cygwin flags
+  SWIGFLAGS += -D_CMPWARN -D__stdcall -DSW_SNAPPY -DNONUMPY
+  CXXFLAGS += -shared -D__STDC_LIMIT_MACROS -DSW_SNAPPY
+  LIBS += -lpython2.6
+  MANIFEST = MANIFEST.win
+  MANIFEST_IN = MANIFEST.in.win
+
+  ifeq ($(SNAP_PY), 2.7)
+    PYTHON = /cygdrive/c/Python27/python
+  else ifeq ($(SNAP_PY), 3.5)
+    PYTHON = /cygdrive/c/Program\ Files/Python35/python
+  else ifeq ($(SNAP_PY), 3.6)
+    PYTHON = /cygdrive/c/Program\ Files/Python36/python
+  else ifeq ($(SNAP_PY), 3.7)
+    PYTHON = /cygdrive/c/Program\ Files/Python37/python
+  else ifeq ($(SNAP_PY), 3.8)
+    PYTHON = /cygdrive/c/Program\ Files/Python38/python
+  else ifeq ($(SNAP_PY), 3.9)
+    PYTHON = /cygdrive/c/Program\ Files/Python39/python
+  endif
+else
+  PYTHON = "/cygdrive/c/Program\ Files/Python37/python"
+endif
+
+SWIGFLAGS3 += $(SWIGFLAGS)
+

snap-python/source/README.md

@@ -0,0 +1,112 @@
+snap-python
+===========
+
+1. Install SWIG for your platform (see below).  Swig should be able to run from the command-line.
+
+2. Checkout the snap-python repository as well as the SNAP C++ repository.
+
+		git clone git@github.com:snap-stanford/snap-python.git
+		git clone git@github.com:snap-stanford/snap.git
+
+2. Then, run `make` from the top-level of `snap-python`. This will make the SNAP code into a Python module, using SWIG.  Finally, it will run some Python tests in the `test` directory.
+
+		cd snap-python
+		make
+
+	From a Python interpreter, you should be able to import `snap` module:
+
+		$ python
+		>>> import sys
+		>>> sys.path.append("swig")
+		>>> import snap
+
+3. There are some examples in the `examples` directory.  For example, to run benchmarks:
+
+		$ cd examples
+		$ python benchmark.py -h
+		usage: benchmark.py [-h] [-v] [-r RANGE] [-e EDGES_DEG] [-d] [-t GRAPH_TYPES]
+		                    [-n NUM_ITERATIONS] [-o OUTPUT_FILE] [-g] [-w]
+
+		optional arguments:
+		  -h, --help            show this help message and exit
+		  -v, --verbose         increase output verbosity
+		  -r RANGE, --range RANGE
+		                        range (4-6) (10^4 to 10^6 nodes)
+		  -e EDGES_DEG, --edges_deg EDGES_DEG
+		                        range of degrees (e.g "2-3" => (10^1 to 10^3 edges per
+		                        node)
+		  -d, --deterministic   deterministic benchmark
+		  -t GRAPH_TYPES, --graph_types GRAPH_TYPES
+		                        Graph types, comma separated. Available: rand_ungraph,
+		                        rand_ngraph, rmat, pref, sw
+		  -n NUM_ITERATIONS, --num_iterations NUM_ITERATIONS
+		                        number of iterations
+		  -o OUTPUT_FILE, --output_file OUTPUT_FILE
+		                        file to output results
+		  -g, --generate        generate new graphs
+		  -w, --write_graph     save graph
+		$ python benchmark.py -v -g -r 4-6	# needs about 4.3GB RAM and 4 min to run
+
+
+SWIG Installation
+-----------------
+
+### Linux
+
+Follow the instructions from SWIG's website: download, configure and make, [SWIG files](http://www.swig.org/download.html).  Or, use your built-in installer (a CentOS example):
+
+	sudo yum install swig
+
+### Mac OS X
+
+swig-1.3.12 and later support OS-X/Darwin.
+
+0. If you have ``homebrew``, simply hit ``brew install swig`` in terminal and ignore the rest of the instructions. Otherwise, download the Unix sources, configure, and build from the command terminal. This has been tested on 10.8.2. The following is adopted from [ColourBlomb](http://blog.colourbomb.net/?p=49).
+
+1. Download the Unix source from http://swig.org/download.html
+
+2. Moving to the terminal, extract the files from the tarball and move to the root directory of the SWIG install:
+
+		cd /Developer/SWIG
+		tar -xf swig-2.0.4.tar.gz
+		cd swig-2.0.4
+
+3. Run `./configure`.  This will produce an error if you don't have the PCRE (Perl Compatible Regular Expressions) library package installed. 
+This dependency is needed for configure to complete. Either:
+	- Install the PCRE developer package on your system (preferred approach).
+	- Download the PCRE source tarball, build and install on your system
+	as you would for any package built from source distribution.
+	- Use the `Tools/pcre-build.sh` script to build PCRE just for SWIG to statically
+	link against. Run `Tools/pcre-build.sh -help` for instructions.
+	(quite easy and does not require privileges to install PCRE on your system)
+	- Configure using the `-without-pcre` option to disable regular expressions support in SWIG
+	(not recommended).
+	See `config.log` for more details.
+		
+			make
+			sudo make install
+
+4. PCRE should now have successfully installed so move to the swig install directory and try `./configure` again:
+
+		cd ../swig-2.0.4
+		./configure
+
+	This time no errors are thrown so try and install:
+
+		make
+		sudo make install
+
+5. Once this has completed test that SWIG has installed correctly, type `swig` into the terminal and hopefully you'll get the response:
+  Must specify an input file. Use `-help` for available options.
+
+SWIG Benchmarks
+-----------------
+Example SWIG programs using the SNAP Ringo for multi-attribute edges are in the `examples` directory.  The benchmark program `benchmark.py` performs a series of functions on the graph data, including node/edge iteration, degree checks, clustering coefficients, largest weakly and strongest components, etc.  For R-MAT graphs with 1 million nodes and 10 million edges, this takes on average: 
+
+- On CentOS 6.3 with 2.66 GHz processor, 19.71 sec to generate a new graph and and 17.49 sec to run the tests.
+- On Mac OSX 10.8 with 2.6 GHz processor, 13.95 sec to generate and 15.06 sec to run the tests.
+	
+To run a benchmark test you can run the following command:
+
+	python benchmark.py --verbose -n 5 --range 4-7 --type rmat --generate
+

snap-python/source/RELEASE.txt

@@ -0,0 +1,203 @@
+Snap.py 6.0 Release Notes
+December 2020
+
+Snap.py is a Python interface for SNAP (Stanford Network Analysis Platform).
+SNAP is a general purpose, high performance system for analysis and
+manipulation of large networks. SNAP is written in C++ and optimized
+for maximum performance and compact graph representation. It easily scales
+to massive networks with hundreds of millions of nodes, and billions of edges.
+Snap.py provides performance benefits of SNAP, combined with flexibility
+of Python. Most of the SNAP functionality is available via Snap.py in Python.
+
+Snap.py 6.0 is a major release with a large number of new features, most
+notably a significantly improved way to call Snap.py functions in Python, a
+NetworkX compatibility layer, standard Python functions to handle SNAP vector
+and hash types, new functions for egonets and graph union, and a completely
+revised package building infrastructure with a better support for various
+versions of Python. These enhancements are backward compatible, so existing
+Snap.py based programs should continue to work.
+
+A high-level description of changes in Snap.py releases is provided below.
+
+Release 6.0.0, Dec 28, 2020
+
+- implemented pylayer, a significantly improved way to call SNAP C++ functions
+  - standalone functions are available as class methods
+  - built-in Python classes (lists, dictionaries) can be provided as parameters
+  - results are available as return values rather than as reference parameters
+  - support for optional parameters has been enhanced
+- implemented SnapX, a NetworkX compatible graph manipulation layer, as a
+  module within Snap.py
+- implemented standard Python interface functions for SNAP vector and hash
+  types to be compatible with Python lists and dictionaries
+- implemented new functions to calculate egonets, GetEgonet, GetEgonetHop,
+  GetInEgonetHop, GetOutEgonetHop, GetInEgonetSub
+- implemented new functions to perform graph union, GetGraphUnion,
+  GetGraphUnionAttr
+- added Dockerfile to containerize a release
+- replaced setup.py with a completely new implementation
+- added scripts for building wheel packages on macOS, Linux and Windows
+- performed a large number of updates in Makefiles
+- performed a major rewrite and extensions of the Snap.py documentation
+- expanded functionality tests
+- added a program to test the speed of various methods for writing and
+  reading a graph
+- fixed formatting problems in creating the documentation with Sphinx
+- added hellotest, a simple module to test the building of Python C/C++
+
+Release 5.0.0, Aug 30, 2019
+
+- implemented support for py3
+- implemented wheel packages and pip for py2 and py3
+- updated tests and documentation for py3
+- updated other python code for the py3 print function
+- upgraded build platforms to Ubuntu 18.04, macOS 14.10, Windows 10
+- upgraded Visual Studio files to VS2019
+- updated install_name_tool to the version from High Sierra 10.13
+- updated setup.py from distutils to setuptools
+- improved the tests for generated files, such as gnuplot files
+- removed the need for Unix dependent commands grep and rm in tests
+- commented out tests for PNG files, since these differ on various platforms
+- implemented various other improvements in tests
+- improved the update_dynlib.sh script 
+- improved the package build process
+- added a license text
+- added troubleshooting notes
+- improved documentation on graph creation
+- updated conf.py for the next release
+
+Release 4.1.0, Jul 27, 2018
+
+- updated C++ codebase to SNAP 4.1
+- implemented GetSubGraphRenumber()
+- implemented GetLen2Paths()
+- implemented GetEigVec()
+- implemented GetSngVec()
+- implemented GetBfsEffDiamAll()
+- implemented GetClustCfAll()
+- implemented GetTriadsAll()
+- implemented GetNodeTriadsAll()
+- improved support for node2vec
+- expanded the set of supported node iterator methods
+- defined TFltVFltV
+- added test programs for gnuplot and Graphviz
+- improved documentation for GetEdgesInOut()
+- improved documentation for GetSubTreeSz()
+- improved documentation for IsTree()
+- improved documentation for GetMxNId()
+- improved documentation for CommunityCNM()
+- improved documentation for CommunityCNM()
+- improved documentation for GetRndNId()
+- performed other minor updates in the documentation
+
+Release 4.0.0, Jul 28, 2017
+
+- updated C++ codebase to SNAP 4.0
+- added a test for TTable
+- minor updates in the documentation
+
+Release 3.0.2, Oct  7, 2016
+
+- fixed a missing ToNetwork() function
+- fixed a few issues with documentation
+- further improved Anaconda Python handling in setup.py
+
+Release 3.0.1, Sep 28, 2016
+
+- improved setup.py for installations with Anaconda Python
+
+Release 3.0.0, Sep 14, 2016
+
+- this is a major release with many new features
+- version number synced up with SNAP
+- updated C++ codebase to SNAP 3.0
+- added support for new classes: multimodal networks TMMNet, TModeNet,
+  TCrossNet, TDirNet, TUndirNet, TNGraphMP, TNEANetMP
+- included support for GetBetweennessCentr(), GetClosenessCentr(),
+  GetFarnessCentr() on TUNGraph(), TNGraph(), TNEANet()
+- implemented multithreaded execution of many operations on Linux and Mac OS X
+- extended test suite in snap-test.py
+- added a batch script for testing on Windows
+- fixed attributes in TNEANet and added a test
+- fixed edge iterators and added a test
+- fixed edge deletion in TNEANet and added a test
+- fixed LoadConnListStr() and added a test
+- fixed LoadEdgeListStr() and added a test
+- fixed GetBfsTree() and added a test
+- fixed GetBetweennessCentr() and added a test
+- fixed GetClosenessCentr() and added a test
+- fixed GetFarnessCentr() and added a test
+- fixed THashKeyDatI and added a test
+- added a test for vector operations
+- extended Makefile with support for new classes: multimodal networks TMMNet,
+  TModeNet, TCrossNet, TNGraphMP, TNEANetMP
+- added documentation for multimodal networks TMMNet
+- added documentation for tables TTable
+- added documentation for conversion of tables to graphs
+- added documentation for sparse attributes
+- added documentation for TUndirNet, TDirNet
+- added documentation for sparse attributes for TNEANet
+- fixed documentation for LoadConnListStr(), LoadEdgeListStr()
+- added GetDat() to documentation on THash
+- fixed a minor typo in documentation for PlotSccDistr()
+
+Release 1.2, May 12, 2015
+
+- updated C++ codebase to SNAP 2.4
+- implemented and documented IsAttrDeletedN(), IsIntAttrDeletedN(),
+  IsFltAttrDeletedN(), IsStrAttrDeletedN(), IsAttrDeletedE(),
+  IsIntAttrDeletedE(), IsFltAttrDeletedE(), IsStrAttrDeletedE(),
+  GetNIdV(), GetEIdV(), GetRndEI()
+- implemented GetIntAttrIndDatE(), GetFtlAttrIndDatE(), GetStrAttrIndDatE()
+- implemented and documented GetAttrIndN(), GetAttrIndE(), IntAttrNameNI(),
+  FltAttrNameNI(), StrAttrNameNI(), IntAttrValueNI(), FltAttrValueNI(),
+  StrAttrValueNI(), GetIntAttrIndDatN(), GetFltAttrIndDatN(),
+  GetStrAttrIndDatN()
+- expanded the code for the TNEAnet.GetEI()
+- changed THashSet iterator to use THashSetKeyI
+- fixed redefinition of Python built-in len() function
+- fixed error with THashSet iterator
+- fixed the code and the documentation for GetEI() in graphs and networks
+- improved tneanet.py, fixed a few typos
+- added tests for empty strings and nested iterators over TIntSet()
+- added programs for the bug reports from CS224W
+- added a bug program for GenRndPowerLaw()
+- added a code that reproduces problem with LoadEdgeListStr()
+- configured short compilation
+- updated documentation and test program for AttrNameNI(), AttrValueNI(),
+  AttrNameEI(), AttrValueEI()
+- documented GetIntAttrIndDatN(), GetFtlAttrIndDatN(), GetStrAttrIndDatN(), 
+  IntAttrNameEI(), FltAttrNameEI(), StrAttrNameEI(), IntAttrValueEI(),
+  FltAttrValueEI(), StrAttrValueEI()
+- updated typo in the documentation for GetNodeWcc()
+- improved documentation for GetNodesAtHop() and GetNodesAtHops()
+- fixed typos in documentation for GetMxSccSz
+- fixed the documentation about the THashKeyDatI Next() iterator
+- fixed errors in reference manual for GetOutDegCnt and GetInDegCnt
+- fixed an small bug in the sample code for GetMxSccSz in the reference manual
+- split documentation on node and edge attribute methods for TNEANet
+- fixed documentation for TNEANetEdgeI.GetId()
+- improved the documentation and a test for the set iterator
+- improved documentation on PrintInfo()
+
+Release 1.1, Jun 16, 2014
+
+- updated C++ codebase to SNAP 2.3
+- added support for installation with Anaconda or Homebrew python on Mac
+- added StackOverflow example
+- added AGM related functionality for community detection
+- added clique percolation method for community detection
+- added a test program and data for clique percolation method for
+  community detection
+- added OpenMP support
+- added more comprehensive tests
+- updated TVec and THash samples
+- added README.txt
+- updated Makefile for tests
+- improved top level Makefile
+
+Release 1.0, Mar 20, 2014
+
+- initial public release of Snap.py
+- included C++ codebase SNAP 2.2
+

snap-python/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+snap-python Project Package Initialization File
+"""

snap-python/source/dev/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

snap-python/source/dev/examples/Makefile

@@ -0,0 +1,14 @@
+#
+#	Makefile for running 
+#
+
+all: benchmark, tneanet
+
+benchmark:
+	python benchmark.py
+
+tneanet:
+	python tneanet.py
+
+clean:
+	rm -rf results *.graph

snap-python/source/dev/examples/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

snap-python/source/dev/examples/benchmark.py

@@ -0,0 +1,431 @@
+#!/usr/bin/python
+# benchmark.py
+#
+# Author: Nick Shelly, Spring 2013
+# Description:
+#     - Loads SNAP as a Python module.
+#     - Randomly generates a graph of specified size and type, and saves
+#         or loads the graph if it has already been created.
+#     - Benchmarks a number of "is this a good graph?" tests on the graph,
+#       calculating the amount of time required and appends to a file.
+#           
+#  usage: benchmark.py [-h] [-v] [-r RANGE] [-d] [-t GRAPH_TYPES]
+#    [-n NUM_ITERATIONS] [-o OUTPUT_FILE] [-g]
+#
+#  optional arguments:
+#    -h, --help            show this help message and exit
+#    -v, --verbose         increase output verbosity
+#    -r RANGE, --range RANGE
+#      range (4-6) (10^4 to 10^6 nodes)
+#    -d, --deterministic   deterministic benchmark
+#    -t GRAPH_TYPES, --graph_types GRAPH_TYPES
+#      Graph types, comma separated. Available: rand_ungraph,
+#      rand_ngraph, rmat, pref, sw
+#    -n NUM_ITERATIONS, --num_iterations NUM_ITERATIONS
+#      number of iterations
+#    -o OUTPUT_FILE, --output_file OUTPUT_FILE
+#      file to output results
+#    -g, --generate        generate new graphs
+#
+#   Examples:
+#   1. Use default arguments.
+#   $ python menchmark.py
+#   2. Generate deterministic RMAT graphs from 10^2-10^3 nodes, and
+#       run 3 times, outputing to results.txt.
+#   $ python benchmark.py -v -n 3 -g -d -r 2-3 -t rmat -o results/results.txt
+#
+
+import os.path
+import sys
+import argparse
+from socket import gethostname
+from time import clock
+from datetime import datetime
+
+sys.path.append("../swig-r")
+import snap
+
+PROPERTY_TYPES = [1, 10]  # 1=Triads, 10=BFS
+
+# Comma-separated, graph types:
+# 'rmat' - R-MAT
+# 'pref' - preferential attachment
+# 'sw' - small world
+# 'rand_ungraph' - random undirected
+# 'rand_ngraph' - random directed
+# 'rand_neanet' - random directed attribute
+# 'syn_ngraph' - random directed
+# 'syn_negraph' - synthetic multi-edge
+# 'syn_neanet' - synthetic directed multi-edge attribute
+
+DEFAULT_TYPES = "rand_neanet"
+
+# Average is 1, non-average is 0.
+DEFAULT_DEGREES = "1-2"  #  Default is 10x and 100x edges/node
+DEFAULT_WRITE = False
+SW_REWIRE_PROB = 0.1
+SYNTHETIC_DELTA = 10
+
+# Exponent range (e.g. 10^x to 10^y)
+DEFAULT_VERBOSE=True
+DEFAULT_RANGE = '3-4'
+DEFAULT_ITERATIONS = 1
+
+# Hostname for results
+HOSTNAME = gethostname()
+
+RESULTS_DIR = 'results'
+DEFAULT_RESULTS_FILE = os.path.join(RESULTS_DIR, 'results%s.txt' % \
+                            datetime.now().strftime('%m%d-%H%M%S'))
+
+def benchmark_ngraph(Graph):
+  '''
+  Perform benchmark tests for Directed Graphs
+  '''
+  
+  results = {}
+  results['num_nodes'] = Graph.GetNodes()
+  results['num_edges'] = Graph.GetEdges()
+  
+  for degree in range(0, 11):
+    num = snap.NodesGTEDegree_PNGraph(Graph, degree)
+    percent_deg = float(num) / results['num_nodes']
+    results['deg_gte_%d' % degree] = num
+    results['deg_gte_%d_percent' % degree] = percent_deg
+
+  # Check for over-weighted nodes
+  results['max_degree'] = snap.MxDegree_PNGraph(Graph)
+
+  num = snap.NodesGTEDegree_PNGraph(Graph, results['max_degree'])
+  results['max_degree_num'] = num
+  
+  results['max_wcc_percent'] = snap.MxWccSz_PNGraph(Graph) \
+    / results['num_nodes']
+  results['max_scc_percent'] = snap.MxSccSz_PNGraph(Graph).GetNodes() \
+    / results['num_nodes']
+
+  return results
+
+def benchmark_ungraph(Graph):
+  '''
+  Perform benchmark tests for Undirected Graphs
+  '''
+
+  results = {}
+  results['num_nodes'] = Graph.GetNodes()
+  results['num_edges'] = Graph.GetEdges()
+  
+  for degree in range(0,11):
+    num = snap.NodesGTEDegree_PUNGraph(Graph, degree)
+    percent_deg = float(num) / results['num_nodes']
+    results['deg_gte_%d' % degree] = num
+    results['deg_gte_%d_percent' % degree] = percent_deg
+  
+  # Check for over-weighted nodes
+  results['max_degree'] = snap.MxDegree_PUNGraph(Graph)
+  
+  num = snap.NodesGTEDegree_PUNGraph(Graph, results['max_degree'])
+  results['max_degree_num'] = num
+  results['max_wcc_percent'] = snap.MxWccSz_PUNGraph(Graph) \
+                                / results['num_nodes']
+  results['max_scc_percent'] = snap.MxSccSz_PUNGraph(Graph).GetNodes() \
+                                / results['num_nodes']
+
+  # TODO: Calculate graph skew
+  return results
+
+def benchmark_neanet(Graph):
+  '''
+    Perform benchmark tests for Directed Attribute Graphs
+    '''
+  
+  results = {}
+  results['num_nodes'] = Graph.GetNodes()
+  results['num_edges'] = Graph.GetEdges()
+  
+  for degree in range(0, 11):
+    num = snap.NodesGTEDegree(Graph, degree)
+    percent_deg = float(num) / results['num_nodes']
+    results['deg_gte_%d' % degree] = num
+    results['deg_gte_%d_percent' % degree] = percent_deg
+  
+  # Check for over-weighted nodes
+  results['max_degree'] = snap.MxDegree(Graph)
+  
+  num = snap.NodesGTEDegree(Graph, results['max_degree'])
+  results['max_degree_num'] = num
+  
+  results['max_wcc_percent'] = snap.MxWccSz(Graph) \
+    / results['num_nodes']
+  results['max_scc_percent'] = snap.MxSccSz(Graph).GetNodes() \
+    / results['num_nodes']
+  
+  return results
+
+
+def convert_graph(Graph, TypeSrc, TypeDst):
+  '''
+  Converts a GRAPH from type TYPESRC to a TYPEDST and returns the new graph
+  '''
+  pass
+
+
+def generate_graph(NNodes, NEdges, Model, Type, Rnd):
+    
+  if Model == 'rand_ungraph':
+    # GnRndGnm returns error, so manually generate
+    Graph = snap.GenRndGnm_PUNGraph(NNodes, NEdges, 0)
+
+  elif Model == 'rand_ngraph':
+    Graph = snap.GenRndGnm_PNGraph(NNodes, NEdges, 1)
+      
+  elif Model == 'rand_neanet':
+    Graph = snap.GenRndGnm(NNodes, NEdges, 1)
+
+  elif Model == 'syn_neanet':
+    Graph = snap.GenSyntheticGraph(NNodes, NEdges/NNodes,
+                                             SYNTHETIC_DELTA)
+
+  elif Model == 'syn_ngraph':
+    Graph = snap.GenSyntheticGraph_PNGraph(NNodes, NEdges/NNodes,
+                                             SYNTHETIC_DELTA)
+
+  elif Model == 'rmat':
+    Graph = snap.GenRMat(NNodes, NEdges, 0.40, 0.25, 0.2, Rnd)
+
+  elif Model == 'sw':
+    Graph = snap.GenSmallWorld(NNodes, NNodes/NEdges, 0.1)
+  
+  elif Model == 'pref':
+    Graph = snap.GenPrefAttach(NNodes, NNodes/NEdges)
+
+  return Graph
+
+def run_tests(num_iterations=3, min_nodes_exponent=3, max_nodes_exponent=4):
+  '''
+  Perform tests with specified exponent range
+  '''
+
+  if verbose:
+    print "Running results from %e to %e" % (min_nodes_exponent,
+                                           max_nodes_exponent)
+
+  Rnd = snap.TRnd()
+
+  for exp in range(min_nodes_exponent,max_nodes_exponent+1):
+    
+    for n in range(num_iterations):
+        
+      if verbose:
+        print "Iteration: %d of %d" % (n+1, num_iterations)
+
+      # Random number of nodes of degree i
+      NNodes = 10**exp;
+      
+      for avg_deg in range(min_degree_edges, max_degree_edges+1):
+          
+        for g in graph_types:
+
+          if deterministic:
+            if verbose:
+              print "Deterministic mode, putting seed"
+          else:
+            if verbose:
+              print "Non-deterministic mode"
+            Rnd.PutSeed(0)
+
+          if verbose: print "Using average degree of 10^%d" % avg_deg
+          NEdges = NNodes*(10**avg_deg)
+        
+          Graph = None
+          if g in ['rmat', 'rand_ngraph', 'syn_ngraph','syn_negraph']:
+            Type = "directed"
+      
+          elif g in ['sw', 'pref', 'rand_ungraph']:
+            Type = "undirected"
+        
+          elif g in ['rand_neanet', 'syn_neanet']:
+            Type = "attribute"
+              
+          else:
+            print "Unknown graph type: %s" % g
+            sys.exit(1)
+          
+          StartTime = clock()
+          FName = os.path.join(RESULTS_DIR, "%s_10e%d_deg%d_%d.graph" %
+                              (g, exp, NEdges/NNodes, n))
+        
+          if not generate:
+            
+            if os.path.exists(FName):
+              try:
+              
+                if verbose:
+                  print "Loading '%s' from ...'%s'" % (g, FName),
+                  sys.stdout.flush()
+
+                FIn = snap.TFIn(snap.TStr(FName))
+                if Type == "directed":
+                  Graph = snap.PNGraph_New()
+                elif Type == "undirected":
+                  Graph = snap.PUNGraph_New()
+                elif Type == "attribute":
+                  Graph = snap.PNEANet_New()
+
+                Graph = Graph.Load(FIn)
+                if verbose: print "done"
+              
+                if verbose:
+                  print "Re-loaded graph with %d Nodes and %d Edges" % \
+                    (Graph.GetNodes(), Graph.GetEdges())
+  
+              except Exception, e:
+                print "Unable to load graph file, '%s': %s" % (FName, str(e))
+
+#            else:
+#              print "File not found: %s" % FName
+            
+          if not Graph:
+            
+            try:
+            
+              # User wants to re-generate graph, or no graph data available.
+              if verbose:
+                print "Generating '%s %s' graph with %e nodes, %e edges..." % \
+                        (Type, g, NNodes, NEdges),
+                sys.stdout.flush()
+              Graph = generate_graph(NNodes, NEdges, g, Type, Rnd)
+              if verbose: print "done"
+            
+              if opt_write:
+              
+                # Save the graph
+                if verbose:
+                  print "Saving '%s' graph to file '%s'..." % (g, FName),
+                  sys.stdout.flush()
+                          
+                if Graph:
+                    FOut = snap.TFOut(snap.TStr(FName))
+                    Graph.__ref__().Save(FOut)   # Save as TUNGraph or TNGraph
+                    FOut.Flush()
+                if verbose: print "done"
+            
+            except Exception, e:
+              print "Unable to generate/save graph file, '%s': %s" % \
+                    (FName, str(e))
+              continue
+
+          TimeGenerate = clock() - StartTime
+
+          print "Running tests...",
+          sys.stdout.flush()
+
+          StartTime = clock()
+
+          if Type == 'directed':
+            results = benchmark_ngraph(Graph)
+          elif Type == 'undirected':
+            results = benchmark_ungraph(Graph)
+          elif Type == 'attribute':
+            results = benchmark_neanet(Graph)
+
+          if verbose: print "done"
+
+          TimeElapsed = clock() - StartTime
+          
+          print "Elapsed Time = %.4f sec" % TimeElapsed
+
+          row_header = ["Hostname", "Model", "Type", "Nodes", "Edges",
+                        "StartTime", "Generation Time", "Run Time"]
+
+          print "Header: %s" % " ".join(row_header)
+
+          import csv
+          with open(results_file, 'a+') as csvfile:
+            writer = csv.writer(csvfile)
+            if verbose:
+              print "Writing to '%s'..." % results_file,
+              sys.stdout.flush()
+
+            row = [HOSTNAME, g, Type, NNodes, NEdges,
+                   datetime.now().strftime("%d/%b/%Y:%H:%M:%S"),
+                   TimeGenerate, TimeElapsed]
+            if verbose: print "done"
+            print "Time Data: %s" % repr(row)
+            writer.writerow(row)
+              
+          print "-"*75
+
+def main():
+  
+  global results_dir, verbose, deterministic, generate, graph_types, \
+          hostname, num_iterations, results_file, \
+          min_degree_edges, max_degree_edges, opt_write
+  
+  parser = argparse.ArgumentParser()
+  parser.add_argument("-v", "--verbose", default=DEFAULT_VERBOSE,
+                      action="store_true", dest="verbose",
+                      help="increase output verbosity")
+
+  parser.add_argument("-r", "--range", default=DEFAULT_RANGE,
+                      help="range (4-6) (10^4 to 10^6 nodes)")
+
+  parser.add_argument("-e", "--edges_deg", default=DEFAULT_DEGREES,
+      help="range of degrees (e.g \"2-3\" => (10^1 to 10^3 edges per node)")
+
+  parser.add_argument("-d", "--deterministic", default=False,
+                        action="store_true", dest="deterministic",
+                        help="deterministic benchmark")
+
+  parser.add_argument("-t", "--graph_types", default=DEFAULT_TYPES,
+                      help='''
+          Graph types, comma separated.
+          Available: rand_ungraph, rand_ngraph, rmat, pref, sw''')
+
+  parser.add_argument("-n", "--num_iterations", type=int,
+                      default=DEFAULT_ITERATIONS, help="number of iterations")
+
+  parser.add_argument("-o", "--output_file",
+                      default=DEFAULT_RESULTS_FILE,
+                      help="file to output results")
+
+  parser.add_argument("-g", "--generate", default=False,
+                      action="store_true", dest="generate",
+                      help="generate new graphs")
+
+  parser.add_argument("-w", "--write_graph", default=DEFAULT_WRITE,
+                      action="store_true", dest="write",
+                      help="save graph")
+
+  args = parser.parse_args()
+
+  verbose = args.verbose
+  generate = args.generate
+  deterministic = args.deterministic
+  results_file = args.output_file
+  num_iterations = args.num_iterations
+  graph_types = args.graph_types.split(",")
+  min_degree_edges = int(args.edges_deg.split("-")[0])
+  max_degree_edges = int(args.edges_deg.split("-")[-1])
+  opt_write = args.write
+
+
+  print "Edge degree = 10^%d to 10^%d edges/node" % \
+        (min_degree_edges, max_degree_edges)
+
+  if verbose:
+    print "Hostname: %s" % HOSTNAME
+  min = int(args.range.split("-")[0])
+  max = int(args.range.split("-")[-1])
+  print "Node range = 10^%d to 10^%d" % (min, max)
+  
+  if not os.path.exists(RESULTS_DIR):
+    print "Creating results directory %s" % RESULTS_DIR
+    os.makedirs(RESULTS_DIR)
+                        
+  run_tests(num_iterations, min, max)
+
+if __name__ == "__main__":
+  main()
+                      
+                      

snap-python/source/dev/examples/convert.py

@@ -0,0 +1,220 @@
+#!/usr/bin/python
+# convert.py
+#
+# Author: Nick Shelly, Spring 2013
+# Description:
+#     - Loads SNAP as a Python module.
+#     - Randomly generates a graph of specified size and type and saving,
+#         or loading the graph if has already been created.
+#     - Converts the graph to the specified file
+#           
+#  usage: convert.py [-h] [-v]
+#
+#  optional arguments:
+#    -h, --help            show this help message and exit
+#
+#   Example:
+#   $ python benchmark.py -v -n 3 -g -d -r 2-3 -t rmat -o results/results.txt
+#
+
+import os.path
+import sys
+import argparse
+from socket import gethostname
+from time import clock
+from datetime import datetime
+
+sys.path.append("../swig-r")
+import snap
+
+PROPERTY_TYPES = [1, 10]  # 1=Triads, 10=BFS
+
+# Comma-separated, graph types:
+# 'rmat' - R-MAT
+# 'pref' - preferential attachment
+# 'sw' - small world
+# 'rand_ungraph' - random undirected
+# 'rand_ngraph' - random directed
+# 'rand_neagraph' - random directed attribute
+# 'syn_ngraph' - random directed
+# 'syn_negraph' - synthetic multi-edge
+# 'syn_neagraph' - synthetic directed multi-edge attribute
+
+GRAPH_TYPES = ['rmat', 'pref', 'sw', \
+                'rand_ungraph', 'rand_ngraph', 'rand_neagraph', \
+                'syn_ngraph', 'syn_negraph', 'syn_neagraph']
+DEFAULT_TYPES = "rmat,rand_ungraph"
+
+DEFAULT_NODES_EXP = 3
+DEFAULT_EDGES_EXP = 4
+
+# Average is 1, non-average is 0.
+DEFAULT_DEGREES = 1-2  #  Default is 10x and 100x edges/node
+DEFAULT_WRITE = False
+SW_REWIRE_PROB = 0.1
+SYNTHETIC_DELTA = 10
+
+# Exponent range (e.g. 10^x to 10^y)
+DEFAULT_RANGE = '5-7'
+DEFAULT_ITERATIONS = 1
+
+# Hostname for results
+HOSTNAME = gethostname()
+
+RESULTS_DIR = 'results'
+DEFAULT_RESULTS_FILE = os.path.join(RESULTS_DIR, 'results%s.txt' % \
+                            datetime.now().strftime('%m%d-%H%M%S'))
+
+def generate_graph(NNodes, NEdges, Model, Rnd):
+  
+  Graph = None
+  if Model == 'rand_ungraph':
+    # GnRndGnm returns error, so manually generate
+    Graph = snap.GenRndGnm_PUNGraph(NNodes, NEdges, 0)
+
+  elif Model == 'rand_ngraph':
+    Graph = snap.GenRndGnm_PNGraph(NNodes, NEdges, 1)
+      
+  elif Model == 'rand_neagraph':
+    Graph = snap.GenRndGnm_PNEANet(NNodes, NEdges, 1)
+
+  elif Model == 'syn_neagraph':
+    Graph = snap.GenSyntheticGraph_PNEANet(NNodes, NEdges/NNodes,
+                                             SYNTHETIC_DELTA)
+
+  elif Model == 'syn_ngraph':
+    Graph = snap.GenSyntheticGraph_PNGraph(NNodes, NEdges/NNodes,
+                                             SYNTHETIC_DELTA)
+
+  elif Model == 'rmat':
+    Graph = snap.GenRMat(NNodes, NEdges, 0.40, 0.25, 0.2, Rnd)
+
+  elif Model == 'sw':
+    Graph = snap.GenSmallWorld(NNodes, NNodes/NEdges, 0.1)
+  
+  elif Model == 'pref':
+    Graph = snap.GenPrefAttach(NNodes, NNodes/NEdges)
+
+  else:
+    print "Unknown model: %s" % Model
+    sys.exit(1)
+
+  return Graph
+
+
+def convert_graph(Graph, TypeSrc, TypeDst):
+  '''
+    Converts a GRAPH from type TYPESRC to a TYPEDST and returns the new graph
+  '''
+  
+  print "Converting from '%s' to '%s'..." % (TypeSrc, TypeDst)
+  sys.stdout.flush()
+  
+  
+  if TypeSrc == 'ngraph' and TypeDst == 'neagraph':
+
+    GraphOut = snap.ConvertGraph_PNGraphToPNEANet(Graph)
+  
+  else:
+    print "Unable to convert: %s to %s" % (TypeSrc, TypeDst)
+    sys.exit(1)
+  
+  print "done"
+
+  print "GraphIn (%s) has %d nodes, %d edges\n" % \
+          (Graph.__class__, Graph.GetNodes(), Graph.GetEdges())
+  print "GraphOut (%s) has %d nodes, %d edges" % \
+          (GraphOut.__class__, GraphOut.GetNodes(), GraphOut.GetEdges())
+
+def run(nodes_exp, edges_exp, InputModel, OutputType):
+  
+  '''
+  Perform tests with specified exponent range
+  '''
+
+  if opt_verbose:
+    print "Running results from %e to %e" % (min_nodes_exponent,
+                                           max_nodes_exponent)
+
+  Rnd = snap.TRnd()
+
+  # Random number of nodes of degree i
+  NNodes = 10**nodes_exp
+  NEdges = 10**edges_exp
+  
+  if opt_deterministic:
+    if opt_verbose:
+      print "Deterministic mode, putting seed"
+  else:
+    if opt_verbose:
+      print "Non-deterministic mode"
+    Rnd.PutSeed(0)
+
+  if opt_verbose: print "Using average degree of 10^%d" % avg_deg
+    
+  StartTime = clock()
+    
+  # User wants to re-generate graph, or no graph data available.
+  if opt_verbose:
+    print "Generating '%s %s' graph with %e nodes, %e edges..." % \
+            (Type, g, NNodes, NEdges),
+    sys.stdout.flush()
+  Graph = generate_graph(NNodes, NEdges, InputModel, Rnd)
+  if opt_verbose: print "done"
+
+  if InputModel in ['rmat', 'rand_ngraph', 'syn_ngraph','syn_negraph']:
+    TypeSrc = "ngraph"
+  
+  elif InputModel in ['sw', 'pref', 'rand_ungraph']:
+    TypeSrc = "ungraph"
+  
+  elif InputModel in ['rand_neagraph', 'syn_neagraph']:
+    TypeSrc = "neagraph"
+  
+  else:
+    print "Unknown graph type: %s" % g
+    sys.exit(1)
+
+  convert_graph(Graph, TypeSrc, OutputType)
+  print "-"*75
+
+def main():
+    
+  parser = argparse.ArgumentParser()
+  parser.add_argument("-v", "--verbose", default=False,
+                      action="store_true", dest="verbose",
+                      help="increase output verbosity")
+
+  parser.add_argument("-n", "--nodes_exp", default=DEFAULT_NODES_EXP,
+                      help="number of nodes, exponent (e.g. 4 => 10^4 nodes)")
+
+  parser.add_argument("-e", "--edges_exp", default=DEFAULT_EDGES_EXP,
+                      help="number of edges, exponent (e.g. 4 => 10^4 edges)")
+
+  parser.add_argument("-d", "--deterministic", default=False,
+                        action="store_true", dest="deterministic",
+                        help="deterministic benchmark")
+
+  parser.add_argument("-i", "--input_model", required=True,
+                      help='''
+          Graph types, comma separated: (rmat, pref, rand_ngraph, syn_ngraph)'''
+
+  parser.add_argument("-o", "--output_type", required=True,
+                      help="output type (PNEANet)")
+
+  args = parser.parse_args()
+
+  global opt_verbose, opt_deterministic, opt_nodes_exp, opt_edges_exp
+
+  opt_verbose = args.verbose
+  opt_deterministic = args.deterministic
+  
+  if opt_verbose:
+    print "Hostname: %s" % HOSTNAME
+
+  run(args.nodes_exp, args.edges_exp, args.input_model, args.output_type)
+
+if __name__ == "__main__":
+  main()
+                      
+                      

snap-python/source/dev/examples/demo.graph.dat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f22e344dfa57b56e57ee72ed707c6591704686e6ca7368eb64dc3e49ca3b0e18
+size 3628690

snap-python/source/dev/examples/getstats.py

@@ -0,0 +1,328 @@
+import os
+import sys
+import time
+from random import randrange, choice
+from socket import gethostname
+import argparse
+
+sys.path.append("../swig-r")
+
+import snap
+
+min_nodes_exponent = 1
+max_nodes_exponent = 4
+NUM_ITERATIONS = 1
+PROPERTY_TYPES = [1, 10]  # 1=Triads, 10=BFS
+GRAPH_TYPES = [0, 3, 4] # Small World, Pref, R-MAT
+DEGREE_TYPES = [0, 1]
+
+AVG_DEG = 3
+AVG_DEGREE_RANGE = range(2, 10)
+
+results_dir = '.'
+combined_dir = 'public_html'
+hostname = gethostname()
+verbose = False
+
+def calc_stats():
+  
+  for g in GRAPH_TYPES:
+    
+    for e in range(min_nodes_exponent,max_nodes_exponent+1):
+      
+        # Random number of nodes of degree i
+        NNodes = randrange(10**e,10**(e+1))
+      
+        for avg in DEGREE_TYPES:
+        
+          if avg:
+            # Use average degree
+            NEdges = NNodes * AVG_DEG
+          
+          else:
+            # Random number of edges (from 1-3x nodes)
+            NEdges = NNodes * choice(AVG_DEGREE_RANGE)
+      
+          print "%s graph: NNodes=%.2e, %.2e" % \
+                (snap.GetGraphDesc(g), NNodes, NEdges)
+      
+          fname = "%s%s" % (snap.GetGraphAbbr(g),
+                            'deg%d' % AVG_DEG if avg else '')
+          # Repeat for all graph types
+          for j in PROPERTY_TYPES:
+            print "Calculating %s..." % snap.GetAttributeDesc(j)
+            t = snap.GetStats(NNodes, NEdges, j, g)
+            f = open('%s/%s_%s.txt' % (results_dir, snap.GetAttributeAbbr(j),
+                                       fname),
+                     'a')
+            f.write("%d %d %.5f\n" % (NNodes, NEdges, t))
+
+            f_all = open('%s/%s_all.txt' % (results_dir,
+                                            snap.GetAttributeAbbr(j)),
+                         'a')
+            f_all.write("%d %d %.5f\n" % (NNodes, NEdges, t))
+  
+    # For each characteristic:
+    # Write out test data to same file (linear fit using matlab?)
+    # NNodes NEdges Time
+    
+  print "-"*75
+
+# --------------- Plotting ---------------
+import matplotlib
+matplotlib.use('Agg')
+
+from pylab import *
+from numpy import sort,array,ones,linalg,column_stack,loadtxt,savetxt
+from scipy import *
+from scipy.optimize import leastsq
+from scipy import linalg
+  
+def plot_2d(property):
+  
+  # Plot average degree on 2d-graph
+  figure()
+  for g in GRAPH_TYPES:
+    
+    fname = '%s/%s_%sdeg%d.txt' % (results_dir, snap.GetAttributeAbbr(property),
+                                   snap.GetGraphAbbr(g), AVG_DEG)
+    A = loadtxt(fname)
+    A = sort(A,0)
+    Y = A[:,-1]     # Last column
+    X = A[:,:-1]    # Columns 0-(n-1)
+    
+    loglog(X[:,0], Y, 'o', label=snap.GetGraphDesc(g))
+    
+    legend(loc='lower right')
+    xlabel('Num Nodes (d_avg = %.1f)' % AVG_DEG)
+    ylabel('time')
+    title('%s runtime (avg degree = %d)' % (snap.GetAttributeDesc(property), AVG_DEG))
+    pname = '%s/plot2d_%s.png' % (results_dir, snap.GetAttributeAbbr(property))
+    print "Saving figure %s" % pname
+    savefig(pname)
+
+# Plot using 3D-graph
+def plot_3d(property):
+  
+  import mpl_toolkits.mplot3d.axes3d as p3
+  fig3d = figure()
+  ax = fig3d.add_subplot(111, projection='3d')
+  
+  for g in GRAPH_TYPES:
+    fname = '%s/%s_%s.txt' % (results_dir, snap.GetAttributeAbbr(property),
+                              snap.GetGraphAbbr(g))
+    
+    if not os.path.exists(fname):
+      print "No such file: %s" % fname
+      return
+  
+    A = loadtxt(fname)
+    A = sort(A,0)
+    Y = A[:,-1]     # Last column
+    X = A[:,:-1]    # Columns 0-(n-1)
+    #      savetxt(fname+'_sorted.txt', A)
+    
+    Nodes = X[:,0]
+    Edges = X[:,1]
+    ax.plot(Nodes,Edges,Y,'o',
+           label="%s-%s" % (snap.GetAttributeAbbr(property),
+                            snap.GetGraphAbbr(g)))
+  
+  ax.set_xlabel('# of nodes', fontsize=9)
+  ax.set_ylabel('# of edges', fontsize=9)
+  ax.set_zlabel('Run time %s (sec)' % snap.GetAttributeAbbr(property),
+                fontsize=9)
+  ax.legend()
+
+#  ax.set_xlim3d([0, 10**max_nodes_exponent])
+#  ax.set_ylim3d([0, 10**max_nodes_exponent*AVG_DEGREE_RANGE[1]])
+#  ax.set_zlim3d([0, max(Y)])
+#  ax.set_xscale('log')
+#  ax.w_xaxis.set_scale('log')
+#  ax.w_yaxis.set_scale('log')
+#  ax.set_zscale('log')
+#  ax.auto_scale_xyz([0, max(Nodes)], [0, max(Edges)], [0, max(Y)])
+#  ax.title("%s run time" % snap.GetAttributeAbbr(property))
+  pname = '%s/plot3d_%s.png' % (results_dir, snap.GetAttributeAbbr(property))
+  print "Saving figure %s" % pname
+
+  fig3d.savefig(pname)
+
+# Fitting the data using given model and least squares
+def plot_fit(Xdata, Ydata, labelstr, fit_type):
+  
+  X1 = Xdata[:,0]  # Nodes
+  X2 = Xdata[:,1]  # Edges
+  Y = Ydata
+  
+  best_r2 = 0
+  
+  if "poly" in fit_type:
+    # Polynomial fit
+    fitfunc = lambda p, x1, x2: (p[0] + p[1] * x1 + p[2] * x2 +
+                                 p[3] * x1**2 + p[4] * x2**2)
+    pinit = [1.0 for i in range(5)]
+  
+  if "exp" in fit_type:
+    # Exponential fit
+    Y = log(Y)
+    fitfunc = lambda p, x1, x2: (p[0] + p[1] * x1 + p[3] * x2)
+    pinit = [1.0 for i in range(5)]
+  
+  if "log" in fit_type:
+    # Logarithmic fit
+    fitfunc = lambda p, x1, x2: (p[0] + p[1] * log10(x1) + p[2] * log10(x2))
+    pinit = [1.0 for i in range(3)]
+  
+  #  errfunc = lambda p, x, y, err: (y - fitfunc(p, x)) / err
+  errfunc = lambda p, y, x1, x2: (y - fitfunc(p, x1, x2))
+
+  pfinal,covar,infodict,mesg,ier = \
+    leastsq(errfunc, pinit, args=(Y, X1, X2), full_output=1)
+  
+  print "pfinal = ", pfinal
+  #  print "covar: \n", covar
+  #  print "infodict['fvec']: ", infodict['fvec']
+  
+  ss_err=(infodict['fvec']**2).sum()
+  ss_tot=((Y-Y.mean())**2).sum()
+  rsquared=1-(ss_err/ss_tot)
+  
+  labelstr = "%s (r2=%.3f)" % (fit_type, rsquared)
+  plot(X1, errfunc(pfinal, Y, X1, X2), '.', label=labelstr)
+
+  return (rsquared, pfinal)
+
+# Calculate and Plot Residual Errors
+def plot_residuals(property):
+
+  # Calculate residuals for all graph types, and combined
+    figure()
+    
+    # All graphs
+    fname = '%s/%s_all.txt' % (results_dir, snap.GetAttributeAbbr(property))
+
+    A = loadtxt(fname)
+    A = sort(A,0)
+    Y = A[:,-1]     # Last column
+    X = A[:,:-1]    # Columns 0-(n-1)
+    #      savetxt(fname+'_sorted.txt', A)
+    
+    best_r2 = 0.0
+    best_model = None
+    best_p = None
+    
+    desc = 'all'
+    abbr = 'all'
+
+    print "Fitting %s for %s" % (snap.GetAttributeDesc(property), desc)
+
+    fname = '%s/coeff_%s.txt' % (results_dir, snap.GetAttributeAbbr(property))
+    f = open(fname, 'w')
+
+    cname = '%s/coeff_%s.txt' % (combined_dir,
+                                 snap.GetAttributeAbbr(property))
+    combined_file = open(cname, 'a+')
+  
+
+    for model in ['poly', 'exp', 'log']:
+      # Plot residuals with multiple fitting types
+      rsquared, pfinal = plot_fit(X, Y, desc, model)
+          
+      f.write("%s, model=%s r2=%.4f pfinal=%s\n" %
+              (abbr, model, rsquared, pfinal))
+
+      if (rsquared > best_r2):
+        best_r2 = rsquared
+        best_model = model
+        best_p = pfinal
+  
+  
+    title('Residual error for approx. of run-time, %s (%s)' %
+          (snap.GetAttributeDesc(property).title(), desc))
+    xscale('log')
+    yscale('symlog')
+    grid(True)
+    xlabel('Number of Nodes')
+    ylabel('Residual')
+    legend(loc='lower right')
+    pname = '%s/residuals_%s_%s.png' % (results_dir,
+                                        snap.GetAttributeAbbr(property),
+                                        abbr)
+    print "Saving figure %s" % pname
+    savefig(pname)
+    print "Best model: %s, r2 = %.3f, pfinal: %s" % \
+            (best_model, best_r2, repr(best_p))
+
+    # TODO: Get most recent date of data
+    print "Best results to %s" % cname
+    combined_file.write(
+            'hostname=%s, model=%s, type=%s, n=%d, r2=%.4f, pfinal=%s\n' % \
+            (hostname, best_model, abbr, len(X), best_r2,
+             ["%.4e" % p for p in best_p]))
+
+def plot_stats():
+  
+  for type in PROPERTY_TYPES:
+    
+    plot_3d(type)
+
+    plot_2d(type)
+
+    plot_residuals(type)
+
+    #end for loop - graph type
+
+  #end for loop - plot type
+
+def main():
+  
+  global results_dir, verbose, hostname, max_nodes_exponent
+      
+  parser = argparse.ArgumentParser()
+  parser.add_argument("-v", "--verbose", default=False,
+                    action="store_true", dest="verbose",
+                    help="increase output verbosity")
+  parser.add_argument("-m", "--max_nodes_exponent", type=int,
+                    default=max_nodes_exponent, help="max nodes exponent (4->10^4")
+  parser.add_argument("-n", "--num_iterations", type=int,
+                    default=NUM_ITERATIONS, help="number of iterations")
+  parser.add_argument("-i", "--hostname", help="hostname")
+  parser.add_argument("-p", "--plot", action="store_true", help="plot stats")
+  parser.add_argument("-r", "--run", action="store_true", help="run stats")
+
+  parser.add_argument("results_dir", help="directory to save/store data")
+  args = parser.parse_args()
+  
+  results_dir = args.results_dir
+  verbose = args.verbose
+
+  if not os.path.exists(results_dir):
+    os.mkdir(results_dir)
+
+  if not os.path.exists(combined_dir):
+    os.mkdir(combined_dir)
+
+  if args.max_nodes_exponent:
+    max_nodes_exponent = args.max_nodes_exponent
+
+  if args.hostname:
+    hostname = args.hostname
+  print "Hostname: %s" % hostname
+  print "Results dir: %s" % results_dir
+
+  if args.run:
+    for n in range(args.num_iterations):
+      if verbose:
+        print "Iteration: %d of %d" % (n+1, args.num_iterations)
+      calc_stats()
+    
+  if args.plot:
+    if verbose:
+      print "Plotting results"
+    plot_stats()
+
+if __name__ == "__main__":
+  main()
+
+

snap-python/source/dev/examples/load.py

@@ -0,0 +1,11 @@
+import snap
+
+for item in dir(snap):
+    if item.find("Load") >= 0:
+        print item
+
+g = snap.LoadEdgeList_PNGraph(snap.TStr("soc-Epinions1.txt"), 0, 1)
+print dir(g)
+print g.GetNodes()
+print g.GetEdges()
+

snap-python/source/dev/examples/plot_results.py

@@ -0,0 +1,194 @@
+import os.path
+import sys
+from socket import gethostname
+import argparse
+from datetime import datetime
+
+sys.path.append("../swig")
+import snap
+from glob import glob
+
+NUM_ITERATIONS = 1
+PROPERTY_TYPES = [1, 10]  # 1=Triads, 10=BFS
+DEFAULT_TYPES = "rmat,rand_ngraph,rand_neanet,rand_negraph"      #   Comma separated
+
+# Random, Small World, Pref, R-MAT
+# Graph types:
+# 'rand_ungraph' - random undirected
+# 'rand_ngraph' - random directed
+# 'rmat' - R-MAT
+# 'pref' - preferential attachment
+# 'sw' - small world
+
+DEGREE_TYPES = [0, 1]
+DEFAULT_RANGE = '5-7'   # Exponent (e.g. 10^x to 10^y)
+DEFAULT_NODES_MIN = 10**5
+
+VERBOSE = False
+DEFAULT_TIME_MIN = 0.0
+
+AVG_DEG = 3
+AVG_DEGREE_RANGE = range(2, 10)
+SW_REWIRE_PROB = 0.1
+
+HOSTNAME = gethostname()
+
+# Where to build the table.
+PUBLIC_DIR = 'public_html'
+TABLE_FILE = os.path.join(PUBLIC_DIR, 'result_table_%s.html' %
+                          datetime.now().strftime('%m%d-%H%M'))
+
+# Where to read-in/generate the graph.
+
+RESULTS_DIR = 'results'
+RESULTS_FILE = os.path.join(RESULTS_DIR, 'results%s.txt' % \
+                            datetime.now().strftime('%m%d-%H%M'))
+
+def parse_file(f, results):
+
+  import csv
+  print "Parsing %s" % f
+
+  with open(f, 'rb') as csvfile:
+    spamreader = csv.reader(csvfile)
+    for row in spamreader:
+      result = {}
+      result["hostname"] = row[0]
+      result["model"] = row[1]
+      result["type"] = row[2]
+      result["num_nodes"] = int(row[3])
+      result["num_edges"] = int(row[4])
+      result["start_time"] = row[5]
+      result["time_generate"] = float(row[6])
+      result["time_elapsed"] = float(row[7])
+ 
+      results.append(result)
+
+def write_stats(results):
+  
+  f = open(TABLE_FILE, 'w')
+  
+  f.write("<html>\n");
+  
+  f.write("<body>\n");
+  f.write("<table border=1 id=\"datatab\" summary=\"Dataset statistics\">\n");
+  
+  f.write("<tr>");
+  f.write("<th>Hostname</th>\n");
+  f.write("<th>Model</th>\n");
+  f.write("<th>Type</th>\n");
+  f.write("<th>Nodes</th>\n");
+  f.write("<th>Edges</th>\n");
+  f.write("<th>Start Time</th>\n");
+  f.write("<th>Gen Time (sec)</th>\n");
+  f.write("<th>Run Time (sec)</th>\n");
+  f.write("</tr>\n");
+
+  for result in results:
+
+      for model in graph_types:
+        
+        if result['time_elapsed'] > time_min \
+          and model in result['model'] and \
+          result['num_nodes'] >= DEFAULT_NODES_MIN:
+          
+          f.write("<tr>\n");
+          f.write("<td>%s</td>" % result['hostname']);
+          f.write("<td>%s</td>" % result['model']);
+          f.write("<td>%s</td>" % result['type']);
+          f.write("<td>%.3e</td>" % result['num_nodes']);
+          f.write("<td>%.3e</td>" % result['num_edges']);
+          f.write("<td>%s</td>" % result['start_time']);
+          f.write("<td>%.4f</td>" % result['time_generate']);
+          f.write("<td>%.4f</td>" % result['time_elapsed']);
+          f.write("</tr>\n");
+
+  f.write("</table>\n");
+  
+  f.write("</body>");
+  f.write("</html>");
+  if verbose:
+    print "Writing to file ", TABLE_FILE
+          
+  f.close();
+
+# --------------- Plotting ---------------
+import matplotlib
+matplotlib.use('Agg')
+
+from pylab import *
+from numpy import sort,array,ones,linalg,column_stack,loadtxt,savetxt
+
+def plot_2d(property):
+  
+  # Plot average degree on 2d-graph
+  figure()
+  for g in GRAPH_TYPES:
+    
+    fname = '%s/%s_%sdeg%d.txt' % (results_dir, snap.GetAttributeAbbr(property),
+                                   snap.GetGraphAbbr(g), AVG_DEG)
+    A = loadtxt(fname)
+    A = sort(A,0)
+    Y = A[:,-1]     # Last column
+    X = A[:,:-1]    # Columns 0-(n-1)
+    
+    loglog(X[:,0], Y, 'o', label=snap.GetGraphDesc(g))
+    
+    legend(loc='lower right')
+    xlabel('Num Nodes (d_avg = %.1f)' % AVG_DEG)
+    ylabel('time')
+    title('%s runtime (avg degree = %d)' % (snap.GetAttributeDesc(property), AVG_DEG))
+    pname = '%s/plot2d_%s.png' % (results_dir, snap.GetAttributeAbbr(property))
+    print "Saving figure %s" % pname
+    savefig(pname)
+
+def main():
+  
+  global results_dir, verbose, time_min, graph_types
+  
+  parser = argparse.ArgumentParser()
+  parser.add_argument("-v", "--verbose", default=False,
+                      action="store_true", dest="verbose",
+                      help="increase output verbosity")
+  
+  parser.add_argument("-d", "--results_dir", help="results directory",
+                      default=RESULTS_DIR)
+  
+  parser.add_argument("-m", "--time_min", type=float,
+                      default=DEFAULT_TIME_MIN,
+                      help="time minimum threshold")
+  
+  parser.add_argument("-t", "--graph_types", default=DEFAULT_TYPES,
+                      help='''
+                        Graph types, comma separated.
+                        Available: rand_ungraph, rand_ngraph, rand_neanet rmat, 
+                        pref, sw''')
+  
+  args = parser.parse_args()
+  
+  verbose = args.verbose
+  graph_types = args.graph_types.split(",")
+  
+  print "Hostname: %s" % HOSTNAME
+  
+  time_min = args.time_min
+  
+  if not os.path.exists(RESULTS_DIR):
+    os.makedirs(RESULTS_DIR)
+  
+  if not os.path.exists(PUBLIC_DIR):
+    os.makedirs(PUBLIC_DIR)
+
+  if verbose:
+    print "Reading results %s" % args.results_dir
+  
+  results = []
+  for f in glob("%s/result*.txt" % args.results_dir):
+    print "Parsing %s" % f
+    parse_file(f, results)
+
+  write_stats(results)
+  
+if __name__ == "__main__":
+  main()
+

snap-python/source/dev/examples/public_html/result_table.html

@@ -0,0 +1,55 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Hostname</th>
+<th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+</tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>19.1000</td><td>16.9700</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>20.8500</td><td>17.3800</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>18.2400</td><td>15.6800</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>18.8100</td><td>16.1100</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>18.7500</td><td>16.4400</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>21.5600</td><td>18.6400</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>21.5000</td><td>19.1500</td></tr>
+<tr>
+<td>madmax2.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>18.8500</td><td>19.6100</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>20.4400</td><td>16.7600</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>13.8408</td><td>15.5060</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>1.1328</td><td>1.0108</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>13.7993</td><td>16.2093</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>13.8415</td><td>14.4375</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>14.0142</td><td>14.7885</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>14.1651</td><td>14.9464</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>13.8763</td><td>15.2115</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>13.8888</td><td>14.3995</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>13.7283</td><td>14.3290</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>14.0119</td><td>15.7053</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>14.1115</td><td>15.0208</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>14.2100</td><td>15.1617</td></tr>
+</table>
+</body></html>

snap-python/source/dev/examples/public_html/result_table_0320-1403.html

@@ -0,0 +1,47 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Hostname</th>
+<th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+</tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>2.4132</td><td>1.7536</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>1.1366</td><td>1.0203</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>23.7658</td><td>8.4573</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>1.6178</td><td>1.7030</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>20.7980</td><td>5.9126</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>2.8777</td><td>2.1940</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>40.0090</td><td>21.3967</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+06</td><td>1.000e+07</td><td>26.1444</td><td>21.8137</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+06</td><td>1.000e+08</td><td>383.3239</td><td>157.0932</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>24.3111</td><td>47.3226</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+06</td><td>1.000e+08</td><td>385.4147</td><td>101.7317</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>39.7669</td><td>40.8386</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+08</td><td>798.9350</td><td>921.3519</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>pref</td><td>undirected</td><td>1.000e+06</td><td>1.000e+07</td><td>1.3549</td><td>4.1890</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>pref</td><td>undirected</td><td>1.000e+06</td><td>1.000e+08</td><td>1.3629</td><td>4.7027</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>sw</td><td>undirected</td><td>1.000e+06</td><td>1.000e+07</td><td>1.3249</td><td>4.6494</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>sw</td><td>undirected</td><td>1.000e+06</td><td>1.000e+08</td><td>1.3194</td><td>4.5435</td></tr>
+</table>
+</body></html>

snap-python/source/dev/examples/public_html/result_table_0320-1417.html

@@ -0,0 +1,47 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Hostname</th>
+<th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+</tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>2.4132</td><td>1.7536</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>1.1366</td><td>1.0203</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>23.7658</td><td>8.4573</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>1.6178</td><td>1.7030</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>20.7980</td><td>5.9126</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>2.8777</td><td>2.1940</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>40.0090</td><td>21.3967</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+06</td><td>1.000e+07</td><td>26.1444</td><td>21.8137</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+06</td><td>1.000e+08</td><td>383.3239</td><td>157.0932</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>24.3111</td><td>47.3226</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+06</td><td>1.000e+08</td><td>385.4147</td><td>101.7317</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>39.7669</td><td>40.8386</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+08</td><td>798.9350</td><td>921.3519</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>pref</td><td>undirected</td><td>1.000e+06</td><td>1.000e+07</td><td>1.3549</td><td>4.1890</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>pref</td><td>undirected</td><td>1.000e+06</td><td>1.000e+08</td><td>1.3629</td><td>4.7027</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>sw</td><td>undirected</td><td>1.000e+06</td><td>1.000e+07</td><td>1.3249</td><td>4.6494</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>sw</td><td>undirected</td><td>1.000e+06</td><td>1.000e+08</td><td>1.3194</td><td>4.5435</td></tr>
+</table>
+</body></html>

snap-python/source/dev/examples/public_html/result_table_0320-1420.html

@@ -0,0 +1,17 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Hostname</th>
+<th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+</tr>
+<tr>
+<td>sheridan</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>9.4968</td><td>3.3481</td></tr>
+<tr>
+<td>sheridan</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>7.0061</td><td>2.0728</td></tr>
+</table>
+</body></html>

snap-python/source/dev/examples/public_html/result_table_0320-1421.html

@@ -0,0 +1,19 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Hostname</th>
+<th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+</tr>
+<tr>
+<td>sheridan</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>9.4968</td><td>3.3481</td></tr>
+<tr>
+<td>sheridan</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>7.0061</td><td>2.0728</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.3892</td><td>12.9903</td></tr>
+</table>
+</body></html>

snap-python/source/dev/examples/public_html/result_table_0320-1423.html

@@ -0,0 +1,19 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Hostname</th>
+<th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+</tr>
+<tr>
+<td>sheridan</td><td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>9.4968</td><td>3.3481</td></tr>
+<tr>
+<td>sheridan</td><td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>7.0061</td><td>2.0728</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.3892</td><td>12.9903</td></tr>
+</table>
+</body></html>

snap-python/source/dev/examples/public_html/result_table_0321-2331.html

@@ -0,0 +1,13 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Hostname</th>
+<th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+</tr>
+</table>
+</body></html>

snap-python/source/dev/examples/public_html/result_table_0321-2332.html

@@ -0,0 +1,61 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Hostname</th>
+<th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+</tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>2.4132</td><td>1.7536</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>2.8777</td><td>2.1940</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>40.0090</td><td>21.3967</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>39.7669</td><td>40.8386</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+08</td><td>798.9350</td><td>921.3519</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.3892</td><td>12.9903</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.7994</td><td>13.0970</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.9588</td><td>13.8366</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.6456</td><td>14.1982</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.0872</td><td>13.3833</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.8590</td><td>12.8888</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>3.7098</td><td>2.2293</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>3.6605</td><td>2.5440</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>61.0159</td><td>77.0117</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>3.6629</td><td>2.8650</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>3.3448</td><td>2.0680</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>4.1631</td><td>3.0476</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>69.7596</td><td>54.4046</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>60.9612</td><td>59.8299</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>3.8324</td><td>2.3204</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>4.3456</td><td>3.2776</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>72.9842</td><td>61.6619</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>74.7449</td><td>68.7944</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+08</td><td>1031.9497</td><td>928.5699</td></tr>
+</table>
+</body></html>

snap-python/source/dev/examples/public_html/result_table_0321-2339.html

@@ -0,0 +1,61 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Hostname</th>
+<th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+</tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>2.4132</td><td>1.7536</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>2.8777</td><td>2.1940</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>40.0090</td><td>21.3967</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>39.7669</td><td>40.8386</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+08</td><td>798.9350</td><td>921.3519</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.3892</td><td>12.9903</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.7994</td><td>13.0970</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.9588</td><td>13.8366</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.6456</td><td>14.1982</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.0872</td><td>13.3833</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.8590</td><td>12.8888</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>3.7098</td><td>2.2293</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>3.6605</td><td>2.5440</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>61.0159</td><td>77.0117</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>3.6629</td><td>2.8650</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>3.3448</td><td>2.0680</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>4.1631</td><td>3.0476</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>69.7596</td><td>54.4046</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>60.9612</td><td>59.8299</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>3.8324</td><td>2.3204</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>4.3456</td><td>3.2776</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>72.9842</td><td>61.6619</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>74.7449</td><td>68.7944</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+08</td><td>1031.9497</td><td>928.5699</td></tr>
+</table>
+</body></html>

snap-python/source/dev/examples/public_html/result_table_0321-2340.html

@@ -0,0 +1,61 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Hostname</th>
+<th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+</tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>2.4132</td><td>1.7536</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>2.8777</td><td>2.1940</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>40.0090</td><td>21.3967</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>39.7669</td><td>40.8386</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+08</td><td>798.9350</td><td>921.3519</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>3.7098</td><td>2.2293</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>3.6605</td><td>2.5440</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>61.0159</td><td>77.0117</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>3.6629</td><td>2.8650</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>3.3448</td><td>2.0680</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>4.1631</td><td>3.0476</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>69.7596</td><td>54.4046</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>60.9612</td><td>59.8299</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>3.8324</td><td>2.3204</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>4.3456</td><td>3.2776</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>72.9842</td><td>61.6619</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+07</td><td>74.7449</td><td>68.7944</td></tr>
+<tr>
+<td>madmax.stanford.edu</td><td>rmat</td><td>directed</td><td>1.000e+06</td><td>1.000e+08</td><td>1031.9497</td><td>928.5699</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.3892</td><td>12.9903</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.7994</td><td>13.0970</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.9588</td><td>13.8366</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.6456</td><td>14.1982</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.0872</td><td>13.3833</td></tr>
+<tr>
+<td>sheridan</td><td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>15.8590</td><td>12.8888</td></tr>
+</table>
+</body></html>

snap-python/source/dev/examples/public_html/results_0320-1303.html

@@ -0,0 +1,215 @@
+<html>
+<body>
+<table border=1 id="datatab" summary="Dataset statistics">
+<tr><th>Model</th>
+<th>Type</th>
+<th>Nodes</th>
+<th>Edges</th>
+<th>Gen Time (sec)</th>
+<th>Run Time (sec)</th>
+<th>Hostname</th>
+</tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0019</td><td>0.0133</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+03</td><td>1.000e+04</td><td>0.0047</td><td>0.0033</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+03</td><td>1.000e+05</td><td>0.0613</td><td>0.0270</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+03</td><td>1.000e+04</td><td>0.0031</td><td>0.0024</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+03</td><td>1.000e+05</td><td>0.0375</td><td>0.0181</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+03</td><td>1.000e+04</td><td>0.0068</td><td>0.0049</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+03</td><td>1.000e+05</td><td>0.0871</td><td>0.0154</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+03</td><td>1.000e+04</td><td>0.0004</td><td>0.0013</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+03</td><td>1.000e+05</td><td>0.0002</td><td>0.0013</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+03</td><td>1.000e+04</td><td>0.0003</td><td>0.0013</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+03</td><td>1.000e+05</td><td>0.0003</td><td>0.0013</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0527</td><td>0.0443</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.7715</td><td>0.2963</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0328</td><td>0.0549</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>0.4893</td><td>0.1846</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0777</td><td>0.0541</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>1.0613</td><td>0.7422</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0023</td><td>0.0220</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0017</td><td>0.0166</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0027</td><td>0.0160</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0018</td><td>0.0137</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0474</td><td>0.0373</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.7119</td><td>0.3017</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0367</td><td>0.0277</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>0.4688</td><td>0.1889</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0782</td><td>0.0579</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>1.1570</td><td>0.7897</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0022</td><td>0.0140</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0016</td><td>0.0132</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0020</td><td>0.0132</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0019</td><td>0.0131</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>0.6291</td><td>0.4348</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>9.5032</td><td>3.4722</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>0.5852</td><td>0.8645</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>7.1251</td><td>2.0593</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>1.0443</td><td>0.8116</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.0948</td><td>13.2966</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>0.0167</td><td>0.1340</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>0.0168</td><td>0.1430</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>0.0208</td><td>0.1472</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>0.0272</td><td>0.1418</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0522</td><td>0.0377</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.7031</td><td>0.2983</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0364</td><td>0.0267</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>0.4759</td><td>0.1864</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0789</td><td>0.0584</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>1.1542</td><td>0.8002</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0017</td><td>0.0137</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0017</td><td>0.0132</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0019</td><td>0.0131</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0020</td><td>0.0135</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>0.6280</td><td>0.4285</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>9.8755</td><td>3.4552</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>0.5372</td><td>0.8366</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>7.3021</td><td>2.1303</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>1.0667</td><td>0.8308</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+03</td><td>1.000e+04</td><td>0.0049</td><td>0.0034</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+03</td><td>1.000e+05</td><td>0.0630</td><td>0.0277</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+03</td><td>1.000e+04</td><td>0.0031</td><td>0.0024</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+03</td><td>1.000e+05</td><td>0.0383</td><td>0.0191</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+03</td><td>1.000e+04</td><td>0.0074</td><td>0.0059</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+03</td><td>1.000e+05</td><td>0.0890</td><td>0.0165</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+03</td><td>1.000e+04</td><td>0.0004</td><td>0.0013</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+03</td><td>1.000e+05</td><td>0.0003</td><td>0.0013</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+03</td><td>1.000e+04</td><td>0.0003</td><td>0.0013</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+03</td><td>1.000e+05</td><td>0.0003</td><td>0.0013</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0517</td><td>0.0407</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.8008</td><td>0.3120</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0373</td><td>0.0669</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>0.5369</td><td>0.1978</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0876</td><td>0.0672</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>1.1729</td><td>0.8125</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0022</td><td>0.0141</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0017</td><td>0.0181</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0020</td><td>0.0138</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0019</td><td>0.0184</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.6068</td><td>13.4748</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>0.0177</td><td>0.1335</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>0.0161</td><td>0.1313</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>0.0185</td><td>0.1318</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>0.0187</td><td>0.1305</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0476</td><td>0.0382</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.7023</td><td>0.2999</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0323</td><td>0.0276</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>0.4846</td><td>0.1927</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0811</td><td>0.0602</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+04</td><td>1.000e+06</td><td>1.1522</td><td>0.7962</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0023</td><td>0.0162</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0018</td><td>0.0131</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+05</td><td>0.0019</td><td>0.0132</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+04</td><td>1.000e+06</td><td>0.0021</td><td>0.0132</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>0.6232</td><td>0.4392</td></tr>
+<tr>
+<td>rnd_ungraph</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>9.4708</td><td>3.5457</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>0.5382</td><td>0.8661</td></tr>
+<tr>
+<td>rnd_ngraph</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>7.3567</td><td>2.1015</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+06</td><td>1.0646</td><td>0.9549</td></tr>
+<tr>
+<td>rmat</td><td>directed</td><td>1.000e+05</td><td>1.000e+07</td><td>16.3262</td><td>14.4413</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>0.0194</td><td>0.1322</td></tr>
+<tr>
+<td>pref</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>0.0209</td><td>0.1333</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+05</td><td>1.000e+06</td><td>0.0192</td><td>0.1376</td></tr>
+<tr>
+<td>sw</td><td>undirected</td><td>1.000e+05</td><td>1.000e+07</td><td>0.0197</td><td>0.1349</td></tr>
+</table>
+</body></html>

snap-python/source/dev/examples/result3.txt

@@ -0,0 +1,5 @@
+Hostname: sheridan
+Range = 10^1 to 10^0
+Running results from 1.000000e+00 to 0.000000e+00
+Non-deterministic mode
+Iteration: 1 of 1

snap-python/source/dev/examples/results-madmax/BFS_all.txt

@@ -0,0 +1,300 @@
+95 475 0.00000
+95 285 0.00000
+608 4864 0.04000
+608 1824 0.03000
+5631 22524 0.63000
+5631 16893 0.54000
+44 396 0.00000
+44 132 0.01000
+458 1832 0.02000
+458 1374 0.02000
+8514 51084 1.47000
+8514 25542 1.53000
+10 70 0.00000
+10 30 0.00000
+210 1050 0.01000
+210 630 0.01000
+7266 21798 0.70000
+7266 21798 0.66000
+80 640 0.01000
+80 240 0.00000
+693 5544 0.05000
+693 2079 0.03000
+7944 71496 1.66000
+7944 23832 0.81000
+27 54 0.00000
+27 81 0.01000
+840 7560 0.05000
+840 2520 0.05000
+7510 15020 1.10000
+7510 22530 0.81000
+19 114 0.00000
+19 57 0.00000
+699 3495 0.03000
+699 2097 0.02000
+9203 27609 0.54000
+9203 27609 0.53000
+24 168 0.00000
+24 72 0.00000
+625 4375 0.03000
+625 1875 0.02000
+9448 37792 0.96000
+9448 28344 0.82000
+40 280 0.00000
+40 120 0.01000
+686 2058 0.04000
+686 2058 0.03000
+8245 57715 1.03000
+8245 24735 1.06000
+94 658 0.01000
+94 282 0.00000
+474 2844 0.01000
+474 1422 0.01000
+8138 73242 1.29000
+8138 24414 0.51000
+49 245 0.00000
+49 147 0.00000
+266 798 0.01000
+266 798 0.01000
+7844 70596 1.30000
+7844 23532 0.55000
+88 704 0.01000
+88 264 0.00000
+192 768 0.01000
+192 576 0.00000
+9274 27822 1.25000
+9274 27822 1.25000
+13 91 0.00000
+13 39 0.00000
+899 7192 0.05000
+899 2697 0.03000
+4901 34307 0.53000
+4901 14703 0.22000
+13 52 0.00000
+13 39 0.00000
+653 5877 0.04000
+653 1959 0.02000
+1495 13455 0.11000
+1495 4485 0.07000
+88 440 0.00000
+88 264 0.01000
+412 3708 0.02000
+412 1236 0.02000
+2702 8106 0.23000
+2702 8106 0.22000
+59 354 0.00000
+59 177 0.00000
+640 2560 0.02000
+640 1920 0.03000
+9907 79256 1.49000
+9907 29721 0.77000
+13 91 0.00000
+13 39 0.00000
+485 1455 0.02000
+485 1455 0.02000
+2953 8859 0.30000
+2953 8859 0.30000
+70 560 0.00000
+70 210 0.01000
+161 1449 0.01000
+161 483 0.01000
+9470 28410 2.07000
+9470 28410 0.48000
+93 651 0.00000
+93 279 0.00000
+731 1462 0.01000
+731 2193 0.01000
+1408 4224 0.02000
+1408 4224 0.02000
+80 560 0.01000
+80 240 0.00000
+452 3164 0.01000
+452 1356 0.01000
+8695 26085 0.23000
+8695 26085 0.22000
+62 124 0.01000
+62 186 0.00000
+624 5616 0.02000
+624 1872 0.02000
+8037 40185 0.37000
+8037 24111 0.38000
+65 585 0.00000
+65 195 0.00000
+899 8091 0.03000
+899 2697 0.02000
+4652 32564 0.17000
+4652 13956 0.09000
+19 76 0.00000
+19 57 0.00000
+332 2656 0.02000
+332 996 0.01000
+4293 30051 0.17000
+4293 12879 0.10000
+70 280 0.00000
+70 210 0.01000
+217 1736 0.02000
+217 651 0.01000
+1330 5320 0.05000
+1330 3990 0.05000
+44 88 0.00000
+44 132 0.00000
+786 2358 0.02000
+786 2358 0.01000
+2300 6900 0.04000
+2300 6900 0.03000
+78 390 0.00000
+78 234 0.00000
+848 1696 0.02000
+848 2544 0.01000
+7091 14182 0.13000
+7091 21273 0.17000
+14 28 0.00000
+14 42 0.00000
+163 1467 0.01000
+163 489 0.01000
+9326 55956 1.48000
+9326 27978 1.47000
+35 140 0.00000
+35 105 0.00000
+821 4926 0.05000
+821 2463 0.03000
+2608 20864 0.27000
+2608 7824 0.14000
+39 78 0.00000
+39 117 0.00000
+783 1566 0.02000
+783 2349 0.03000
+7338 66042 1.26000
+7338 22014 0.64000
+38 114 0.00000
+38 114 0.00000
+425 2550 0.02000
+425 1275 0.02000
+1018 5090 0.06000
+1018 3054 0.06000
+62 124 0.00000
+62 186 0.00000
+126 378 0.00000
+126 378 0.01000
+4056 8112 0.14000
+4056 12168 0.21000
+17 136 0.00000
+17 51 0.00000
+584 1168 0.01000
+584 1752 0.02000
+3306 9918 0.18000
+3306 9918 0.18000
+19804 59412 2.74000
+19804 59412 3.02000
+42 168 0.00000
+42 126 0.00000
+387 2709 0.01000
+387 1161 0.01000
+3797 22782 0.36000
+3797 11391 0.36000
+34028 102084 12.56000
+34028 102084 13.10000
+97 291 0.00000
+97 291 0.00000
+741 2964 0.03000
+741 2223 0.02000
+7391 51737 1.08000
+7391 22173 0.57000
+67897 203691 14.37000
+67897 203691 7.04000
+95 285 0.00000
+95 285 0.01000
+547 1094 0.02000
+547 1641 0.02000
+8498 59486 1.14000
+8498 25494 0.71000
+72579 290316 50.46000
+72579 217737 18.71000
+81 162 0.00000
+81 243 0.01000
+409 3272 0.02000
+409 1227 0.02000
+8863 79767 1.26000
+8863 26589 1.93000
+89153 624071 96.92000
+89153 267459 85.52000
+83 581 0.01000
+83 249 0.00000
+686 6174 0.04000
+686 2058 0.03000
+5255 42040 0.67000
+5255 15765 0.26000
+65123 325615 26.67000
+65123 195369 15.17000
+85 510 0.00000
+85 255 0.00000
+574 4592 0.03000
+574 1722 0.02000
+8536 76824 1.53000
+8536 25608 0.75000
+81055 162110 14.32000
+81055 243165 41.29000
+57 285 0.01000
+57 171 0.00000
+794 4764 0.04000
+794 2382 0.04000
+9500 76000 1.15000
+9500 28500 1.00000
+37275 74550 15.67000
+37275 111825 13.68000
+78 312 0.00000
+78 234 0.00000
+594 4752 0.04000
+594 1782 0.02000
+6160 36960 0.61000
+6160 18480 0.32000
+41142 329136 3.86000
+41142 123426 2.90000
+81 486 0.00000
+81 243 0.01000
+918 1836 0.05000
+918 2754 0.06000
+3685 33165 0.67000
+3685 11055 0.37000
+78419 313676 71.96000
+78419 235257 53.10000
+89 267 0.01000
+89 267 0.00000
+560 1680 0.04000
+560 1680 0.04000
+6184 37104 1.07000
+6184 18552 1.06000
+44276 177104 17.07000
+44276 132828 21.02000
+71 213 0.00000
+71 213 0.00000
+729 5832 0.04000
+729 2187 0.02000
+7082 42492 0.72000
+7082 21246 0.37000
+11383 45532 0.98000
+11383 34149 0.86000
+56 392 0.00000
+56 168 0.00000
+200 800 0.01000
+200 600 0.01000
+9689 29067 0.94000
+9689 29067 0.95000
+16287 114009 3.56000
+16287 48861 1.84000
+13 104 0.00000
+13 39 0.00000
+348 1740 0.02000
+348 1044 0.02000
+6074 30370 0.74000
+6074 18222 0.72000
+96859 678013 89.74000
+96859 290577 106.46000
+51 255 0.00000
+51 153 0.00000
+654 5886 0.06000
+654 1962 0.04000
+9041 36164 1.10000
+9041 27123 0.75000
+18740 168660 7.29000
+18740 56220 2.52000

snap-python/source/dev/examples/results-madmax/BFS_pref.txt

@@ -0,0 +1,50 @@
+44 396 0.00000
+458 1832 0.02000
+8514 51084 1.47000
+27 54 0.00000
+840 7560 0.05000
+7510 15020 1.10000
+40 280 0.00000
+686 2058 0.04000
+8245 57715 1.03000
+88 704 0.01000
+192 768 0.01000
+9274 27822 1.25000
+88 440 0.00000
+412 3708 0.02000
+2702 8106 0.23000
+70 560 0.00000
+161 1449 0.01000
+9470 28410 2.07000
+62 124 0.01000
+624 5616 0.02000
+8037 40185 0.37000
+70 280 0.00000
+217 1736 0.02000
+1330 5320 0.05000
+14 28 0.00000
+163 1467 0.01000
+9326 55956 1.48000
+38 114 0.00000
+425 2550 0.02000
+1018 5090 0.06000
+42 168 0.00000
+387 2709 0.01000
+3797 22782 0.36000
+34028 102084 12.56000
+81 162 0.00000
+409 3272 0.02000
+8863 79767 1.26000
+89153 624071 96.92000
+57 285 0.01000
+794 4764 0.04000
+9500 76000 1.15000
+37275 74550 15.67000
+89 267 0.01000
+560 1680 0.04000
+6184 37104 1.07000
+44276 177104 17.07000
+13 104 0.00000
+348 1740 0.02000
+6074 30370 0.74000
+96859 678013 89.74000