npm_dependency_graph.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "23a1fb80",
   "metadata": {},
   "outputs": [],
   "source": [
    "import queue\n",
    "import csv\n",
    "import pandas as pd\n",
    "import re\n",
    "import ast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b6315729",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vulnerability:\n",
    "    title = \"\"\n",
    "    severity = \"\"\n",
    "    transPath = []\n",
    "    isUpgradable = False\n",
    "    upgradePath = []\n",
    "    isPatchable = False\n",
    "    isPinnable = False\n",
    "    \n",
    "    def __init__(self, title, severity, transPath, isUpgradable, upgradePath, isPatchable, isPinnable):\n",
    "        self.title = title\n",
    "        self.severity = severity\n",
    "        self.transPath = transPath\n",
    "        self.isUpgradable = isUpgradable\n",
    "        self.upgradePath = upgradePath\n",
    "        self.isPatchable = isPatchable\n",
    "        self.isPinnable = isPinnable\n",
    "        \n",
    "    def get_root(self):\n",
    "        if len(self.transPath) == 0:\n",
    "            print(\"Error: no vulnerability has been detected.\")\n",
    "            return None, None\n",
    "        else:\n",
    "            root = self.transPath[-1]\n",
    "            name, version = root.split(\"@\")\n",
    "            return name, version\n",
    "        \n",
    "    def get_path_length(self):\n",
    "        return len(self.transPath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5a051b52",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    projectId = -1\n",
    "    projectName = \"\"\n",
    "    vulnCounts = [0, 0, 0]\n",
    "    vulnList = []\n",
    "    version = \"0.0.0\"\n",
    "    timestamp = \"\"\n",
    "    directReach = set() # all packages directly dependent on this node\n",
    "    directTrust = set() # all pacakges directly dependent by this node\n",
    "    \n",
    "    def __init__(self, pid, pname, version, timestamp):\n",
    "        self.projectId = pid\n",
    "        self.projectName = pname\n",
    "        self.version = version\n",
    "        self.timestamp = timestamp\n",
    "        self.vulnCounts = [0, 0, 0]\n",
    "        self.vulnList = []\n",
    "        self.directReach = set()\n",
    "        self.directTrust = set()\n",
    "        \n",
    "    def description(self):\n",
    "        print(f\"Project ID:{self.projectId}\")\n",
    "        print(f\"Project Name:{self.projectName} Version:{self.version}\")\n",
    "        print(f\"Published Time:{self.timestamp}\")\n",
    "        if self.vulnCounts[0] > 0:\n",
    "            print(f\"Original Vulnerability: {self.vulnCounts[0]}\")\n",
    "        if self.vulnCounts[1] > 0:\n",
    "            print(f\"Direct Dependent Vulnerability: {self.vulnCounts[1]}\")\n",
    "        if self.vulnCounts[2] > 0:\n",
    "            print(f\"Direct Independent Vulnerability: {self.vulnCounts[2]}\")\n",
    "        print(f\"{len(self.directReach)} packages are directly dependent on the node.\")\n",
    "        print(f\"{len(self.directTrust)} packages are directly dependent by the node.\")\n",
    "        \n",
    "    def is_vuln(self):\n",
    "        print(sum(self.vulnCounts) > 0)\n",
    "        \n",
    "    def update_deps(self, edges):\n",
    "        for e in edges:\n",
    "            if e[0] == self.projectId:\n",
    "                self.directTrust.add(e[1])\n",
    "            if e[1] == self.projectId:\n",
    "                self.directReach.add(e[0])\n",
    "                \n",
    "    def update_vulns(self, v):\n",
    "        for vuln in self.vulnList:\n",
    "            if v.title == vuln.title:\n",
    "                return\n",
    "        path_length = v.get_path_length()\n",
    "        if path_length == 1:\n",
    "            self.vulnCounts[0] += 1\n",
    "        elif path_length == 2:\n",
    "            self.vulnCounts[1] += 1\n",
    "        elif path_length > 2:\n",
    "            self.vulnCounts[2] += 1\n",
    "        self.vulnList.append(v)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2e6dc63a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DiGraph: \n",
    "    nodes = set()\n",
    "    edges = set()\n",
    "    \n",
    "    def __init__(self, nodeList, edgeList):\n",
    "        for n in nodeList:\n",
    "            self.nodes.add(n.projectId)\n",
    "        self.edges = edgeList\n",
    "    \n",
    "    def add_node(self, pid, n):\n",
    "        self.nodes.add(pid)\n",
    "        nodeMap[pid] = n\n",
    "    \n",
    "    def add_edge(self, e):\n",
    "        self.edges.add(e)\n",
    "        \n",
    "    def update_direct_reach_trust(self):\n",
    "        k = 0\n",
    "        for pid, n in nodeMap.items():\n",
    "            n.update_deps(self.edges)\n",
    "            k += 1\n",
    "            if k % 1000 == 0:\n",
    "                print(f\"{k} of {len(self.nodes)} nodes updated.\")\n",
    "    \n",
    "    def PR(self, pid):\n",
    "        q = queue.Queue()\n",
    "        q.put(pid)\n",
    "        vertices = []\n",
    "        print(f\"Start finding projects dependent on {nodeMap[pid].projectName}.\")\n",
    "        while q.empty() == False:\n",
    "            v = q.get()\n",
    "            #print(nodeMap[v].projectName)\n",
    "            for e in self.edges:\n",
    "                if v == e[1] and e[0] not in vertices:\n",
    "                    vertices.append(e[0])\n",
    "                    q.put(e[0])\n",
    "        print(f\"{len(vertices)} projects dependent on {nodeMap[pid].projectName}.\")\n",
    "        return vertices\n",
    "    \n",
    "    def ITP(self, pid):\n",
    "        q = queue.Queue()\n",
    "        q.put(pid)\n",
    "        vertices = []\n",
    "        while(q.empty() == False):\n",
    "            v = q.get()\n",
    "            for e in self.edges:\n",
    "                if v == e[0] and e[1] not in vertices:\n",
    "                    vertices.append(e[1])\n",
    "                    q.put(e[1])\n",
    "        return vertices\n",
    "    \n",
    "    def find_path(self, fid, tid):\n",
    "        q = queue.Queue()\n",
    "        q.put(fid)\n",
    "        path = []\n",
    "        backList = [-1]\n",
    "        vertices = []\n",
    "        while len(backList) < 100000:\n",
    "            v = q.get()\n",
    "            bidx = len(backList) - 1\n",
    "            for e in self.edges:\n",
    "                if v == e[0] and e[1] not in vertices:\n",
    "                    backList.append(bidx)\n",
    "                    vertices.append(e[1])\n",
    "                    if e[1] == tid:\n",
    "                        path.append(tid)\n",
    "                        while bidx != -1:\n",
    "                            path.append(vertices[bidx])\n",
    "                            bidx = backList[bidx]\n",
    "                        break\n",
    "                    q.put(e[1])\n",
    "            if len(path) > 0:\n",
    "                for pid in reversed(path):\n",
    "                    n = nodeMap[pid]\n",
    "                    ans.append(n.projectName + '@' + n.version)\n",
    "                ans.append(nodeMap[fid].projectName + '@' + nodeMap[fid].version)\n",
    "                return ans\n",
    "        return None\n",
    "    \n",
    "    def flag_vulns(self, popVulnList):\n",
    "        k = 0\n",
    "        for pid in popVulnList:\n",
    "            node = nodeMap[pid]\n",
    "            if sum(node.vulnCounts) > 0:\n",
    "                reach = set(self.PR(pid))\n",
    "                for p in reach:\n",
    "                    n = nodeMap[p]\n",
    "                    for i, v in enumerate(node.vulnList):\n",
    "                        tp = self.find_path(pid, p)\n",
    "                        if tp is not None:\n",
    "                            n.update_vulns(Vulnerability(v.title, v.severity, tp[:-1] + v.transPath, v.isUpgradable, v.upgradePath, v.isPatchable, v.isPinnable))\n",
    "                        print(f\"{i} vulnerabilities have been updated.\")\n",
    "            k += 1\n",
    "            print(f\"{k} of {len(popVulnList)} packages have been updated.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6fc094d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def atoi(s):\n",
    "    ret = re.findall(r\"^\\d+\", s.strip())\n",
    "    if ret:\n",
    "        return int(ret[0])\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "861267e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.1.x = ~1.1.0\n",
    "# 1.x.x = ^1.0.0\n",
    "def vercmp(v1, v2):\n",
    "    f1 = False\n",
    "    f2 = False\n",
    "    f3 = False\n",
    "    f4 = False\n",
    "    if len(v1) == 0 or len(v2) == 0:\n",
    "        return 0\n",
    "    if v1 == '*' or v2 == '*':\n",
    "        return 0\n",
    "    try:\n",
    "        a1, b1, c1 = v1.split('.', 2)\n",
    "    except ValueError:\n",
    "        try:\n",
    "            a1, b1 = v1.split('.', 1)\n",
    "            c1 = 'x'\n",
    "        except ValueError:\n",
    "            a1 = v1\n",
    "            b1 = 'x'\n",
    "            c1 = 'x'\n",
    "    try:\n",
    "        a2, b2, c2 = v2.split('.', 2)\n",
    "    except ValueError:\n",
    "        try:\n",
    "            a2, b2 = v2.split('.', 1)\n",
    "            c2 = 'x'\n",
    "        except ValueError:\n",
    "            a2 = v2\n",
    "            b2 = 'x'\n",
    "            c2 = 'x'\n",
    "    if len(a1) == 0:\n",
    "        a1 = '0'\n",
    "    if len(a2) == 0:\n",
    "        a2 = '0'\n",
    "    if a1[0] == '^':\n",
    "        f1 = True\n",
    "        a1 = a1[1:]\n",
    "    elif a1[0] == '~':\n",
    "        f2 = True\n",
    "        a1 = a1[1:]\n",
    "    elif a1[0:2] == '>=':\n",
    "        f3 = True\n",
    "        a1 = a1[2:]\n",
    "    elif a1[0] == '>':\n",
    "        f3 = True\n",
    "        a1 = a1[1:]\n",
    "    elif a1[0:2] == '<=':\n",
    "        f4 = True\n",
    "        a1 = a1[2:]\n",
    "    elif a1[0] == '<':\n",
    "        f4 = True\n",
    "        a1 = a1[1:]\n",
    "    if a2[0] == '^':\n",
    "        f1 = True\n",
    "        a2 = a2[1:]\n",
    "    elif a2[0] == '~':\n",
    "        f2 = True\n",
    "        a2 = a2[1:]\n",
    "    elif a2[0:2] == '>=':\n",
    "        f4 = True\n",
    "        a2 = a2[2:]\n",
    "    elif a2[0] == '>':\n",
    "        f4 = True\n",
    "        a2 = a2[1:]\n",
    "    elif a2[0:2] == '<=':\n",
    "        f3 = True\n",
    "        a2 = a2[2:]\n",
    "    elif a2[0] == '<':\n",
    "        f3 = True\n",
    "        a2 = a2[1:]\n",
    "    \n",
    "    try:\n",
    "        if a1 == 'x' or a2 == 'x':\n",
    "            return 0\n",
    "        if atoi(a1) > atoi(a2):\n",
    "            if f4 == True:\n",
    "                return 0\n",
    "            return 1\n",
    "        if atoi(a1) < atoi(a2):\n",
    "            if f3 == True:\n",
    "                return 0\n",
    "            return -1\n",
    "        if atoi(a1) == atoi(a2):\n",
    "            if f1 == True:\n",
    "                return 0\n",
    "            if b1 == 'x' or b2 == 'x':\n",
    "                return 0\n",
    "            if atoi(b1) > atoi(b2):\n",
    "                if f4 == True:\n",
    "                    return 0\n",
    "                return 1\n",
    "            if atoi(b1) < atoi(b2):\n",
    "                if f3 == True:\n",
    "                    return 0\n",
    "                return -1\n",
    "            if atoi(b1) == atoi(b2):\n",
    "                if f2 == True:\n",
    "                    return 0\n",
    "                if c1 == 'x' or c2 == 'x':\n",
    "                    return 0\n",
    "                if atoi(c1) > atoi(c2):\n",
    "                    if f4 == True:\n",
    "                        return 0\n",
    "                    return 1\n",
    "                if atoi(c1) < atoi(c2):\n",
    "                    if f3 == True:\n",
    "                        return 0\n",
    "                    return -1\n",
    "                if atoi(c1) == atoi(c2):\n",
    "                    return 0\n",
    "    except ValueError:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "23335c88",
   "metadata": {},
   "outputs": [],
   "source": [
    "nodeList = []\n",
    "\n",
    "with open(\"npm/(NPM_extracted)projects-1.6.0-2020-01-12.csv\", 'r', encoding='utf-8') as f:\n",
    "    proj_file = csv.reader(f)\n",
    "    header = next(proj_file)\n",
    "    old_n = None\n",
    "    for row in proj_file:\n",
    "        n = Node(row[0], row[2], row[13], row[12])\n",
    "        nodeList.append(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d290fa8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "nodeMap = {}\n",
    "name2id = {}\n",
    "\n",
    "for n in nodeList:\n",
    "    nodeMap[n.projectId] = n\n",
    "    name2id[n.projectName] = n.projectId"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1fb23cd2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ID', 'Platform', 'Project Name', 'Project ID', 'Version Number', 'Version ID', 'Dependency Name', 'Dependency Platform', 'Dependency Kind', 'Optional Dependency', 'Dependency Requirements', 'Dependency Project ID']\n",
      "100000 edges have been record.\n",
      "200000 edges have been record.\n",
      "300000 edges have been record.\n",
      "400000 edges have been record.\n",
      "500000 edges have been record.\n",
      "600000 edges have been record.\n",
      "700000 edges have been record.\n",
      "800000 edges have been record.\n",
      "900000 edges have been record.\n",
      "1000000 edges have been record.\n",
      "1100000 edges have been record.\n",
      "1200000 edges have been record.\n",
      "1300000 edges have been record.\n",
      "1400000 edges have been record.\n",
      "1500000 edges have been record.\n",
      "1600000 edges have been record.\n",
      "1700000 edges have been record.\n",
      "1800000 edges have been record.\n",
      "1900000 edges have been record.\n",
      "2000000 edges have been record.\n",
      "2100000 edges have been record.\n",
      "2200000 edges have been record.\n",
      "2300000 edges have been record.\n",
      "2400000 edges have been record.\n",
      "2500000 edges have been record.\n",
      "2600000 edges have been record.\n",
      "2700000 edges have been record.\n",
      "2800000 edges have been record.\n",
      "2900000 edges have been record.\n",
      "3000000 edges have been record.\n",
      "3100000 edges have been record.\n",
      "3200000 edges have been record.\n",
      "3300000 edges have been record.\n",
      "3400000 edges have been record.\n"
     ]
    }
   ],
   "source": [
    "edgeList = []\n",
    "\n",
    "with open(\"npm/(NPM_extracted)dependencies-1.6.0-2020-01-12.csv\", 'r', encoding='utf-8') as f:\n",
    "    dep_file = csv.reader(f)\n",
    "    header = next(dep_file)\n",
    "    print(header)\n",
    "    for row in dep_file:\n",
    "        if row[8] != 'runtime' or row[7] != 'NPM':\n",
    "            continue\n",
    "        fid = row[3]\n",
    "        fver = row[4]\n",
    "        if fid != '' and fid in nodeMap.keys():\n",
    "            fromNode = nodeMap[fid]\n",
    "            if vercmp(fromNode.version, fver) == 0:\n",
    "                tid = row[-1]\n",
    "                tver_range = row[-2]\n",
    "                if tid != '' and tid in nodeMap.keys():\n",
    "                    toNode = nodeMap[tid]\n",
    "                    if vercmp(toNode.version, tver_range) == 0:\n",
    "                        edgeList.append((fid, tid))\n",
    "                        if len(edgeList) % 100000 == 0:\n",
    "                            print(f\"{len(edgeList)} edges have been record.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "292f1d85",
   "metadata": {},
   "outputs": [],
   "source": [
    "dep_graph = DiGraph(nodeList, edgeList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "0d635890",
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "G = nx.DiGraph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "8abb459d",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"npm/(NPM_extracted)projects-1.6.0-2020-01-12.csv\", 'r', encoding='utf-8') as f:\n",
    "    proj_file = csv.reader(f)\n",
    "    header = next(proj_file)\n",
    "    old_n = None\n",
    "    for row in proj_file:\n",
    "        G.add_node(row[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "3cacf6f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"npm/(NPM_extracted)dependencies-1.6.0-2020-01-12.csv\", \"r\", encoding='utf-8') as csvfile:\n",
    "    datareader = csv.reader(csvfile)\n",
    "    next(datareader) # remove header\n",
    "    for row in datareader:\n",
    "        dep_kind = row[8]\n",
    "        dep_plat = row[7]\n",
    "\n",
    "    # Consider 'runtime' and 'optional' dependencies\n",
    "    # Exclude non-npm dependency\n",
    "        isRuntime = dep_kind != 'Development'\n",
    "        isNPM = dep_plat == 'NPM'\n",
    "        if isRuntime and isNPM:\n",
    "            id = row[3]\n",
    "            dep_id = row[-1]\n",
    "            G.add_edge(dep_id, id) # Edge between two nodes represents dependency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1068322b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.47771548156740623"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = set(edgeList)\n",
    "s2 = set(G.edges)\n",
    "su = s1 & s2\n",
    "len(su) / len(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9b8f3e8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['X', 'Rank', 'Language', 'Name', 'Release.Name', 'Release.Time', 'is_ok', 'vulnIndex', 'creationTime', 'disclosureTime', 'modificationTime', 'publicationTime', 'severity', 'title', 'path', 'pathDepth', 'rootPackage', 'rootPackageVersion', 'upgradePath', 'isUpgradable', 'isPatchable', 'isPinnable']\n",
      "100000 rows have been scanned\n",
      "200000 rows have been scanned\n",
      "300000 rows have been scanned\n",
      "400000 rows have been scanned\n",
      "500000 rows have been scanned\n",
      "600000 rows have been scanned\n",
      "700000 rows have been scanned\n",
      "800000 rows have been scanned\n",
      "900000 rows have been scanned\n",
      "1000000 rows have been scanned\n",
      "1100000 rows have been scanned\n",
      "1200000 rows have been scanned\n",
      "1300000 rows have been scanned\n",
      "1400000 rows have been scanned\n",
      "1500000 rows have been scanned\n",
      "1600000 rows have been scanned\n"
     ]
    }
   ],
   "source": [
    "popVulnSet = set()\n",
    "rootVulnSet = set()\n",
    "\n",
    "with open(\"npm/top_2000_package_release_vulnCount_had_vuln_vulnDetails.tsv\", \"r\") as f:\n",
    "    vul_file = csv.reader(f, delimiter=\"\\t\", quotechar='\"')\n",
    "    header = next(vul_file)\n",
    "    print(header)\n",
    "    for k, row in enumerate(vul_file):\n",
    "        rawPath = row[14].replace(' ', '')\n",
    "        rawPath = rawPath[1:-1]\n",
    "        isPinnable = (row[-1] == 'TRUE')\n",
    "        isPatchable = (row[-2] == 'TRUE')\n",
    "        isUpgradable = (row[-3] == 'TRUE')\n",
    "        name = row[3]\n",
    "        root = row[16]\n",
    "        if name in name2id.keys():\n",
    "            node = nodeMap[name2id[name]]\n",
    "            if vercmp(node.version, row[4]) == 0: \n",
    "                popVulnSet.add(node.projectId)\n",
    "                if root in name2id.keys():\n",
    "                    rootVulnSet.add(root)\n",
    "                    rootNode = nodeMap[name2id[root]]\n",
    "                    if vercmp(rootNode.version, row[17]) == 0:\n",
    "                        rootNode.update_vulns(Vulnerability(row[13], row[12], [root + '@' + row[17]], isUpgradable, row[-4], isPatchable, isPinnable))\n",
    "                node.update_vulns(Vulnerability(row[13], row[12], list(rawPath.split(',')), isUpgradable, row[-4], isPatchable, isPinnable))\n",
    "        k += 1\n",
    "        if k > 0 and k % 100000 == 0:\n",
    "            print(f\"{k} rows have been scanned\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "4a1546a8",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-61-8077e6a24b02>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mpid\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mnew\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mpid\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mvertices\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m             \u001b[0mq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mput\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpid\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     13\u001b[0m     \u001b[0mvertices\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvertices\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mnew\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvertices\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "vertices = list(popVulnSet)\n",
    "q = queue.Queue()\n",
    "for pid in popVulnSet:\n",
    "    q.put(pid)\n",
    "while q.empty() != True:\n",
    "    i = q.get()\n",
    "    new = []\n",
    "    if i in list(G.nodes):\n",
    "        new = list(G.neighbors(i))\n",
    "    for pid in new:\n",
    "        if pid not in vertices:\n",
    "            q.put(pid)\n",
    "    vertices += list(set(vertices + new))\n",
    "len(vertices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "ed1a2b16",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1275525"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G.number_of_nodes()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "efb52055",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "G = nx.petersen_graph()\n",
    "nx.draw(G, with_labels=True, font_weight='bold')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "742a6590",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start finding projects dependent on mout.\n",
      "699 projects dependent on mout.\n",
      "Start finding projects dependent on material-ui.\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-2706ac6b6cce>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mvertices\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mpid\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mpopVulnSet\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mvertices\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdep_graph\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mPR\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpid\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[0mvertices\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvertices\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-4-e80c9ab70b5c>\u001b[0m in \u001b[0;36mPR\u001b[1;34m(self, pid)\u001b[0m\n\u001b[0;32m     32\u001b[0m             \u001b[1;31m#print(nodeMap[v].projectName)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     33\u001b[0m             \u001b[1;32mfor\u001b[0m \u001b[0me\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0medges\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 34\u001b[1;33m                 \u001b[1;32mif\u001b[0m \u001b[0mv\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mvertices\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     35\u001b[0m                     \u001b[0mvertices\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     36\u001b[0m                     \u001b[0mq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mput\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "vertices = []\n",
    "for pid in popVulnSet:\n",
    "    vertices.append(dep_graph.PR(pid))\n",
    "vertices = list(set(vertices))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e0aa17c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ID</th>\n",
       "      <th>Platform</th>\n",
       "      <th>Project Name</th>\n",
       "      <th>Project ID</th>\n",
       "      <th>Version Number</th>\n",
       "      <th>Version ID</th>\n",
       "      <th>Dependency Name</th>\n",
       "      <th>Dependency Platform</th>\n",
       "      <th>Dependency Kind</th>\n",
       "      <th>Optional Dependency</th>\n",
       "      <th>Dependency Requirements</th>\n",
       "      <th>Dependency Project ID</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1080746</td>\n",
       "      <td>NPM</td>\n",
       "      <td>7</td>\n",
       "      <td>30621</td>\n",
       "      <td>0.0.1</td>\n",
       "      <td>18347</td>\n",
       "      <td>should</td>\n",
       "      <td>NPM</td>\n",
       "      <td>Development</td>\n",
       "      <td>False</td>\n",
       "      <td>~1.2.2</td>\n",
       "      <td>313128</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1080747</td>\n",
       "      <td>NPM</td>\n",
       "      <td>7</td>\n",
       "      <td>30621</td>\n",
       "      <td>0.0.1</td>\n",
       "      <td>18347</td>\n",
       "      <td>mocha</td>\n",
       "      <td>NPM</td>\n",
       "      <td>Development</td>\n",
       "      <td>False</td>\n",
       "      <td>~1.12.0</td>\n",
       "      <td>295363</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1080748</td>\n",
       "      <td>NPM</td>\n",
       "      <td>7</td>\n",
       "      <td>30621</td>\n",
       "      <td>0.0.2</td>\n",
       "      <td>18348</td>\n",
       "      <td>should</td>\n",
       "      <td>NPM</td>\n",
       "      <td>Development</td>\n",
       "      <td>False</td>\n",
       "      <td>~1.2.2</td>\n",
       "      <td>313128</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1080749</td>\n",
       "      <td>NPM</td>\n",
       "      <td>7</td>\n",
       "      <td>30621</td>\n",
       "      <td>0.0.2</td>\n",
       "      <td>18348</td>\n",
       "      <td>mocha</td>\n",
       "      <td>NPM</td>\n",
       "      <td>Development</td>\n",
       "      <td>False</td>\n",
       "      <td>~1.12.0</td>\n",
       "      <td>295363</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1080750</td>\n",
       "      <td>NPM</td>\n",
       "      <td>1</td>\n",
       "      <td>30622</td>\n",
       "      <td>0.0.1</td>\n",
       "      <td>18349</td>\n",
       "      <td>commander</td>\n",
       "      <td>NPM</td>\n",
       "      <td>runtime</td>\n",
       "      <td>False</td>\n",
       "      <td>1.0.x</td>\n",
       "      <td>137207</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        ID Platform  Project Name  Project ID Version Number  Version ID  \\\n",
       "0  1080746      NPM             7       30621          0.0.1       18347   \n",
       "1  1080747      NPM             7       30621          0.0.1       18347   \n",
       "2  1080748      NPM             7       30621          0.0.2       18348   \n",
       "3  1080749      NPM             7       30621          0.0.2       18348   \n",
       "4  1080750      NPM             1       30622          0.0.1       18349   \n",
       "\n",
       "  Dependency Name Dependency Platform Dependency Kind  Optional Dependency  \\\n",
       "0          should                 NPM     Development                False   \n",
       "1           mocha                 NPM     Development                False   \n",
       "2          should                 NPM     Development                False   \n",
       "3           mocha                 NPM     Development                False   \n",
       "4       commander                 NPM         runtime                False   \n",
       "\n",
       "  Dependency Requirements  Dependency Project ID  \n",
       "0                  ~1.2.2                 313128  \n",
       "1                 ~1.12.0                 295363  \n",
       "2                  ~1.2.2                 313128  \n",
       "3                 ~1.12.0                 295363  \n",
       "4                   1.0.x                 137207  "
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample = pd.read_csv(\"npm/(NPM_extracted)dependencies-1.6.0-2020-01-12.csv\", nrows=5)\n",
    "sample"
   ]
  }
 ],
 "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": 5
}