WQ_Classes_and_ORM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import seaborn as sns\n",
    "matplotlib.rcParams['savefig.dpi'] = 144"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we will build a few classes to represent some data, namely people in a company. The first class we need to define is a `Person` which is the general class representing a person. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(object):\n",
    "    def __init__(self, name, age, degree, salary):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.degree = degree\n",
    "        self.salary = salary\n",
    "        \n",
    "    def describe(self):\n",
    "        fmt = \"{} is {} years old, holds a {}, with a salary of {}\"\n",
    "        return fmt.format(self.name, self.age, self.degree, self.salary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now a degree is something we probably want to abstract as well, so lets create a degree class.\n",
    "\n",
    "We might also do some validation, so we can use Mixin here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Validate(object):\n",
    "    def _validate(self, ele, allowed):\n",
    "        if ele not in allowed:\n",
    "            raise ValueError('{} is not allowed for class {}'.format(ele, type(self)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Degree(Validate):\n",
    "    ALLOWED_LEVELS = ['bachelors', 'masters', 'phd'] #class variable\n",
    "    \n",
    "    def __init__(self, level, area):\n",
    "        self._validate(level, self.ALLOWED_LEVELS)\n",
    "        self.level = level\n",
    "        self.area = area\n",
    "       \n",
    "    def __repr__(self):\n",
    "        return \"{} in {}\".format(self.level, self.area)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Salary(Validate):\n",
    "    ALLOWED_PERIODS = {'weekly': 52.0,\n",
    "                       'biweekly': 26.0,\n",
    "                       'monthly': 12,\n",
    "                       'quarterly': 4.0,\n",
    "                       'annually':1.0}\n",
    "    def __init__(self, amt, pay_period):\n",
    "        self._validate(pay_period, self.ALLOWED_PERIODS)\n",
    "        self.amt = amt\n",
    "        self.period = pay_period\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return \"${:.2f} per year\".format(self.amt*self.ALLOWED_PERIODS[self.period])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = Person('Eric', 25, Degree('masters', 'physics'), Salary(200, 'biweekly'))\n",
    "p.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee(Person):\n",
    "    def __init__(self, idn, production, name, age, degree, salary):\n",
    "        super(Employee, self).__init__(name, age, degree, salary)\n",
    "        self.id = idn\n",
    "        self.production = production\n",
    "    \n",
    "    def __repr__(self):\n",
    "         return \"ID: {}, name: {}\".format(self.id, self.name)\n",
    "        \n",
    "class Manager(Employee):\n",
    "    def __init__(self, capacity, idn, production, name, age, degree, salary):\n",
    "        super(Manager, self).__init__(idn, production, name, age, degree, salary)\n",
    "        self.capacity = capacity\n",
    "        \n",
    "    def can_manage(self, n):\n",
    "        return n <= self.capacity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Group(object):\n",
    "    def __init__(self):\n",
    "        self.members = {}\n",
    "    \n",
    "    def add_member(self, member):\n",
    "        self.members[member.id] = member\n",
    "        \n",
    "    def remove_member(self, member):\n",
    "        del self.members[member.id]\n",
    "        \n",
    "    def get_member_ids(self):\n",
    "        return self.members.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Team(Group):\n",
    "    def __init__(self,idn, name, desc):\n",
    "        self.name = name\n",
    "        self.id = idn\n",
    "        self.desc = desc\n",
    "        \n",
    "        self.manager = None\n",
    "        super(Team, self).__init__()\n",
    "        \n",
    "    def add_manager(self, manager):\n",
    "        if self.manager is None:\n",
    "            self.manager = manager.id\n",
    "            self.add_member(manager)\n",
    "        else:\n",
    "            raise ValueError(\"can only have a single manager\")\n",
    "            \n",
    "    def remove_manager(self):\n",
    "        if self.manager is None:\n",
    "            raise ValueError(\"cannot remove that which does not exist\")\n",
    "        else:\n",
    "            del self.members[self.manager]\n",
    "            self.manager = None\n",
    "        \n",
    "    def check_health(self):\n",
    "        num_members = len(self.members)\n",
    "        if num_members > 0 and self.manager is None:\n",
    "            return False, \"no manager for employees\"\n",
    "        elif self.manager is not None:\n",
    "            if self.members[self.manager].can_manage(num_members - 1): # don't count self\n",
    "                return True, \"\"\n",
    "            else:\n",
    "                return False, \"too many employees for manager\"\n",
    "        else:\n",
    "            return True, \"\"\n",
    "                  \n",
    "    def production(self):\n",
    "        return sum([i.production for i in self.members.values()])\n",
    "    \n",
    "    def describe(self):\n",
    "        return \"team {} has {} members and produces ${}\".format(self.name, len(self.members), self.production())\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return \"ID: {}, Name: {}\".format(self.id, self.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "class Company(Group):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        super(Company, self).__init__()\n",
    "\n",
    "    def production(self):\n",
    "        return sum([i.production() for i in self.members.values()])\n",
    "    \n",
    "    def _single_assign(self):\n",
    "        \"\"\"check that each person is only on a single team\"\"\"\n",
    "        ids = [j for i in self.members.values() for j in i.get_member_ids()]\n",
    "        c = Counter(ids)\n",
    "        return c.most_common(1)[0][1] == 1\n",
    "    \n",
    "    def check_health(self):\n",
    "        problems = []\n",
    "        if not self._single_assign():\n",
    "            problems.append(\"employee assigned to more than one team\")\n",
    "        for k, v in self.members.iteritems():\n",
    "            health, reason = v.check_health()\n",
    "            if not health:\n",
    "                problem = \"{} is not healthy because {}\".format(v.name, reason)\n",
    "                problems.append(problem)\n",
    "        return problems\n",
    "    \n",
    "    def describe(self):\n",
    "        problems = self.check_health()\n",
    "        if not problems: #truthyness of lists\n",
    "            print(\"{} is healthy and has production of ${}\".format(self.name, self.production()))\n",
    "            for k, team in self.members.iteritems():\n",
    "                print(\"  \" + team.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often these can be mapped in a fairly straightforward way to a database.  We will describe a company here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Salaries\n",
    "low_salary = Salary(1800, 'biweekly')\n",
    "mid_salary = Salary(5600, 'biweekly')\n",
    "high_salary = Salary(100000, 'annually')\n",
    "\n",
    "# Degrees\n",
    "b_business = Degree('bachelors', 'business')\n",
    "m_math = Degree('masters', 'mathematics')\n",
    "b_finance = Degree('bachelors', 'finance')\n",
    "b_physics = Degree('bachelors', 'physics')\n",
    "p_math = Degree('phd', 'mathematics')\n",
    "\n",
    "# Employees\n",
    "fred = Employee(1, 120000, \"Fred\", 28, low_salary, b_business)\n",
    "amy = Employee(2, 136000, \"Amy\", 29, low_salary, b_finance)\n",
    "erica = Employee(5, 140000, \"Erica\", 47, mid_salary, b_physics)\n",
    "jerry = Employee(7, 165000, \"Jerry\", 45, mid_salary, b_business)\n",
    "sam = Employee(8, 127000, \"Sam\", 35, low_salary, b_finance)\n",
    "danny = Employee(9, 128000, \"Danny\", 32, low_salary, m_math)\n",
    "carrie = Employee(10, 120000, \"Carrie\", 39, low_salary, m_math)\n",
    "\n",
    "# Managers\n",
    "sally = Manager(5, 4, 131000, \"Sally\", 50, mid_salary, b_business)\n",
    "arnold = Manager(10, 3, 125000, \"Arnold\", 60, mid_salary, m_math)\n",
    "molly = Manager(10, 6, 180000, \"Molly\", 62, high_salary, p_math)\n",
    "\n",
    "# Teams\n",
    "tech = Team(1, 'tech', 'handles technical duties')\n",
    "sales = Team(2, 'sales', 'handles sales duties')\n",
    "executive = Team(3, 'executive', 'makes large business decisions')\n",
    "\n",
    "for emp in [fred, amy, carrie]:\n",
    "    tech.add_member(emp)\n",
    "\n",
    "tech.add_manager(sally)\n",
    "\n",
    "for emp in [erica, jerry, sam, danny]:\n",
    "    sales.add_member(emp)\n",
    "\n",
    "sales.add_manager(arnold)\n",
    "\n",
    "executive.add_manager(molly)\n",
    "\n",
    "# Company\n",
    "company = Company(\"the-company\")\n",
    "for team in [tech, sales, executive]:\n",
    "    company.add_member(team)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "company.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "company.members"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "company.members[1].members[10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object-relation mapping (ORM)\n",
    "\n",
    "There is a parallel between the interrelated classes we've defined and SQL tables. Just as we had a `Salary` class, a `Degree` class, an `Employee` class, etc. we could imagine a company having a `Salaries` table, `Degrees` table, and `Employees` table. Each row of one of these tables would be similar to a single object of that type (i.e. an instance of a class).\n",
    "\n",
    "We can therefore imagine a _mapping_ between rows of a SQL table and Python objects. There are tools that make this mapping concrete, called object-relation mapping (ORM) tools. These tools can connect to databases and allow us to treat relations in the database as Python objects. This can be very useful for annotating SQL relations with global constants (such as an important date) and routine functions for analysis. It also allows for seamless integration of database relations into applications as fully-fledged Python objects.\n",
    "\n",
    "We will use an ORM tool called `SQLAlchemy` to build a database from our example above, complete with not only the attributes of each object but also the reporting functions such as `check_health()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlalchemy as sql # this is not conventional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will follow the analogy of classes and tables; to create a table in our database, we declare a class. Our classes will inherit from a special base class that hooks into `SQLAlchemy`. **Be warned**, there's a lot going on in these class definitions and they will look different from other class definitions in order to support SQL operations. Looking below we'll notice several patterns:\n",
    "\n",
    "1. All classes inherit from Base, possibly through other classes\n",
    "1. All classes are associated with a SQL table via a `__tablename__` variable\n",
    "1. There is no `__init__` method for initializing attributes; instead attributes are declared as variables of the type `sql.Column`\n",
    "1. The attributes are typed; below we use the types `sql.Integer` and `sql.String`\n",
    "1. All classes contain at least one `primary_key`\n",
    "1. Relationships between classes/tables are accomplished through use of `sql.orm.relationship` and `sql.ForeignKey`\n",
    "\n",
    "Some relationships managed by inheritance. Just as before, since `Manager` inherits from `Employee`, we don't need to add columns for production, name, salary, etc. At a SQL level, there is a `managers` table with `idn` and `capacity` columns that gets joined to the `employees` table (by `idn`) any time we want to know a manager's name (or production, or salary, etc.). This helps the SQL backend follow good database design principles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy.ext.declarative import declarative_base\n",
    "from sqlalchemy.ext.hybrid import hybrid_property, hybrid_method\n",
    "\n",
    "Base = declarative_base()\n",
    "\n",
    "class Team(Base):\n",
    "    __tablename__ = 'teams'\n",
    "\n",
    "    idn = sql.Column(sql.Integer, primary_key=True)\n",
    "    name = sql.Column(sql.String)\n",
    "\n",
    "    members = sql.orm.relationship(\n",
    "        'Employee',\n",
    "        back_populates='team',\n",
    "        cascade='all, delete-orphan')\n",
    "\n",
    "    @hybrid_property\n",
    "    def manager(self):\n",
    "        for member in self.members:\n",
    "            if isinstance(member, Manager):\n",
    "                return member\n",
    "        return None\n",
    "    \n",
    "    @hybrid_property\n",
    "    def healthy(self):\n",
    "        num_members = len(self.members)\n",
    "        if len(self.members) > 0 and self.manager is None:\n",
    "            return False\n",
    "        elif self.manager is not None:\n",
    "            if self.manager.can_manage(num_members - 1):\n",
    "                return True\n",
    "            else:\n",
    "                return False\n",
    "        else:\n",
    "            return True\n",
    "\n",
    "    @hybrid_property\n",
    "    def production(self):\n",
    "        return sum(member.production for member in self.members)\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Team(idn={}, name={})'.format(self.idn, self.name)\n",
    "\n",
    "\n",
    "class Employee(Base):\n",
    "    __tablename__ = 'employees'\n",
    "\n",
    "    idn = sql.Column(sql.Integer, primary_key=True)\n",
    "    name = sql.Column(sql.String)\n",
    "    age = sql.Column(sql.Integer)\n",
    "    production = sql.Column(sql.Integer)\n",
    "    team_idn = sql.Column(sql.ForeignKey('teams.idn'))\n",
    "    salary_amt = sql.Column(sql.Integer)\n",
    "    salary_period = sql.Column(sql.Integer)\n",
    "    degree_level = sql.Column(sql.String)\n",
    "    degree_area = sql.Column(sql.String)\n",
    "    employee_type = sql.Column(sql.String)\n",
    "    \n",
    "    team = sql.orm.relationship('Team', back_populates='members')\n",
    "\n",
    "    __mapper_args__ = {\n",
    "        'polymorphic_identity': 'employee',\n",
    "        'polymorphic_on': employee_type\n",
    "    }\n",
    "\n",
    "    @hybrid_property\n",
    "    def salary(self):\n",
    "        return self.salary_amt * self.salary_period\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Employee(idn={}, name={}, age={}, production={}, team_idn={}, salary_amt={}, salary_period={}, degree_level={}, degree_area={}, employee_type={})'.format(self.idn, self.name, self.age, self.production, self.team_idn, self.salary_amt, self.salary_period, self.degree_level, self.degree_area, self.employee_type)\n",
    "\n",
    "\n",
    "class Manager(Employee):\n",
    "    __tablename__ = 'managers'\n",
    "    \n",
    "    idn = sql.Column(sql.ForeignKey('employees.idn'), primary_key=True)\n",
    "    capacity = sql.Column(sql.Integer)\n",
    "\n",
    "    __mapper_args__ = {\n",
    "        'polymorphic_identity': 'manager',\n",
    "    }\n",
    "\n",
    "    @hybrid_method\n",
    "    def can_manage(self, n):\n",
    "        return n <= self.capacity\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Employee(idn={}, age={}, production={}, team_idn={}, employee_type={})'.format(self.idn, self.age,\n",
    "                                                                                                        self.production, self.team_idn,\n",
    "                                                                                                        self.employee_type, self.capacity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `@hybrid_method` and `@hybrid_attribute` decorators are where `SQLAlchemy` starts to help us. Often we will be interested in some combination of attributes in a table. For instance, we might want to know an employee's annual salary. We can calculate this as their salary per pay period times the number of pay periods in the year. Rather than store the annual salary in the table (which would be redundant), we can tell `SQLAlchemy` to calculate this on the fly and treat it as an attribute. This way, I can interact with attributes of my objects in the same way whether they are actually stored in the underlying database or not. This can be particularly useful when the attribute has a complex definition.\n",
    "\n",
    "Let's see `SQLAlchemy` in action. We'll create an `engine` that will manage database connections. The `echo=True` keyword will show us all the SQL that get's executed as we interact with `SQLAlchemy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "engine = sql.create_engine('sqlite:///company.db', echo=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will then prepare the database by creating all the tables that inherit from `Base`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Base.metadata.create_all(engine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will create a `Session` object which performs the object-relation mapping, i.e. the `Session` object is responsible for translating our actions with the objects we defined above into SQL, which can then be passed to the database through the `engine`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "session = sql.orm.Session(engine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's create our data and add it to the database."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Salaries\n",
    "periods = {'weekly': 52.0,\n",
    "           'biweekly': 26.0,\n",
    "           'monthly': 12,\n",
    "           'quarterly': 4.0,\n",
    "           'annually':1.0}\n",
    "\n",
    "low_salary = dict(salary_amt=1800, salary_period=periods['biweekly'])\n",
    "mid_salary = dict(salary_amt=5600, salary_period=periods['biweekly'])\n",
    "high_salary = dict(salary_amt=100000, salary_period=periods['annually'])\n",
    "\n",
    "# Degrees\n",
    "b_business = dict(degree_level='bachelors', degree_area='business')\n",
    "m_math = dict(degree_level='masters', degree_area='mathematics')\n",
    "b_finance = dict(degree_level='bachelors', degree_area='finance')\n",
    "b_physics = dict(degree_level='bachelors', degree_area='physics')\n",
    "p_math = dict(degree_level='phd', degree_area='mathematics')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cat_dict(*args):\n",
    "    all_keys = [key for dictionary in args for key in dictionary.keys()]\n",
    "    if len(set(all_keys)) < len(all_keys):\n",
    "        raise ValueError(\"Keys are not unique!\")\n",
    "    return {k: v for dictionary in args for k, v in dictionary.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Employees\n",
    "fred = Employee(name='Fred', production=120000, age=28, **cat_dict(low_salary, b_business))\n",
    "amy = Employee(name='Amy', production=136000, age=29, **cat_dict(low_salary, b_finance))\n",
    "erica = Employee(name='Erica', production=140000, age=47, **cat_dict(mid_salary, b_physics))\n",
    "jerry = Employee(name='Jerry', production=165000, age=45, **cat_dict(mid_salary, b_business))\n",
    "sam = Employee(name='Sam', production=127000, age=35, **cat_dict(low_salary, b_finance))\n",
    "danny = Employee(name='Danny', production=128000, age=32, **cat_dict(low_salary, m_math))\n",
    "carrie = Employee(name='Carrie', production=120000, age=39, **cat_dict(low_salary, m_math))\n",
    "\n",
    "# Managers\n",
    "sally = Manager(capacity=5, production=131000, name=\"Sally\", age=50, **cat_dict(mid_salary, b_business))\n",
    "arnold = Manager(capacity=10, production=125000, name=\"Arnold\", age=60, **cat_dict(mid_salary, m_math))\n",
    "molly = Manager(capacity=10, production=180000, name=\"Molly\", age=62, **cat_dict(high_salary, p_math))\n",
    "\n",
    "# Teams\n",
    "tech = Team(name='tech', members=[fred, amy, carrie, sally])\n",
    "sales = Team(name='sales', members=[erica, jerry, sam, danny, arnold])\n",
    "executive = Team(name='executive', members=[molly])\n",
    "\n",
    "# add the teams to the database; this also adds all attached objects\n",
    "session.add(tech)\n",
    "session.add(sales)\n",
    "session.add(executive)\n",
    "\n",
    "# commit the changes\n",
    "session.commit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can still interact with the objects we've created as Python objects...\n",
    "tech.members"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or as SQL relations via the session\n",
    "q = session.query(Team).filter(Team.name=='tech')\n",
    "\n",
    "for team in q:\n",
    "    for member in team.members:\n",
    "        print member"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a hybrid_attribute behaves just like a regular attribute\n",
    "# even though it is not actually stored in the database or the object\n",
    "print tech.production\n",
    "print tech.healthy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `query` method of our session, we can perform all our usual SQL operations: filtering, joining, aggregating, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_employees = session.query(Employee).filter(Employee.name.like('A%'))\n",
    "for a in a_employees:\n",
    "    print a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for total in session.query(Team.name, sql.func.sum(Employee.salary)).join(Employee.team).group_by(Team.name):\n",
    "    print total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Copyright &copy; 2018 The Data Incubator.  All rights reserved.*"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "datacourse"
  },
  "nbclean": true
 },
 "nbformat": 4,
 "nbformat_minor": 0
}