git_exploration.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": "true"
   },
   "source": [
    "# Table of Contents\n",
    " <p><div class=\"lev1 toc-item\"><a href=\"#Introduction-to-Version-Control-and-Git\" data-toc-modified-id=\"Introduction-to-Version-Control-and-Git-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Introduction to Version Control and Git</a></div><div class=\"lev2 toc-item\"><a href=\"#Setting-up-Git-on-our-computer\" data-toc-modified-id=\"Setting-up-Git-on-our-computer-11\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Setting up Git on our computer</a></div><div class=\"lev2 toc-item\"><a href=\"#Setting-up-a-project-that-we-will-track-with-git\" data-toc-modified-id=\"Setting-up-a-project-that-we-will-track-with-git-12\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Setting up a project that we will track with git</a></div><div class=\"lev2 toc-item\"><a href=\"#Initializing-a-Git-repository\" data-toc-modified-id=\"Initializing-a-Git-repository-13\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Initializing a Git repository</a></div><div class=\"lev1 toc-item\"><a href=\"#Versioning-edits-with-Git\" data-toc-modified-id=\"Versioning-edits-with-Git-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Versioning edits with Git</a></div><div class=\"lev2 toc-item\"><a href=\"#Where-Are-My-Changes?\" data-toc-modified-id=\"Where-Are-My-Changes?-21\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Where Are My Changes?</a></div><div class=\"lev2 toc-item\"><a href=\"#The-Git-Lifecycle\" data-toc-modified-id=\"The-Git-Lifecycle-22\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>The Git Lifecycle</a></div><div class=\"lev1 toc-item\"><a href=\"#Running-our-python-script\" data-toc-modified-id=\"Running-our-python-script-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Running our python script</a></div><div class=\"lev1 toc-item\"><a href=\"#Collaboration-with-Git-and-GitHub\" data-toc-modified-id=\"Collaboration-with-Git-and-GitHub-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Collaboration with Git and GitHub</a></div><div class=\"lev2 toc-item\"><a href=\"#Creating-a-repository-on-GitHub\" data-toc-modified-id=\"Creating-a-repository-on-GitHub-41\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Creating a repository on GitHub</a></div><div class=\"lev2 toc-item\"><a href=\"#Pushing-to-a-remote-repository\" data-toc-modified-id=\"Pushing-to-a-remote-repository-42\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Pushing to a remote repository</a></div><div class=\"lev2 toc-item\"><a href=\"#Submitting-a-pull-request\" data-toc-modified-id=\"Submitting-a-pull-request-43\"><span class=\"toc-item-num\">4.3&nbsp;&nbsp;</span>Submitting a pull request</a></div><div class=\"lev3 toc-item\"><a href=\"#Overview-of-collaboration-workflow\" data-toc-modified-id=\"Overview-of-collaboration-workflow-431\"><span class=\"toc-item-num\">4.3.1&nbsp;&nbsp;</span>Overview of collaboration workflow</a></div><div class=\"lev2 toc-item\"><a href=\"#An-overview-of-collaboration-with-git\" data-toc-modified-id=\"An-overview-of-collaboration-with-git-44\"><span class=\"toc-item-num\">4.4&nbsp;&nbsp;</span>An overview of collaboration with git</a></div><div class=\"lev2 toc-item\"><a href=\"#Dealing-with-conflict\" data-toc-modified-id=\"Dealing-with-conflict-45\"><span class=\"toc-item-num\">4.5&nbsp;&nbsp;</span>Dealing with conflict</a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Version Control and Git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Questions:\n",
    "- \"What is version control and why should I use it?\"\n",
    "- \"How do I get set up to use Git?\"\n",
    "- \"Where does Git store information?\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Objectives:\n",
    "- \"Understand the benefits of an automated version control system.\"\n",
    "- \"Understand the basics of how Git works.\"\n",
    "- \"Configure `git` the first time it is used on a computer.\"\n",
    "- \"Understand the meaning of the `--global` configuration flag.\"\n",
    "- \"Create a local Git repository.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Keypoints:\n",
    "- \"Version control is like an unlimited 'undo'.\"\n",
    "- \"Version control also allows many people to work in parallel.\"\n",
    "- \"All changes tracked by git are stored in the hidden repository '.git'.\"\n",
    "-   \"Use `git config` to configure a user name, email address, editor, and other preferences once per machine.\"\n",
    "- \"`git init` initializes a repository.\"\n",
    "- \"`git status` shows the status of a repository.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll start by exploring how version control can be used\n",
    "to keep track of what one person did and when.\n",
    "Even if you aren't collaborating with other people,\n",
    "automated version control is much better than this situation:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Piled Higher and Deeper by Jorge Cham, http://www.phdcomics.com/comics/archive_print.php?comicid=1531](figures/phd101212s.png)](http://www.phdcomics.com)\n",
    "\n",
    "\"Piled Higher and Deeper\" by Jorge Cham, http://www.phdcomics.com"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've all been in this situation before: it seems ridiculous to have\n",
    "multiple nearly-identical versions of the same document. Some word\n",
    "processors let us deal with this a little better, such as Microsoft\n",
    "Word's \"Track Changes\" or Google Docs' [version\n",
    "history](https://support.google.com/docs/answer/190843?hl=en).\n",
    "\n",
    "Version control systems start with a base version of the document and\n",
    "then save just the changes you made at each step of the way. You can\n",
    "think of it as a tape: if you rewind the tape and start at the base\n",
    "document, then you can play back each change and end up with your\n",
    "latest version."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Changes Are Saved Sequentially](figures/play_changes.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you think of changes as separate from the document itself, you\n",
    "can then think about \"playing back\" different sets of changes onto the\n",
    "base document and getting different versions of the document. For\n",
    "example, two users can make independent sets of changes based on the\n",
    "same document."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Different Versions Can be Saved](figures/versions.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If there aren't conflicts, you can even play two sets of changes onto the same base document."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Multiple Versions Can be Merged](figures/merge.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A version control system is a tool that keeps track of these changes for us and\n",
    "helps us version and merge our files. It allows you to\n",
    "decide which changes make up the next version, called a\n",
    "[commit]({{ page.root }}/reference/#commit), and keeps useful metadata about them. The\n",
    "complete history of commits for a particular project and their metadata make up\n",
    "a [repository]({{ page.root }}/reference/#repository). Repositories can be kept in sync\n",
    "across different computers facilitating collaboration among different people."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### The Long History of Version Control Systems\n",
    "\n",
    "> Automated version control systems are nothing new.\n",
    "> Tools like RCS, CVS, or Subversion have been around since the early 1980s and are used by many large companies.\n",
    "> However, many of these are now becoming considered as legacy systems due to various limitations in their capabilities.\n",
    "> In particular, the more modern systems, such as Git and [Mercurial](http://swcarpentry.github.io/hg-novice/)\n",
    "> are *distributed*, meaning that they do not need a centralized server to host the repository.\n",
    "> These modern systems also include powerful merging tools that make it possible for multiple authors to work within\n",
    "> the same files concurrently.\n",
    "> \n",
    "\n",
    "> ##### Paper Writing\n",
    "\n",
    "> *   Imagine you drafted an excellent paragraph for a paper you are writing, but later ruin it. How would you retrieve\n",
    ">     the *excellent* version of your conclusion? Is it even possible?\n",
    "\n",
    "> *   Imagine you have 5 co-authors. How would you manage the changes and comments they make to your paper?\n",
    ">     If you use LibreOffice Writer or Microsoft Word, what happens if you accept changes made using the\n",
    ">     `Track Changes` option? Do you have a history of those changes?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setting up Git on our computer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we use Git on a new computer for the first time, we need to configure a\n",
    "[few things](http://swcarpentry.github.io/git-novice/02-setup/). Below are a\n",
    "few examples of configurations we will set as we get started with Git:\n",
    "\n",
    "*   our name and email address,\n",
    "*   to colorize our output,\n",
    "*   what our preferred text editor is,\n",
    "*   and that we want to use these settings globally (i.e. for every project)\n",
    "\n",
    "On a command line, Git commands are written as `git verb`,\n",
    "where `verb` is what we actually want to do. So we should type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git config --global color.ui \"auto\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the 3 commands commented out below with the appropriate text changed within the quotes\n",
    "# git config --global user.name \"our name\"\n",
    "# git config --global core.editor \"atom --wait\"\n",
    "# git config --global user.email \"our email address\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This user name and email will be associated with your subsequent Git activity,\n",
    "which means that any changes pushed to [GitHub](http://github.com/),\n",
    "[BitBucket](http://bitbucket.org/), [GitLab](http://gitlab.com/) or another Git\n",
    "host server in a later lesson will include this information. If you are\n",
    "concerned about privacy, please review GitHub's\n",
    "[instructions](https://help.github.com/articles/keeping-your-email-address-private/)\n",
    " for keeping your email address private.\n",
    "\n",
    "\n",
    "The four commands we just ran above only need to be run once: the flag `--global` tells Git\n",
    "to use the settings for every project, in your user account, on this computer.\n",
    "\n",
    "You can check your settings at any time:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "git config --list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can reconfigure these settings whenever you wish."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Proxy\n",
    "\n",
    "> In some networks you need to use a\n",
    "> [proxy](https://en.wikipedia.org/wiki/Proxy_server). If this is the case, you\n",
    "> may also need to tell Git about the proxy:\n",
    "\n",
    "> git config --global http.proxy proxy-url\n",
    "\n",
    "> git config --global https.proxy proxy-url\n",
    "\n",
    "\n",
    "> To disable the proxy, use:\n",
    "\n",
    "> git config --global --unset http.proxy\n",
    "\n",
    "> git config --global --unset https.proxy\n",
    "\n",
    "\n",
    "\n",
    "> ##### Git Help and Manual\n",
    "\n",
    "> Always remember that if you forget a git command, you can access the list of command by using -h and access the git manual by using --help :\n",
    "\n",
    "> git config -h\n",
    "\n",
    "> git config --help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Setting up a project that we will track with git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To start using Git we must first create a git repository for a given project. \n",
    "We'll  first setup a basic project which we can start to track using git. \n",
    "\n",
    "The project setup consists of: \n",
    "\n",
    "1.  Creating a project directory\n",
    "2. Changing our present directory to be this project directory\n",
    "3. Adding a python script to this project directory.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir git_demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/rodgersleejg/Downloads/temp/faes_teaching/piday_course/git_demo\n"
     ]
    }
   ],
   "source": [
    "%cd git_demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 3.\n",
    "This step can be complete by running the cell below or by opening a text editor, adding the code below (excluding the first line), and by saving the file to the project directory as generate_figure.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing generate_figure.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile generate_figure.py\n",
    "# coding: utf-8\n",
    "import matplotlib as mpl\n",
    "mpl.use('Agg')\n",
    "import seaborn as sns\n",
    "\n",
    "df = sns.load_dataset('tips')\n",
    "seaborn_plot = sns.pairplot(df)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initializing a Git repository"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are in the project directory \"git_demo\", and we have a python script that will later generate a plot for us. Let's start to use git to start tracking changes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To turn this project directory into a git repository we now use the 'git init' command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized empty Git repository in /Users/rodgersleejg/Downloads/temp/faes_teaching/piday_course/git_demo/.git/\n"
     ]
    }
   ],
   "source": [
    "!git init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generate_figure.py\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It appears that nothing has changed. But if we add the `-a` flag to show all\n",
    "files, including hidden ones, we can see that Git has created a hidden directory\n",
    "called `.git`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m.\u001b[m\u001b[m                  \u001b[34m..\u001b[m\u001b[m                 \u001b[34m.git\u001b[m\u001b[m               generate_figure.py\n"
     ]
    }
   ],
   "source": [
    "!ls -a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Git stores information about the project in this special sub-directory. If we\n",
    "ever delete it, we will lose the project's history.\n",
    "\n",
    "We can check that everything is set up correctly by asking Git to tell us the\n",
    "status of our project. It should display the following text:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "\n",
      "No commits yet\n",
      "\n",
      "Untracked files:\n",
      "  (use \"git add <file>...\" to include in what will be committed)\n",
      "\n",
      "\t\u001b[31mgenerate_figure.py\u001b[m\n",
      "\n",
      "nothing added to commit but untracked files present (use \"git add\" to track)\n"
     ]
    }
   ],
   "source": [
    "!git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Versioning edits with Git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Questions:\n",
    "- \"How do I record changes in Git?\"\n",
    "- \"How do I record notes about what changes I made and why?\"\n",
    "\n",
    "##### Objectives:\n",
    "- \"Go through the modify-add-commit cycle for one or more files.\"\n",
    "- \"Explain where information is stored at each stage of Git commit workflow.\"\n",
    "\n",
    "##### Keypoints:\n",
    "- \"Files can be stored in a project's working directory (which users see), the staging area (where the next commit is being built up) and the local repository (where commits are permanently recorded).\"\n",
    "- \"`git add` puts files in the staging area.\"\n",
    "- \"`git commit` saves the staged content as a new commit in the local repository.\"\n",
    "- \"Always write a log message when committing changes.\"\n",
    "- \"View previous commits using the `git log` command.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first step in tracking a file in Git is to add it to the Git staging area. In order to do this we use \"git add\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git add generate_figure.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We check how this changed the way Git see our current project with the \"git status\" command once again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "\n",
      "No commits yet\n",
      "\n",
      "Changes to be committed:\n",
      "  (use \"git rm --cached <file>...\" to unstage)\n",
      "\n",
      "\t\u001b[32mnew file:   generate_figure.py\u001b[m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Git now knows that it's supposed to keep track of 'generate_figure.py', but\n",
    "it hasn't recorded these changes permanently in its repository yet. To\n",
    "permanently store the current state of the generate_figure.py file in the\n",
    "Git repository we need to commit the changes that are staged. We use the `git\n",
    "commit` command for this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master (root-commit) 2665528] add script to generate figure\n",
      " 1 file changed, 7 insertions(+)\n",
      " create mode 100644 generate_figure.py\n"
     ]
    }
   ],
   "source": [
    "!git commit -m \"add script to generate figure\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### The staging area helps to keep track of different changes\n",
    "> \n",
    "> If you think of Git as taking snapshots of changes over the life of a\n",
    "> project, \"git add\" specifies *what* will go in a snapshot (putting things in\n",
    "> the staging area), and \"git commit\" then *actually takes* the snapshot, and\n",
    "> makes a permanent record of it (as a commit). If you don't have anything\n",
    "> staged when you type \"git commit\", Git will prompt you to use \"git commit -a\"\n",
    "> or \"git commit --all\", which is kind of like gathering *everyone* for the\n",
    "> picture! However, it's almost always better to explicitly add things to the\n",
    "> staging area, because you might commit changes you forgot you made. Try to\n",
    "> stage things manually, or you might find yourself searching for \"git undo\n",
    "> commit\" more than you would like!\n",
    "> ![](figures/git_local_overview.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we run `git commit`, Git takes everything we have told it to save by using\n",
    "`git add` and stores a copy permanently inside the special `.git` directory.\n",
    "This permanent copy is called a commit (or\n",
    "revision and its short identifier is\n",
    "an alpha-numeric string within the square brackets on the first line of the output above.\n",
    "\n",
    "We use the `-m` flag (for \"message\") to record a short, descriptive, and\n",
    "specific comment that will help us remember later on what we did and why. If we\n",
    "just run `git commit` without the `-m` option, Git will launch `atom` (or\n",
    "whatever other editor we configured as `core.editor`) so that we can write a\n",
    "longer message.\n",
    "\n",
    "[Good commit messages](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html) start with a brief (<50 characters) summary of\n",
    "changes made in the commit.  If you want to go into more detail, add\n",
    "a blank line between the summary line and your additional notes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now when we run \"git status\" we see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "nothing to commit, working tree clean\n"
     ]
    }
   ],
   "source": [
    "!git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not only is the generate_figure.py file now tracked but it is also\n",
    "no longer part of the output of  \"git status\". It is now in the unmodified\n",
    "state. When we look at our repository's history we can observe our commit. For\n",
    "this, we use \"git log\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mcommit 2665528b7b9fef0f178a0f7835e2eee3f149c51d\u001b[m\u001b[33m (\u001b[m\u001b[1;36mHEAD -> \u001b[m\u001b[1;32mmaster\u001b[m\u001b[33m)\u001b[m\n",
      "Author: leej3 <johnleenimh@gmail.com>\n",
      "Date:   Thu Oct 3 09:03:20 2019 -0400\n",
      "\n",
      "    add script to generate figure\n"
     ]
    }
   ],
   "source": [
    "!git log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"git log\" lists all commits  made to a repository in reverse chronological\n",
    "order. The listing for each commit includes the commit's full identifier (which\n",
    "starts with the same characters as the short identifier printed by the `git\n",
    "commit` command earlier), the commit's author, when it was created, and the log\n",
    "message Git was given when the commit was created."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Where Are My Changes?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point there is has been no obvious change to the filesystem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generate_figure.py\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are no obvious changes observed in the project directory because Git\n",
    "saves information about files' history in the special `.git` directory\n",
    "mentioned earlier so that our filesystem doesn't become cluttered (and so that\n",
    "we can't accidentally edit or delete an old version).\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Git Lifecycle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have now seen the different states that files typically inhabit as Git\n",
    "tracks them. The default file state is unmodified. Any time we make a change to\n",
    "any of our files tracked by Git we will observe that they are listed as\n",
    "modified. We must stage and then commit such changes to return the files to\n",
    "their unmodified state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cycle of making changes to files, staging these changes, and then\n",
    "committing them is continually repeated and our project continues to develop\n",
    "with each file being represented in the Git repository as a combination of\n",
    "committed changes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will start working through such a cycle now by editing our script so that it saves our plot to a file. In order to do this we must add the following line of code to the end of our text file:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "seaborn_plot.savefig('pairplot.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to edit the file we can use a text editor or execute the following command in bash:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "!echo \"seaborn_plot.savefig('pairplot.png')\" >> generate_figure.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our file has changed from an \"unmodified\" state to a \"modified\" state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "Changes not staged for commit:\n",
      "  (use \"git add <file>...\" to update what will be committed)\n",
      "  (use \"git checkout -- <file>...\" to discard changes in working directory)\n",
      "\n",
      "\t\u001b[31mmodified:   generate_figure.py\u001b[m\n",
      "\n",
      "no changes added to commit (use \"git add\" and/or \"git commit -a\")\n"
     ]
    }
   ],
   "source": [
    "!git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We previously used \"git add\" to add an untracked file to the staging area. This\n",
    "time we will use it to add a modified file to the staging area."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git add generate_figure.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now commit the file to complete the git lifecycle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master 1602b58] save plot file\n",
      " 1 file changed, 1 insertion(+)\n"
     ]
    }
   ],
   "source": [
    "!git commit -m \"save plot file\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point \"git status\" will show us that we have no modified files and \"git log\" will show us that we have made snapshotted our project at two points in time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/git_local_repository.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modified from [blog-pedrezo.com](http://blog.podrezo.com/git-introduction-for-cvssvntfs-users/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running our python script"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to run our python script we need a working installation of python 3 with the seaborn plotting package installed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assuming these criteria are met we can run our script from the bash command line by simply typing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run generate_figure.py\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have created an additional file in our project directory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generate_figure.py pairplot.png\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we will add this plot to our git repository before we learn about how to use github.com to collaborate with others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git add pairplot.png"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master c4046d2] Add plot\n",
      " 1 file changed, 0 insertions(+), 0 deletions(-)\n",
      " create mode 100644 pairplot.png\n"
     ]
    }
   ],
   "source": [
    "!git commit -m \"Add plot\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Collaboration with Git and GitHub"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Questions:\n",
    "- \"How do I share my changes with others on the web?\"\n",
    "- \"How can I use version control to collaborate with other people?\"\n",
    "- \"What do I do when my changes conflict with someone else's?\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Objectives:\n",
    "- \"Explain what remote repositories are and why they are useful.\"\n",
    "- \"Push to or pull from a remote repository.\"\n",
    "- \"Clone a remote repository.\"\n",
    "- \"Collaborate  by forking a repository and submitting a pull request.\"\n",
    "- \"Explain what conflicts are and when they can occur.\"\n",
    "- \"Resolve conflicts resulting from a merge.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Keypoints:\n",
    "- \"A local Git repository can be connected to one or more remote repositories.\"\n",
    "- \"Use the HTTPS protocol to connect to remote repositories until you have learned how to set up SSH.\"\n",
    "- \"`git push` copies changes from a local repository to a remote repository.\"\n",
    "- \"`git pull` copies changes from a remote repository to a local repository.\"\n",
    "- \"`git clone` copies a remote repository to create a local repository with a remote called `origin` automatically set up.\"\n",
    "- \"Conflicts occur when two or more people change the same file(s) at the same time.\"\n",
    "- \"The version control system does not allow people to overwrite each other's changes blindly, but highlights conflicts so that they can be resolved.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a repository on GitHub"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Version control really comes into its own when we begin to collaborate with\n",
    "other people.  We already have most of the machinery we need to do this; the\n",
    "only thing missing is to copy changes from one repository to another."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Systems like Git allow us to move work between any two repositories.  In\n",
    "practice, though, it's easiest to use one copy as a central hub, and to keep it\n",
    "on the web rather than on someone's laptop.  Most programmers use hosting\n",
    "services like [GitHub](http://github.com), [BitBucket](http://bitbucket.org) or\n",
    "[GitLab](http://gitlab.com/) to hold those master copies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start by sharing the changes we've made to our current project with the world.  \n",
    "\n",
    "* Sign up for an account at [GitHub](github.com). \n",
    "\n",
    "* Once you are signed in click on the icon in the top right corner to create a new repository:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/github-create-repo-01.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Name your repository \"piday_workshop\" and then click \"Create Repository\":\n",
    "\n",
    "* This effectively makes a directory with a `.git` repository in it on the github servers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As soon as the repository is created, GitHub displays a page with a URL and some information on how to configure your local repository:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/github_new_repo_instructions.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Pushing to a remote repository"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our local repository contains our earlier work on `generate_figure.py`, but the\n",
    "remote repository on GitHub doesn't contain any files yet.\n",
    "\n",
    "The next step is to connect the two repositories.  We do this by making the\n",
    "GitHub repository a remote for the local repository.\n",
    "The home page of the repository on GitHub includes the string we need to\n",
    "identify it.\n",
    "\n",
    "Click on the 'HTTPS' link to change the protocol from SSH to HTTPS."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### HTTPS vs. SSH\n",
    "\n",
    "> We use HTTPS here because it does not require additional configuration.  After\n",
    "> the workshop you may want to set up SSH access, which is a bit more secure, by\n",
    "> following one of the great tutorials from\n",
    "> [GitHub](https://help.github.com/articles/generating-ssh-keys),\n",
    "> [Atlassian/BitBucket](https://confluence.atlassian.com/display/BITBUCKET/Set+up+SSH+for+Git)\n",
    "> and [GitLab](https://about.gitlab.com/2014/03/04/add-ssh-key-screencast/)\n",
    "> (this one has a screencast)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copy that URL from the browser, go into the local `piday_workshop` repository, and run\n",
    "the following command. Make sure to use the URL for your repository i.e. the only\n",
    "difference should be your username instead of `nih-fmrif`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git remote add origin https://github.com/nih-fmrif/piday_workshop.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check that the command has worked by running `git remote -v`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "origin\thttps://github.com/nih-fmrif/piday_workshop.git (fetch)\n",
      "origin\thttps://github.com/nih-fmrif/piday_workshop.git (push)\n"
     ]
    }
   ],
   "source": [
    "!git remote -v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The name `origin` is a local nickname for your remote repository: we could use\n",
    "something else if we wanted to, but `origin` is by far the most common choice.\n",
    "\n",
    "Once the nickname `origin` is set up, the following command will push the changes from\n",
    "our local repository to the repository on GitHub. You will be asked for your github username and password to complete this step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To https://github.com/nih-fmrif/piday_workshop.git\n",
      " \u001b[31m! [rejected]       \u001b[m master -> master (fetch first)\n",
      "\u001b[31merror: failed to push some refs to 'https://github.com/nih-fmrif/piday_workshop.git'\n",
      "\u001b[m\u001b[33mhint: Updates were rejected because the remote contains work that you do\u001b[m\n",
      "\u001b[33mhint: not have locally. This is usually caused by another repository pushing\u001b[m\n",
      "\u001b[33mhint: to the same ref. You may want to first integrate the remote changes\u001b[m\n",
      "\u001b[33mhint: (e.g., 'git pull ...') before pushing again.\u001b[m\n",
      "\u001b[33mhint: See the 'Note about fast-forwards' in 'git push --help' for details.\u001b[m\n"
     ]
    }
   ],
   "source": [
    "!git push origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Proxy\n",
    "\n",
    "> If the network you are connected to uses a proxy there is an chance that your\n",
    "> last command failed with \"Could not resolve hostname\" as the error message. To\n",
    "> solve this issue you need to tell Git about the proxy:\n",
    "\n",
    "> git config --global http.proxy http://user:password@proxy.url\n",
    "\n",
    "> git config --global https.proxy http://user:password@proxy.url\n",
    "\n",
    "\n",
    "> When you connect to another network that doesn't use a proxy you will need to\n",
    "> tell Git to disable the proxy using:\n",
    "\n",
    "> git config --global --unset http.proxy\n",
    "\n",
    "> git config --global --unset https.proxy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Password Managers\n",
    "\n",
    "> If your operating system has a password manager configured, `git push` will\n",
    "> try to use it when it needs your username and password.  For example, this\n",
    "> is the default behavior for Git Bash on Windows. If you want to type your\n",
    "> username and password at the terminal instead of using a password manager,\n",
    "> type:\n",
    "\n",
    "> unset SSH_ASKPASS\n",
    "\n",
    "\n",
    "> in the terminal, before you run `git push`.  Despite the name, [git uses\n",
    "> `SSH_ASKPASS` for all credential\n",
    "> entry](http://git-scm.com/docs/gitcredentials#_requesting_credentials), so\n",
    "> you may want to unset `SSH_ASKPASS` whether you are using git via SSH or\n",
    "> https.\n",
    "\n",
    "> You may also want to add `unset SSH_ASKPASS` at the end of your `~/.bashrc`\n",
    "> to make git default to using the terminal for usernames and passwords."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can pull changes from the remote repository to the local one as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From https://github.com/nih-fmrif/piday_workshop\n",
      " * branch            master     -> FETCH_HEAD\n",
      "Already up-to-date.\n"
     ]
    }
   ],
   "source": [
    "!git pull origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pulling has no effect in this case because the two repositories are already\n",
    "synchronized.  If someone else had pushed some changes to the repository on\n",
    "GitHub, though, this command would download them to our local repository."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Submitting a pull request"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the next step, get into pairs.  One person will be the \"Owner\" and the other\n",
    "will be the \"Collaborator\". The goal is that the Collaborator add changes into\n",
    "the Owner's repository. We will switch roles at the end, so both persons will\n",
    "play Owner and Collaborator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overview of collaboration workflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. The collaborator forks the owners repository.\n",
    "1. The collaborator makes an edit.\n",
    "1. The collaborator submits a pull request for this edit.\n",
    "1. The owner reviews and accepts this edit to merge the changes into their original repository."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Forking the repository"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to fork the owner's repository, search for their username on github, select the repository, and click fork:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/github_fork_pic.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Making an edit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The collaborator is taken to the newly forked repo on their own github profile. The easiest way to make an edit is to use the github web interface (alternatively we could clone our forked repository to our local machine and edit it there). The collaborator should select generate_figure.py and then click the icon to \"Edit this file\" (depicted below). The collaborator should then make a small change to the file before continuing to the next step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/editing_a_file.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Submitting a pull request"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to request that the edit is added to the owner's repository the collaborator must submit a pull request by selecting the icon depicted below and following the subsequent steps presented."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/github_pull_request.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Accepting the pull request"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final step to complete the collaboration is for the owner to view the pull request listed in their repository, review the changes made and accept it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">\n",
    "##### An alternative to pull requests\n",
    "\n",
    "If the owner of a repository add the collaborator to the github repository (option is found in the settings on github)\n",
    " direct pushes from the collaborator to the owners repository can be made. This makes things easier because the collaborator can simply clone the repository, edit, and push changes and skip the forking and pull requests.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An overview of collaboration with git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/git-operations.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dealing with conflict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As soon as people can work in parallel, it's likely someone's going to step on someone else's toes.  This will even happen with a single person: if we are working on a piece of software on both our laptop and a server in the lab, we could make different changes to each copy.  Version control helps us manage these conflicts by giving us tools to resolve overlapping changes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see how we can resolve conflicts, we must first create one.  The file\n",
    "`generate_figure.py` currently looks like this in both partners' copies of our `piday_workshop`\n",
    "repository:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "%less generate_figure.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Let's add a line to one partner's copy only:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**... make the edit to generate_figure.py...**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31m# coding: utf-8\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mmpl\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0mmpl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Agg'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0;32mimport\u001b[0m \u001b[0mseaborn\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_dataset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'tips'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0mseaborn_plot\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpairplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0mseaborn_plot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'pairplot.png'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%less generate_figure.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and then push the change to GitHub:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "nothing to commit, working tree clean\n"
     ]
    }
   ],
   "source": [
    "!git add generate_figure.py\n",
    "!git commit -m \"Adding a line in our home copy\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To https://github.com/nih-fmrif/piday_workshop.git\n",
      " \u001b[31m! [rejected]       \u001b[m master -> master (fetch first)\n",
      "\u001b[31merror: failed to push some refs to 'https://github.com/nih-fmrif/piday_workshop.git'\n",
      "\u001b[m\u001b[33mhint: Updates were rejected because the remote contains work that you do\u001b[m\n",
      "\u001b[33mhint: not have locally. This is usually caused by another repository pushing\u001b[m\n",
      "\u001b[33mhint: to the same ref. You may want to first integrate the remote changes\u001b[m\n",
      "\u001b[33mhint: (e.g., 'git pull ...') before pushing again.\u001b[m\n",
      "\u001b[33mhint: See the 'Note about fast-forwards' in 'git push --help' for details.\u001b[m\n"
     ]
    }
   ],
   "source": [
    "git push origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's have the other partner\n",
    "make a different change to their copy\n",
    "*without* updating from GitHub:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**... make the edit to generate_figure.py...**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31m# coding: utf-8\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mmpl\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0mmpl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Agg'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0;32mimport\u001b[0m \u001b[0mseaborn\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_dataset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'tips'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0mseaborn_plot\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpairplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0mseaborn_plot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'pairplot.png'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%less generate_figure.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can commit the change locally:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "nothing to commit, working tree clean\n"
     ]
    }
   ],
   "source": [
    "!git add generate_figure.py\n",
    "!git commit -m \"Adding a line in the second local copy\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but Git won't let us push it to GitHub:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To https://github.com/nih-fmrif/piday_workshop.git\n",
      " \u001b[31m! [rejected]       \u001b[m master -> master (fetch first)\n",
      "\u001b[31merror: failed to push some refs to 'https://github.com/nih-fmrif/piday_workshop.git'\n",
      "\u001b[m\u001b[33mhint: Updates were rejected because the remote contains work that you do\u001b[m\n",
      "\u001b[33mhint: not have locally. This is usually caused by another repository pushing\u001b[m\n",
      "\u001b[33mhint: to the same ref. You may want to first integrate the remote changes\u001b[m\n",
      "\u001b[33mhint: (e.g., 'git pull ...') before pushing again.\u001b[m\n",
      "\u001b[33mhint: See the 'Note about fast-forwards' in 'git push --help' for details.\u001b[m\n"
     ]
    }
   ],
   "source": [
    "git push origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![The Conflicting Changes](figures/conflict.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Git detects that the changes made in one copy overlap with those made in the\n",
    "other and stops us from trampling on our previous work. What we have to do is\n",
    "pull the changes from GitHub, [merge]({{ page.root }}/reference/#merge) them\n",
    "into the copy we're currently working in, and then push that. Let's start by\n",
    "pulling:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "git pull origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`git pull` tells us there's a conflict, and marks that conflict in the affected\n",
    "file.\n",
    "\n",
    "Our change—the one in `HEAD`—is preceded by `<<<<<<<`. Git has then inserted\n",
    "`=======` as a separator between the conflicting changes and marked the end of\n",
    "the content downloaded from GitHub with `>>>>>>>`. (The string of letters and\n",
    "digits after that marker identifies the commit we've just downloaded.)\n",
    "\n",
    "It is now up to us to edit this file to remove these markers and reconcile the\n",
    "changes. We can do anything we want: keep the change made in the local\n",
    "repository, keep the change made in the remote repository, write something new\n",
    "to replace both, or get rid of the change entirely. Let's replace both with a\n",
    "comment stating that we resolved our first of many git conflicts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "%less generate_figure.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To finish merging, we add `generate_figure.py` to the changes being made by\n",
    "the merge and then commit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "git add generate_figure.py\n",
    "git status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "git commit -m \"Merging changes from GitHub\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can push our changes to GitHub:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "git push origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Git keeps track of what we've merged with what, so we don't have to fix things\n",
    "by hand again when the collaborator who made the first change pulls again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "git pull origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get the merged file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%less generate_figure.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We don't need to merge again because Git knows someone has already done that.\n",
    "\n",
    "Version control's ability to merge conflicting changes is another reason users\n",
    "tend to divide their programs and papers into multiple files instead of storing\n",
    "everything in one large file. There's another benefit too: whenever there are\n",
    "repeated conflicts in a particular file, the version control system is\n",
    "essentially trying to tell its users that they ought to clarify who's\n",
    "responsible for what, or find a way to divide the work up differently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### GitHub GUI\n",
    "> \n",
    "> Browse to your `piday_workshop` repository on GitHub.\n",
    "> Under the Code tab, find and click on the text that says \"XX commits\" (where \"XX\" is some number).\n",
    "> Hover over, and click on, the three buttons to the right of each commit.\n",
    "> What information can you gather/explore from these buttons?\n",
    "> How would you get that same information in the shell?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### GitHub Timestamp\n",
    "> \n",
    "> Create a remote repository on GitHub.  Push the contents of your local\n",
    "> repository to the remote.  Make changes to your local repository and push\n",
    "> these changes.  Go to the repo you just created on Github and check the\n",
    "> [timestamps]({{ page.root }}/reference/#timestamp) of the files.  How does GitHub record\n",
    "> times, and why?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Push vs. Commit\n",
    "> \n",
    "> In this lesson, we introduced the \"git push\" command.\n",
    "> How is \"git push\" different from \"git commit\"?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Fixing Remote Settings\n",
    "> \n",
    "> It happens quite often in practice that you made a typo in the\n",
    "> remote URL. This exercice is about how to fix this kind of issues.\n",
    "> First start by adding a remote with an invalid URL:\n",
    "> \n",
    "> > git remote add broken https://github.com/this/url/is/invalid\n",
    "\n",
    "> \n",
    "> Do you get an error when adding the remote? Can you think of a\n",
    "> command that would make it obvious that your remote URL was not\n",
    "> valid? Can you figure out how to fix the URL (tip: use `git remote\n",
    "> -h`)? Don't forget to clean up and remove this remote once you are\n",
    "> done with this exercise.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### GitHub License and README files\n",
    "> \n",
    "> In this section we learned about creating a remote repository on GitHub, but when you initialized your\n",
    "> GitHub repo, you didn't add a README.md or a license file. If you had, what do you think would have happened when\n",
    "> you tried to link your local and remote repositories?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Switch Roles and Repeat\n",
    "> \n",
    "> Switch roles and repeat the whole process.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Review Changes\n",
    "> \n",
    "> The Owner push commits to the repository without giving any information\n",
    "> to the Collaborator. How can the Collaborator find out what has changed with\n",
    "> command line? And on GitHub?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Comment Changes in GitHub\n",
    "> \n",
    "> The Collaborator has some questions about one line change made by the Owner and\n",
    "> has some suggestions to propose.\n",
    "> \n",
    "> With GitHub, it is possible to comment the diff of a commit. Over the line of\n",
    "> code to comment, a blue comment icon appears to open a comment window.\n",
    "> \n",
    "> The Collaborator posts its comments and suggestions using GitHub interface.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Version History, Backup, and Version Control\n",
    "> \n",
    "> Some backup software can keep a history of the versions of your files. They also\n",
    "> allows you to recover specific versions. How is this functionality different from version control?\n",
    "> What are some of the benifits of using version control, Git and Github?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Solving Conflicts that You Create\n",
    "> \n",
    "> Clone the repository created by your instructor.\n",
    "> Add a new file to it,\n",
    "> and modify an existing file (your instructor will tell you which one).\n",
    "> When asked by your instructor,\n",
    "> pull her changes from the repository to create a conflict,\n",
    "> then resolve it.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### Conflicts on Non-textual files\n",
    "> \n",
    "> What does Git do\n",
    "> when there is a conflict in an image or some other non-textual file\n",
    "> that is stored in version control?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ##### A Typical Work Session\n",
    "> \n",
    "> You sit down at your computer to work on a shared project that is tracked in a\n",
    "> remote Git repository. During your work session, you take the following\n",
    "> actions, but not in this order:\n",
    "> \n",
    "> - *Make changes* by appending the number `100` to a text file `numbers.txt`\n",
    "> - *Update remote* repository to match the local repository\n",
    "> - *Celebrate* your success with beer(s)\n",
    "> - *Update local* repository to match the remote repository\n",
    "> - *Stage changes* to be committed\n",
    "> - *Commit changes* to the local repository\n",
    "> \n",
    "> In what order should you perform these actions to minimize the chances of\n",
    "> conflicts? Put the commands above in order in the *action* column of the table\n",
    "> below. When you have the order right, see if you can write the corresponding\n",
    "> commands in the *command* column. A few steps are populated to get you\n",
    "> started.\n",
    "> \n",
    "> |order|action . . . . . . . . . . |command . . . . . . . . . . |\n",
    "> |-----|---------------------------|----------------------------|\n",
    "> |1    |                           |                            |\n",
    "> |2    |                           | `echo 100 >> numbers.txt`  |\n",
    "> |3    |                           |                            |\n",
    "> |4    |                           |                            |\n",
    "> |5    |                           |                            |\n",
    "> |6    | Celebrate!                | `AFK`                      |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[31mDEPRECATION: The default format will switch to columns in the future. You can use --format=(legacy|columns) (or define a format=(legacy|columns) in your pip.conf under the [list] section) to disable this warning.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "conda env export -f ../environment.yml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: piday\n",
      "channels:\n",
      "- !!python/unicode\n",
      "  'defaults'\n",
      "dependencies:\n",
      "- !!python/unicode\n",
      "  'bleach=1.5.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'cycler=0.10.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'dbus=1.10.10=0'\n",
      "- !!python/unicode\n",
      "  'decorator=4.0.11=py36_0'\n",
      "- !!python/unicode\n",
      "  'entrypoints=0.2.2=py36_1'\n",
      "- !!python/unicode\n",
      "  'expat=2.1.0=0'\n",
      "- !!python/unicode\n",
      "  'fontconfig=2.12.1=3'\n",
      "- !!python/unicode\n",
      "  'freetype=2.5.5=2'\n",
      "- !!python/unicode\n",
      "  'glib=2.50.2=1'\n",
      "- !!python/unicode\n",
      "  'gst-plugins-base=1.8.0=0'\n",
      "- !!python/unicode\n",
      "  'gstreamer=1.8.0=0'\n",
      "- !!python/unicode\n",
      "  'html5lib=0.999=py36_0'\n",
      "- !!python/unicode\n",
      "  'icu=54.1=0'\n",
      "- !!python/unicode\n",
      "  'ipykernel=4.6.1=py36_0'\n",
      "- !!python/unicode\n",
      "  'ipython=6.0.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'ipython_genutils=0.2.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'ipywidgets=6.0.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'jinja2=2.9.6=py36_0'\n",
      "- !!python/unicode\n",
      "  'jpeg=9b=0'\n",
      "- !!python/unicode\n",
      "  'jsonschema=2.6.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'jupyter=1.0.0=py36_3'\n",
      "- !!python/unicode\n",
      "  'jupyter_client=5.0.1=py36_0'\n",
      "- !!python/unicode\n",
      "  'jupyter_console=5.1.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'jupyter_core=4.3.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'libffi=3.2.1=1'\n",
      "- !!python/unicode\n",
      "  'libgcc=5.2.0=0'\n",
      "- !!python/unicode\n",
      "  'libgfortran=3.0.0=1'\n",
      "- !!python/unicode\n",
      "  'libiconv=1.14=0'\n",
      "- !!python/unicode\n",
      "  'libpng=1.6.27=0'\n",
      "- !!python/unicode\n",
      "  'libsodium=1.0.10=0'\n",
      "- !!python/unicode\n",
      "  'libxcb=1.12=1'\n",
      "- !!python/unicode\n",
      "  'libxml2=2.9.4=0'\n",
      "- !!python/unicode\n",
      "  'markupsafe=0.23=py36_2'\n",
      "- !!python/unicode\n",
      "  'matplotlib=2.0.0=np112py36_0'\n",
      "- !!python/unicode\n",
      "  'mistune=0.7.4=py36_0'\n",
      "- !!python/unicode\n",
      "  'mkl=2017.0.1=0'\n",
      "- !!python/unicode\n",
      "  'nbconvert=5.1.1=py36_0'\n",
      "- !!python/unicode\n",
      "  'nbformat=4.3.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'notebook=5.0.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'numpy=1.12.1=py36_0'\n",
      "- !!python/unicode\n",
      "  'openssl=1.0.2k=1'\n",
      "- !!python/unicode\n",
      "  'pandas=0.19.2=np112py36_1'\n",
      "- !!python/unicode\n",
      "  'pandocfilters=1.4.1=py36_0'\n",
      "- !!python/unicode\n",
      "  'path.py=10.3.1=py36_0'\n",
      "- !!python/unicode\n",
      "  'pcre=8.39=1'\n",
      "- !!python/unicode\n",
      "  'pexpect=4.2.1=py36_0'\n",
      "- !!python/unicode\n",
      "  'pickleshare=0.7.4=py36_0'\n",
      "- !!python/unicode\n",
      "  'pip=9.0.1=py36_1'\n",
      "- !!python/unicode\n",
      "  'prompt_toolkit=1.0.14=py36_0'\n",
      "- !!python/unicode\n",
      "  'ptyprocess=0.5.1=py36_0'\n",
      "- !!python/unicode\n",
      "  'pygments=2.2.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'pyparsing=2.1.4=py36_0'\n",
      "- !!python/unicode\n",
      "  'pyqt=5.6.0=py36_2'\n",
      "- !!python/unicode\n",
      "  'python=3.6.1=0'\n",
      "- !!python/unicode\n",
      "  'python-dateutil=2.6.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'pytz=2017.2=py36_0'\n",
      "- !!python/unicode\n",
      "  'pyzmq=16.0.2=py36_0'\n",
      "- !!python/unicode\n",
      "  'qt=5.6.2=3'\n",
      "- !!python/unicode\n",
      "  'qtconsole=4.3.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'readline=6.2=2'\n",
      "- !!python/unicode\n",
      "  'scipy=0.19.0=np112py36_0'\n",
      "- !!python/unicode\n",
      "  'seaborn=0.7.1=py36_0'\n",
      "- !!python/unicode\n",
      "  'setuptools=27.2.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'simplegeneric=0.8.1=py36_1'\n",
      "- !!python/unicode\n",
      "  'sip=4.18=py36_0'\n",
      "- !!python/unicode\n",
      "  'six=1.10.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'sqlite=3.13.0=0'\n",
      "- !!python/unicode\n",
      "  'terminado=0.6=py36_0'\n",
      "- !!python/unicode\n",
      "  'testpath=0.3=py36_0'\n",
      "- !!python/unicode\n",
      "  'tk=8.5.18=0'\n",
      "- !!python/unicode\n",
      "  'tornado=4.5.1=py36_0'\n",
      "- !!python/unicode\n",
      "  'traitlets=4.3.2=py36_0'\n",
      "- !!python/unicode\n",
      "  'wcwidth=0.1.7=py36_0'\n",
      "- !!python/unicode\n",
      "  'wheel=0.29.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'widgetsnbextension=2.0.0=py36_0'\n",
      "- !!python/unicode\n",
      "  'xz=5.2.2=1'\n",
      "- !!python/unicode\n",
      "  'zeromq=4.1.5=0'\n",
      "- !!python/unicode\n",
      "  'zlib=1.2.8=3'\n",
      "- pip:\n",
      "  - bash-kernel==0.6\n",
      "  - colorama==0.3.9\n",
      "  - ipython-genutils==0.2.0\n",
      "  - jupyter-client==5.0.1\n",
      "  - jupyter-console==5.1.0\n",
      "  - jupyter-core==4.3.0\n",
      "  - nbdime==0.2.0\n",
      "  - prompt-toolkit==1.0.14\n",
      "  - requests==2.13.0\n",
      "prefix: !!python/unicode '/data/rodgersleejg/python/envs/piday'\n"
     ]
    }
   ],
   "source": [
    "cat ../environment.yml\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "901px",
    "width": "309px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": true,
   "toc_position": {
    "height": "1055px",
    "left": "0px",
    "right": "auto",
    "top": "105px",
    "width": "212px"
   },
   "toc_section_display": "block",
   "toc_window_display": true,
   "widenNotebook": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}