update

.pre-commit-config.yaml

@@ -21,7 +21,7 @@ repos:
         language: system
         entry: pipenv run flake8 py_code_analyzer
         types: [python]
-        exclude: setup.py
+        exclude: setup.py|pyvis
 
       - id: mypy
         name: mypy

pyvis

@@ -1 +0,0 @@
-Subproject commit e8249fb97d5797eaccce50d5c87bd45b76d9b5df

pyvis/.gitignore

@@ -0,0 +1,26 @@
+# binaries
+*.pyc
+.cache/
+.coverage
+
+# notebook checkpoints
+.ipynb_checkpoints/
+notebooks/.ipynb_checkpoints
+
+# test related
+.pytest_cache/
+pyvis/test.py
+
+# local files
+pyvis/full_graph.txt
+pyvis/source/stormofswords.csv
+
+# package details
+pyvis.egg-info/
+build/
+dist/
+pyvis/make.bat
+
+# vscode specific
+.vscode/
+venv

pyvis/CONTRIBUTING.md

@@ -0,0 +1,18 @@
+# Pull Requests
+
+Here are some guidelines for pull requests:
+
+* All work is submitted via Pull Requests.
+* Pull Requests can be submitted as soon as there is code worth discussing. The worst case is that the PR is closed.
+* Pull Requests should be made against master
+* Pull Requests should be tested, if feasible:
+    - bugfixes should include regression tests.
+    - new behavior should at least get minimal exercise.
+    - new features should include a screenshot
+* Don't make 'cleanup' pull requests just to change code style. We don't follow any style guide strictly, and we consider formatting changes unnecessary noise. If you're making functional changes, you can clean up the specific pieces of code you're working on.
+
+Pyvis wraps  vis.js so JavaScript functionality issues should be directed at the main `vis.js` project.
+
+# Other contributions
+
+Outside of Pull Requests (PRs), we welcome additions/corrections/clarification to the existing documentation as contributions at least as valuable as code submissions.  

pyvis/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include pyvis/templates *.html

pyvis/README.md

