docs/source/install/python/raphtory.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2370415f",
   "metadata": {},
   "source": [
    "# Install\n",
    "\n",
    "Raphtory can be easily installed via `pip`. This will pull all of the background dependencies for Raphtory, automatically setting up any system paths to point at the correct location. Our only requirement here is you running `python version 3.10`.\n",
    "\n",
    "## Install \n",
    "\n",
    "    pip install raphtory"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70b1549b",
   "metadata": {},
   "source": [
    "\n",
    "# Running Raphtory\n",
    "\n",
    "Once installed, let's set up the most bare bones Raphtory graph, test that we can add some data to it and run our first query. Once this is all working we can move on to some much more exciting examples in the next section! \n",
    "\n",
    "Before we start, however, you may have noticed that this page looks oddly like a iPython notebook. That is because it is! If you click the `open on github` link in the top right of the page you can follow along on your own machine. Right, Back to the code!\n",
    "\n",
    "First we need to import `Raphtory`. You may see some references to `Rust` in the logs here, this is because under the hood Raphtory is written in `Rust`. You don't have to worry about any of that though as its all hidden away! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "67814d1e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-02-03T13:12:06.672329Z",
     "iopub.status.busy": "2023-02-03T13:12:06.669862Z",
     "iopub.status.idle": "2023-02-03T13:12:06.724691Z",
     "shell.execute_reply": "2023-02-03T13:12:06.723519Z"
    }
   },
   "outputs": [],
   "source": [
    "from raphtory import Graph"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5576341a",
   "metadata": {},
   "source": [
    "\n",
    "## Creating your first graph\n",
    "\n",
    "Once Raphtory is installed we can create our first graph! To do this we create a `Graph` object. \n",
    "\n",
    "This takes one parameter, which is the number of shards to split the data into. This is useful when working with large graphs that are distributed across across multiple machines. But we do not need to worry about this when running it locally. \n",
    "\n",
    "Once we have our graph we can add data into and run queries on.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "75033ab0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-02-03T13:12:06.731150Z",
     "iopub.status.busy": "2023-02-03T13:12:06.730607Z",
     "iopub.status.idle": "2023-02-03T13:12:31.003993Z",
     "shell.execute_reply": "2023-02-03T13:12:31.000696Z"
    }
   },
   "outputs": [],
   "source": [
    "graph = Graph(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73642007",
   "metadata": {},
   "source": [
    "\n",
    "## Adding data to your Graph\n",
    "\n",
    "Once a graph is created, we need to add some data to it if we want run anything interesting. There are loads of ways of doing this in Raphtory, which we will cover in the next section, but for simplicity lets just add some vertices and edges without any properties. \n",
    "\n",
    "As Raphtory is focused on dynamic and temporal analysis, all events in the graph's history  (adding, updating or deleting nodes/edges) must happen at a given time. This can all be at the same time (if, for example, you are working with snapshots) but we still need a time.\n",
    "\n",
    "As such, when we add a vertex we have two arguments: the `timestamp` and the `vertex ID`. Similarly, when adding an edge, we have three arguments: the `timestamp`, the `source vertex` and the `destination vertex`. \n",
    "The `vertex ID` can either be an `int` or a `str`\n",
    "\n",
    "In the following code block we have five updates for our graph, adding three vertices (`1`,`2`,`3`) at time `1` and two edges (`1->2`, `1->3`) at time `2` . \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "65e1cfee",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-02-03T13:12:31.016113Z",
     "iopub.status.busy": "2023-02-03T13:12:31.014845Z",
     "iopub.status.idle": "2023-02-03T13:12:31.481274Z",
     "shell.execute_reply": "2023-02-03T13:12:31.479224Z"
    }
   },
   "outputs": [],
   "source": [
    "graph.add_vertex(1, 1)\n",
    "graph.add_vertex(1, 2)\n",
    "graph.add_vertex(1, 3)\n",
    "graph.add_edge(2, 1, 2)\n",
    "graph.add_edge(2, 1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09f8eca9",
   "metadata": {},
   "source": [
    "\n",
    "## Running your first Query\n",
    "Now that our data is loaded we can start interrogating it! \n",
    "\n",
    "While we can write some very complicated algorithms in Raphtory, lets start off with something simple, getting the `in_degree` and `out_degree` of our nodes. \n",
    "\n",
    "For this we call the `in_degree` and `out_degree` functions on each node, and also use an algorithm for the entire graph. \n",
    "\n",
    "Per node we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c667c34c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-02-03T13:12:31.492540Z",
     "iopub.status.busy": "2023-02-03T13:12:31.491307Z",
     "iopub.status.idle": "2023-02-03T13:12:36.414575Z",
     "shell.execute_reply": "2023-02-03T13:12:36.412625Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vertex 1 - In degree: 0\n",
      "Vertex 2 - In degree: 1\n",
      "Vertex 1 - Out degree: 2\n",
      "Vertex 2 - Out degree: 0\n"
     ]
    }
   ],
   "source": [
    "print(\"Vertex 1 - In degree: %i\" % graph.vertex(1).in_degree())\n",
    "print(\"Vertex 2 - In degree: %i\" % graph.vertex(2).in_degree())\n",
    "print(\"Vertex 1 - Out degree: %i\" % graph.vertex(1).out_degree())\n",
    "print(\"Vertex 2 - Out degree: %i\" % graph.vertex(2).out_degree())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70131380",
   "metadata": {},
   "source": [
    "\n",
    "For the entire graph we can run a graph algorithm. We have created many built in algorithms, and they can be found on the documentation. \n",
    "\n",
    "For the graph we can run:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "90fb50b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Graph - Max out degree: 2\n"
     ]
    }
   ],
   "source": [
    "from raphtory import algorithms\n",
    "\n",
    "print(\"Graph - Max out degree: %i\" %  algorithms.max_out_degree(graph))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8da38b9a",
   "metadata": {},
   "source": [
    "\n",
    "As with every other cool feature I have hinted at, you will soon be an expert in queries, time-analysis and much more. All you have to do is continue on to the next page!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  },
  "vscode": {
   "interpreter": {
    "hash": "a9a34730827747ae273d5a5e0748f342e2039a3997e32d9a086d01739bd0f055"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}