09_git.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "---\n",
    "description: Interacting with Git repositories in Python, extracting commit history\n",
    "  from them, and turning it into NetworkX DiGraph\n",
    "output-file: git.html\n",
    "title: Extracting commit graphs from Git repositories\n",
    "\n",
    "---\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| default_exp commit_graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| output: false\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imports for the `commit_graph` module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "# creating graphs in Python\n",
    "import networkx as nx\n",
    "# calling git commands\n",
    "import subprocess\n",
    "# checking for existence of paths, and manipulating paths\n",
    "from pathlib import Path\n",
    "# saving to a file\n",
    "from git_commit_graph_ext.checkpoint import _savefile_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imports for plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interacting with Git repositories in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are various ways of interacting with Git repositories from Python code:\n",
    "\n",
    "- shelling out and running `git` directly (for example using `import subprocess`)\n",
    "- using [GitPython][] (`import git`)\n",
    "- using [pygit2][] (`import pygit2`) - Python bindings to libgit2 library\n",
    "\n",
    "[GitPython]: https://gitpython.readthedocs.io/\n",
    "[pygit2]: https://www.pygit2.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**GitPython** is a python library used to interact with git repositories, high-level like git-porcelain, or low-level like git-plumbing.\n",
    "\n",
    "It provides abstractions of git objects for easy access of repository data, and additionally allows you to access the git repository more directly using either a pure python implementation, or the faster, but more resource intensive git command implementation.\n",
    "\n",
    "The object database implementation is optimized for handling large quantities of objects and large datasets, which is achieved by using low-level structures and data streaming. \n",
    "\n",
    "<u>_NOTE:_</u> Promisory objects (in sparse clone, `--filter=tree:0`) might be not supported.\n",
    "\n",
    "```python\n",
    "import git\n",
    "\n",
    "repo = git.Repo.clone_from(url, path, ['--mirror', '--filter=tree:0'])\n",
    "repo = git.Repo(path) # just open the repository\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pygit2** is a set of Python bindings to the libgit2 shared library, libgit2 implements the core of Git.\n",
    "\n",
    "<u>_NOTE:_</u> It is quite low level, and not everything is implemented yet (especially new features).\n",
    "\n",
    "```python\n",
    "import pygit2\n",
    "\n",
    "pygit2.clone_repository(url, path, bare=True) # no support for filters?\n",
    "repo = pygit2.Repository(path)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **subprocess** module in the Python standard library allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes.\n",
    "\n",
    "The recommended approach to invoking subprocesses is to use the `run()` function for all use cases it can handle.\n",
    "\n",
    "```python\n",
    "import subprocess\n",
    "\n",
    "subprocess.run(['git', 'clone', '--mirror', '--filter=tree:0', '--quiet', url, path])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cloning git.git repository, and extracting and saving the commit graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":::{.callout-note}\n",
    "\n",
    "The exploration was moved to the Appendix for this notebook: [`A.09_git_explore.ipynb`](A.09_git_explore.ipynb)\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary of off-the-record findings about cloning repositories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why it is important to use sparse clone - it is much faster, and takes up less space.  For example for git.git repository we have the following (all times are wall time, and subject to interference from other CPU load):\n",
    "- full clone: 54s\n",
    "- mirror: 1min 19s\n",
    "- sparse: 14.9s - 19.4s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary of findings of testing different graph output formats (saving graph to a file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Storing DataFrame of edgelist data</u>\n",
    "\n",
    "The DataFrame is created using `nx.to_pandas_edgelist(graph)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The smallest file is the result of storing DataFrame of edgelist data as gzipped pickle (written using Pandas' `to_pickle()`) - the **\\*.df_edgelist.pickle.gz** file.\n",
    "\n",
    "- Advantages:\n",
    "  - 2nd smallest size\n",
    "  - no extra modules to install\n",
    "  - preserves types\n",
    "- Disadvantages:\n",
    "  - Python-specific\n",
    "  - unsafe\n",
    "  - slow (?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next smallest is, surprisingly, gzipped CSV representing DataFrame of edgelist data (written using Pandas' `to_csv()`) - the **\\*.df_edgelist.csv.gz** file.\n",
    "\n",
    "- Advantages:\n",
    "  - 3rd smallest size\n",
    "  - no extra modules to install\n",
    "  - universal format\n",
    "- Disadvantages:\n",
    "  - slow (?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fast interchange formats, [Feather](https://github.com/wesm/feather) and [Parquet](https://parquet.apache.org/) turned out to produce quite large files; they are however 4th smallest and 2nd smallest, respectively, among uncompressed formats.\n",
    "\n",
    "**_Feather_** provides a binary columnar serialization for data frames. It is designed to make reading and writing data frames efficient, and to make sharing data across data analysis languages easy.\n",
    "\n",
    "Feather is designed to faithfully serialize and de-serialize `DataFrame`s, supporting all of the pandas dtypes, including extension dtypes such as categorical and datetime with tz.\n",
    "\n",
    "**_Apache Parquet_** provides a _partitioned_ binary columnar serialization for data frames. It is designed to make reading and writing data frames efficient, and to make sharing data across data analysis languages easy. Parquet can use a variety of compression techniques (default is to use 'snappy') to shrink the file size as much as possible while still maintaining good read performance.\n",
    "\n",
    "Parquet is designed to faithfully serialize and de-serialize `DataFrame`s, supporting all of the pandas dtypes, including extension dtypes such as datetime with tz.\n",
    "\n",
    "- Advantages:\n",
    "  - universal, cross language\n",
    "  - preserves types\n",
    "  - fast\n",
    "- Disadvantages:\n",
    "  - requires `pyarrow` package to be installed\n",
    "  - quite large file size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **_HDF5_** format has the advantage of being able to store multiple `DataFrame`s in a single file, for example one `DataFrame` to hold edgelist data to define the graph connections, and one `DataFrame` holding various per vertex (per node) rechablity index data.  Unfortunately, even internally compressed it has one of larger file sizes (and largest compressed).\n",
    "\n",
    "[Hierarchical Data Format (HDF)](https://portal.hdfgroup.org/display/HDF5/HDF5) is self-describing, allowing an application to interpret the structure and contents of a file with no outside information. One HDF file can hold a mix of related objects which can be accessed as a group or as individual objects.\n",
    "\n",
    "The `to_hdf()` method in Pandas uses the `HDFStore` in the background, which in turn utilizes the [PyTables](https://www.pytables.org/) library.\n",
    "\n",
    "- Advantages:\n",
    "  - universal, cross language\n",
    "  - preserves types\n",
    "  - can store multiple `DataFrame`s\n",
    "- Disadvantages:\n",
    "  - large file size\n",
    "  - requires `tables` package to be installed (PyTables)\n",
    "  - slow (?)\n",
    "  - unsafe (because of serializing object-dtype data with pickle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "<u>Storing NetworkX DiGraph directly</u>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It turns out that the [graph6 / sparse6 format](https://networkx.org/documentation/stable/reference/readwrite/sparsegraph6.html)\n",
    "is not a good choice for storing the commit graph for the following reasons:\n",
    "- NetworkX does not support digraph6 format; neither `write_graph6` not `write_sparse6` are implemented for directed graphs\n",
    "- the [digraph6 format](http://users.cecs.anu.edu.au/~bdm/data/formats.txt) is dense graph format, storing the encoded adjacency matrix; there is no disparse6 or digraph6sparse format\n",
    "- SparseGraph6 formats do not store node/vertex names, which might be needed for future computations or visualizations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Except for the adjacency lists format (**\\*.adjlist.txt**), which cannot store any additional data (not even per-edge), the multi-line adjacency lists (**\\*.multiline_adjlist.txt**) and edge lists (**\\*.edgelist.txt**) formats have file sizes larger than the Parquet storing `DataFrame` of edge lists.  Note however that they are uncompressed.\n",
    "\n",
    "The adjacency list format can be created directly by appropriate Git command.\n",
    "\n",
    "Because those formats cannot store per-node data, they are not considered for use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Among specialized graph file formats, which I assume can store both per-node and per-edge data, **_Pajek_** format is smallest (compressed), and 4th smallest among all considered storage formats.  It is also smallest uncompressed among similar file formats."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Writing NetworkX graphs as Python pickles using `write_gpickle()` (\\***.gpickle.gz**) results in quite large file compressed, one of the largest files uncompressed.\n",
    "\n",
    "On the other hand NetworkX graphs can contain any hashable Python object as node (not just integers and strings). For arbitrary data types it may be difficult to represent the data as text. In that case using Python pickles to store the graph data can be used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Examining computing and storing reachability labels and other per-node data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ":::{.callout-note}\n",
    "\n",
    "The exploration was moved to the Appendix for this notebook: [`A.09_git_explore.ipynb`](A.09_git_explore.ipynb)\n",
    "\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary of findings of storing computed reachability labels and related stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strangely,smallest files size this time is given when storing using the **_HDF5_** (with `compresslevel=6`) format, which is also 2nd fastest.\n",
    "\n",
    "Saving `DataFrame` using the **_Parquet_** format is fastest, but this time it gives the largest size of the file\n",
    "\n",
    "Saving as **\\*.pickle.gz** or **\\*.csv.gz** is slowest and second slowest, while both being in the middlle with respect to file sizes (the pickle-based format gives smaller file size)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions for creating the commit-graph out of repository, computing labelling, etc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Those directories would be needed for tests:\n",
    "- `repos` for storing cloned Git repositories\n",
    "- `datasets` for storing extracted commit graphs, and other data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Path(\"repos\").mkdir(exist_ok=True)\n",
    "Path(\"datasets\").mkdir(exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions for cloning the repository"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because the repository is needed only to extract the commit graph from it, therefore to save time and disk space sparse clone will be used.\n",
    "\n",
    "This strongly suggests using the Git command line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def sparse_clone(url, repo_name=None, repos_dir=\"repos\"):\n",
    "    \"\"\"Clone Git repository by URL using sparse/partial clone\n",
    "\n",
    "    The \"Sparse Clone\" or the \"Partial Clone\" feature is a performance\n",
    "    optimization for Git that allows Git to function without having\n",
    "    a complete copy of the repository.  The goal of this feature is to allow\n",
    "    Git better handle extremely large repositories, or in this case store\n",
    "    the repository using less disk space.\n",
    "\n",
    "    To retrieve the commit graph out of the git repository only commit\n",
    "    objects are needed, so all tree and blob objects can be omitted from the\n",
    "    clone.\n",
    "\n",
    "    Using sparse clone is much more efficient: the process is faster, and\n",
    "    the resulting repository takes much less disk space than full clone.\n",
    "\n",
    "    NOTE: Use of partial clone requires that the user be online and the origin\n",
    "    remote or other promisor remotes be available for on-demand fetching\n",
    "    of missing objects, unless the user can stay within the pre-selected\n",
    "    subset of objects.\n",
    "\n",
    "    see: https://git-scm.com/docs/git-clone\n",
    "    see: https://git-scm.com/docs/git-rev-list#Documentation/git-rev-list.txt---filterltfilter-specgt\n",
    "    see: https://github.com/git/git/blob/master/Documentation/technical/partial-clone.txt\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    url : str\n",
    "        The repository to be cloned, in most cases it would be public URL\n",
    "        that can be used to clone the remote repository.\n",
    "\n",
    "    repo_name: str\n",
    "        The name of a new directory to clone into. The \"humanish\" part of\n",
    "        the source repository (of the `url` parameter) is used if no directory\n",
    "        is explicitly given (`repo` for `/path/to/repo.git` and `foo` for\n",
    "        `host.xz:foo/.git`).  Cloning into an existing directory is only\n",
    "        allowed if the directory is empty.\n",
    "\n",
    "    repos_dir : str\n",
    "        The directory where to put cloned repository into.\n",
    "        By default \"repos\" is used.\n",
    "    \"\"\"\n",
    "    cmd = ['git']\n",
    "    if repos_dir:\n",
    "        cmd.extend(['-C', repos_dir])\n",
    "    cmd.extend(['clone', '--mirror', '--filter=tree:0', '--quiet', url])\n",
    "    if repo_name:\n",
    "        cmd.append(repo_name)\n",
    "    subprocess.run(cmd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's **test** **`sparse_clone()`**, for example using quite small and archived [`https://github.com/githubtraining/hellogitworld`](https://github.com/githubtraining/hellogitworld) \"Hello Git World\" sample training repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ok - repository exists as directory after cloning\n",
      "ok - and it looks like a git repository\n",
      "ok - cloned repository has correct url\n"
     ]
    }
   ],
   "source": [
    "# remove the test repository, if exists\n",
    "from shutil import rmtree\n",
    "\n",
    "repo_url=\"https://github.com/githubtraining/hellogitworld\"\n",
    "repo_path=\"repos/hellogitworld.git\"\n",
    "repo_name=\"hellogitworld.git\"\n",
    "#rmtree(repo_path, ignore_errors=True)\n",
    "\n",
    "# clone the repository\n",
    "sparse_clone(repo_url, repo_name=repo_path, repos_dir=None)\n",
    "\n",
    "# the directory should exist, and be a directory\n",
    "assert Path(repo_path).is_dir()\n",
    "print('ok - repository exists as directory after cloning')\n",
    "# it should look like a git repository\n",
    "assert (Path(repo_path) / \"HEAD\").is_file()\n",
    "assert (Path(repo_path) / \"objects\").is_dir()\n",
    "print('ok - and it looks like a git repository')\n",
    "\n",
    "#!git -C repos/hellogitworld.git config --get remote.origin.url\n",
    "#!git -C repos/hellogitworld.git remote show -n origin\n",
    "\n",
    "# NOTE: `capture_output` was added in Python 3.7, GitHub CI runs Python 3.6\n",
    "assert subprocess.run(['git', '-C', repo_path, 'config', '--get', 'remote.origin.url'],\n",
    "                      stdout=subprocess.PIPE).stdout.decode(\"utf-8\").strip() == repo_url\n",
    "print('ok - cloned repository has correct url')\n",
    "\n",
    "# attempt cleanup after the test, which may not work on MS Windows\n",
    "#rmtree(repo_path, ignore_errors=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If repository exists, there is no need to clone it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def get_repo(url, repo_path, refresh=False):\n",
    "    \"\"\"Clone Git repository into given path, if needed\n",
    "\n",
    "    If the path given by `repo_path` does not exist, or `refresh` is true,\n",
    "    clone Git repository at `url` for later extraction of the commit graph.\n",
    "\n",
    "    see: `sparse_clone()`\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    url : str\n",
    "        The repository to be cloned, in most cases it would be public URL\n",
    "        that can be used to clone the remote repository.\n",
    "\n",
    "    repo_path: str\n",
    "        The pathname under which one can find resulting Git repository.\n",
    "\n",
    "    refresh: bool\n",
    "        Whether to re-clone the repository if `repo_path` path exists.\n",
    "        Default is false, to not perform a clone if not needed.\n",
    "    \"\"\"\n",
    "    if refresh or not Path(repo_path).exists():\n",
    "        sparse_clone(url, repo_name=repo_path, repos_dir=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions for extracting the commit graph out of git repository"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using Git commands, we can easily create text file that store commit-graph information in the adjacency list format, from which it is easy to create a NetworkX graph (`DiGraph`).  Shortened object identifiers (shortened SHA-1) will be used to identify commits which are nodes / vertices of the commit graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def _repo_basename(repo_path):\n",
    "    \"\"\"Create name of repository out of its pathname\n",
    "\n",
    "    This is a helper function used, among others, in ...\n",
    "\n",
    "    Examples:\n",
    "    ---------\n",
    "    >>>> _repo_basename('hellogitworld')\n",
    "    'hellogitworld'\n",
    "    >>>> _repo_basename('repos/hellogitworld.git')\n",
    "    'hellogitworld'\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    repo_path : str\n",
    "        Path to the Git repository, for example 'hellogitworld',\n",
    "        or 'hellogitworld.git', or 'repos/hellogitworld.git', or 'repos/hellogitworld/.git'\n",
    "        for Git repository cloned from <https://github.com/githubtraining/hellogitworld>\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    str\n",
    "        The name of repository, to be later used as a base for commit graph name,\n",
    "        and the pathname of a file where to save information about thw history\n",
    "        structure of the repository.\n",
    "    \"\"\"\n",
    "    # generate the name of the output file, as `pathlib.Path` object\n",
    "    # removing the '*.git' extension / suffix from `repo_path`, if needed\n",
    "    out_pathname = Path(repo_path).stem\n",
    "\n",
    "    # convert it to string\n",
    "    return str(out_pathname)\n",
    "\n",
    "\n",
    "def _commit_graph_name(repo_name):\n",
    "    \"\"\"Create the name of a commit graph out of repository name.\n",
    "    \n",
    "    This is a helper function used, among others, in ...\n",
    "\n",
    "    Examples:\n",
    "    ---------\n",
    "    >>>> _commit_graph_name('hellogitworld')\n",
    "    'hellogitworld-commit_graph'\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    repo_name : str\n",
    "        The name of the repository, for example the result of calling the\n",
    "        `_repo_basename()` function.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    str\n",
    "        The name of the commit graph of the repository, to be used as a base\n",
    "        for the pathname of a file where to save information about the history\n",
    "        structure of the repository.\n",
    "    \"\"\"\n",
    "    return repo_name + '-commit_graph'\n",
    "\n",
    "\n",
    "def _repo_graph_name(repo_path):\n",
    "    \"\"\"Create the name of a commit graph out of repository path (its pathname)\n",
    "    \n",
    "    This is a helper function used, among others, in ...\n",
    "\n",
    "    Examples:\n",
    "    ---------\n",
    "    >>>> _repo_graph_name('repos/hellogitworld.git')\n",
    "    'hellogitworld-commit_graph'\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    repo_path : str\n",
    "        Path to the Git repository (`<graph>.name` can be used), for example\n",
    "        'hellogitworld', or 'hellogitworld.git', or 'repos/hellogitworld.git'\n",
    "        for Git repository cloned from <https://github.com/githubtraining/hellogitworld>\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    str\n",
    "        The name of the commit graph of the repository, to be used as a base\n",
    "        for the pathname of a file where to save information about the history\n",
    "        structure of the repository.\n",
    "    \"\"\"\n",
    "    return _commit_graph_name(_repo_basename(repo_path))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Test</u> that examples from the docstring works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print('%r' % _repo_basename('hellogitworld'))\n",
    "assert _repo_basename('hellogitworld') == 'hellogitworld'\n",
    "#print('%r' % _repo_basename('hellogitworld.git'))\n",
    "assert _repo_basename('hellogitworld.git') == 'hellogitworld'\n",
    "#print('%r' % _repo_basename('repos/hellogitworld.git'))\n",
    "assert _repo_basename('repos/hellogitworld.git') == 'hellogitworld'\n",
    "#print('%r' % _repo_basename('repos/hellogitworld/.git'))\n",
    "#assert _repo_basename('repos/hellogitworld/.git') == 'hellogitworld'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert _commit_graph_name('hellogitworld') == 'hellogitworld-commit_graph'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert _repo_graph_name('repos/hellogitworld.git') == 'hellogitworld-commit_graph'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def _repo_graph_savefile(repo_path, out_dir='datasets'):\n",
    "    \"\"\"Create filename for storing adjacency list out of repository path\n",
    "\n",
    "    This is a helper function used, among others, in `repo_generate_adjlist()`\n",
    "    and `repo_adjlist_to_graph()`.\n",
    "\n",
    "    It makes use of `_safefile_name()` from `checkpoint`, to have common code\n",
    "    for generating the names of files, and common naming convention.\n",
    "\n",
    "    Examples:\n",
    "    ---------\n",
    "    >>>> _repo_graph_savefile('repos/hellogitworld.git')\n",
    "    Path('datasets/hellogitworld-commit_graph.adjlist.txt')\n",
    "    >>>> _repo_graph_savefile('repos/hellogitworld.git', out_dir='data')\n",
    "    Path('data/hellogitworld-commit_graph.adjlist.txt')\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    repo_path : str\n",
    "        Path to the Git repository, for example 'hellogitworld',\n",
    "        or 'hellogitworld.git', or 'repos/hellogitworld.git', or 'repos/hellogitworld/.git'\n",
    "        for Git repository cloned from <https://github.com/githubtraining/hellogitworld>\n",
    "\n",
    "    out_dir : str\n",
    "        Directory where extracted commit graph data would be stored.\n",
    "        Defaults to \"datasets\".\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    Path\n",
    "        Path to the file storing the commit graph in the adjacency list\n",
    "        file format.\n",
    "\n",
    "        see: https://networkx.org/documentation/stable/reference/readwrite/adjlist.html\n",
    "    \"\"\"\n",
    "    graph_name = _repo_graph_name(repo_path)\n",
    "    return _savefile_name(graph_name, out_dir=out_dir, kind='adjlist', file_format='txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's **test** the easy-to-test internal function **`_repo_graph_savefile()`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert _savefile_name('example_graph', kind='adjlist', file_format='txt') == Path('datasets/example_graph.adjlist.txt')\n",
    "assert _savefile_name('example_graph', out_dir='data', kind='adjlist', file_format='txt') == Path('data/example_graph.adjlist.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert _repo_graph_savefile('repos/hellogitworld.git') == Path('datasets/hellogitworld-commit_graph.adjlist.txt')\n",
    "assert _repo_graph_savefile('repos/hellogitworld.git', out_dir='data') == Path('data/hellogitworld-commit_graph.adjlist.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> TODO: Fix the problem with generating savefile name if the repository path does not exist  \n",
    "> `_repo_graph_savefile('repos/example.git')` returns `WindowsPath`, not `Path` (???)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'example'\n",
      "'example-commit_graph'\n",
      "'example-commit_graph'\n",
      "WindowsPath('datasets/example-commit_graph.adjlist.txt')\n"
     ]
    }
   ],
   "source": [
    "#assert _repo_graph_savefile('repos/example.git') == Path('datasets/example-commit_graph.adjlist.txt')\n",
    "#assert _repo_graph_savefile('repos/example.git', out_dir='data') == Path('data/example-commit_graph.adjlist.txt')\n",
    "print('%r' % _repo_basename('repos/example.git'))\n",
    "print('%r' % _commit_graph_name('example'))\n",
    "print('%r' % _repo_graph_name('repos/example.git'))\n",
    "print('%r' % _repo_graph_savefile('repos/example.git'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def repo_generate_adjlist(repo_path, out_dir=\"datasets\", refresh=False):\n",
    "    \"\"\"Generate graph of revisions in the adjacency list format\n",
    "\n",
    "    Can be read with `nx.read_adjlist()`; don't forget to ensure that\n",
    "    NetworkX generates _directed_ graph.\n",
    "\n",
    "    >>>> path = repo_generate_adjlist(\"repos/git.git\")\n",
    "    >>>> graph = nx.read_adjlist(path, create_using=nx.DiGraph)\n",
    "\n",
    "    By default it does not recreate the file if it exists already,\n",
    "    unless `refresh=True` argument is passed.\n",
    "\n",
    "    Format\n",
    "    ------\n",
    "    The adjacency list format consists of lines with node labels.  The first\n",
    "    label in a line is the source node. Further labels in the line are\n",
    "    considered target nodes and are added to the graph along with an edge\n",
    "    between the source node and target node.\n",
    "\n",
    "    The graph with edges a-b, a-c, d-e can be represented as the following\n",
    "    adjacency list (anything following the # in a line is a comment):\n",
    "\n",
    "    > a b c # source target target\n",
    "    > d e\n",
    "\n",
    "    see: https://networkx.org/documentation/stable/reference/readwrite/adjlist.html\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    repo_path : str\n",
    "        Path to the Git repository\n",
    "\n",
    "    out_dir : str\n",
    "        Directory where extracted commit graph data would be stored.\n",
    "        Defaults to \"datasets\".\n",
    "\n",
    "    refresh : bool\n",
    "        Whether to regenerate the file with the commit graph in adjacency\n",
    "        format if it exists.  Defaults to false.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    Path\n",
    "        Path where the commit graph in the adjacency file format\n",
    "        can be found.\n",
    "    \"\"\"\n",
    "    out_pathname = _repo_graph_savefile(repo_path, out_dir=out_dir)\n",
    "    # generate the adjacency list using git-log command; note: skip pull requests\n",
    "    if refresh or not out_pathname.exists():\n",
    "        with out_pathname.open(\"w\") as outfile:\n",
    "            subprocess.run(['git', '-C', repo_path,\n",
    "                            'log', '--format=%h %p', '--topo-order', '--branches'],\n",
    "                           stdout=outfile)\n",
    "    return out_pathname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To process the commit graph, we need to create a NetworkX *directed* graph from it, using adjacency list file in text format, generated using `git log` with appropriate parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def repo_adjlist_to_graph(repo_path, datasets_dir=\"datasets\"):\n",
    "    \"\"\"Create `DiGraph` out of adjacency list file created from it\n",
    "\n",
    "    NOTE: the `repo_to_graph()` function is safer to use, as it generates\n",
    "    the graph of commits in the adjacency list file format of needed.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    repo_path : str\n",
    "        Path to the Git repository\n",
    "\n",
    "    datasets_dir : str\n",
    "        Directory where extracted commit graph data would be stored.\n",
    "        Defaults to \"datasets\".\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    nx.DiGraph\n",
    "        Directed graph of revisions as NetworkX's `DiGraph`\n",
    "    \"\"\"\n",
    "    out_pathname = _repo_graph_savefile(repo_path, out_dir=datasets_dir)\n",
    "    return nx.read_adjlist(out_pathname, create_using=nx.DiGraph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tying it all together, to get a directed graph of revision history of a given repository into NetworkX `DiGraph`, we need to create a sparse clone of a repository if it does not exist, write log of revision history in adjacency list format if the file does not exist, and create the commit graph as NetworkX `DiGraph`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def repo_to_graph(repo_path, datasets_dir=\"datasets\", refresh=False):\n",
    "    \"\"\"Create a graph of commits for given local repository\n",
    "\n",
    "    It uses existing file with the commit graph in the adjacency list file\n",
    "    format, unless refresh is requested with `refresh=True`.  Automatically\n",
    "    generates such file if it does not exist.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    repo_path : str\n",
    "        Path to the local Git repository\n",
    "\n",
    "    datasets_dir : str\n",
    "        Directory where extracted commit graph data can be stored, or will\n",
    "        be stored.  Defaults to \"datasets\".\n",
    "\n",
    "    refresh : bool\n",
    "        Whether to regenerate the file with the commit graph in adjacency\n",
    "        format if it exists.  Defaults to false.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    nx.DiGraph\n",
    "        Directed graph of revisions as NetworkX's `DiGraph`\n",
    "    \"\"\"\n",
    "    out_pathname = repo_generate_adjlist(repo_path, out_dir=datasets_dir, refresh=refresh)\n",
    "    return nx.read_adjlist(out_pathname, create_using=nx.DiGraph)\n",
    "\n",
    "\n",
    "def commit_graph(url, repo_name,\n",
    "                 repos_dir=\"repos\", datasets_dir=\"datasets\",\n",
    "                 reclone=False, rescan=False):\n",
    "    \"\"\"Create a graph of commits for given remote repository, stored locally\n",
    "\n",
    "    Given a Git repository `url`, clone it as `repo_name` in `repo_dir`\n",
    "    directory, then create a graph of its commits as NetworkX `DiGraph`.\n",
    "\n",
    "    Avoids re-cloning of the remote repository unless `reclone=True` is\n",
    "    passed, and avoids rescanning the local copy of the repository if file\n",
    "    in the adjacency list format with the commit graph information exists\n",
    "    unless `rescan=True` is passed.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    url : str\n",
    "        The repository to be cloned, in most cases it would be public URL\n",
    "        that can be used to clone the remote repository.\n",
    "\n",
    "    repo_name: str\n",
    "        The name of a new directory to clone into (or in other words name\n",
    "        of local clone of the remote repository).\n",
    "\n",
    "    repos_dir : str\n",
    "        The directory where to put cloned repository into.\n",
    "        By default \"repos\" is used.\n",
    "\n",
    "    datasets_dir : str\n",
    "        Directory where extracted commit graph data can be stored, or will\n",
    "        be stored.  Defaults to \"datasets\".\n",
    "\n",
    "    reclone : bool\n",
    "        Whether to re-clone the repository if the local clone exists.\n",
    "        Default is false, to not perform a clone if not needed.\n",
    "\n",
    "    rescan : bool\n",
    "        Whether to regenerate the file with the commit graph in adjacency\n",
    "        format if it exists.  Defaults to false.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    nx.DiGraph\n",
    "        Directed graph of revisions as NetworkX's `DiGraph`\n",
    "    \"\"\"\n",
    "    repo_path = Path(repos_dir) / repo_name\n",
    "    get_repo(url, repo_path, refresh=reclone)\n",
    "    graph = repo_to_graph(repo_path, datasets_dir=datasets_dir, refresh=rescan)\n",
    "    graph.name = _commit_graph_name(repo_name)\n",
    "    return graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of testing all those functions one by one, let's simply **test the final one**, namely **`commit_graph()`**, which would would as an integration test.  It would stress test almost all other functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ok - commit_graph() result is `DiGraph`\n",
      "ok - number of nodes 55 matches 55 commits on all branches\n",
      "ok - number of edges 53 matches\n",
      "ok - number of sources 6 matches 6 independent branches\n",
      "ok - number of sinks 4 matches number of unrelated branches\n",
      "ok - all node names looks like object identifiers (are hexdigits)\n"
     ]
    }
   ],
   "source": [
    "# remove the test repository\n",
    "from shutil import rmtree\n",
    "# check the format of node names\n",
    "import re\n",
    "\n",
    "repo_url=\"https://github.com/githubtraining/hellogitworld\"\n",
    "repo_path=\"repos/hellogitworld.git\"\n",
    "repo_name=\"hellogitworld.git\"\n",
    "#rmtree(repo_path, ignore_errors=True)\n",
    "\n",
    "# get commit graph of remote repository\n",
    "graph = commit_graph(repo_url, repo_name, rescan=True)\n",
    "\n",
    "# find sinks (roots in git terminology) and sources (heads in git terminology)\n",
    "sinks  =[n for n in graph if graph.out_degree(n) == 0]\n",
    "sources=[n for n in graph if graph.in_degree(n)  == 0]\n",
    "\n",
    "assert isinstance(graph, nx.DiGraph)\n",
    "print('ok - commit_graph() result is `DiGraph`')\n",
    "# this is an archived repository, so it should not change at all\n",
    "assert graph.number_of_nodes() == 55\n",
    "print('ok - number of nodes {:d} matches 55 commits on all branches'.format(graph.number_of_nodes()))\n",
    "assert graph.number_of_edges() == 53\n",
    "print('ok - number of edges {:d} matches'.format(graph.number_of_edges()))\n",
    "assert len(sources) == 6\n",
    "print('ok - number of sources {:d} matches 6 independent branches'.format(len(sources)))\n",
    "assert len(sinks) == 4\n",
    "print('ok - number of sinks {:d} matches number of unrelated branches'.format(len(sinks)))\n",
    "\n",
    "id_regexp = re.compile(r'^[0-9a-f]+$')\n",
    "assert all([id_regexp.fullmatch(node) is not None for node in graph.nodes])\n",
    "print('ok - all node names looks like object identifiers (are hexdigits)')\n",
    "\n",
    "# attempt cleanup\n",
    "#rmtree(repo_path, ignore_errors=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <https://github.com/githubtraining/hellogitworld> repository has:\n",
    "- 26 commits on the 'master' branch\n",
    "- 55 commits on all branches\n",
    "- 345 commits among all references, including pull requests (5 open, 156 closed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# this plot is here to check if the number of edges found is plausible\n",
    "try:\n",
    "    import pydot\n",
    "    \n",
    "    fig=plt.figure(figsize=(8,7))\n",
    "    plt.suptitle('The commit graph of https://github.com/githubtraining/hellogitworld repository\\n'+\n",
    "                 'source nodes are red, sink nodes are yellow, isolated nodes are yellow with red outline')\n",
    "    plt.title(\"drawn using 'dot' algorithm from GraphViz, via 'pydot' module\")\n",
    "    pos=nx.drawing.nx_pydot.pydot_layout(graph, prog='dot')\n",
    "    nx.draw(graph, pos=pos,\n",
    "            node_size=80,width=1.0,node_color='#FF7F00')\n",
    "    nx.draw_networkx_nodes(graph, pos=pos, nodelist=sources,\n",
    "                           node_size=90,node_color='#FF1100')\n",
    "    nx.draw_networkx_nodes(graph, pos=pos, nodelist=sinks,\n",
    "                           node_size=60,node_color='#FFDD00')\n",
    "    plt.draw()\n",
    "except ModuleNotFoundError:\n",
    "    print(\"'pydot' module not installed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 01_tools.ipynb.\n",
      "Converted 02_related.ipynb.\n",
      "Converted 03_example_graphs.ipynb.\n",
      "Converted 05_reachability_index.ipynb.\n",
      "Converted 06_levels.ipynb.\n",
      "Converted 07_interval_labels.ipynb.\n",
      "Converted 08_reach.ipynb.\n",
      "Converted 09_git.ipynb.\n",
      "Converted 10_checkpoint.ipynb.\n",
      "Converted A.09_git_explore.ipynb.\n",
      "Converted index.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#| include: false\n",
    "# this should be the last cell of the notebook\n",
    "from nbdev import nbdev_export\n",
    "nbdev_export()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}