{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Identity Graph Sample\n",
    "### Made Available by:  AWS Adtech/Martech Team"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## About this sample solution\n",
    "\n",
    "An identity graph provides a single unified view of customers and prospects by linking multiple identifiers such as cookies, device identifiers, IP addresses, email IDs, and internal enterprise IDs to a known person or anonymous profile using privacy-compliant methods.  Typically, identity graphs are part of a larger identity resolution architecture.  Identity resolution is the process of matching human identity across a set of devices used by the same person or a household of persons for the purposes of building a representative identity, or known attributes, for targeted advertising.  \n",
    "\n",
    "The following notebook walks you through a sample solution for identity graph and how it can be used within a larger identity resolution architecture using an open dataset and the use of a graph database, Amazon Neptune.  In this notebook, we also show a number of data visualizations that allow one to better understand the structure of an identity graph and the aspects of an identity resolution dataset and use case.  Later in the notebook, we expose some additional use cases that can be exposed using this particular dataset.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Glossary\n",
    "\n",
    "* **transient identity** - cookie or user device that interacted with the website\n",
    "* **persistent identity** - single user, one user might have many transient identifiers, as he might own many devices, or use many cookies\n",
    "* **group identity** (identityGroup) - group of persistent identites forming up households, or companies\n",
    "* **group of websites** (websiteGroup) - group of websites with the same domain\n",
    "* **session** - group of single user events on one domain. User can have many sessions, each session has at least one event. Events a, b, and c belongs to the same session if following conditions holds: \n",
    "  * each event is inititated by the same transientId\n",
    "  * each event is on the same domain; \n",
    "  * given timestamp(a) < timestamp(b) < timestamp(c) and maximum delta between two consecutive events X\n",
    "    * timestamp(b) - timestamp(a) < X and \n",
    "    * timestamp(c) - timestamp(a) < X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset\n",
    "\n",
    "The dataset used for the purposes of this demo comes from **CIKM Cup 2016 Track 1: Cross-Device Entity Linking Challenge**, https://competitions.codalab.org/competitions/11171.\n",
    "\n",
    "The dataset contains an anonymized browse log for a set of anonymized userIDs representing the same user across multiple devices, as well as obfuscated site URLs and HTML titles those users visited.  There are not much of user attributes, so they had to be generated artificially."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataset download\n",
    "\n",
    "The dataset has already been loaded into an Amazon Neptune cluster for you to use with this notebook.  However, should you choose to inspect the raw data itself, the data can be found here:\n",
    "\n",
    "Links with CSV files below:\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/identity_group_edges.csv\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/identity_group_nodes.csv\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/ip_edges.csv\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/ip_nodes.csv\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/persistent_edges.csv\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/persistent_nodes.csv\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/transient_edges.csv\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/transient_nodes.csv\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/website_group_edges.csv\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/website_group_nodes.csv\n",
    "* https://aws-admartech-samples.s3.amazonaws.com/identity-resolution/data/websites.csv\n",
    " \n"
   ]
  },
  {
   "attachments": {
    "Untitled%20%281%29.svg": {
     "image/svg+xml": [
      "<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
   xmlns:dc="http://purl.org/dc/elements/1.1/"
   xmlns:cc="http://creativecommons.org/ns#"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   contentScriptType="text/ecmascript"
   width="600"
   zoomAndPan="magnify"
   contentStyleType="text/css"
   viewBox="-1221 -336 600 600"
   height="600"
   preserveAspectRatio="xMidYMid meet"
   version="1.1"
   id="svg150"
   sodipodi:docname="Untitled.svg"
   inkscape:version="0.92.3 (2405546, 2018-03-11)">
  <metadata
     id="metadata156">
    <rdf:RDF>
      <cc:Work
         rdf:about="">
        <dc:format>image/svg+xml</dc:format>
        <dc:type
           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
        <dc:title />
      </cc:Work>
    </rdf:RDF>
  </metadata>
  <defs
     id="defs154" />
  <sodipodi:namedview
     pagecolor="#ffffff"
     bordercolor="#666666"
     borderopacity="1"
     objecttolerance="10"
     gridtolerance="10"
     guidetolerance="10"
     inkscape:pageopacity="0"
     inkscape:pageshadow="2"
     inkscape:window-width="1920"
     inkscape:window-height="1015"
     id="namedview152"
     showgrid="false"
     inkscape:zoom="1.28"
     inkscape:cx="317.18444"
     inkscape:cy="386.17148"
     inkscape:window-x="0"
     inkscape:window-y="840"
     inkscape:window-maximized="1"
     inkscape:current-layer="svg150"
     showguides="false" />
  <g
     id="edges"
     transform="matrix(0.93626859,0,0,0.93626859,-52.107341,5.592693)">
    <path
       d="m -937.70752,-171.64271 c -50.58032,-10.8883 -110.11828,-103.09115 -99.22998,-153.67144"
       class="id_1 id_5"
       id="path2"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -937.70752,-171.64271 c -32.2699,-29.3014 -36.72253,-121.65825 -7.42114,-153.92809"
       class="id_1 id_6"
       id="path4"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -937.70752,-171.64271 c -12.5918,-50.8877 50.60784,-120.92514 101.49554,-133.51694"
       class="id_1 id_7"
       id="path6"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1"
       sodipodi:nodetypes="cc" />
    <path
       d="m -1001.611,-104.97653 c -0.5525,-26.11392 72.32462,-30.49932 67.14115,-63.06878"
       class="id_0 id_1"
       id="path8"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
       sodipodi:nodetypes="cc" />
    <path
       d="m -1001.611,-104.97653 c 56.01585,-30.97188 186.49741,6.594053 217.46928,62.609877"
       class="id_0 id_2"
       id="path10"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -1001.611,-104.97653 c 49.62467,23.005217 89.55387,131.950025 66.54862,181.574675"
       class="id_0 id_3"
       id="path12"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -1001.611,-104.97653 c 8.37189,31.663362 -26.6928,68.490993 -59.9777,59.967905"
       class="id_0 id_4"
       id="path14"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
       sodipodi:nodetypes="cc" />
    <path
       d="m -784.14172,-42.366653 c 13.32061,-35.908493 87.16424,-69.790317 123.07275,-56.469696"
       class="id_2 id_8"
       id="path16"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -784.14172,-42.366653 c 27.73571,-25.314209 107.31054,-21.681977 132.62475,6.053714"
       class="id_2 id_9"
       id="path18"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -784.14172,-42.366653 c 37.26941,-5.170449 100.92926,42.978002 106.09967,80.247421"
       class="id_2 id_10"
       id="path20"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -1036.9617,155.30098 c 14.2038,-30.01543 80.0239,-32.87413 101.89932,-78.702835"
       class="id_12 id_3"
       id="path22"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1"
       sodipodi:nodetypes="cc" />
    <path
       d="m -935.06238,76.598145 c 48.7262,7.447113 110.64478,91.707035 103.19763,140.433195"
       class="id_3 id_11"
       id="path26"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -935.06238,76.598145 c 9.29682,50.267285 -52.15887,139.613475 -102.42612,148.910305"
       class="id_3 id_13"
       id="path28"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -1061.5887,-45.008625 c -42.0684,10.026417 -120.2107,-38.036572 -130.2371,-80.104975"
       class="id_4 id_14"
       id="path30"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -1061.5887,-45.008625 c -32.4676,29.179306 -124.9379,24.246979 -154.1171,-8.220543"
       class="id_4 id_15"
       id="path32"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -1061.5887,-45.008625 c -16.5407,43.298664 -106.2995,83.43576 -149.5982,66.895161"
       class="id_4 id_16"
       id="path34"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1" />
    <path
       d="m -937.70752,-171.64271 c -192.67748,-0.0937 -125.60558,46.13647 -254.11828,46.52911"
       class="id_1 id_14"
       id="path36"
       inkscape:connector-curvature="0"
       style="fill:none;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:2, 2;stroke-dashoffset:0;stroke-opacity:1"
       sodipodi:nodetypes="cc" />
  </g>
  <g
     id="nodes"
     transform="matrix(0.93626859,0,0,0.93626859,-52.107341,5.592693)">
    <circle
       r="10"
       cx="-1001.611"
       class="id_0"
       cy="-104.97653"
       id="circle43"
       style="fill:#87de87;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="10"
       cx="-937.70752"
       class="id_1"
       cy="-171.64272"
       id="circle45"
       style="fill:#80b3ff;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="10"
       cx="-784.14172"
       class="id_2"
       cy="-42.366653"
       id="circle47"
       style="fill:#80b3ff;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="10"
       cx="-935.06238"
       class="id_3"
       cy="76.598145"
       id="circle49"
       style="fill:#80b3ff;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="10"
       cx="-1061.5887"
       class="id_4"
       cy="-45.008625"
       id="circle51"
       style="fill:#80b3ff;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-1036.9375"
       class="id_5"
       cy="-325.31415"
       id="circle53"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-945.12866"
       class="id_6"
       cy="-325.5708"
       id="circle55"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-834.05353"
       class="id_7"
       cy="-305.15964"
       id="circle57"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-661.06897"
       class="id_8"
       cy="-98.836349"
       id="circle59"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-651.51697"
       class="id_9"
       cy="-36.312939"
       id="circle61"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-678.04205"
       class="id_10"
       cy="37.880768"
       id="circle63"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-831.86475"
       class="id_11"
       cy="217.03134"
       id="circle65"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-1036.6224"
       class="id_12"
       cy="156.43829"
       id="circle67"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-1037.4885"
       class="id_13"
       cy="225.50845"
       id="circle69"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-1191.8258"
       class="id_14"
       cy="-125.1136"
       id="circle71"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-1215.7058"
       class="id_15"
       cy="-53.229168"
       id="circle73"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
    <circle
       r="5"
       cx="-1211.1869"
       class="id_16"
       cy="21.886536"
       id="circle75"
       style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
  </g>
  <g
     id="node-labels"
     transform="matrix(0.93626859,0,0,0.93626859,-65.579893,2.898182)">
    <text
       font-size="24"
       x="-1060.532"
       y="-106.00553"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:17.64508438px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.73521185"
       class="id_0"
       id="text78">persistentId</text>
    <text
       font-size="24"
       x="-856.00177"
       y="-161.92519"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:17.64508438px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.73521185"
       class="id_1"
       id="text80"
       inkscape:transform-center-x="23.214667"
       inkscape:transform-center-y="6.5879491">transientId</text>
    <text
       font-size="24"
       x="-784.55585"
       y="-14.905201"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:17.64508438px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.73521185"
       class="id_2"
       id="text82">transientId</text>
    <text
       font-size="24"
       x="-852.05707"
       y="65.298775"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:17.64508438px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.73521185"
       class="id_3"
       id="text84">transientId</text>
    <text
       font-size="24"
       x="-994.88849"
       y="-18.879873"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:17.64508438px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.73521185"
       class="id_4"
       id="text86">transientId</text>
    <text
       font-size="12"
       x="-1053.9797"
       y="-313.05881"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_5"
       id="text88">website</text>
    <text
       font-size="12"
       x="-966.48773"
       y="-318.71155"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_6"
       id="text90">website</text>
    <text
       font-size="12"
       x="-815.34698"
       y="-289.30688"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_7"
       id="text92">website</text>
    <text
       font-size="12"
       x="-643.80139"
       y="-80.937813"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_8"
       id="text94">website</text>
    <text
       font-size="12"
       x="-634.24939"
       y="-18.414402"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_9"
       id="text96">website</text>
    <text
       font-size="12"
       x="-660.77448"
       y="55.779305"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_10"
       id="text98">website</text>
    <text
       font-size="12"
       x="-853.95215"
       y="219.21396"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_11"
       id="text100">website</text>
    <text
       font-size="12"
       x="-1021.3026"
       y="172.46564"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_12"
       id="text102">website</text>
    <text
       font-size="12"
       x="-1058.7947"
       y="227.69107"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_13"
       id="text104">website</text>
    <text
       font-size="12"
       x="-1173.479"
       y="-135.88165"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_14"
       id="text106">website</text>
    <text
       font-size="12"
       x="-1195.2006"
       y="-62.198509"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_15"
       id="text108">website</text>
    <text
       font-size="12"
       x="-1193.5596"
       y="13.636676"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:12px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000"
       class="id_16"
       id="text110">website</text>
  </g>
  <text
     id="text113"
     class="id_1"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="-212.44034"
     x="-1022.4066"
     font-size="10">visited</text>
  <text
     id="text115"
     class="id_2"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="-232.86406"
     x="-975.75891"
     font-size="10">visited</text>
  <text
     id="text117"
     class="id_3"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="-233.41827"
     x="-878.15118"
     font-size="10">visited</text>
  <text
     id="text119"
     class="id_4"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#ff6600;fill-opacity:1;stroke-width:0.93626857"
     y="-132.87688"
     x="-969.33142"
     font-size="10">has_identity</text>
  <text
     id="text121"
     class="id_5"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#ff6600;fill-opacity:1;stroke-width:0.93626857"
     y="-105.03999"
     x="-876.59192"
     font-size="10">has_identity</text>
  <text
     id="text123"
     class="id_6"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#ff6600;fill-opacity:1;stroke-width:0.93626857"
     y="-15.354239"
     x="-904.26416"
     font-size="10">has_identity</text>
  <text
     id="text125"
     class="id_7"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#ff6600;fill-opacity:1;stroke-width:0.93626857"
     y="-63.365463"
     x="-1028.2551"
     font-size="10">has_identity</text>
  <text
     id="text127"
     class="id_9"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="-65.600342"
     x="-727.15985"
     font-size="10">visited</text>
  <text
     id="text129"
     class="id_10"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="-35.651588"
     x="-725.35907"
     font-size="10">visited</text>
  <text
     id="text131"
     class="id_11"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="11.90019"
     x="-726.00934"
     font-size="10">visited</text>
  <text
     id="text135"
     class="id_13"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="125.93059"
     x="-956.41919"
     font-size="10">visited</text>
  <text
     id="text137"
     class="id_14"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="135.14076"
     x="-837.15662"
     font-size="10">visited</text>
  <text
     id="text139"
     class="id_15"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="167.98705"
     x="-932.22565"
     font-size="10">visited</text>
  <text
     id="text141"
     class="id_16"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="-69.123894"
     x="-1107.4799"
     font-size="10">visited</text>
  <text
     id="text143"
     class="id_17"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="-28.413658"
     x="-1120.6887"
     font-size="10">visited</text>
  <text
     id="text145"
     class="id_19"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="6.1159439"
     x="-1113.7499"
     font-size="10">visited</text>
  <text
     id="text147"
     class="id_20"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.36268616px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;stroke-width:0.93626857"
     y="-142.98676"
     x="-1080.473"
     font-size="10">visited</text>
  <flowRoot
     xml:space="preserve"
     id="flowRoot886"
     style="font-style:normal;font-weight:normal;font-size:40px;line-height:1000;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
     transform="matrix(0.93626859,0,0,0.93626859,-1211.4584,-308.99355)"><flowRegion
       id="flowRegion888"><rect
         id="rect890"
         width="91.574997"
         height="157.71249"
         x="711.23248"
         y="86.739998" /></flowRegion><flowPara
       id="flowPara892">).by(T.id, Order.incr)</flowPara></flowRoot>  <flowRoot
     xml:space="preserve"
     id="flowRoot894"
     style="font-style:normal;font-weight:normal;font-size:40px;line-height:1000;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
     transform="matrix(0.93626859,0,0,0.93626859,-1211.4584,-308.99355)"><flowRegion
       id="flowRegion896"><rect
         id="rect898"
         width="104.8025"
         height="163.8175"
         x="729.54749"
         y="67.407501" /></flowRegion><flowPara
       id="flowPara900">- transientId:  - uid:String- persistentId  - pid:String- website:  - url:String  - title:String- visited:  - ts:Date  - visited_url:String- has_identity- transientId:  - uid:String- persistentId  - pid:String- website:  - url:String  - title:String- visited:  - ts:Date  - visited_url:String- has_identity</flowPara><flowPara
       id="flowPara902" /><flowPara
       id="flowPara904" /><flowPara
       id="flowPara906" /><flowPara
       id="flowPara908" /><flowPara
       id="flowPara910" /><flowPara
       id="flowPara912" /><flowPara
       id="flowPara914" /><flowPara
       id="flowPara916" /><flowPara
       id="flowPara918" /><flowPara
       id="flowPara920" /><flowPara
       id="flowPara922" /><flowPara
       id="flowPara924" /><flowPara
       id="flowPara926" /><flowPara
       id="flowPara928" /><flowPara
       id="flowPara930" /><flowPara
       id="flowPara932" /><flowPara
       id="flowPara934" /><flowPara
       id="flowPara936" /><flowPara
       id="flowPara938" /><flowPara
       id="flowPara940" /></flowRoot>  <text
     xml:space="preserve"
     style="font-style:normal;font-weight:normal;font-size:10.4469614px;line-height:1;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.13277766"
     x="-734.92938"
     y="-313.59357"
     id="text944"><tspan
       sodipodi:role="line"
       id="tspan942"
       x="-734.92938"
       y="-313.59357"
       style="font-weight:bold;font-size:10.4469614px;fill:#80b3ff;fill-opacity:1;stroke-width:0.13277766">transientId</tspan><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-303.14661"
       id="tspan966"
       style="font-weight:bold;font-size:10.4469614px;fill:#000000;fill-opacity:1;stroke-width:0.13277766">  uid: <tspan
   style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:sans-serif;stroke-width:0.13277766"
   id="tspan1082">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-292.69965"
       style="font-weight:bold;font-size:10.4469614px;fill:#000000;fill-opacity:1;stroke-width:0.13277766"
       id="tspan986" /><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-282.25269"
       id="tspan968"
       style="font-weight:bold;font-size:10.4469614px;fill:#87de87;fill-opacity:1;stroke-width:0.13277766">persistentId</tspan><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-271.80573"
       id="tspan970"
       style="font-weight:bold;font-size:10.4469614px;fill:#000000;fill-opacity:1;stroke-width:0.13277766">  pid: <tspan
   style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:sans-serif;stroke-width:0.13277766"
   id="tspan1084">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-261.35876"
       style="font-weight:bold;font-size:10.4469614px;fill:#000000;fill-opacity:1;stroke-width:0.13277766"
       id="tspan988" /><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-250.9118"
       id="tspan972"
       style="font-weight:bold;font-size:10.4469614px;fill:#ff8080;fill-opacity:1;stroke-width:0.13277766">website</tspan><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-240.46484"
       id="tspan974"
       style="font-weight:bold;font-size:10.4469614px;fill:#000000;fill-opacity:1;stroke-width:0.13277766">  url: <tspan
   style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:sans-serif;stroke-width:0.13277766"
   id="tspan1086">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-230.01788"
       id="tspan976"
       style="font-weight:bold;font-size:10.4469614px;fill:#000000;fill-opacity:1;stroke-width:0.13277766">  title: <tspan
   style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:sans-serif;stroke-width:0.13277766"
   id="tspan1088">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-219.57091"
       style="font-weight:bold;font-size:10.4469614px;fill:#000000;fill-opacity:1;stroke-width:0.13277766"
       id="tspan990" /><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-209.12395"
       id="tspan978"
       style="font-weight:bold;font-size:10.4469614px;fill:#a856bc;fill-opacity:1;stroke-width:0.13277766">visited</tspan><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-198.67699"
       id="tspan980"
       style="font-weight:bold;font-size:10.4469614px;fill:#000000;fill-opacity:1;stroke-width:0.13277766">  ts: <tspan
   style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:sans-serif;stroke-width:0.13277766"
   id="tspan1090">Date</tspan></tspan><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-188.23003"
       id="tspan982"
       style="font-weight:bold;font-size:10.4469614px;fill:#000000;fill-opacity:1;stroke-width:0.13277766">  visited_url: <tspan
   style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:sans-serif;-inkscape-font-specification:sans-serif;stroke-width:0.13277766"
   id="tspan1092">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-177.78307"
       style="font-weight:bold;font-size:10.4469614px;fill:#000000;fill-opacity:1;stroke-width:0.13277766"
       id="tspan992" /><tspan
       sodipodi:role="line"
       x="-734.92938"
       y="-167.33611"
       id="tspan984"
       style="font-weight:bold;font-size:10.4469614px;fill:#ff6600;fill-opacity:1;stroke-width:0.13277766">has_identity</tspan></text>
  <rect
     style="fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.84085858;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
     id="rect994"
     width="117.88374"
     height="179.35379"
     x="-741.38531"
     y="-332.21725"
     rx="18.311306"
     ry="18.95365" />
</svg>
"
     ]
    },
    "extended.svg": {
     "image/svg+xml": [
      "<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
   xmlns:dc="http://purl.org/dc/elements/1.1/"
   xmlns:cc="http://creativecommons.org/ns#"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   contentScriptType="text/ecmascript"
   width="600"
   zoomAndPan="magnify"
   contentStyleType="text/css"
   viewBox="-560.41003 -404 600 600"
   height="600"
   preserveAspectRatio="xMidYMid meet"
   version="1.1"
   id="svg250"
   sodipodi:docname="extended.svg"
   inkscape:version="0.92.3 (2405546, 2018-03-11)">
  <metadata
     id="metadata256">
    <rdf:RDF>
      <cc:Work
         rdf:about="">
        <dc:format>image/svg+xml</dc:format>
        <dc:type
           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
        <dc:title />
      </cc:Work>
    </rdf:RDF>
  </metadata>
  <defs
     id="defs254" />
  <sodipodi:namedview
     pagecolor="#ffffff"
     bordercolor="#666666"
     borderopacity="1"
     objecttolerance="10"
     gridtolerance="10"
     guidetolerance="10"
     inkscape:pageopacity="0"
     inkscape:pageshadow="2"
     inkscape:window-width="1920"
     inkscape:window-height="1015"
     id="namedview252"
     showgrid="false"
     inkscape:lockguides="true"
     inkscape:zoom="1"
     inkscape:cx="272.83483"
     inkscape:cy="399.97491"
     inkscape:window-x="0"
     inkscape:window-y="840"
     inkscape:window-maximized="1"
     inkscape:current-layer="svg250" />
  <path
     style="fill:none;stroke:#1a1a1a;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:1.873, 1.87300000000000000;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path2"
     class="id_1 id_5"
     d="M -203.85448,-49.319909 C -151.27538,84.798939 -256.15285,50.80378 -267.36961,80.06227"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:1.873, 1.873;stroke-dashoffset:0;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path6"
     class="id_1 id_7"
     d="m -203.85448,-49.319909 c -20.43768,12.610049 2.70576,26.977344 -13.75111,41.1370566"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:22.47600031, 22.47600031;stroke-dashoffset:18.72999954;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path8"
     class="id_0 id_1"
     d="m -343.06547,-81.468532 c 59.77006,-5.526186 61.64292,34.982765 139.21099,32.148623"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:22.476, 22.476;stroke-dashoffset:18.72999954;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path10"
     class="id_0 id_2"
     d="m -343.06547,-81.468532 c 32.3471,29.670178 -53.24929,96.665154 -45.59444,157.00515"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:22.47600031, 22.47600031;stroke-dashoffset:18.72999954;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path12"
     class="id_0 id_3"
     d="M -343.06547,-81.468532 C -437.31966,-143.66625 -280.78923,-186.93366 -451.45303,-266.6112"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:22.47600031,22.47600031;stroke-dashoffset:18.73000026"
     inkscape:connector-curvature="0"
     id="path14"
     class="id_0 id_4"
     d="m -343.06547,-81.468532 c -3.41602,-39.180988 37.06187,-109.543998 76.24286,-112.960018"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:1.87300003, 1.87300003000000004;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path16"
     class="id_2 id_8"
     d="M -391.15164,77.474626 C -403.58229,4.722074 -458.38137,45.857033 -476.22975,-8.537468"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#1a1a1a;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:1.873, 1.87300000000000000;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path18"
     class="id_2 id_9"
     d="m -388.65991,75.536618 c 57.55634,-14.04126 26.42116,-32.078479 37.50816,-49.075918"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#1a1a1a;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:1.873, 1.87300000000000000;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path20"
     class="id_2 id_10"
     d="m -391.15164,77.474626 c 7.78811,23.629904 -14.31341,72.694914 23.7961,70.239264"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#1a1a1a;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:1.873, 1.873;stroke-dashoffset:0;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path24"
     class="id_12 id_3"
     d="m -395.85287,-313.30587 c -5.7811,24.25897 -31.3412,52.47577 -55.60016,46.69467"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#1a1a1a;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:1.873, 1.873;stroke-dashoffset:0;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path26"
     class="id_3 id_11"
     d="m -451.45303,-266.6112 c 6.16979,34.3688 18.5936,63.6211 -15.66125,82.24466"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#1a1a1a;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:1.873, 1.873;stroke-dashoffset:0;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path28"
     class="id_3 id_13"
     d="m -451.45303,-266.6112 c -12.58404,1.31148 -52.9273,-16.09737 -54.23881,-28.6814"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#1a1a1a;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:1.873, 1.87300000000000000;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path30"
     class="id_4 id_14"
     d="m -266.82261,-194.42855 c 57.60823,25.75836 -14.21903,77.84019 56.06841,85.76957"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#1a1a1a;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:1.873, 1.873;stroke-dashoffset:0;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path32"
     class="id_4 id_15"
     d="m -266.82261,-194.42855 c 14.41762,8.69958 55.30671,-20.40337 86.91573,-1.15333"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#1a1a1a;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:1.873, 1.87300000000000000;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path34"
     class="id_4 id_16"
     d="m -266.82261,-194.42855 c -23.5428,-61.38967 63.00242,-63.36189 -6.73012,-133.40769"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#1a1a1a;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:1.873, 1.87300000000000000;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path36"
     class="id_1 id_14"
     d="m -203.85448,-49.319909 c 42.22991,-40.117015 -27.47638,-32.018566 -6.89972,-59.339071"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:14.98400021, 3.74600005000000014, 1.87300003000000004, 3.74600005000000014;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path38"
     class="id_2 id_33"
     d="m -391.15164,77.474626 c -7.33067,-16.913531 -109.48791,52.580284 -92.57438,45.249634"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:14.98400021, 3.74600005, 1.87300003, 3.74600005;stroke-dashoffset:0;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path40"
     class="id_3 id_33"
     d="m -451.45303,-266.6112 c -9.62778,17.77167 -119.81177,87.36899 -32.27299,389.33546"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path42"
     class="id_0 id_17"
     d="m -343.06547,-81.468532 c -0.99716,39.091946 -58.73499,-3.262219 -76.48869,10.679954"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:0.46825001,0.46825001;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path44"
     class="id_12 id_26"
     d="m -395.85287,-313.30587 c -26.72609,6.44209 -76.47836,-23.9839 -82.92047,-50.70999" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:0.46825001,0.46825001;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path46"
     class="id_13 id_26"
     d="m -505.69184,-295.2926 c -8.36097,-19.12836 7.79015,-60.36228 26.9185,-68.72326" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:0.46825001,0.46825001;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path48"
     class="id_16 id_28"
     d="m -273.55273,-327.83624 c -37.18269,-8.2404 -37.74114,68.0448 -96.88523,43.82074"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:0.46825001, 0.46825001;stroke-dashoffset:0;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path50"
     class="id_10 id_29"
     d="m -367.35554,147.71389 c 99.40189,-16.40112 -6.58717,-127.470354 100.29377,-133.20796"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:0.46825001, 0.46825001;stroke-dashoffset:0;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path52"
     class="id_11 id_27"
     d="m -467.11428,-184.36654 c -10.69582,6.99899 -31.7547,32.64942 -30.71018,67.38632"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:0.46825001,0.46825001;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path54"
     class="id_8 id_27"
     d="m -476.22975,-8.537468 c 1.35987,-9.938312 20.0146,-68.114822 -21.59471,-108.442752"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:0.46825001,0.46825001;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path56"
     class="id_29 id_9"
     d="m -267.06177,14.50593 c -26.98204,-38.019266 -45.48475,14.625656 -83.73643,10.187003"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:0.46825001, 0.46825001;stroke-dashoffset:0;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path58"
     class="id_7 id_29"
     d="m -219.72691,-8.1828524 c -25.34896,0.09049 -7.36204,17.0066871 -47.33486,22.6887824"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:0.46825001,0.46825001;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path60"
     class="id_5 id_30"
     d="m -267.36961,80.06227 c 37.12807,44.77762 42.23178,8.547498 78.01497,51.29609"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:0.46825001,0.46825001;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path62"
     class="id_6 id_30"
     d="m -192.89187,65.103054 c -10.4134,37.259116 25.97138,40.117486 3.53723,66.255306"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:0.46825001,0.46825001;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path64"
     class="id_15 id_31"
     d="m -179.90688,-195.58188 c 5.18911,20.73176 76.62744,-0.31425 59.07767,33.33588"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:0.46825001,0.46825001;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path66"
     class="id_14 id_31"
     d="m -210.7542,-108.65898 c 0.42779,-25.68217 78.29412,-11.39252 89.92499,-53.58702"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:14.98400021, 3.74600005, 1.87300003, 3.74600005;stroke-dashoffset:0;stroke-opacity:1"
     inkscape:connector-curvature="0"
     id="path68"
     class="id_1 id_33"
     d="M -203.85448,-49.319909 C 63.072134,198.44634 -425.8882,245.77532 -483.72602,122.72426"
     sodipodi:nodetypes="cc" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1.87300003;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:14.98400021, 3.74600005000000014, 1.87300003000000004, 3.74600005000000014;stroke-dashoffset:0"
     inkscape:connector-curvature="0"
     id="path70"
     class="id_4 id_32"
     d="m -266.82261,-194.42855 c 69.25114,-18.15046 21.98583,-69.66253 73.37029,-84.55708"
     sodipodi:nodetypes="cc" />
  <circle
     style="fill:#87de87;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle73"
     cy="-81.218529"
     class="id_0"
     cx="-342.81549"
     r="7.208467" />
  <circle
     style="fill:#80b3ff;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle77"
     cy="75.427948"
     class="id_2"
     cx="-389.27313"
     r="7.208467" />
  <circle
     style="fill:#80b3ff;fill-opacity:1;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
     id="circle79"
     cy="-267.46475"
     class="id_3"
     cx="-451.15402"
     r="7.208467" />
  <circle
     style="fill:#80b3ff;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle81"
     cy="-194.78212"
     class="id_4"
     cx="-266.46906"
     r="7.208467" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle83"
     cy="79.828079"
     class="id_5"
     cx="-267.60379"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle85"
     cy="65.434242"
     class="id_6"
     cx="-193.12605"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
     id="circle87"
     cy="-7.7257471"
     class="id_7"
     cx="-219.19658"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle89"
     cy="-9.187006"
     class="id_8"
     cx="-475.83823"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle91"
     cy="26.10713"
     class="id_9"
     cx="-351.15173"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle93"
     cy="147.16017"
     class="id_10"
     cx="-367.90924"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle95"
     cy="-185.23152"
     class="id_11"
     cx="-466.47281"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle97"
     cy="-313.30588"
     class="id_12"
     cx="-395.85284"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle99"
     cy="-295.2926"
     class="id_13"
     cx="-505.69189"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle101"
     cy="-108.3278"
     class="id_14"
     cx="-211.48366"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle103"
     cy="-195.58188"
     class="id_15"
     cx="-179.7301"
     r="3.6042335" />
  <circle
     style="fill:#ff8080;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle105"
     cy="-327.83624"
     class="id_16"
     cx="-273.55273"
     r="3.6042335" />
  <circle
     style="fill:#de87cd;fill-opacity:1;stroke:#000000;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
     id="circle107"
     cy="-71.685028"
     class="id_17"
     cx="-422.73615"
     r="7.208467" />
  <circle
     style="fill:#00d4aa;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle109"
     cy="122.54265"
     class="id_33"
     cx="-482.65311"
     r="7.208467" />
  <circle
     style="fill:#00d4aa;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle111"
     cy="-279.69275"
     class="id_32"
     cx="-193.45232"
     r="7.208467" />
  <circle
     style="fill:#ffdd55;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle113"
     cy="-160.83179"
     class="id_31"
     cx="-121.53632"
     r="7.208467" />
  <circle
     style="fill:#ffdd55;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle115"
     cy="131.31602"
     class="id_30"
     cx="-189.65659"
     r="7.208467" />
  <circle
     style="fill:#ffdd55;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle117"
     cy="14.280853"
     class="id_29"
     cx="-267.48282"
     r="7.208467" />
  <circle
     style="fill:#ffdd55;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle119"
     cy="-284.0155"
     class="id_28"
     cx="-370.43799"
     r="7.208467" />
  <circle
     style="fill:#ffdd55;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle121"
     cy="-115.26595"
     class="id_27"
     cx="-496.08792"
     r="7.208467" />
  <circle
     style="fill:#ffdd55;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle123"
     cy="-364.01584"
     class="id_26"
     cx="-478.77335"
     r="7.208467" />
  <text
     id="text126"
     class="id_0"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="-95.764946"
     x="-309.48364"
     font-size="24">persistentId</text>
  <text
     id="text128"
     class="id_1"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="-49.062801"
     x="-151.56358"
     font-size="24">transientId</text>
  <text
     id="text130"
     class="id_2"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="67.976112"
     x="-442.53064"
     font-size="24">transientId</text>
  <text
     id="text132"
     class="id_3"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="-259.51611"
     x="-511.0202"
     font-size="24">transientId</text>
  <text
     id="text134"
     class="id_4"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="-202.03632"
     x="-318.91061"
     font-size="24">transientId</text>
  <text
     id="text136"
     class="id_5"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:8.65016079px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671"
     y="90.118965"
     x="-281.70193"
     font-size="12">website</text>
  <text
     id="text138"
     class="id_6"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:8.65016079px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671"
     y="64.958168"
     x="-169.12369"
     font-size="12">website</text>
  <text
     id="text140"
     class="id_7"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:8.65016079px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671"
     y="-17.712736"
     x="-238.07005"
     font-size="12">website</text>
  <text
     id="text142"
     class="id_8"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:8.65016079px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671"
     y="-8.4844398"
     x="-450.88409"
     font-size="12">website</text>
  <text
     id="text144"
     class="id_9"
     style="font-size:8.65016079px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671"
     y="33.449104"
     x="-333.50818"
     font-size="12">
    <tspan
       style="font-weight:bold"
       id="tspan1861">website</tspan>
  </text>
  <text
     id="text146"
     class="id_10"
     style="font-size:8.65016079px;font-family:sans-serif;dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671;-inkscape-font-specification:'sans-serif Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="157.11269"
     x="-368.10175"
     font-size="12">website</text>
  <text
     id="text148"
     class="id_11"
     style="font-size:8.65016079px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671"
     y="-184.82788"
     x="-442.30499"
     font-size="12">website</text>
  <text
     id="text150"
     class="id_12"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:8.65016079px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671"
     y="-323.19879"
     x="-393.65311"
     font-size="12">website</text>
  <text
     id="text152"
     class="id_13"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:8.65016079px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671"
     y="-293.9754"
     x="-529.86218"
     font-size="12">website</text>
  <text
     id="text154"
     class="id_14"
     style="font-size:8.65016079px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671"
     y="-106.08726"
     x="-189.4908"
     font-size="12">
    <tspan
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:Arial;-inkscape-font-specification:'Arial Bold'"
       id="tspan1859">website</tspan>
  </text>
  <text
     id="text156"
     class="id_15"
     style="font-size:8.65016079px;font-family:sans-serif;dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671;-inkscape-font-specification:'sans-serif Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="-206.6945"
     x="-176.37134"
     font-size="12">website</text>
  <text
     id="text158"
     class="id_16"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:8.65016079px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.72084671"
     y="-332.14542"
     x="-251.0074"
     font-size="12">website</text>
  <text
     id="text160"
     class="id_17"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="-54.49361"
     x="-404.84439"
     font-size="24">groupIdentity</text>
  <text
     id="text162"
     class="id_33"
     style="font-size:14.44243908px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.60176826"
     y="138.37213"
     x="-516.72803"
     font-size="24">
    <tspan
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:Arial;-inkscape-font-specification:'Arial Bold';stroke-width:0.60176826"
       id="tspan1857">IPLocation</tspan>
  </text>
  <text
     id="text164"
     class="id_32"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:14.437356px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.60155642"
     y="-296.8035"
     x="-193.43414"
     font-size="24">IPLocation</text>
  <text
     id="text166"
     class="id_31"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="-167.95103"
     x="-183.4379"
     font-size="24">websiteGroup</text>
  <text
     id="text168"
     class="id_30"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="147.29059"
     x="-224.15486"
     font-size="24">websiteGroup</text>
  <text
     id="text170"
     class="id_29"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="35.694077"
     x="-253.75"
     font-size="24">websiteGroup</text>
  <text
     id="text172"
     class="id_28"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="-265.31366"
     x="-346.11215"
     font-size="24">websiteGroup</text>
  <text
     id="text174"
     class="id_27"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:13.86846638px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.57785273"
     y="-117.9165"
     x="-433.48755"
     font-size="24">websiteGroup</text>
  <text
     id="text176"
     class="id_26"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:14.437356px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#000000;stroke-width:0.60155642"
     y="-379.98752"
     x="-478.78873"
     font-size="24">websiteGroup</text>
  <text
     id="text181"
     class="id_2"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="-35.834854"
     x="-229.39928"
     font-size="10">visited</text>
  <text
     id="text183"
     class="id_3"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="21.258574"
     x="-206.65714"
     font-size="10">visited</text>
  <text
     id="text185"
     class="id_4"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:Arial;-inkscape-font-specification:'Arial Bold';dominant-baseline:central;text-anchor:middle;fill:#ff6600;fill-opacity:1;stroke-width:0.72084671"
     y="-69.636452"
     x="-287.76663"
     font-size="10">has_identity</text>
  <text
     id="text187"
     class="id_5"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:Arial;-inkscape-font-specification:'Arial Bold';dominant-baseline:central;text-anchor:middle;fill:#ff6600;fill-opacity:1;stroke-width:0.72084671"
     y="-24.647402"
     x="-346.64264"
     font-size="10">has_identity</text>
  <text
     id="text189"
     class="id_6"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:Arial;-inkscape-font-specification:'Arial Bold';dominant-baseline:central;text-anchor:middle;fill:#ff6600;fill-opacity:1;stroke-width:0.72084671"
     y="-172.41006"
     x="-368.58017"
     font-size="10">has_identity</text>
  <text
     id="text191"
     class="id_7"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:Arial;-inkscape-font-specification:'Arial Bold';dominant-baseline:central;text-anchor:middle;fill:#ff6600;fill-opacity:1;stroke-width:0.72084671"
     y="-140.89136"
     x="-323.50269"
     font-size="10">has_identity</text>
  <text
     id="text193"
     class="id_9"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="20.37962"
     x="-423.25812"
     font-size="10">visited</text>
  <text
     id="text195"
     class="id_10"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="72.201614"
     x="-351.30807"
     font-size="10">visited</text>
  <text
     id="text197"
     class="id_11"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="119.97665"
     x="-374.50159"
     font-size="10">visited</text>
  <text
     id="text199"
     class="id_12"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="-287.76459"
     x="-428.36285"
     font-size="10">visited</text>
  <text
     id="text203"
     class="id_14"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="-213.31374"
     x="-427.00528"
     font-size="10">visited</text>
  <text
     id="text205"
     class="id_15"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="-283.53699"
     x="-473.72855"
     font-size="10">visited</text>
  <text
     id="text207"
     class="id_16"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="-141.17375"
     x="-260.14374"
     font-size="10">visited</text>
  <text
     id="text209"
     class="id_17"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="-193.80461"
     x="-215.60733"
     font-size="10">visited</text>
  <text
     id="text211"
     class="id_19"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="-276.8183"
     x="-262.87717"
     font-size="10">visited</text>
  <text
     id="text213"
     class="id_20"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="-71.152214"
     x="-207.20294"
     font-size="10">visited</text>
  <text
     id="text215"
     class="id_41"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#ff2a2a;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;fill-opacity:1;"
     y="-64.654877"
     x="-533.06921"
     font-size="10">uses</text>
  <text
     id="text217"
     class="id_40"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#ff2a2a;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;fill-opacity:1;"
     y="106.40356"
     x="-438.57278"
     font-size="10">uses</text>
  <text
     id="text219"
     class="id_24"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:Arial;-inkscape-font-specification:'Arial Bold';dominant-baseline:central;text-anchor:middle;fill:#ff2a7f;stroke-width:0.72084671;"
     y="-77.41349"
     x="-381.23975"
     font-size="10">member</text>
  <text
     id="text221"
     class="id_27"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="-337.18295"
     x="-438.55563"
     font-size="10">links_to</text>
  <text
     id="text223"
     class="id_28"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="-335.45975"
     x="-518.09741"
     font-size="10">links_to</text>
  <text
     id="text225"
     class="id_29"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="-303.10248"
     x="-328.06839"
     font-size="10">links_to</text>
  <text
     id="text227"
     class="id_33"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:Arial;-inkscape-font-specification:'Arial Bold';dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671"
     y="111.21833"
     x="-305.66586"
     font-size="10">links_to</text>
  <text
     id="text229"
     class="id_31"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="-156.05252"
     x="-471.96738"
     font-size="10">links_to</text>
  <text
     id="text231"
     class="id_32"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="-66.183113"
     x="-487.37579"
     font-size="10">links_to</text>
  <text
     id="text233"
     class="id_34"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="9.9799271"
     x="-328.39841"
     font-size="10">links_to</text>
  <text
     id="text235"
     class="id_35"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:Arial;-inkscape-font-specification:'Arial Bold';dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671"
     y="0.10326958"
     x="-255.40355"
     font-size="10">links_to</text>
  <text
     id="text237"
     class="id_36"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="95.82373"
     x="-229.15044"
     font-size="10">links_to</text>
  <text
     id="text239"
     class="id_37"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="89.502663"
     x="-177.58423"
     font-size="10">links_to</text>
  <text
     id="text241"
     class="id_38"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="-192.44249"
     x="-146.87909"
     font-size="10">links_to</text>
  <text
     id="text243"
     class="id_39"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#00aad4;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;"
     y="-135.92622"
     x="-183.40439"
     font-size="10">links_to</text>
  <text
     id="text245"
     class="id_42"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:Arial;-inkscape-font-specification:'Arial Bold';dominant-baseline:central;text-anchor:middle;fill:#ff2a2a;fill-opacity:1;stroke-width:0.72084671"
     y="180.48503"
     x="-308.29529"
     font-size="10">uses</text>
  <text
     id="text247"
     class="id_43"
     style="font-size:7.20846701px;font-family:Arial;dominant-baseline:central;text-anchor:middle;fill:#ff2a2a;stroke-width:0.72084671;-inkscape-font-specification:'Arial Bold';font-weight:bold;font-style:normal;font-stretch:normal;font-variant:normal;fill-opacity:1;"
     y="-235.409"
     x="-235.50246"
     font-size="10">uses</text>
  <text
     xml:space="preserve"
     style="font-style:normal;font-weight:normal;font-size:29.36859703px;line-height:0.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.73421496"
     x="-96.145706"
     y="-382.11075"
     id="text1067"><tspan
       sodipodi:role="line"
       id="tspan1065"
       x="-96.145706"
       y="-382.11075"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#80b3ff;fill-opacity:1;stroke-width:0.73421496">transientId</tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-372.13"
       id="tspan1069"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  uid: <tspan
   style="font-weight:normal"
   id="tspan981">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-362.14929"
       id="tspan1071"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  user_agent: <tspan
   style="font-weight:normal"
   id="tspan983">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-352.16855"
       id="tspan1073"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  device: <tspan
   style="font-weight:normal"
   id="tspan985">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-342.18781"
       id="tspan1075"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  os: <tspan
   style="font-weight:normal"
   id="tspan987">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-332.20709"
       id="tspan1077"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  browser: <tspan
   style="font-weight:normal"
   id="tspan989">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-322.22635"
       id="tspan1079"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  email: <tspan
   style="font-weight:normal"
   id="tspan991">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-312.24561"
       id="tspan1081"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  type: <tspan
   style="font-weight:normal"
   id="tspan993">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-302.26486"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496"
       id="tspan1553" /><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-294.92273"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#87de87;fill-opacity:1;stroke-width:0.73421496"
       id="tspan1865">persistentId</tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-284.94199"
       id="tspan1085"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  pid: <tspan
   style="font-weight:normal"
   id="tspan995">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-274.96127"
       id="tspan1087"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496" /><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-267.61911"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#de87cd;fill-opacity:1;stroke-width:0.73421496"
       id="tspan1555">identityGroup</tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-257.63837"
       id="tspan1089"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  igid: <tspan
   style="font-weight:normal"
   id="tspan997">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-247.65764"
       id="tspan1091"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  type: <tspan
   style="font-weight:normal"
   id="tspan999">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-237.67691"
       id="tspan1093"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496" /><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-230.33476"
       id="tspan1095"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff8080;fill-opacity:1;stroke-width:0.73421496">website</tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-220.35402"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496"
       id="tspan1898">  url: <tspan
   style="font-weight:normal"
   id="tspan1001">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-210.37329"
       id="tspan1097"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  title: <tspan
   style="font-weight:normal"
   id="tspan1003">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-200.39255"
       id="tspan1099"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496" /><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-193.0504"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ffdd55;fill-opacity:1;stroke-width:0.73421496"
       id="tspan1559">websiteGroup</tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-183.06967"
       id="tspan1101"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  url: <tspan
   style="font-weight:normal"
   id="tspan1005">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-173.08894"
       id="tspan1103"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  category: <tspan
   style="font-weight:normal"
   id="tspan1013">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-163.1082"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496"
       id="tspan1561">  categoryCode: <tspan
   style="font-weight:normal"
   id="tspan1011">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-153.12747"
       id="tspan1107"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496" /><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-145.78532"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#00d4aa;fill-opacity:1;stroke-width:0.73421496"
       id="tspan1565">IPLoc</tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-135.80458"
       id="tspan1109"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  state: <tspan
   style="font-weight:normal"
   id="tspan1015">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-125.82385"
       id="tspan1111"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  city: <tspan
   style="font-weight:normal"
   id="tspan1017">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-115.84312"
       id="tspan1113"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  ip_address: <tspan
   style="font-weight:normal"
   id="tspan1019">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-105.86238"
       id="tspan1115"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496" /><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-98.520233"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#a856bc;fill-opacity:1;stroke-width:0.73421496"
       id="tspan1567">visited</tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-88.539497"
       id="tspan1117"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  ts: <tspan
   style="font-weight:normal"
   id="tspan1021">Date</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-78.558769"
       id="tspan1119"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  visited_url: <tspan
   style="font-weight:normal"
   id="tspan1023">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-68.578033"
       id="tspan1121"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  state: <tspan
   style="font-weight:normal"
   id="tspan1025">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-58.597298"
       id="tspan1123"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  city: <tspan
   style="font-weight:normal"
   id="tspan1027">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-48.616562"
       id="tspan1125"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496">  ip_address: <tspan
   style="font-weight:normal"
   id="tspan1029">String</tspan></tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-38.63583"
       id="tspan1127"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.73421496" /><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-31.29368"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff6600;fill-opacity:1;stroke-width:0.73421496"
       id="tspan1569">has_identity</tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-21.312946"
       id="tspan1129"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#00aad4;fill-opacity:1;stroke-width:0.73421496">links_to</tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-11.332212"
       id="tspan1131"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff2a2a;fill-opacity:1;stroke-width:0.73421496">uses</tspan><tspan
       sodipodi:role="line"
       x="-96.145706"
       y="-1.3514781"
       id="tspan1133"
       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.78953266px;line-height:0.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';fill:#ff2a7f;fill-opacity:1;stroke-width:0.73421496">member</tspan></text>
  <flowRoot
     xml:space="preserve"
     id="flowRoot1587"
     style="font-style:normal;font-weight:normal;font-size:40px;line-height:1.25;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none"
     transform="translate(-560.41003,-362)"><flowRegion
       id="flowRegion1589"><rect
         id="rect1591"
         width="76.488876"
         height="64.367691"
         x="813.7915"
         y="66.046936" /></flowRegion><flowPara
       id="flowPara1593" /></flowRoot>  <path
     sodipodi:nodetypes="cc"
     d="m -203.85448,-49.319909 c 49.01292,83.153315 20.03484,84.762373 10.96261,114.422963"
     class="id_1 id_5"
     id="path1855"
     inkscape:connector-curvature="0"
     style="fill:none;stroke:#1a1a1a;stroke-width:1.87300003;stroke-miterlimit:4;stroke-dasharray:1.873, 1.873;stroke-dashoffset:0;stroke-opacity:1" />
  <circle
     style="fill:#80b3ff;fill-opacity:1;stroke:#000000;stroke-width:1.873;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
     id="circle75"
     cy="-49.319908"
     class="id_1"
     cx="-204.10448"
     r="7.208467" />
  <text
     id="text183-3"
     class="id_3"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.20846701px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';dominant-baseline:central;text-anchor:middle;fill:#a856bc;fill-opacity:1;stroke-width:0.72084671"
     y="41.814823"
     x="-163.65837"
     font-size="10">visited</text>
  <rect
     style="fill:none;fill-opacity:1;stroke:#000000;stroke-width:3.03905845;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
     id="rect994"
     width="139.47235"
     height="413.15561"
     x="-103.35941"
     y="-400.32047"
     rx="20.3267"
     ry="20.3267" />
</svg>
"
     ]
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph model\n",
    "Diagrams below show the dataset represented as a graph before and after manipulations.\n",
    "\n",
    "Before:\n",
    "![Untitled%20%281%29.svg](attachment:Untitled%20%281%29.svg)\n",
    "\n",
    "After:\n",
    "![extended.svg](attachment:extended.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In short:\n",
    "* more transient node attributes  (type, user agents and its derivatives, email addresses) \n",
    "* IP & Location nodes (IP address, state, city) \n",
    "* identity group nodes (with type attribute)\n",
    "* website groups (aka root domains with information about the content on the page, with IAB categories)\n",
    "* more context to visiting page events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph Statistics\n",
    "\n",
    "The following commands will provide detail to the number of vertices and edges by label."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "\n",
    "pip --disable-pip-version-check install colorlover tqdm intervaltree sortedcontainers scipy --no-deps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython import get_ipython\n",
    "import json\n",
    "ipython = get_ipython()\n",
    "result = ipython.magic(\"graph_notebook_config\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "from nepytune.traversal import get_traversal\n",
    "\n",
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:  The following is going to do a count of all vertices and edges in the graph.  This can take 2-3 minutes to return results.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%gremlin --store-to counts_of_vertices --silent\n",
    "\n",
    "g.V().groupCount().by(T.label).toList()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%gremlin --store-to counts_of_edges --silent\n",
    "\n",
    "g.E().groupCount().by(T.label).toList()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Execute the following cell to visualize the counts of both vertices and edges:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from nepytune.visualizations.bar_plots import make_bars\n",
    "\n",
    "chart1 = make_bars(counts_of_vertices[0], \n",
    "          \"Number of Vertices per label\",\n",
    "          y_title=\"Number of vertices\",\n",
    "          x_title=\"Vertices per label\",\n",
    "          lazy=True)\n",
    "chart1.show()\n",
    "\n",
    "chart2 = make_bars(counts_of_edges[0], \n",
    "          \"Number of Edges per label\",\n",
    "          y_title=\"Number of edges\",\n",
    "          x_title=\"Edges per label\",\n",
    "          lazy=True)\n",
    "chart2.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pprint\n",
    "\n",
    "from nepytune.usecase import (\n",
    "    user_summary, \n",
    "    undecided_users, \n",
    "    brand_interaction, \n",
    "    users_from_household, \n",
    "    purchase_path,\n",
    "    similar_audience\n",
    ")\n",
    "\n",
    "pp = pprint.PrettyPrinter(indent=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use case queries\n",
    "Each of the use case queries follows the same presentation pattern:\n",
    "* define the query parameters\n",
    "* show the traversal code\n",
    "* draw part of referenced subgraph for the visual introspection of the query results\n",
    "* describe the plot\n",
    "\n",
    "The referenced subgraph is built using **networkx** package and rendered using **plotly** library. We use mostly networkx for computing positions, except for venn diagram visualisations where we compute the positions ourselves. You can find all the code with use-case query and subgraph generation in the `nepytune/usecase` package.\n",
    "\n",
    "The subgraph query is distinct from the use case query as it often extracts more information for the purposes of the visualisation, and as a consequence is often less efficient. \n",
    "\n",
    "Some of the use-case query visualisations are explained to guide the reader and help with their understanding. \n",
    "The purpose is just to present the complexity of the dataset and to introspect the query results. Each of the plot is interactive, so feel free to play with it. \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use case 1)  \n",
    "###  Advertisers want to find out information about user interests to provide an accurate targeting. The data should be based on the activity of the user across all devices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRANSIENT_ID = \"8ff869623f18f72f7cd073120dd905ec\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%gremlin --store-to sibling_attrs --silent\n",
    "\n",
    "g.V('${TRANSIENT_ID}')\n",
    "    .choose(\n",
    "        in(\"has_identity\"),  // check if this transient id has persistent id\n",
    "        in(\"has_identity\").\n",
    "            project(\n",
    "                \"identity_group_id\", \"persistent_id\", \"attributes\", \"ip_location\", \"iab_categories\"\n",
    "            ).by(in(\"member\").values(\"igid\"))\n",
    "            .by(values(\"pid\"))\n",
    "            .by(\n",
    "                out(\"has_identity\").valueMap().unfold()\n",
    "                .group()\n",
    "                .by(keys)\n",
    "                .by(select(values).unfold().dedup().fold())\n",
    "            )\n",
    "            .by(\n",
    "                out(\"has_identity\")\n",
    "                .out(\"uses\").dedup().valueMap().fold()\n",
    "            )\n",
    "            .by(\n",
    "                out(\"has_identity\")\n",
    "                .out(\"visited\")\n",
    "                .in(\"links_to\")\n",
    "                .values(\"categoryCode\").dedup().fold()\n",
    "            )\n",
    "        , project(\n",
    "            \"identity_group_id\", \"persistent_id\", \"attributes\", \"ip_location\", \"iab_categories\"\n",
    "        ).by(constant(\"\"))\n",
    "        .by(constant(\"\"))\n",
    "        .by(\n",
    "            valueMap().unfold()\n",
    "            .group()\n",
    "            .by(keys)\n",
    "            .by(select(values).unfold().dedup().fold())\n",
    "        )\n",
    "        .by(\n",
    "            out(\"uses\").dedup().valueMap().fold()\n",
    "        )\n",
    "        .by(\n",
    "            out(\"visited\")\n",
    "            .in(\"links_to\")\n",
    "            .values(\"categoryCode\").dedup().fold()\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pp.pprint(sibling_attrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "user_summary.draw_refrenced_subgraph(g, TRANSIENT_ID)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Graph description\n",
    "\n",
    "There are 6 node types on the graph:\n",
    "* red one representing IP & Location node\n",
    "* green one representing identity group node of type household\n",
    "* violet one representing persistent identities (aka different users)\n",
    "* orange one representing transient identities (aka various user devices)\n",
    "* blue one representing website subpages\n",
    "* pink one representing website root domains\n",
    "\n",
    "The goal of this query is to find the summary of given persistent identity profile based on one of transient identities. Graph presented above shows part of the houshold (to which given transient identity belongs) activity on the web."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use case 2) \n",
    "### Ecommerce publishers want to convince undecided users to purchase the product by offering them discount codes as soon as they have met certain criteria. Find all users who have visited product page at least X times in the last 30 days, but did not buy anything (have not visited thank you page)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are actually two questions we can formulate for created audiences: \n",
    "* who belongs to the audience? \n",
    "* does this user belong to the audience?\n",
    "\n",
    "Each question above has separate implementation presented. The membership test query can be answered more efficiently and if the performance is good enough for the use case, might be used in a real-time application. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "TRANSIENT_ID = \"808d27e1fbe3016cf9523de320bfb1be\"\n",
    "WEBSITE_URL = \"b23e286d713f61fd/f9077d4b41c9e32e\"\n",
    "THANK_YOU_PAGE_URL = \"b23e286d713f61fd/f9077d4b41c9e32e/4b2b32d4f88fb014\"\n",
    "SINCE = datetime.datetime(2016, 6, 7)\n",
    "SINCE_ISO = SINCE.isoformat()\n",
    "MIN_VISITED_COUNT = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following two queries check if a user is a member of an audience by looking at connections to a specific thank you page:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%gremlin --store-to undecided_user_audience_check\n",
    "\n",
    "g.V('${TRANSIENT_ID}')\n",
    "    .hasLabel(\"transientId\")\n",
    "    .in(\"has_identity\")\n",
    "    .out(\"has_identity\")\n",
    "    .outE(\"visited\")\n",
    "    .has(\"ts\", gt(datetime('${SINCE_ISO}')))\n",
    "    .choose(\n",
    "        has(\"visited_url\",'${WEBSITE_URL}'),\n",
    "        groupCount(\"visits\").by(constant(\"page_visits\"))\n",
    "    )\n",
    "    .choose(\n",
    "        has(\"visited_url\", '${THANK_YOU_PAGE_URL}'),\n",
    "        groupCount(\"visits\").by(constant(\"thank_you_page_vists\"))\n",
    "    )\n",
    "    .cap(\"visits\")\n",
    "    .coalesce(\n",
    "        and(\n",
    "            coalesce(select(\"thank_you_page_vists\"), constant(0)).is(0),\n",
    "            select(\"page_visits\").is(gt(${MIN_VISITED_COUNT}))\n",
    "        ).choose(\n",
    "            count().is(1),\n",
    "            constant(true)\n",
    "        ),\n",
    "        constant(false)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%gremlin --store-to undecided_user_audience_check\n",
    "\n",
    "g.V('${TRANSIENT_ID}')\n",
    "    .hasLabel(\"transientId\")\n",
    "    .in(\"has_identity\")\n",
    "    .out(\"has_identity\")\n",
    "    .outE(\"visited\")\n",
    "    .has(\"ts\", gt(datetime('${SINCE_ISO}')))\n",
    "    .choose(\n",
    "        has(\"visited_url\",'${WEBSITE_URL}'),\n",
    "        groupCount(\"visits\").by(constant(\"page_visits\"))\n",
    "    )\n",
    "    .choose(\n",
    "        has(\"visited_url\", '${THANK_YOU_PAGE_URL}-this-page-not-exist'),\n",
    "        groupCount(\"visits\").by(constant(\"thank_you_page_vists\"))\n",
    "    )\n",
    "    .cap(\"visits\")\n",
    "    .coalesce(\n",
    "        and(\n",
    "            coalesce(select(\"thank_you_page_vists\"), constant(0)).is(0),\n",
    "            select(\"page_visits\").is(gt(${MIN_VISITED_COUNT}))\n",
    "        ).choose(\n",
    "            count().is(1),\n",
    "            constant(true)\n",
    "        ),\n",
    "        constant(false)\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following query looks at all users in a given audience given landing on a product conversion / \"thank you\" page:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%gremlin --store-to users\n",
    "\n",
    "g.V('${WEBSITE_URL}')\n",
    "    .hasLabel(\"website\")\n",
    "    .inE(\"visited\").has(\"ts\", gt(datetime('${SINCE_ISO}'))).outV()\n",
    "    .in(\"has_identity\")\n",
    "    .groupCount()\n",
    "    .unfold().dedup()\n",
    "    .where(\n",
    "        select(values).is(gt(${MIN_VISITED_COUNT}))\n",
    "    )\n",
    "    .select(keys).as(\"pids\")\n",
    "    .map(\n",
    "        out(\"has_identity\")\n",
    "        .outE(\"visited\")\n",
    "        .has(\"visited_url\", '${THANK_YOU_PAGE_URL}')\n",
    "        .has(\"ts\", gt(datetime('${SINCE_ISO}'))).outV()\n",
    "        .in(\"has_identity\").dedup()\n",
    "        .values(\"pid\").fold()\n",
    "    ).as(\"pids_that_visited\")\n",
    "    .select(\"pids\")\n",
    "    .not(\n",
    "        has(\"pid\", where(within(\"pids_that_visited\")))\n",
    "    )\n",
    "    .out(\"has_identity\")\n",
    "        .values(\"uid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following cell to visualize the audience:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "undecided_users.draw_referenced_subgraph(g, WEBSITE_URL, THANK_YOU_PAGE_URL, SINCE, MIN_VISITED_COUNT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Graph description\n",
    "\n",
    "There are 4 node types on the graph:\n",
    "* red one representing persistent identities (aka different users)\n",
    "* violet one representing transient identities (aka various user devices) \n",
    "* green one representing website thank you page (page that is visited when user converts)  \n",
    "* orange one representing website product page \n",
    "\n",
    "The goal of this query is to find all the user devices (violet nodes) that belongs to an audience (user (red node) belongs to an audience if he visited product page (orange node), but did not buy the product (green node) on any of its devices (violet node), and all this should happen in provided date interval - last X days).\n",
    "\n",
    "The opaque user nodes (red ones) and user device nodes (violet ones) form the desired audience. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use case 3) \n",
    "### Advertisers want to generate audiences for DSP platform targeting. Specific audience could be the users who are interested in specific car brands"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given website url, get its root node (root domain)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%gremlin --store-to root_url\n",
    "\n",
    "g.V('${WEBSITE_URL}')\n",
    "    .hasLabel(\"website\")\n",
    "    .in(\"links_to\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given website url, get all transitive (through persistent) identities\n",
    "    that interacted with this brand on any of its pages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%gremlin --store-to brand_interaction_audience\n",
    "\n",
    "g.V('${WEBSITE_URL}')\n",
    "    .hasLabel(\"website\")\n",
    "    .in(\"links_to\")\n",
    "    .out(\"links_to\") // get all websites from this root url\n",
    "    .in(\"visited\")\n",
    "    .in(\"has_identity\").dedup()\n",
    "    .out(\"has_identity\")\n",
    "    .values(\"uid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "WEBSITE_URL = \"b23e286d713f61fd\"\n",
    "print(f\"Number of subpages: {g.V(WEBSITE_URL).in_('links_to').out('links_to').count().next()}\")\n",
    "users = brand_interaction.brand_interaction_audience(g, WEBSITE_URL).toList()\n",
    "print(f\"Audience size: {len(users)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "brand_interaction.draw_referenced_subgraph(g, WEBSITE_URL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Graph description\n",
    "\n",
    "There are 4 node types on the graph:\n",
    "* red one representing persistent identities (aka different users)\n",
    "* green one representing transient identities (aka various user devices) \n",
    "* violet one representing website subpages \n",
    "* orange one representing website root domain\n",
    "\n",
    "The goal of this query is to given one website subpage (violet) node, find all user devices (green nodes) that interacted with any of the subpages on that domain. \n",
    "\n",
    "In other words, we are interested in all user device or cookie identifiers (also the ones that did not explicitly interacted with the brand, but belongs to the same user), that showed up on any of the domain page. It might be usefull for the purposes of retargeting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use case 4) \n",
    "### User has visited a travel agency website recently. Advertisers want to display ads about travel promotions to all members of his household.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given transient id, get all transient ids from its household."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%gremlin --store-to all_transient_ids_in_household\n",
    "\n",
    "g.V('${TRANSIENT_ID}')\n",
    "    .hasLabel(\"transientId\")\n",
    "    .in(\"has_identity\")\n",
    "    .in(\"member\")\n",
    "    .has(\"type\", \"household\")\n",
    "    .out(\"member\")\n",
    "    .out(\"has_identity\")\n",
    ".values(\"uid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "users_from_household.draw_referenced_subgraph(g, TRANSIENT_ID)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Graph description\n",
    "\n",
    "There are 3 node types on the graph:\n",
    "* red one representing identity group node of type household\n",
    "* green one representing persistent identities (aka various users belonging to this household) \n",
    "* violet one representing transient identities (aka various user devices or different cookie IDs)\n",
    "\n",
    "The goal of this query is to given one transient identifier in the household (violet node), find other transient identifiers that belongs to the same household.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use-Case 5)\n",
    "\n",
    "### Marketing analyst wants to understand path to purchase of a new product by a few early adopters ( say 5) through interactive queries. This product is high involvement and expensive, and therefore they want to understand the research undertaken by the customer.\n",
    "\n",
    "* Which device was used to initiate the first research. Was that prompted by an ad, email promotion?\n",
    "* How many devices were used overall and what was the time taken from initial research to final purchase\n",
    "* On which devices did the customer spend more time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SKIP_SINGLE_TRANSIENTS='true'\n",
    "LIMIT=5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%gremlin --store-to early_adopters_activities\n",
    "\n",
    " g.V('${THANK_YOU_PAGE_URL}')\n",
    "        .hasLabel(\"website\").as(\"thank_you\")\n",
    "        .in(\"links_to\").as(\"website_group\")\n",
    "        .select(\"thank_you\")\n",
    "        .inE(\"visited\")\n",
    "        .order().by(\"ts\")\n",
    "        .choose(\n",
    "            constant(${SKIP_SINGLE_TRANSIENTS}).is(eq(true)),\n",
    "            where(outV().in(\"has_identity\")),\n",
    "            identity()\n",
    "        )\n",
    "        .choose(\n",
    "            outV().in(\"has_identity\"),\n",
    "            project(\n",
    "                \"type\", \"id\", \"purchase_ts\"\n",
    "            )\n",
    "                .by(constant(\"persistent\"))\n",
    "                .by(outV().in(\"has_identity\"))\n",
    "                .by(values(\"ts\")),\n",
    "            project(\n",
    "                \"type\", \"id\", \"purchase_ts\"\n",
    "            )\n",
    "                .by(constant(\"transient\"))\n",
    "                .by(outV())\n",
    "                .by(values(\"ts\"))\n",
    "        ).dedup(\"id\").limit(${LIMIT})\n",
    "        .choose(\n",
    "            select(\"type\").is(\"persistent\"),\n",
    "            project(\n",
    "                \"persistent_id\", \"transient_id\", \"purchase_ts\"\n",
    "            ).by(select(\"id\").values(\"pid\"))\n",
    "             .by(select(\"id\").out(\"has_identity\").fold())\n",
    "             .by(select(\"purchase_ts\")),\n",
    "            project(\"persistent_id\", \"transient_id\", \"purchase_ts\")\n",
    "                .by(constant(\"\"))\n",
    "                .by(select(\"id\").fold())\n",
    "                .by(select(\"purchase_ts\"))\n",
    "        ).project(\"persistent_id\", \"purchase_ts\", \"devices\", \"visits\")\n",
    "            .by(select(\"persistent_id\"))\n",
    "            .by(select(\"purchase_ts\"))\n",
    "            .by(select(\"transient_id\").unfold().group().by(values(\"uid\")).by(values(\"type\")))\n",
    "            .by(\n",
    "                select(\"transient_id\").unfold().outE(\"visited\").order().by(\"ts\")\n",
    "                .where(\n",
    "                    inV().in(\"links_to\").where(eq(\"website_group\"))\n",
    "                )\n",
    "                .project(\n",
    "                    \"transientId\", \"url\", \"ts\"\n",
    "                ).by(\"uid\").by(\"visited_url\").by(\"ts\").fold())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pp.pprint(early_adopters_activities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following two cell are using Python to parse the content into a format for the subsequent visualizations.  These cells may take a couple of minutes to execute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "activities = list(purchase_path.transform_activities(early_adopters_activities))\n",
    "\n",
    "paths = list(\n",
    "    purchase_path.compute_subgraph_pos(activities, THANK_YOU_PAGE_URL)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "purchase_path.draw_referenced_subgraph(*paths[0])\n",
    "purchase_path.draw_referenced_subgraph(*paths[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Graph description\n",
    "\n",
    "There are 6 node types on each of the graph:\n",
    "* purple ones representing user events\n",
    "* red ones representing persistent identities (aka various users) \n",
    "* deep red ones representing transient identities (aka various user devices or different cookie IDs)\n",
    "* blue ones representing user sessions\n",
    "* orange ones representing thank you page\n",
    "* green one representing visited webpage with dropped query strings\n",
    "\n",
    "The goal of this query is to display the single user path to purchase the product and visually represent information like: \n",
    "* what webpages were visited\n",
    "* how many devices were used\n",
    "* display the session counts\n",
    "\n",
    "In the graph above, there is one user that used single device to both do the research and make the purchase. User had 3 sessions and visited 6 subpages in total.\n",
    "\n",
    "It's important to emphasise that in this dataset **it is not possible** to determine what domains represents actual products. We selected the domain and thank you page that seemed reasonable in terms of number of events and visited webpages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "purchase_path.draw_referenced_subgraph(*paths[2])\n",
    "purchase_path.draw_referenced_subgraph(*paths[3])\n",
    "purchase_path.draw_referenced_subgraph(*paths[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other descriptive graph statistics\n",
    "\n",
    "Charts below display:\n",
    "* time to purchase the product per each user\n",
    "* all users session statistics where you can find out about:\n",
    "  * the total time spent across all devices and sessions\n",
    "  * duration of each session\n",
    "* most common visited subpages before purchase splitted per single user (persistentId)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats = purchase_path.generate_stats(activities)\n",
    "plots = purchase_path.custom_plots(stats)\n",
    "for plot in plots:\n",
    "    plot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use-Case 6)\n",
    "\n",
    "### Identify look-alike customers for a product. \n",
    "\n",
    "* The goal here is to identify prospects, who show similar behavioral patterns as your existing customers. While we can easily do this algorithmically and automate this, the goal here is to provide visual query to improve human understanding to the marketing analysts. \n",
    "\n",
    "* What are the device ids from my customer graph, who are not yet buying my product (say Golf Club), but are show similar behavior patterns such lifestyle choices of buying golf or other sporting goods.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "pp.pprint(similar_audience.recommend_similar_audience(g, THANK_YOU_PAGE_URL).toList())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "similar_audience.draw_average_buyer_profile_pie_chart(g, THANK_YOU_PAGE_URL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "similar_audience.draw_referenced_subgraph(g, THANK_YOU_PAGE_URL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Graph description\n",
    "\n",
    "There are 4 node types:\n",
    "* purple ones representing IAB categories\n",
    "* blue ones representing persistent identities (aka various users) \n",
    "* red ones representing transient identities (aka various user devices or different cookie IDs)\n",
    "* orange ones representing average buyer\n",
    "\n",
    "The goal of this query is to display similar audience created from \"average buyer\".\n",
    "Average buyer profile is created as mean of most popular categories across people who bought the product. In other words, we try to measure what are the user interests based on their activity and then we compute averaged profile composed of 3 best categories which can be used for futher reference. \n",
    "\n",
    "User belongs to an audience if any of his interests is at least as big as in referenced averaged profile. \n",
    "\n",
    "The opaque nodes represents users or user devices who either are not interested in this type of content, or are not interested enough."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualisations "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I want to know the most popular hours of users activity that belong to a given segment\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nepytune.visualizations import histogram, segments\n",
    "\n",
    "WEBSITE_ID = \"a997482113271d8f/5758f309e11931ce\"\n",
    "\n",
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "histogram.show(\n",
    "    segments.get_all_devices_from_website_visitors(g, WEBSITE_ID).outE(\"visited\").values(\"ts\").toList(),\n",
    "    website_name=WEBSITE_ID\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I want to know what are the most popular devices used by specific audience segment\n",
    "\n",
    "Segment is built from users who are active between 16.00 and 18.00. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from nepytune.visualizations import pie_chart, sunburst_chart, commons\n",
    "\n",
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "\n",
    "conditions = commons.get_timerange_condition(g, start_hour=16, end_hour=18)\n",
    "\n",
    "stats_activities = commons.get_user_device_statistics(g, conditions, limit=10000).next()\n",
    "\n",
    "pie_chart.show(stats_activities)\n",
    "sunburst_chart.show(stats_activities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I want to know the common part of specific segments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nepytune.visualizations import segments, commons, venn_diagram\n",
    "\n",
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "users_interested_in_content = segments.query_users_intersted_in_content(\n",
    "    g, ['IAB11-3'], limit=3000\n",
    ").toList()\n",
    "\n",
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "users_active_between_16_18 = segments.query_users_active_in_given_date_intervals(\n",
    "    g, commons.get_timerange_condition(g, start_hour=16, end_hour=18), limit=1000\n",
    ").toList()\n",
    "\n",
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "users_active_in_last_30_days = segments.query_users_active_in_n_days(g, n=30, limit=1000).toList()\n",
    "\n",
    "venn_diagram.show_venn_diagram(\n",
    "    venn_diagram.get_intersections(\n",
    "        users_interested_in_content,\n",
    "        users_active_between_16_18, \n",
    "        users_active_in_last_30_days\n",
    "    ), labels=[\n",
    "        \"Users interested in specific content type\",\n",
    "        \"Users active in the evenings\",\n",
    "        \"Users who have visited website in past 30 days\"\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Users that visited website on more than one device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nepytune.visualizations import network_graph\n",
    "\n",
    "WEBSITE_ID = \"a997482113271d8f/5758f309e11931ce\"\n",
    "g = get_traversal(f\"wss://{result.host}:8182/gremlin\")\n",
    "network_graph.show(g, WEBSITE_ID)\n",
    "    \n"
   ]
  }
 ],
 "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}