@@ -0,0 +1,45 @@
+## Pyvis - a Python library for visualizing networks
+
+![](pyvis/source/tut.gif?raw=true)
+
+## Description
+Pyvis is built around [visjs](http://visjs.org/), a JavaScript visualization library.
+
+## Documentation
+Pyvis' full documentation can be found at http://pyvis.readthedocs.io/en/latest/
+## Installation
+You can install pyvis through pip:
+
+```bash
+pip install pyvis
+```
+Or if you have an archive of the project simply run the following from the top level directory:
+
+```bash
+python setup.py install
+```
+
+## Dependencies
+[networkx](https://networkx.github.io/)
+
+[jinja2](http://jinja.pocoo.org/)
+
+[ipython](https://ipython.org/ipython-doc/2/install/install.html)
+
+[jsonpickle](https://jsonpickle.github.io/)
+
+## Quick Start
+The most basic use case of a pyvis instance is to create a Network object and invoke methods:
+
+```python
+from pyvis.network import Network
+
+g = Network()
+g.add_node(0)
+g.add_node(1)
+g.add_edge(0, 1)
+g.show("basic.html")
+```
+
+## Interactive Notebook playground with examples
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/WestHealth/pyvis/master?filepath=notebooks%2Fexample.ipynb)

pyvis/__init__.py

@@ -0,0 +1 @@
+from .pyvis.network import Network

pyvis/notebooks/example.ipynb

@@ -0,0 +1,483 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append('../')\n",
+    "from pyvis.network import Network"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Basic Example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"500px\"\n",
+       "            height=\"500px\"\n",
+       "            src=\"example.html\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x7fbe1d273d30>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "g = Network(notebook=True)\n",
+    "g.add_nodes(range(5))\n",
+    "g.add_edges([\n",
+    "    (0, 2),\n",
+    "    (0, 3),\n",
+    "    (0, 4),\n",
+    "    (1, 1),\n",
+    "    (1, 3),\n",
+    "    (1, 2)\n",
+    "])\n",
+    "g.show(\"example.html\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Dot File example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"500px\"\n",
+       "            height=\"500px\"\n",
+       "            src=\"dot.html\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x7fbe3d2ead00>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "h = Network(notebook=True)\n",
+    "h.from_DOT(\"test.dot\")\n",
+    "\n",
+    "# All properties have to be enclosed by double quotes and \n",
+    "# there and there must be no comma at the end of a list.\n",
+    "# See https://visjs.github.io/vis-network/docs/network/ for all options\n",
+    "h.set_options(\"\"\"\n",
+    "var options = {\n",
+    "    \"physics\": {\n",
+    "        \"enabled\": true,\n",
+    "        \"barnesHut\": {\n",
+    "            \"theta\": 0.5,\n",
+    "            \"gravitationalConstant\": -2000,\n",
+    "            \"centralGravity\": 0.3,\n",
+    "            \"springLength\": 200,\n",
+    "            \"springConstant\": 0.04,\n",
+    "            \"damping\": 0.09,\n",
+    "            \"avoidOverlap\": 0\n",
+    "        },\n",
+    "        \"maxVelocity\": 50,\n",
+    "        \"minVelocity\": 0.1,\n",
+    "        \"solver\": \"barnesHut\",\n",
+    "        \"stabilization\": {\n",
+    "            \"enabled\": true,\n",
+    "            \"iterations\": 1000,\n",
+    "            \"updateInterval\": 100,\n",
+    "            \"onlyDynamicEdges\": false,\n",
+    "            \"fit\": true\n",
+    "        }\n",
+    "    }\n",
+    "}\n",
+    "\"\"\")\n",
+    "h.show(\"dot.html\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Basic NetworkX example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx as nx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"500px\"\n",
+       "            height=\"500px\"\n",
+       "            src=\"example.html\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x7f3ef910af40>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "nxg = nx.random_tree(20)\n",
+    "g.from_nx(nxg)\n",
+    "g.show(\"example.html\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Disabling Physics interaction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"500px\"\n",
+       "            height=\"500px\"\n",
+       "            src=\"example.html\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x7f882040c6d0>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "g.toggle_physics(False)\n",
+    "g.show(\"example.html\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Explicit coordinates to layout nodes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"500px\"\n",
+       "            height=\"500px\"\n",
+       "            src=\"example.html\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x7f87dc679b50>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "g = Network(notebook=True)\n",
+    "g.add_nodes([1,2,3],\n",
+    "            value=[10, 100, 400],\n",
+    "            title=[\"I am node 1\", \"node 2 here\", \"and im node 3\"],\n",
+    "            x=[21.4, 21.4, 21.4], y=[100.2, 223.54, 32.1],\n",
+    "            label=[\"NODE 1\", \"NODE 2\", \"NODE 3\"],\n",
+    "            color=[\"#00ff1e\", \"#162347\", \"#dd4b39\"])\n",
+    "g.show(\"example.html\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Full Game of Thrones example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"750px\"\n",
+       "            src=\"example.html\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x7f87da76e430>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "got_net = Network(notebook=True, height=\"750px\", width=\"100%\", bgcolor=\"#222222\", font_color=\"white\")\n",
+    "\n",
+    "# set the physics layout of the network\n",
+    "got_net.barnes_hut()\n",
+    "got_data = pd.read_csv(\"https://www.macalester.edu/~abeverid/data/stormofswords.csv\")\n",
+    "\n",
+    "sources = got_data['Source']\n",
+    "targets = got_data['Target']\n",
+    "weights = got_data['Weight']\n",
+    "\n",
+    "edge_data = zip(sources, targets, weights)\n",
+    "\n",
+    "for e in edge_data:\n",
+    "    src = e[0]\n",
+    "    dst = e[1]\n",
+    "    w = e[2]\n",
+    "\n",
+    "    got_net.add_node(src, src, title=src)\n",
+    "    got_net.add_node(dst, dst, title=dst)\n",
+    "    got_net.add_edge(src, dst, value=w)\n",
+    "\n",
+    "neighbor_map = got_net.get_adj_list()\n",
+    "\n",
+    "# add neighbor data to node hover data\n",
+    "for node in got_net.nodes:\n",
+    "    node[\"title\"] += \" Neighbors:<br>\" + \"<br>\".join(neighbor_map[node[\"id\"]])\n",
+    "    node[\"value\"] = len(neighbor_map[node[\"id\"]]) # this value attrribute for the node affects node size\n",
+    "\n",
+    "got_net.show(\"example.html\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Experimenting with options UI\n",
+    "Scroll down underneath the graph to play around with the physics settings to acheive optimal layout and behavior. You can use the generate options button to display the JSON representation of the configuration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"750px\"\n",
+       "            src=\"example.html\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x7f87da76ee50>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "got_net.show_buttons(filter_=\"physics\")\n",
+    "got_net.show(\"example.html\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "got_net.set_options('''var options = {\n",
+    "  \"physics\": {\n",
+    "    \"barnesHut\": {\n",
+    "      \"gravitationalConstant\": -80000,\n",
+    "      \"springLength\": 250,\n",
+    "      \"springConstant\": 0.001\n",
+    "    },\n",
+    "    \"maxVelocity\": 34,\n",
+    "    \"minVelocity\": 0.75\n",
+    "  }\n",
+    "}''')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx as nx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"750px\"\n",
+       "            src=\"nx.html\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x7f88443e75b0>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "nx_graph = nx.cycle_graph(10)\n",
+    "nx_graph.nodes[1]['title'] = 'Number 1'\n",
+    "nx_graph.nodes[1]['group'] = 1\n",
+    "nx_graph.nodes[3]['title'] = 'I belong to a different group!'\n",
+    "nx_graph.nodes[3]['group'] = 10\n",
+    "nx_graph.add_node(20, size=20, title='couple', group=2)\n",
+    "nx_graph.add_node(21, size=15, title='couple', group=2)\n",
+    "nx_graph.add_edge(20, 21, weight=5)\n",
+    "nx_graph.add_node(25, size=25, label='lonely', title='lonely node', group=3)\n",
+    "\n",
+    "nt = Network(notebook=True, height=\"750px\", width=\"100%\")\n",
+    "\n",
+    "nt.from_nx(nx_graph)\n",
+    "nt.show(\"nx.html\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

pyvis/notebooks/test.dot

@@ -0,0 +1,9 @@
+digraph {
+    a [label=12, entity_id=12, entity_class="truck"];
+    b [label=7, entity_id=7,entity_class="bike"];
+    c [label=3, entity_id=3, entity_class="car"];
+    a -> b[label="solid edge"];                     
+    a -> b [label="dashed edge", style=dashed]; 
+    a -> c [label="dashed edge", style=dashed]; 
+    a -> c [label="dotted edge", style=dotted];      
+}

pyvis/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta:__legacy__"

pyvis/pyvis/Makefile

@@ -0,0 +1,230 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = build
+
+# User-friendly check for sphinx-build
+ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
+$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don\'t have Sphinx installed, grab it from http://sphinx-doc.org/)
+endif
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
+
+.PHONY: help
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  applehelp  to make an Apple Help Book"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  epub3      to make an epub3"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  xml        to make Docutils-native XML files"
+	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+	@echo "  coverage   to run coverage check of the documentation (if enabled)"
+	@echo "  dummy      to check syntax errors of document sources"
+
+.PHONY: clean
+clean:
+	rm -rf $(BUILDDIR)/*
+
+.PHONY: html
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+.PHONY: dirhtml
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+.PHONY: singlehtml
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+.PHONY: pickle
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+.PHONY: json
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+.PHONY: htmlhelp
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+.PHONY: qthelp
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/pyvis.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/pyvis.qhc"
+
+.PHONY: applehelp
+applehelp:
+	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
+	@echo
+	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
+	@echo "N.B. You won't be able to view it unless you put it in" \
+	      "~/Library/Documentation/Help or install it in your application" \
+	      "bundle."
+
+.PHONY: devhelp
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/pyvis"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/pyvis"
+	@echo "# devhelp"
+
+.PHONY: epub
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+.PHONY: epub3
+epub3:
+	$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
+	@echo
+	@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
+
+.PHONY: latex
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+.PHONY: latexpdf
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: latexpdfja
+latexpdfja:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through platex and dvipdfmx..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: text
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+.PHONY: man
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+.PHONY: texinfo
+texinfo:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+.PHONY: info
+info:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+.PHONY: gettext
+gettext:
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+.PHONY: changes
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+.PHONY: linkcheck
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+.PHONY: doctest
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+.PHONY: coverage
+coverage:
+	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
+	@echo "Testing of coverage in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/coverage/python.txt."
+
+.PHONY: xml
+xml:
+	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
+	@echo
+	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
+
+.PHONY: pseudoxml
+pseudoxml:
+	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
+	@echo
+	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
+
+.PHONY: dummy
+dummy:
+	$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
+	@echo
+	@echo "Build finished. Dummy builder generates no files."

pyvis/pyvis/__init__.py

@@ -0,0 +1,2 @@
+from . import network
+from ._version import __version__

pyvis/pyvis/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"  # bump version

pyvis/pyvis/edge.py

@@ -0,0 +1,8 @@
+class Edge(object):
+    def __init__(self, source, dest, directed=False, **options):
+        self.options = options
+        self.options["from"] = source
+        self.options["to"] = dest
+        if directed:
+            if "arrows" not in self.options:
+                self.options["arrows"] = "to"

pyvis/pyvis/network.py

@@ -0,0 +1,984 @@
+import json
+import os
+import platform
+import shutil
+import tempfile
+import webbrowser
+from collections import defaultdict
+from platform import uname
+
+import jsonpickle
+import networkx as nx
+from IPython.core.display import HTML
+from IPython.display import IFrame
+from jinja2 import Template
+
+from .edge import Edge
+from .node import Node
+from .options import Configure, Options
+from .utils import check_html
+
+
+class Network(object):
+    """
+    The Network class is the focus of this library. All viz functionality
+    should be implemented off of a Network instance.
+
+    To instantiate:
+
+    >>> nt = Network()
+    """
+
+    def __init__(
+        self,
+        height="500px",
+        width="100%",
+        directed=False,
+        notebook=False,
+        neighborhood_highlight=False,
+        select_menu=False,
+        bgcolor="#ffffff",
+        font_color=False,
+        layout=None,
+        heading="",
+    ):
+        """
+        :param height: The height of the canvas
+        :param width: The width of the canvas
+        :param directed: Whether or not to use a directed graph. This is false
+                         by default.
+        :param notebook: True if using jupyter notebook.
+        :param bgcolor: The background color of the canvas.
+        :font_color: The color of the node labels text
+        :layout: Use hierarchical layout if this is set
+
+        :type height: num or str
+        :type width: num or str
+        :type directed: bool
+        :type notebook: bool
+        :type bgcolor: str
+        :type font_color: str
+        :type layout: bool
+        """
+        self.nodes = []
+        self.edges = []
+        self.height = height
+        self.width = width
+        self.heading = heading
+        self.html = ""
+        self.shape = "dot"
+        self.font_color = font_color
+        self.directed = directed
+        self.bgcolor = bgcolor
+        self.use_DOT = False
+        self.dot_lang = ""
+        self.options = Options(layout)
+        self.widget = False
+        self.node_ids = []
+        self.node_map = {}
+        self.template = None
+        self.conf = False
+        self.path = os.path.dirname(__file__) + "/templates/template.html"
+        self.neighborhood_highlight = neighborhood_highlight
+        self.select_menu = select_menu
+
+        if notebook:
+            self.prep_notebook()
+
+    def __str__(self):
+        """
+        override print to show readable graph data
+        """
+        return str(
+            json.dumps(
+                {
+                    "Nodes": self.node_ids,
+                    "Edges": self.edges,
+                    "Height": self.height,
+                    "Width": self.width,
+                    "Heading": self.heading,
+                },
+                indent=4,
+            )
+        )
+
+    def __repr__(self):
+        return "{} |N|={} |E|={:,}".format(
+            self.__class__, self.num_nodes(), self.num_edges()
+        )
+
+    def add_node(self, n_id, label=None, shape="dot", **options):
+        """
+        This method adds a node to the network, given a mandatory node ID.
+        Node labels default to node ids if no label is specified during the
+        call.
+
+        >>> nt = Network("500px", "500px")
+        >>> nt.add_node(0, label="Node 0")
+        >>> nt.add_node(1, label="Node 1", color = "blue")
+
+        :param n_id: The id of the node. The id is mandatory for nodes and
+                     they have to be unique. This should obviously be set per
+                     node, not globally.
+
+        :param label: The label is the piece of text shown in or under the
+                      node, depending on the shape.
+
+        :param borderWidth:	The width of the border of the node.
+
+        :param borderWidthSelected:	The width of the border of the node when
+                                    it is selected. When undefined, the
+                                    borderWidth * 2 is used.
+
+        :param brokenImage:	When the shape is set to image or circularImage,
+                            this option can be an URL to a backup image in
+                            case the URL supplied in the image option cannot
+                            be resolved.
+
+        :param group: When not undefined, the node will belong to the defined
+                      group. Styling information of that group will apply to
+                      this node. Node specific styling overrides group styling.
+
+        :param hidden: When true, the node will not be shown. It will still be
+                       part of the physics simulation though!
+
+        :param image: When the shape is set to image or circularImage, this
+                      option should be the URL to an image. If the image
+                      cannot be found, the brokenImage option can be used.
+
+        :param labelHighlightBold: Determines whether or not the label becomes
+                                   bold when the node is selected.
+
+        :param level: When using the hierarchical layout, the level determines
+                      where the node is going to be positioned.
+
+        :param mass: The barnesHut physics model (which is enabled by default)
+                     is based on an inverted gravity model. By increasing
+                     the mass of a node, you increase it's repulsion. Values
+                     lower than 1 are not recommended.
+
+        :param physics:	When false, the node is not part of the physics
+                        simulation. It will not move except for from
+                        manual dragging.
+
+        :param shape: The shape defines what the node looks like. There are
+                      two types of nodes. One type has the label inside of
+                      it and the other type has the label underneath it. The
+                      types with the label inside of it are: ellipse, circle,
+                      database, box, text. The ones with the label outside of
+                      it are: image, circularImage, diamond, dot, star,
+                      triangle, triangleDown, square and icon.
+
+        :param size: The size is used to determine the size of node shapes that
+                     do not have the label inside of them. These shapes are:
+                     image, circularImage, diamond, dot, star, triangle,
+                     triangleDown, square and icon.
+
+        :param title: Title to be displayed when the user hovers over the node.
+                      The title can be an HTML element or a string containing
+                      plain text or HTML.
+
+        :param value: When a value is set, the nodes will be scaled using the
+                      options in the scaling object defined above.
+
+        :param x: This gives a node an initial x position. When using the
+                  hierarchical layout, either the x or y position is set by the
+                  layout engine depending on the type of view. The other value
+                  remains untouched. When using stabilization, the stabilized
+                  position may be different from the initial one. To lock the
+                  node to that position use the physics or fixed options.
+
+        :param y: This gives a node an initial y position. When using the
+                  hierarchical layout,either the x or y position is set by
+                  the layout engine depending on the type of view. The
+                  other value remains untouched. When using stabilization,
+                  the stabilized position may be different from the initial
+                  one. To lock the node to that position use the physics or
+                  fixed options.
+
+        :type n_id: str or int
+        :type label: str or int
+        :type borderWidth: num (optional)
+        :type borderWidthSelected: num (optional)
+        :type brokenImage: str (optional)
+        :type group: str (optional)
+        :type hidden: bool (optional)
+        :type image: str (optional)
+        :type labelHighlightBold: bool (optional)
+        :type level: num (optional)
+        :type mass: num (optional)
+        :type physics: bool (optional)
+        :type shape: str (optional)
+        :type size: num (optional)
+        :type title: str or html element (optional)
+        :type value: num (optional)
+        :type x: num (optional)
+        :type y: num (optional)
+        """
+        assert isinstance(n_id, str) or isinstance(n_id, int)
+        if label:
+            node_label = label
+        else:
+            node_label = n_id
+        if n_id not in self.node_ids:
+
+            n = Node(
+                n_id, shape, label=node_label, font_color=self.font_color, **options
+            )
+
+            # if "group" in options:
+            #    n = Node(n_id, shape, label=node_label, font_color=self.font_color, **options)
+            # else:
+            #    n = Node(n_id, shape, label=node_label, color=color, font_color=self.font_color, **options)
+
+            self.nodes.append(n.options)
+            self.node_ids.append(n_id)
+            self.node_map[n_id] = n.options
+
+    def add_nodes(self, nodes, **kwargs):
+        """
+        This method adds multiple nodes to the network from a list.
+        Default behavior uses values of 'nodes' for node ID and node label
+        properties. You can also specify other lists of properties to go
+        along each node.
+
+        Example:
+
+        >>> g = net.Network()
+        >>> g.add_nodes([1, 2, 3], size=[2, 4, 6], title=["n1", "n2", "n3"])
+        >>> g.nodes
+        >>> [{'id': 1, 'label': 1, 'shape': 'dot', 'size': 2, 'title': 'n1'},
+
+        Output:
+
+        >>> {'id': 2, 'label': 2, 'shape': 'dot', 'size': 4, 'title': 'n2'},
+        >>> {'id': 3, 'label': 3, 'shape': 'dot', 'size': 6, 'title': 'n3'}]
+
+
+        :param nodes: A list of nodes.
+
+        :type nodes: list
+        """
+        valid_args = ["size", "value", "title", "x", "y", "label", "color", "shape"]
+        for k in kwargs:
+            assert k in valid_args, "invalid arg '" + k + "'"
+
+        nd = defaultdict(dict)
+        for i in range(len(nodes)):
+            for k, v in kwargs.items():
+                assert len(v) == len(nodes), (
+                    "keyword arg %s [length %s] does not match"
+                    "[length %s] of nodes" % (k, len(v), len(nodes))
+                )
+                nd[nodes[i]].update({k: v[i]})
+
+        for node in nodes:
+            # check if node is `number-like`
+            try:
+                node = int(node)
+                self.add_node(node, **nd[node])
+            except:
+                # or node could be string
+                assert isinstance(node, str)
+                self.add_node(node, **nd[node])
+
+    def num_nodes(self):
+        """
+        Return number of nodes
+
+        :returns: :py:class:`int`
+        """
+        return len(self.node_ids)
+
+    def num_edges(self):
+        """
+        Return number of edges
+
+        :returns: :py:class:`int`
+        """
+        return len(self.edges)
+
+    def add_edge(self, source, to, **options):
+        """
+
+        Adding edges is done based off of the IDs of the nodes. Order does
+        not matter unless dealing with a directed graph.
+
+        >>> nt.add_edge(0, 1) # adds an edge from node ID 0 to node ID
+        >>> nt.add_edge(0, 1, value = 4) # adds an edge with a width of 4
+
+
+        :param arrowStrikethrough: When false, the edge stops at the arrow.
+                                   This can be useful if you have thick lines
+                                   and you want the arrow to end in a point.
+                                   Middle arrows are not affected by this.
+
+        :param from: Edges are between two nodes, one to and one from. This
+                     is where you define the from node. You have to supply
+                     the corresponding node ID. This naturally only applies
+                     to individual edges.
+
+        :param hidden: When true, the edge is not drawn. It is part still part
+                       of the physics simulation however!
+
+        :param physics:	When true, the edge is part of the physics simulation.
+                        When false, it will not act as a spring.
+
+        :param title: The title is shown in a pop-up when the mouse moves over
+                      the edge.
+
+        :param to: Edges are between two nodes, one to and one from. This is
+                   where you define the to node. You have to supply the
+                   corresponding node ID. This naturally only applies to
+                   individual edges.
+
+        :param value: When a value is set, the edges' width will be scaled
+                      using the options in the scaling object defined above.
+
+        :param width: The width of the edge. If value is set, this is not used.
+
+
+        :type arrowStrikethrough: bool
+        :type from: str or num
+        :type hidden: bool
+        :type physics: bool
+        :type title: str
+        :type to: str or num
+        :type value: num
+        :type width: num
+        """
+        edge_exists = False
+
+        # verify nodes exists
+        assert source in self.get_nodes(), "non existent node '" + str(source) + "'"
+
+        assert to in self.get_nodes(), "non existent node '" + str(to) + "'"
+
+        # we only check existing edge for undirected graphs
+        if not self.directed:
+            for e in self.edges:
+                frm = e["from"]
+                dest = e["to"]
+                if (source == dest and to == frm) or (source == frm and to == dest):
+                    # edge already exists
+                    edge_exists = True
+
+        if not edge_exists:
+            e = Edge(source, to, self.directed, **options)
+            self.edges.append(e.options)
+
+    def add_edges(self, edges):
+        """
+        This method serves to add multiple edges between existing nodes
+        in the network instance. Adding of the edges is done based off
+        of the IDs of the nodes. Order does not matter unless dealing with a
+        directed graph.
+
+        :param edges: A list of tuples, each tuple consists of source of edge,
+                      edge destination and and optional width.
+
+        :type arrowStrikethrough: list of tuples
+        """
+        for edge in edges:
+            # if incoming tuple contains a weight
+            if len(edge) == 3:
+                self.add_edge(edge[0], edge[1], width=edge[2])
+            else:
+                self.add_edge(edge[0], edge[1])
+
+    def get_network_data(self):
+        """
+        Extract relevant information about this network in order to inject into
+        a Jinja2 template.
+
+        Returns:
+                nodes (list), edges (list), height (
+                    string), width (string), options (object)
+
+        Usage:
+
+        >>> nodes, edges, heading, height, width, options = net.get_network_data()
+        """
+        if isinstance(self.options, dict):
+            return (
+                self.nodes,
+                self.edges,
+                self.heading,
+                self.height,
+                self.width,
+                json.dumps(self.options),
+            )
+        else:
+            return (
+                self.nodes,
+                self.edges,
+                self.heading,
+                self.height,
+                self.width,
+                self.options.to_json(),
+            )
+
+    def save_graph(self, name):
+        """
+        Save the graph as html in the current directory with name.
+
+        :param name: the name of the html file to save as
+        :type name: str
+        """
+        check_html(name)
+        self.write_html(name)
+
+    def generate_html(self, notebook=False):
+        """
+        This method generates HTML from the data structures supporting the nodes, edges,
+        and options and updates the template to generate the HTML holding
+        the visualization.
+
+        :type notebook: bool
+
+        Returns
+        :type out: str
+        """
+
+        # here, check if an href is present in the hover data
+        use_link_template = False
+        for n in self.nodes:
+            title = n.get("title", None)
+            if title:
+                if "href" in title:
+                    """
+                    this tells the template to override default hover
+                    mechanic, as the tooltip would move with the mouse
+                    cursor which made interacting with hover data useless.
+                    """
+                    use_link_template = True
+                    break
+        if not notebook:
+            with open(self.path) as html:
+                content = html.read()
+            template = Template(content)
+        else:
+            template = self.template
+
+        nodes, edges, heading, height, width, options = self.get_network_data()
+
+        # check if physics is enabled
+        if isinstance(self.options, dict):
+            if "physics" in self.options and "enabled" in self.options["physics"]:
+                physics_enabled = self.options["physics"]["enabled"]
+            else:
+                physics_enabled = True
+        else:
+            physics_enabled = self.options.physics.enabled
+
+        out = template.render(
+            height=height,
+            width=width,
+            nodes=nodes,
+            edges=edges,
+            heading=heading,
+            options=options,
+            physics_enabled=physics_enabled,
+            use_DOT=self.use_DOT,
+            dot_lang=self.dot_lang,
+            widget=self.widget,
+            bgcolor=self.bgcolor,
+            conf=self.conf,
+            tooltip_link=use_link_template,
+            neighborhood_highlight=self.neighborhood_highlight,
+            select_menu=self.select_menu,
+        )
+
+        return out
+
+    def write_html(self, name="index.html", local=True, notebook=False):
+        """
+        This method gets the data structures supporting the nodes, edges,
+        and options and updates the template to write the HTML holding
+        the visualization.
+        :type name_html: str
+        """
+        check_html(name)
+        self.html = self.generate_html(notebook=notebook)
+
+        if notebook:
+            if os.path.exists("lib"):
+                shutil.rmtree(f"lib")
+            shutil.copytree(f"{os.path.dirname(__file__)}/lib", "lib")
+            with open(name, "w+") as out:
+                out.write(self.html)
+            return IFrame(name, width=self.width, height="600px")
+        else:
+            if local:
+                tempdir = "."
+            else:
+                tempdir = tempfile.mkdtemp()
+            # with tempfile.mkdtemp() as tempdir:
+            if os.path.exists(f"{tempdir}/lib"):
+                shutil.rmtree(f"{tempdir}/lib")
+            shutil.copytree(f"{os.path.dirname(__file__)}/lib", f"{tempdir}/lib")
+
+            with open(f"{tempdir}/{name}", "w+") as out:
+                out.write(self.html)
+                webbrowser.open(f"{tempdir}/{name}")
+
+    def show(self, name, local=True):
+        """
+        Writes a static HTML file and saves it locally before opening.
+
+        :param: name: the name of the html file to save as
+        :type name: str
+        """
+        check_html(name)
+        if self.template is not None:
+            return self.write_html(name, local, notebook=True)
+        else:
+            self.write_html(name, local)
+            # webbrowser.open(name)
+
+    def prep_notebook(self, custom_template=False, custom_template_path=None):
+        """
+        Loads the template data into the template attribute of the network.
+        This should be done in a jupyter notebook environment before showing
+        the network.
+
+        Example:
+                >>> net.prep_notebook()
+                >>> net.show("nb.html")
+
+
+        :param path: the relative path pointing to a template html file
+        :type path: string
+        """
+        if custom_template and custom_template_path:
+            self.set_template(custom_template_path)
+        with open(self.path) as html:
+            content = html.read()
+        self.template = Template(content)
+
+    def set_template(self, path_to_template):
+        self.path = path_to_template
+
+    def from_DOT(self, dot):
+        """
+        This method takes the contents of .DOT file and converts it
+        to a PyVis visualization.
+
+        Assuming the contents of test.dot contains:
+        digraph sample3 {
+        A -> {B ; C ; D}
+        C -> {B ; A}
+        }
+
+        Usage:
+
+        >>> nt.Network("500px", "500px")
+        >>> nt.from_DOT("test.dot")
+        >>> nt.show("dot.html")
+
+        :param dot: The path of the dotfile being converted.
+        :type dot: .dot file
+
+        """
+        self.use_DOT = True
+        file = open(dot, "r")
+        s = str(file.read())
+        self.dot_lang = " ".join(s.splitlines())
+        self.dot_lang = self.dot_lang.replace('"', '\\"')
+
+    def get_adj_list(self):
+        """
+        This method returns the user an adjacency list representation
+        of the network.
+
+        :returns: dictionary mapping of Node ID to list of Node IDs it
+        is connected to.
+        """
+        a_list = {}
+        for i in self.nodes:
+            a_list[i["id"]] = set()
+        if self.directed:
+            for e in self.edges:
+                source = e["from"]
+                dest = e["to"]
+                a_list[source].add(dest)
+        else:
+            for e in self.edges:
+                source = e["from"]
+                dest = e["to"]
+                if dest not in a_list[source] and source not in a_list[dest]:
+                    a_list[source].add(dest)
+                    a_list[dest].add(source)
+        return a_list
+
+    def neighbors(self, node):
+        """
+        Given a node id, return the set of neighbors of this particular node.
+
+        :param node: The node to get the neighbors from
+        :type node: str or int
+
+        :returns: set
+        """
+        assert isinstance(node, str) or isinstance(
+            node, int
+        ), "error: expected int or str for node but got %s" % type(node)
+        assert node in self.node_ids, "error: %s node not in network" % node
+        return self.get_adj_list()[node]
+
+    def from_nx(
+        self,
+        nx_graph,
+        node_size_transf=(lambda x: x),
+        edge_weight_transf=(lambda x: x),
+        default_node_size=10,
+        default_edge_weight=1,
+        show_edge_weights=True,
+        edge_scaling=False,
+    ):
+        """
+        This method takes an exisitng Networkx graph and translates
+        it to a PyVis graph format that can be accepted by the VisJs
+        API in the Jinja2 template. This operation is done in place.
+
+        :param nx_graph: The Networkx graph object that is to be translated.
+        :type nx_graph: networkx.Graph instance
+        :param node_size_transf: function to transform the node size for plotting
+        :type node_size_transf: func
+        :param edge_weight_transf: function to transform the edge weight for plotting
+        :type edge_weight_transf: func
+        :param default_node_size: default node size if not specified
+        :param default_edge_weight: default edge weight if not specified
+        >>> nx_graph = nx.cycle_graph(10)
+        >>> nx_graph.nodes[1]['title'] = 'Number 1'
+        >>> nx_graph.nodes[1]['group'] = 1
+        >>> nx_graph.nodes[3]['title'] = 'I belong to a different group!'
+        >>> nx_graph.nodes[3]['group'] = 10
+        >>> nx_graph.add_node(20, size=20, title='couple', group=2)
+        >>> nx_graph.add_node(21, size=15, title='couple', group=2)
+        >>> nx_graph.add_edge(20, 21, weight=5)
+        >>> nx_graph.add_node(25, size=25, label='lonely', title='lonely node', group=3)
+        >>> nt = Network("500px", "500px")
+        # populates the nodes and edges data structures
+        >>> nt.from_nx(nx_graph)
+        >>> nt.show("nx.html")
+        """
+        assert isinstance(nx_graph, nx.Graph)
+        edges = nx_graph.edges(data=True)
+        nodes = nx_graph.nodes(data=True)
+
+        if len(edges) > 0:
+            for e in edges:
+                if "size" not in nodes[e[0]].keys():
+                    nodes[e[0]]["size"] = default_node_size
+                nodes[e[0]]["size"] = int(node_size_transf(nodes[e[0]]["size"]))
+                if "size" not in nodes[e[1]].keys():
+                    nodes[e[1]]["size"] = default_node_size
+                nodes[e[1]]["size"] = int(node_size_transf(nodes[e[1]]["size"]))
+                self.add_node(e[0], **nodes[e[0]])
+                self.add_node(e[1], **nodes[e[1]])
+
+                # if user does not pass a 'weight' argument
+                if "value" not in e[2] or "width" not in e[2]:
+                    if edge_scaling:
+                        width_type = "value"
+                    else:
+                        width_type = "width"
+                    if "weight" not in e[2].keys():
+                        e[2]["weight"] = default_edge_weight
+                    e[2][width_type] = edge_weight_transf(e[2]["weight"])
+                    # replace provided weight value and pass to 'value' or 'width'
+                    e[2][width_type] = e[2].pop("weight")
+
+                self.add_edge(e[0], e[1], **e[2])
+
+        for node in nx.isolates(nx_graph):
+            if "size" not in nodes[node].keys():
+                nodes[node]["size"] = default_node_size
+            self.add_node(node, **nodes[node])
+
+    def get_nodes(self):
+        """
+        This method returns an iterable list of node ids
+
+        :returns: list
+        """
+        return self.node_ids
+
+    def get_node(self, n_id):
+        """
+        Lookup node by ID and return it.
+
+        :param n_id: The ID given to the node.
+
+        :returns: dict containing node properties
+        """
+        return self.node_map[n_id]
+
+    def get_edges(self):
+        """
+        This method returns an iterable list of edge objects
+
+        :returns: list
+        """
+        return self.edges
+
+    def barnes_hut(
+        self,
+        gravity=-80000,
+        central_gravity=0.3,
+        spring_length=250,
+        spring_strength=0.001,
+        damping=0.09,
+        overlap=0,
+    ):
+        """
+        BarnesHut is a quadtree based gravity model. It is the fastest. default
+        and recommended solver for non-hierarchical layouts.
+
+        :param gravity: The more negative the gravity value is, the stronger the
+                        repulsion is.
+        :param central_gravity: The gravity attractor to pull the entire network
+                                to the center.
+        :param spring_length: The rest length of the edges
+        :param spring_strength: The strong the edges springs are
+        :param damping: A value ranging from 0 to 1 of how much of the velocity
+                        from the previous physics simulation iteration carries
+                        over to the next iteration.
+        :param overlap: When larger than 0, the size of the node is taken into
+                        account. The distance will be calculated from the radius
+                        of the encompassing circle of the node for both the
+                        gravity model. Value 1 is maximum overlap avoidance.
+
+        :type gravity: int
+        :type central_gravity: float
+        :type spring_length: int
+        :type spring_strength: float
+        :type damping: float
+        :type overlap: float
+        """
+        self.options.physics.use_barnes_hut(locals())
+
+    def repulsion(
+        self,
+        node_distance=100,
+        central_gravity=0.2,
+        spring_length=200,
+        spring_strength=0.05,
+        damping=0.09,
+    ):
+        """
+        Set the physics attribute of the entire network to repulsion.
+        When called, it sets the solver attribute of physics to repulsion.
+
+        :param node_distance: This is the range of influence for the repulsion.
+        :param central_gravity: The gravity attractor to pull the entire network
+                                to the center.
+        :param spring_length: The rest length of the edges
+        :param spring_strength: The strong the edges springs are
+        :param damping: A value ranging from 0 to 1 of how much of the velocity
+                        from the previous physics simulation iteration carries
+                        over to the next iteration.
+
+        :type node_distance: int
+        :type central_gravity float
+        :type spring_length: int
+        :type spring_strength: float
+        :type damping: float
+        """
+        self.options.physics.use_repulsion(locals())
+
+    def hrepulsion(
+        self,
+        node_distance=120,
+        central_gravity=0.0,
+        spring_length=100,
+        spring_strength=0.01,
+        damping=0.09,
+    ):
+        """
+        This model is based on the repulsion solver but the levels are
+        taken into account and the forces are normalized.
+
+        :param node_distance: This is the range of influence for the repulsion.
+        :param central_gravity: The gravity attractor to pull the entire network
+                                to the center.
+        :param spring_length: The rest length of the edges
+        :param spring_strength: The strong the edges springs are
+        :param damping: A value ranging from 0 to 1 of how much of the velocity
+                        from the previous physics simulation iteration carries
+                        over to the next iteration.
+
+        :type node_distance: int
+        :type central_gravity float
+        :type spring_length: int
+        :type spring_strength: float
+        :type damping: float
+        """
+        self.options.physics.use_hrepulsion(locals())
+
+    def force_atlas_2based(
+        self,
+        gravity=-50,
+        central_gravity=0.01,
+        spring_length=100,
+        spring_strength=0.08,
+        damping=0.4,
+        overlap=0,
+    ):
+        """
+        The forceAtlas2Based solver makes use of some of the equations provided
+        by them and makes use of the barnesHut implementation in vis. The main
+        differences are the central gravity model, which is here distance
+        independent, and the repulsion being linear instead of quadratic. Finally,
+        all node masses have a multiplier based on the amount of connected edges
+        plus one.
+
+        :param gravity: The more negative the gravity value is, the stronger the
+                        repulsion is.
+        :param central_gravity: The gravity attractor to pull the entire network
+                                to the center.
+        :param spring_length: The rest length of the edges
+        :param spring_strength: The strong the edges springs are
+        :param damping: A value ranging from 0 to 1 of how much of the velocity
+                        from the previous physics simulation iteration carries
+                        over to the next iteration.
+        :param overlap: When larger than 0, the size of the node is taken into
+                        account. The distance will be calculated from the radius
+                        of the encompassing circle of the node for both the
+                        gravity model. Value 1 is maximum overlap avoidance.
+
+        :type gravity: int
+        :type central_gravity: float
+        :type spring_length: int
+        :type spring_strength: float
+        :type damping: float
+        :type overlap: float
+        """
+        self.options.physics.use_force_atlas_2based(locals())
+
+    def to_json(self, max_depth=1, **args):
+        return jsonpickle.encode(self, max_depth=max_depth, **args)
+
+    def set_edge_smooth(self, smooth_type):
+        """
+        Sets the smooth.type attribute of the edges.
+
+        :param smooth_type: Possible options: 'dynamic', 'continuous',
+                            'discrete', 'diagonalCross', 'straightCross',
+                            'horizontal', 'vertical', 'curvedCW',
+                            'curvedCCW', 'cubicBezier'.
+                            When using dynamic, the edges will have an
+                            invisible support node guiding the shape.
+                            This node is part of the physics simulation.
+                            Default is set to continous.
+
+        :type smooth_type: string
+        """
+        self.options.edges.smooth.enabled = True
+        self.options.edges.smooth.type = smooth_type
+
+    def toggle_hide_edges_on_drag(self, status):
+        """
+        Displays or hides edges while dragging the network. This makes
+        panning of the network easy.
+
+        :param status: True if edges should be hidden on drag
+
+        :type status: bool
+        """
+        self.options.interaction.hideEdgesOnDrag = status
+
+    def toggle_hide_nodes_on_drag(self, status):
+        """
+        Displays or hides nodes while dragging the network. This makes
+        panning of the network easy.
+
+        :param status: When set to True, the nodes will hide on drag.
+                       Default is set to False.
+
+        :type status: bool
+        """
+        self.options.interaction.hideNodesOnDrag = status
+
+    def inherit_edge_colors(self, status):
+        """
+        Edges take on the color of the node they are coming from.
+
+        :param status: True if edges should adopt color coming from.
+        :type status: bool
+        """
+        self.options.edges.inherit_colors(status)
+
+    def show_buttons(self, filter_=None):
+        """
+        Displays or hides certain widgets to dynamically modify the
+        network.
+
+        Usage:
+        >>> g.show_buttons(filter_=['nodes', 'edges', 'physics'])
+
+        Or to show all options:
+        >>> g.show_buttons()
+
+        :param status: When set to True, the widgets will be shown.
+                       Default is set to False.
+        :param filter_: Only include widgets specified by `filter_`.
+                        Valid options: True (gives all widgets)
+                                       List of `nodes`, `edges`,
+                                       `layout`, `interaction`,
+                                       `manipulation`, `physics`,
+                                       `selection`, `renderer`.
+
+        :type status: bool
+        :type filter_: bool or list:
+        """
+        self.conf = True
+        self.options.configure = Configure(enabled=True, filter_=filter_)
+        self.widget = True
+
+    def toggle_physics(self, status):
+        """
+        Toggles physics simulation
+
+        :param status: When False, nodes are not part of the physics
+                       simulation. They will not move except for from
+                       manual dragging.
+                       Default is set to True.
+
+        :type status: bool
+        """
+        self.options.physics.enabled = status
+
+    def toggle_drag_nodes(self, status):
+        """
+        Toggles the dragging of the nodes in the network.
+
+        :param status: When set to True, the nodes can be dragged around
+                       in the network. Default is set to True.
+
+        :type status: bool
+        """
+        self.options.interaction.dragNodes = status
+
+    def toggle_stabilization(self, status):
+        """
+        Toggles the stablization of the network.
+
+        :param status: Default is set to True.
+
+        :type status: bool
+        """
+        self.options.physics.toggle_stabilization(status)
+
+    def set_options(self, options):
+        """
+        Overrides the default options object passed to the VisJS framework.
+        Delegates to the :meth:`options.Options.set` routine.
+
+        :param options: The string representation of the Javascript-like object
+                        to be used to override default options.
+
+        :type options: str
+        """
+        self.options = self.options.set(options)

pyvis/pyvis/node.py

@@ -0,0 +1,8 @@
+class Node(object):
+    def __init__(self, n_id, shape, label, font_color=False, **opts):
+        self.options = opts
+        self.options["id"] = n_id
+        self.options["label"] = label
+        self.options["shape"] = shape
+        if font_color:
+            self.options["font"] = dict(color=font_color)

pyvis/pyvis/options.py

@@ -0,0 +1,233 @@
+from .physics import *
+
+
+class EdgeOptions(object):
+    """
+    This is where the construction of the edges' options takes place.
+    So far, the edge smoothness can be switched through this object
+    as well as the edge color's inheritance.
+    """
+
+    def __init__(self):
+        self.smooth = self.Smooth()
+        self.color = self.Color()
+
+    def inherit_colors(self, status):
+        """
+        Whether or not to inherit colors from the source node.
+        If this is set to `from` then the edge will take the color
+        of the source node. If it is set to `to` then the color will
+        be that of the destination node.
+
+        .. note:: If set to `True` then the `from` behavior is adopted
+                  and vice versa.
+        """
+        self.color.inherit = status
+
+    def toggle_smoothness(self, smooth_type):
+        """
+        Change smooth option for edges. When using dynamic, the edges will
+        have an invisible support node guiding the shape. This node is part
+        of the physics simulation,
+
+        :param smooth_type: Possible options are dynamic, continuous, discrete,
+                            diagonalCross, straightCross, horizontal, vertical,
+                            curvedCW, curvedCCW, cubicBezier
+
+        :type smooth_type: str
+        """
+        self.smooth.type = smooth_type
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+    class Smooth(object):
+        """
+        When the edges are made to be smooth, the edges are drawn as a
+        dynamic quadratic bezier curve. The drawing of these curves
+        takes longer than that of the straight curves but it looks better.
+        There is a difference between dynamic smooth curves and static
+        smooth curves. The dynamic smooth curves have an invisible support
+        node that takes part in the physics simulation. If there are a lot
+        of edges, another kind of smooth than dynamic would be better for
+        performance.
+        """
+
+        def __repr__(self):
+            return str(self.__dict__)
+
+        def __init__(self):
+            self.enabled = True
+            self.type = "dynamic"
+
+    class Color(object):
+        """
+        The color object contains the color information of the edge
+        in every situation. When the edge only needs a single color value
+        like 'rgb(120,32,14)', '#ffffff' or 'red' can be supplied instead
+        of an object.
+        """
+
+        def __repr__(self):
+            return str(self.__dict__)
+
+        def __init__(self):
+            self.inherit = True
+
+
+class Interaction(object):
+    """
+    Used for all user interaction with the network. Handles mouse
+    and touch events as well as the navigation buttons and the popups.
+    """
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+    def __init__(self):
+        self.hideEdgesOnDrag = False
+        self.hideNodesOnDrag = False
+        self.dragNodes = True
+
+    def __getitem__(self, item):
+        return self.__dict__[item]
+
+
+class Configure(object):
+    """
+    Handles the HTML part of the canvas and generates
+    an interactive option editor with filtering.
+    """
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+    def __init__(self, enabled=False, filter_=None):
+        self.enabled = enabled
+        if filter_:
+            self.filter = filter_
+
+    def __getitem__(self, item):
+        return self.__dict__[item]
+
+
+class Layout(object):
+    """
+    Acts as the camera that looks on the canvas.
+    Does the animation, zooming and focusing.
+    """
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+    def __init__(self, randomSeed=None, improvedLayout=True):
+        if not randomSeed:
+            self.randomSeed = 0
+        else:
+            self.randomSeed = randomSeed
+        self.improvedLayout = improvedLayout
+        self.hierarchical = self.Hierarchical(enabled=True)
+
+    def set_separation(self, distance):
+        """
+        The distance between the different levels.
+        """
+        self.hierarchical.levelSeparation = distance
+
+    def set_tree_spacing(self, distance):
+        """
+        Distance between different trees (independent networks). This is
+        only for the initial layout. If you enable physics, the repulsion
+        model will denote the distance between the trees.
+        """
+        self.hierarchical.treeSpacing = distance
+
+    def set_edge_minimization(self, status):
+        """
+        Method for reducing whitespace. Can be used alone or together with
+        block shifting. Enabling block shifting will usually speed up the
+        layout process. Each node will try to move along its free axis to
+        reduce the total length of it's edges. This is mainly for the
+        initial layout. If you enable physics, they layout will be determined
+        by the physics. This will greatly speed up the stabilization time
+        """
+        self.hierarchical.edgeMinimization = status
+
+    class Hierarchical(object):
+        def __getitem__(self, item):
+            return self.__dict__[item]
+
+        def __init__(
+            self,
+            enabled=False,
+            levelSeparation=150,
+            treeSpacing=200,
+            blockShifting=True,
+            edgeMinimization=True,
+            parentCentralization=True,
+            sortMethod="hubsize",
+        ):
+
+            self.enabled = enabled
+            self.levelSeparation = levelSeparation
+            self.treeSpacing = treeSpacing
+            self.blockShifting = blockShifting
+            self.edgeMinimization = edgeMinimization
+            self.parentCentralization = parentCentralization
+            self.sortMethod = sortMethod
+
+
+class Options(object):
+    """
+    Represents the global options of the network.
+    This object consists of indiviual sub-objects
+    that map to VisJS's modules of:
+        - configure
+        - layout
+        - interaction
+        - physics
+        - edges
+
+    The JSON representation of this object is directly passed
+    in to the VisJS framework.
+    In the future this can be expanded to completely mimic
+    the structure VisJS can expect.
+    """
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+    def __getitem__(self, item):
+        return self.__dict__[item]
+
+    def __init__(self, layout=None):
+        if layout:
+            self.layout = Layout()
+        self.interaction = Interaction()
+        self.configure = Configure()
+        self.physics = Physics()
+        self.edges = EdgeOptions()
+
+    def set(self, new_options):
+        """
+        This method should accept a JSON string and replace its internal
+        options structure with the given argument after parsing it.
+        In practice, this method should be called after using the browser
+        to experiment with different physics and layout options, using
+        the generated JSON options structure that is spit out from the
+        front end to serve as input to this method as a string.
+
+        :param new_options: The JSON like string of the options that will
+                            override.
+
+        :type new_options: str
+        """
+
+        options = new_options.replace("\n", "").replace(" ", "")
+        first_bracket = options.find("{")
+        options = options[first_bracket:]
+        options = json.loads(options)
+        return options
+
+    def to_json(self):
+        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)

pyvis/pyvis/physics.py

@@ -0,0 +1,117 @@
+import json
+
+
+class Physics(object):
+
+    engine_chosen = False
+
+    def __getitem__(self, item):
+        return self.__dict__[item]
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+    class barnesHut(object):
+        """
+        BarnesHut is a quadtree based gravity model.
+        This is the fastest, default and recommended.
+        """
+
+        def __init__(self, params):
+            self.gravitationalConstant = params["gravity"]
+            self.centralGravity = params["central_gravity"]
+            self.springLength = params["spring_length"]
+            self.springConstant = params["spring_strength"]
+            self.damping = params["damping"]
+            self.avoidOverlap = params["overlap"]
+
+    class forceAtlas2Based(object):
+        """
+        Force Atlas 2 has been develoved by Jacomi et all (2014)
+        for use with Gephi. The force Atlas based solver makes use
+        of some of the equations provided by them and makes use of
+        some of the barnesHut implementation in vis. The Main differences
+        are the central gravity model, which is here distance independent,
+        and repulsion being linear instead of quadratic. Finally, all node
+        masses have a multiplier based on the amount of connected edges
+        plus one.
+        """
+
+        def __init__(self, params):
+            self.gravitationalConstant = params["gravity"]
+            self.centralGravity = params["central_gravity"]
+            self.springLength = params["spring_length"]
+            self.springConstant = params["spring_strength"]
+            self.damping = params["damping"]
+            self.avoidOverlap = params["overlap"]
+
+    class Repulsion(object):
+        """
+        The repulsion model assumes nodes have a simplified field
+        around them. Its force lineraly decreases from 1
+        (at 0.5*nodeDistace and smaller) to 0 (at 2*nodeDistance)
+        """
+
+        def __init__(self, params):
+            self.nodeDistance = params["node_distance"]
+            self.centralGravity = params["central_gravity"]
+            self.springLength = params["spring_length"]
+            self.springConstant = params["spring_strength"]
+            self.damping = params["damping"]
+
+    class hierarchicalRepulsion(object):
+        """
+        This model is based on the repulsion solver but the levels
+        are taken into accound and the forces
+        are normalized.
+        """
+
+        def __init__(self, params):
+            self.nodeDistance = params["node_distance"]
+            self.centralGravity = params["central_gravity"]
+            self.springLength = params["spring_length"]
+            self.springConstant = params["spring_strength"]
+            self.damping = params["damping"]
+
+    class Stabilization(object):
+        """
+        This makes the network stabilized on load using default settings.
+        """
+
+        def __getitem__(self, item):
+            return self.__dict__[item]
+
+        def __init__(self):
+            self.enabled = True
+            self.iterations = 1000
+            self.updateInterval = 50
+            self.onlyDynamicEdges = False
+            self.fit = True
+
+        def toggle_stabilization(self, status):
+            self.enabled = status
+
+    def __init__(self):
+        self.enabled = True
+        self.stabilization = self.Stabilization()
+
+    def use_barnes_hut(self, params):
+        self.barnesHut = self.barnesHut(params)
+
+    def use_force_atlas_2based(self, params):
+        self.forceAtlas2Based = self.forceAtlas2Based(params)
+        self.solver = "forceAtlas2Based"
+
+    def use_repulsion(self, params):
+        self.repulsion = self.Repulsion(params)
+        self.solver = "repulsion"
+
+    def use_hrepulsion(self, params):
+        self.hierarchicalRepulsion = self.hierarchicalRepulsion(params)
+        self.solver = "hierarchicalRepulsion"
+
+    def toggle_stabilization(self, status):
+        self.stabilization.toggle_stabilization(status)
+
+    def to_json(self):
+        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)

pyvis/pyvis/source/conf.py

@@ -0,0 +1,308 @@
+# -*- coding: utf-8 -*-
+#
+# pyvis documentation build configuration file, created by
+# sphinx-quickstart on Wed Nov 02 20:10:44 2016.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import os
+import sys
+
+import sphinx_rtd_theme
+
+# dynamically read the version
+exec(open("../_version.py").read())
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+sys.path.insert(0, os.path.abspath("../.."))
+
+# os.path.abspath('mydir/myfile.txt')
+
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.ifconfig",
+    "sphinx.ext.viewcode",
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+# source_suffix = ['.rst', '.md']
+source_suffix = ".rst"
+
+# The encoding of source files.
+# source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = "index"
+
+# General information about the project.
+project = "pyvis"
+copyright = "2016-2018, West Health Institute"
+author = "Giancarlo Perrone"
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = __version__
+# The full version, including alpha/beta/rc tags.
+release = "0.1.3.1"
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+# today = ''
+# Else, today_fmt is used as the format for a strftime call.
+# today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+exclude_patterns = []
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+# default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+# add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+# add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+# show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = "sphinx"
+
+# A list of ignored prefixes for module index sorting.
+# modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+# keep_warnings = False
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = "sphinx_rtd_theme"
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+# html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
+
+# The name for this set of Sphinx documents.
+# "<project> v<release> documentation" by default.
+# html_title = u'pyvis v0.0.1'
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+# html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+# html_logo = None
+
+# The name of an image file (relative to this directory) to use as a favicon of
+# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+# html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+# html_extra_path = []
+
+# If not None, a 'Last updated on:' timestamp is inserted at every page
+# bottom, using the given strftime format.
+# The empty string is equivalent to '%b %d, %Y'.
+# html_last_updated_fmt = None
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+# html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+# html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+# html_additional_pages = {}
+
+# If false, no module index is generated.
+# html_domain_indices = True
+
+# If false, no index is generated.
+# html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+# html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+# html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+# html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+# html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+# html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+# html_file_suffix = None
+
+# Language to be used for generating the HTML full-text search index.
+# Sphinx supports the following languages:
+#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
+#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh'
+# html_search_language = 'en'
+
+# A dictionary with options for the search language support, empty by default.
+# 'ja' uses this config value.
+# 'zh' user can custom change `jieba` dictionary path.
+# html_search_options = {'type': 'default'}
+
+# The name of a javascript file (relative to the configuration directory) that
+# implements a search results scorer. If empty, the default will be used.
+# html_search_scorer = 'scorer.js'
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = "pyvisdoc"
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #'papersize': 'letterpaper',
+    # The font size ('10pt', '11pt' or '12pt').
+    #'pointsize': '10pt',
+    # Additional stuff for the LaTeX preamble.
+    #'preamble': '',
+    # Latex figure (float) alignment
+    #'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (
+        master_doc,
+        "pyvis.tex",
+        "pyvis Documentation",
+        "Giancarlo Perrone, Shashank Soni",
+        "manual",
+    ),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+# latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+# latex_use_parts = False
+
+# If true, show page references after internal links.
+# latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+# latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+# latex_appendices = []
+
+# If false, no module index is generated.
+# latex_domain_indices = True
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [(master_doc, "pyvis", "pyvis Documentation", [author], 1)]
+
+# If true, show URL addresses after external links.
+# man_show_urls = False
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (
+        master_doc,
+        "pyvis",
+        "pyvis Documentation",
+        author,
+        "pyvis",
+        "One line description of project.",
+        "Miscellaneous",
+    ),
+]
+
+# Documents to append as an appendix to all manuals.
+# texinfo_appendices = []
+
+# If false, no module index is generated.
+# texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+# texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+# texinfo_no_detailmenu = False
+
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {"https://docs.python.org/": None}

pyvis/pyvis/source/documentation.rst

@@ -0,0 +1,9 @@
+=============
+Documentation
+=============
+
+.. automodule:: pyvis.network
+	:members:
+
+.. automodule:: pyvis.options
+	:members:

pyvis/pyvis/source/index.rst

@@ -0,0 +1,33 @@
+
+.. image:: net.png
+    :width: 30%
+.. image:: net2.png
+    :width: 30%
+.. image:: net3.png
+	:width: 30%
+
+Interactive network visualizations
+==================================
+.. image:: tut.gif
+
+Contents:
+=========
+.. toctree::
+   :maxdepth: 2
+   
+   install
+   introduction
+   tutorial
+   license
+   documentation
+
+
+
+
+Indices and tables
+------------------
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+* :ref:`glossary`

pyvis/pyvis/source/install.rst

@@ -0,0 +1,20 @@
+============
+Installation
+============
+
+----------------
+Install with pip
+----------------
+
+.. code-block:: bash
+
+    $ pip install pyvis
+
+Or you can download an archive of the project here_. To install, unpack it 
+and run the following in the top-level directory:
+
+.. code-block:: bash
+
+    $ python setup.py install
+
+.. _here: https://github.com/WestHealth/pyvis/

pyvis/pyvis/source/introduction.rst

@@ -0,0 +1,13 @@
+============
+Introduction
+============
+
+The goal of this project is to build a python based approach to constructing and visualizing
+network graphs in the same space. A pyvis network can be customized on a per node or per edge
+basis. Nodes can be given colors, sizes, labels, and other metadata. Each graph can be interacted
+with, allowing the dragging, hovering, and selection of nodes and edges. Each graph's layout
+algorithm can be tweaked as well to allow experimentation with rendering of larger graphs.
+
+Pyvis is built around the amazing VisJS_ library.
+
+.. _VisJS: https://visjs.github.io/vis-network/examples/

pyvis/pyvis/source/license.rst

@@ -0,0 +1,33 @@
+============
+License
+============
+
+Pyvis is distributed with the BSD 3 Clause license.
+
+Copyright (c) 2018, West Health Institute
+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 West Health Institute 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 AND CONTRIBUTORS "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 HOLDER OR CONTRIBUTORS 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.

pyvis/pyvis/source/tutorial.rst

@@ -0,0 +1,227 @@
+    
+============
+Tutorial
+============
+The pyvis library is meant for quick generation of visual network graphs
+with minimal python code. It is designed as a wrapper around the popular 
+Javascript visJS library found at this link_.
+
+.. _link: https://visjs.github.io/vis-network/examples/
+
+
+Getting started
+---------------
+All networks must be instantiated as a ``Network`` class instance
+
+>>> from pyvis.network import Network
+>>> net = Network()
+
+Add nodes to the network
+------------------------ 
+>>> net.add_node(1, label="Node 1") # node id = 1 and label = Node 1
+>>> net.add_node(2) # node id and label = 2
+
+Here, the first parameter to the add_node method is the desired ID to give the
+Node. This can be a string or a numeric. The label argument is the string that
+will be visibly attached to the node in the final visualization. If no label
+argument is specified then the node id will be used as a label.
+
+.. note:: The ``ID`` parameter must be unique
+
+You can also add a list of nodes
+
+>>> nodes = ["a", "b", "c", "d"]
+>>> net.add_nodes(nodes) # node ids and labels = ["a", "b", "c", "d"]
+>>> net.add_nodes("hello") # node ids and labels = ["h", "e", "l", "o"]
+
+.. note:: :meth:`network.Network.add_nodes` accepts any iterable as long as the contents are strings or numerics 
+
+Node properties
+---------------
+A call to :meth:`add_node` supports various node properties that can be set
+individually. All of these properties can be found here_, courtesy of VisJS_.
+For the direct Python translation of these attributes, reference the
+:meth:`network.Network.add_node` docs. 
+
+.. _here: https://visjs.github.io/vis-network/docs/network/nodes.html
+.. _VisJS: https://visjs.github.io/vis-network/docs/network/
+
+.. note:: Through no fault of pyvis, some of the attributes in the VisJS_ documentation do not 
+   work as expected, or at all. Pyvis can translate into the JavaScript
+   elements for VisJS_ but after that it's up to VisJS_!
+
+Indexing a Node
+---------------
+Use the :meth:`get_node` method to index a node by its ID:
+
+>>> net.add_nodes(["a", "b", "c"])
+>>> net.get_node("c")
+>>> {'id': 'c', 'label': 'c', 'shape': 'dot'}
+
+
+Adding list of nodes with properties
+------------------------------------
+When using the :meth:`network.Network.add_nodes` method optional keyword arguments can be
+passed in to add properties to these nodes as well. The valid properties in this case are
+
+   >>> ['size', 'value', 'title', 'x', 'y', 'label', 'color']
+
+Each of these keyword args must be the same length as the nodes parameter to the method.
+
+Example:
+
+    >>> g = Network()
+    >>> g.add_nodes([1,2,3], value=[10, 100, 400], 
+                             title=['I am node 1', 'node 2 here', 'and im node 3'], 
+                             x=[21.4, 54.2, 11.2], 
+                             y=[100.2, 23.54, 32.1], 
+                             label=['NODE 1', 'NODE 2', 'NODE 3'], 
+                             color=['#00ff1e', '#162347', '#dd4b39'])
+
+.. raw:: html
+	:file: mulnodes.html
+
+.. note:: If you mouse over each node you will see that the ``title`` of a node
+   attribute is responsible for rendering data on mouse hover. You can add ``HTML`` 
+   in your ``title`` string and it will be rendered as such.
+
+.. note:: The ``color`` attribute can also be a plain HTML ``color`` like red or blue. You can also 
+   specify the full ``rgba`` specification if needed. The VisJS_ documentation has more 
+   details.
+
+Detailed optional argument documentation for nodes are in the
+:meth:`network.Network.add_node` method documentation.
+
+Edges
+-----
+
+Assuming the network's nodes exist, the edges can then be added according to node id's
+
+   >>> net.add_node(0, label='a')
+   >>> net.add_node(1, label='b')
+   >>> net.add_edge(0, 1)
+
+Edges can contain a ``weight`` attribute as well
+
+   >>> net.add_edge(0, 1, weight=.87)
+
+Edges can be customized and documentation on options can be found at
+:meth:`network.Network.add_edge` method documentation, or by referencing the
+original VisJS edge_ module docs.
+
+.. _edge: https://visjs.github.io/vis-network/docs/network/edges.html
+
+`Networkx <https://networkx.github.io/>`_ integration
+------------------------------------------------------
+
+An easy way  to visualize and construct pyvis networks is to use `Networkx <https://networkx.github.io>`_ 
+and use pyvis's built-in networkx helper method to translate the graph. Note that the
+Networkx node properties with the same names as those consumed by pyvis (e.g., ``title``)  are 
+translated directly to the correspondingly-named pyvis node attributes.
+
+   >>> from pyvis.network import Network
+   >>> import networkx as nx
+   >>> nx_graph = nx.cycle_graph(10)
+   >>> nx_graph.nodes[1]['title'] = 'Number 1'
+   >>> nx_graph.nodes[1]['group'] = 1
+   >>> nx_graph.nodes[3]['title'] = 'I belong to a different group!'
+   >>> nx_graph.nodes[3]['group'] = 10
+   >>> nx_graph.add_node(20, size=20, title='couple', group=2)
+   >>> nx_graph.add_node(21, size=15, title='couple', group=2)
+   >>> nx_graph.add_edge(20, 21, weight=5)
+   >>> nx_graph.add_node(25, size=25, label='lonely', title='lonely node', group=3)
+   >>> nt = Network('500px', '500px')
+   # populates the nodes and edges data structures
+   >>> nt.from_nx(nx_graph)
+   >>> nt.show('nx.html')
+
+.. raw:: html
+	:file: nx.html
+
+
+Visualization
+-------------
+
+The displaying of a graph is achieved by a single method call on
+:meth:`network.Network.show()` after the underlying network is constructed.
+The interactive visualization is presented as a static HTML file.
+
+>>> net.toggle_physics(True)
+>>> net.show('mygraph.html')
+
+.. note:: Triggering the :meth:`toggle_physics` method allows for more fluid graph interactions 
+
+Example: Visualizing a Game of Thrones character network
+--------------------------------------------------------
+
+The following code block is a minimal example of the capabilities of pyvis. 
+
+.. code-block:: python
+
+    from pyvis.network import Network
+    import pandas as pd
+
+    got_net = Network(height='750px', width='100%', bgcolor='#222222', font_color='white')
+
+    # set the physics layout of the network
+    got_net.barnes_hut()
+    got_data = pd.read_csv('https://www.macalester.edu/~abeverid/data/stormofswords.csv')
+
+    sources = got_data['Source']
+    targets = got_data['Target']
+    weights = got_data['Weight']
+
+    edge_data = zip(sources, targets, weights)
+
+    for e in edge_data:
+        src = e[0]
+        dst = e[1]
+        w = e[2]
+
+        got_net.add_node(src, src, title=src)
+        got_net.add_node(dst, dst, title=dst)
+        got_net.add_edge(src, dst, value=w)
+
+    neighbor_map = got_net.get_adj_list()
+
+    # add neighbor data to node hover data
+    for node in got_net.nodes:
+        node['title'] += ' Neighbors:<br>' + '<br>'.join(neighbor_map[node['id']])
+        node['value'] = len(neighbor_map[node['id']])
+
+    got_net.show('gameofthrones.html')
+
+    
+If you want to try out the above code, the csv data source can be `downloaded <https://www.macalester.edu/~abeverid/data/stormofswords.csv>`_
+
+.. note:: The ``title`` attribute of each node is responsible for rendering data on node hover.
+
+.. raw:: html
+	:file: gameofthrones.html
+
+Using the configuration UI to dynamically tweak ``Network`` settings
+----------------------------------------------------------------
+You also have the option of supplying your visualization with a UI used to
+dynamically alter some of the settings pertaining to your network. This could
+be useful for finding the most optimal parameters to your graph's physics and
+layout function.
+
+>>> net.show_buttons(filter_=['physics'])
+
+.. image:: buttons.gif
+
+.. note:: You can copy/paste the output from the `generate options` button in the above UI 
+          into :meth:`network.Network.set_options` to finalize your results from experimentation
+          with the settings. 
+
+.. image:: set_options_ex.gif
+
+Using pyvis within `Jupyter <https://jupyter.org>`_ notebook
+------------------------------------------------------------
+
+Pyvis supports `Jupyter <https://jupyter.org>`_ notebook embedding through the
+use of the :meth:`network.Network` constructor.  The network instance must be
+"prepped" during instantiation by supplying the `notebook=True` kwarg.
+Example:
+
+.. image:: jup.png

pyvis/pyvis/tests/test_graph.py

@@ -0,0 +1,335 @@
+import os
+import unittest
+
+from ..network import Network
+
+
+class NodeTestCase(unittest.TestCase):
+    def setUp(self):
+        self.g = Network()
+
+    def test_one_node_g(self):
+        self.g.add_node(0, 0)
+        self.assertEqual(0, self.g.nodes[0]["id"])
+        self.assertEqual(0, self.g.nodes[0]["label"])
+        self.assertTrue(0 in self.g.get_nodes())
+
+    def test_one_conn(self):
+        self.g.add_nodes([0, 1])
+        self.assertTrue(1 in self.g.get_nodes())
+        self.assertTrue(0 in self.g.get_nodes())
+        self.g.add_edge(0, 1)
+        self.assertTrue(
+            self.g.get_edges()[0]["from"] == 0 and self.g.get_edges()[0]["to"] == 1
+        )
+
+    def test_no_dup_edges(self):
+        self.g.add_nodes([0, 1])
+        self.g.add_edge(0, 1)
+        self.assertTrue(len(self.g.get_edges()) == 1)
+        self.g.add_edge(1, 0)
+        self.assertTrue(len(self.g.get_edges()) == 1)
+
+    def test_no_dup_nodes(self):
+        self.g.add_node(100, 100)
+        self.g.add_node(100, 100)
+        self.assertTrue(len(self.g.nodes) == 1)
+        self.g.add_node(100, "n101")
+        self.assertTrue(len(self.g.nodes) == 1)
+
+    def test_node_labels(self):
+        self.g.add_node(1, "n2")
+        self.g.add_node(2, "n3")
+        self.g.add_node(3, "n4")
+        self.assertEqual(
+            set(map(lambda s: s["label"], self.g.nodes)), set(["n2", "n3", "n4"])
+        )
+
+    def test_node_titles(self):
+        self.g.add_nodes(range(10))
+
+        for n in self.g.nodes:
+            n["title"] = "node #" + str(n["id"])
+
+        ref = ["node #" + str(i) for i in range(10)]
+        self.assertEqual(set(map(lambda s: s["title"], self.g.nodes)), set(ref))
+
+    def test_node_sizes(self):
+        self.g.add_nodes(range(10))
+
+        for n in self.g.nodes:
+            n["size"] = n["id"] * 2
+
+        ref = [i * 2 for i in range(10)]
+        self.assertEqual(set(map(lambda s: s["size"], self.g.nodes)), set(ref))
+
+    def test_adding_nodes(self):
+        g = self.g
+        g.add_nodes(range(5))
+        self.assertTrue(g.get_nodes(), range(5))
+
+    def test_adding_nodes_with_props(self):
+        g = self.g
+        g.add_nodes(
+            range(4),
+            size=range(4),
+            color=range(4),
+            title=range(4),
+            label=range(4),
+            x=range(4),
+            y=range(4),
+        )
+        for i, n in enumerate(g.nodes):
+            self.assertEqual(n["size"], i)
+            self.assertEqual(n["color"], i)
+            self.assertEqual(n["title"], i)
+            self.assertEqual(n["label"], i)
+            self.assertEqual(n["x"], i)
+            self.assertEqual(n["y"], i)
+
+    def test_labels(self):
+        g = self.g
+        g.add_node(0)
+        self.assertTrue(g.nodes[0]["label"] == 0)
+        g.add_node(50, label="NODE 50")
+        self.assertTrue(g.nodes[1]["label"] == "NODE 50")
+
+    def test_nodes_with_stringids(self):
+        g = self.g
+        g.add_nodes(["n1", "n2", "n3"])
+        self.assertTrue(g.node_ids == ["n1", "n2", "n3"])
+
+    def test_adj_list(self):
+        g = self.g
+        g.add_nodes(range(4))
+        g.add_edges([(0, 1, 1), (0, 2, 1), (0, 3, 1), (1, 3, 1)])
+        alist = g.get_adj_list()
+        self.assertEqual(len(alist), g.num_nodes())
+        self.assertEqual(alist[0], set([1, 2, 3]))
+        self.assertEqual(alist[1], set([0, 3]))
+
+    def test_neighbors(self):
+        g = self.g
+        g.add_nodes(range(5))
+        g.add_edge(0, 1)
+        g.add_edge(0, 2)
+        g.add_edge(1, 3)
+        g.add_edge(1, 4)
+        self.assertEqual(g.neighbors(0), set([1, 2]))
+
+    def test_length(self):
+        g = self.g
+        g.add_node(0)
+        self.assertEqual(g.num_nodes(), 1)
+
+    def test_get_network_data(self):
+        self.assertEqual(len(self.g.get_network_data()), 6)
+
+
+class EdgeTestCase(unittest.TestCase):
+    def setUp(self):
+        self.g = Network()
+        self.g.add_nodes([0, 1, 2, 3])
+
+    def test_non_existent_edge(self):
+        self.assertRaises(AssertionError, self.g.add_edge, 5, 1)
+        self.assertRaises(AssertionError, self.g.add_edge, "node1", "node2")
+
+    def test_no_edge_length(self):
+        self.assertTrue(self.g.num_nodes() == 4)
+        self.assertTrue(self.g.num_edges() == 0)
+
+    def test_add_one_edge(self):
+        self.g.add_edge(0, 1)
+        self.assertTrue(self.g.num_edges() == 1)
+        self.assertTrue({"from": 0, "to": 1} in self.g.edges)
+
+    def test_add_two_edges_no_dups(self):
+        self.g.add_edge(0, 1)
+        self.g.add_edge(0, 1)
+        self.assertTrue(self.g.num_edges() == 1)
+        self.g.add_edge(1, 2)
+        self.assertTrue(self.g.num_edges() == 2)
+        self.assertEqual([{"from": 0, "to": 1}, {"from": 1, "to": 2}], self.g.edges)
+
+    def test_add_edges_no_weights(self):
+        self.g.add_edges([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)])
+        self.assertEqual(self.g.num_edges(), 6)
+        self.assertEqual(self.g.neighbors(0), set([1, 2, 3]))
+        self.assertEqual(self.g.neighbors(1), set([0, 2, 3]))
+        self.assertEqual(self.g.neighbors(2), set([0, 1, 3]))
+        self.assertEqual(self.g.neighbors(3), set([0, 1, 2]))
+        self.assertTrue("weight" not in [es for es in self.g.edges])
+
+    def test_add_edges_weights(self):
+        self.g.add_edges(
+            [(0, 1, 1), (0, 2, 2), (0, 3, 3), (1, 2, 4), (1, 3, 5), (2, 3, 6)]
+        )
+        self.assertEqual(self.g.num_edges(), 6)
+        self.assertEqual(self.g.neighbors(0), set([1, 2, 3]))
+        self.assertEqual(self.g.neighbors(1), set([0, 2, 3]))
+        self.assertEqual(self.g.neighbors(2), set([0, 1, 3]))
+        self.assertEqual(self.g.neighbors(3), set([0, 1, 2]))
+        for edges in self.g.edges:
+            self.assertTrue("width" in edges)
+        self.assertEqual(
+            list([1, 2, 3, 4, 5, 6]), list(map(lambda x: x["width"], self.g.edges))
+        )
+
+    def test_add_edges_mixed_weights(self):
+        self.g.add_edges([(0, 1, 1), (0, 2), (0, 3, 3), (1, 2), (1, 3, 5), (2, 3)])
+        self.assertEqual(self.g.num_edges(), 6)
+        self.assertEqual(self.g.neighbors(0), set([1, 2, 3]))
+        self.assertEqual(self.g.neighbors(1), set([0, 2, 3]))
+        self.assertEqual(self.g.neighbors(2), set([0, 1, 3]))
+        self.assertEqual(self.g.neighbors(3), set([0, 1, 2]))
+        self.assertEqual(
+            list([1, None, 3, None, 5, None]),
+            list(map(lambda x: x.get("width", None), self.g.edges)),
+        )
+
+    def test_add_edge_directed(self):
+        self.g.directed = True
+        self.g.add_edge(0, 1)
+        self.assertTrue(self.g.edges)
+        for e in self.g.edges:
+            self.assertTrue(e["arrows"] == "to")
+
+
+class UtilsTestCase(unittest.TestCase):
+    def setUp(self):
+        self.g = Network()
+        self.g.add_nodes([0, 1, 2, 3])
+
+    def test_html_naming(self):
+        self.assertRaises(AssertionError, self.g.write_html, "4nodes.htl")
+        self.assertRaises(AssertionError, self.g.write_html, "4nodes.hltm")
+        self.assertRaises(AssertionError, self.g.write_html, "4nodes. htl")
+        self.g.write_html("4nodes.html")
+        self.assertTrue("4nodes.html" in os.listdir("."))
+        os.remove("4nodes.html")
+
+
+class PhysicsTestCase(unittest.TestCase):
+    def setUp(self):
+        self.g = Network()
+        self.g.add_nodes([0, 1, 2, 3])
+
+    def test_barnes_hut(self):
+        self.g.barnes_hut()
+        self.assertTrue("barnesHut" in vars(self.g.options.physics))
+
+    def test_repulsion(self):
+        self.g.repulsion()
+        self.assertTrue("repulsion" in vars(self.g.options.physics))
+
+    def test_hrepulsion(self):
+        self.g.hrepulsion()
+        self.assertTrue("hierarchicalRepulsion" in vars(self.g.options.physics))
+
+    def test_force_atlas_2based(self):
+        self.g.force_atlas_2based()
+        self.assertTrue("forceAtlas2Based" in vars(self.g.options.physics))
+
+    def test_toggle_physics(self):
+        self.assertTrue(self.g.options.physics["enabled"])
+        self.g.toggle_physics(False)
+        self.assertFalse(self.g.options.physics["enabled"])
+
+    def test_stabilization(self):
+        self.g.toggle_stabilization(True)
+        self.assertTrue(self.g.options.physics.stabilization["enabled"])
+        self.g.toggle_stabilization(False)
+        self.assertFalse(self.g.options.physics.stabilization["enabled"])
+
+
+class InteractionTestCase(unittest.TestCase):
+    def setUp(self):
+        self.g = Network()
+        self.g.add_nodes([0, 1, 2, 3])
+
+    def test_toggle_drag_nodes(self):
+        self.assertTrue(self.g.options.interaction["dragNodes"])
+        self.g.toggle_drag_nodes(False)
+        self.assertFalse(self.g.options.interaction["dragNodes"])
+
+    def test_toggle_hide_edges_on_drag(self):
+        self.assertFalse(self.g.options.interaction["hideEdgesOnDrag"])
+        self.g.toggle_hide_edges_on_drag(True)
+        self.assertTrue(self.g.options.interaction["hideEdgesOnDrag"])
+
+    def test_toggle_hide_nodes_on_drag(self):
+        self.assertFalse(self.g.options.interaction["hideNodesOnDrag"])
+        self.g.toggle_hide_nodes_on_drag(True)
+        self.assertTrue(self.g.options.interaction["hideNodesOnDrag"])
+
+
+class ConfigureTestCase(unittest.TestCase):
+    def setUp(self):
+        self.g = Network()
+        self.g.add_nodes([0, 1, 2, 3])
+
+    def test_show_buttons(self):
+        self.assertFalse(self.g.options.configure["enabled"])
+        self.g.show_buttons(True)
+        self.assertTrue(self.g.options.configure["enabled"])
+
+
+class EdgeOptionsTestCase(unittest.TestCase):
+    def setUp(self):
+        self.g = Network()
+        self.g.add_nodes([0, 1, 2, 3])
+
+    def test_set_edge_smooth(self):
+        self.assertEqual(self.g.options.edges.smooth.type, "dynamic")
+        self.g.set_edge_smooth("continuous")
+        self.assertEqual(self.g.options.edges.smooth.type, "continuous")
+
+    def test_inherit_colors(self):
+        self.assertTrue(self.g.options.edges.color.inherit)
+        self.g.inherit_edge_colors(False)
+        self.assertFalse(self.g.options.edges.color.inherit)
+
+
+class LayoutTestCase(unittest.TestCase):
+    def setUp(self):
+        self.g = Network(layout=True)
+
+    def test_can_enable_init(self):
+        self.assertTrue(self.g.options["layout"])
+
+    def test_layout_disabled(self):
+        self.g = Network()
+        self.assertRaises(KeyError, lambda: self.g.options["layout"])
+
+    def test_levelSeparation(self):
+        self.assertTrue(self.g.options.layout.hierarchical.levelSeparation)
+
+    def test_treeSpacing(self):
+        self.assertTrue(self.g.options.layout.hierarchical.treeSpacing)
+
+    def test_blockShifting(self):
+        self.assertTrue(self.g.options.layout.hierarchical.blockShifting)
+
+    def test_edgeMinimization(self):
+        self.assertTrue(self.g.options.layout.hierarchical.edgeMinimization)
+
+    def test_parentCentralization(self):
+        self.assertTrue(self.g.options.layout.hierarchical.parentCentralization)
+
+    def test_sortMethod(self):
+        self.assertTrue(self.g.options.layout.hierarchical.sortMethod)
+
+    def test_set_edge_minimization(self):
+        self.g.options.layout.set_separation(10)
+        self.assertTrue(self.g.options.layout.hierarchical.levelSeparation == 10)
+
+    def test_set_tree_spacing(self):
+        self.g.options.layout.set_tree_spacing(10)
+        self.assertTrue(self.g.options.layout.hierarchical.treeSpacing == 10)
+
+    def test_set_edge_minimization(self):
+        self.g.options.layout.set_edge_minimization(True)
+        self.assertTrue(self.g.options.layout.hierarchical.edgeMinimization == True)
+        self.g.options.layout.set_edge_minimization(False)
+        self.assertTrue(self.g.options.layout.hierarchical.edgeMinimization == False)

pyvis/pyvis/tests/test_me.py

@@ -0,0 +1,83 @@
+import numpy as np
+
+from ..network import Network
+
+
+def test_canvas_size():
+    """
+    Test the canvas size
+    """
+    net = Network(500, 500)
+    assert net.width == 500 and net.height == 500
+
+
+def test_add_node():
+    """
+    Test adding a node to the network.
+    """
+    net = Network()
+
+    net.add_node(0, "Test")
+
+    assert "Test" in net.nodes[0].values()
+
+
+def test_add_ten_nodes():
+    """
+    Test adding multiple nodes to this network
+    """
+    net = Network()
+
+    for i in range(10):
+        net.add_node(i, "Test " + str(i))
+
+    assert len(net.nodes) == 10
+
+
+def test_add_nodes_with_options():
+    """
+    Test adding nodes with different options
+    """
+    net = Network()
+
+    sizes = [10, 20, 30]
+
+    net.add_node(0, "Node 0", color="green", size=10)
+    net.add_node(1, "Node 1", color="blue", size=20)
+    net.add_node(2, "Node 2", color="yellow", size=30)
+
+    assert (sizes[node["id"]] == node["size"] for node in net.nodes)
+
+
+def test_add_edge():
+    """
+    Test adding an edge between nodes
+    """
+
+    net = Network()
+
+    for i in range(10):
+        net.add_node(i, "Node " + str(i))
+
+    net.add_edge(0, 1)
+    net.add_edge(0, 2)
+    net.add_edge(0, 3)
+    net.add_edge(0, 4)
+    net.add_edge(0, 5)
+    net.add_edge(0, 6)
+    net.add_edge(0, 7)
+    net.add_edge(0, 8)
+    net.add_edge(0, 9)
+
+    assert net.get_adj_list()[0] == set([2, 1, 3, 4, 5, 6, 7, 8, 9])
+
+
+def test_add_numpy_nodes():
+    """
+    Test adding numpy array nodes since these
+    nodes will have specific numpy types
+    """
+    arrayNodes = np.array([1, 2, 3, 4])
+    g = Network()
+    g.add_nodes(np.array([1, 2, 3, 4]))
+    assert g.get_nodes() == [1, 2, 3, 4]

pyvis/pyvis/utils.py

@@ -0,0 +1,12 @@
+# utility and helper functions for use in pyvis
+
+
+def check_html(name):
+    """
+    Given a name of graph to save or write, check if it is of valid syntax
+
+    :param: name: the name to check
+    :type name: str
+    """
+    assert len(name.split(".")) >= 2, "invalid file type for %s" % name
+    assert name.split(".")[-1] == "html", "%s is not a valid html file" % name

pyvis/setup.py

@@ -0,0 +1,26 @@
+from setuptools import find_packages, setup
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+exec(open("pyvis/_version.py").read())
+setup(
+    name="pyvis",
+    version=__version__,
+    description="A Python network graph visualization library",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/WestHealth/pyvis",
+    author="Jose Unpingco",
+    author_email="datascience@westhealth.org",
+    license="BSD",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "jinja2 >= 2.9.6",
+        "networkx >= 1.11",
+        "ipython >= 5.3.0",
+        "jsonpickle >= 1.4.1",
+    ],
+    python_requires=">3.6",
+)