hw5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Objects Homework"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###   `__repr__`  vs  `__str__`\n",
    "\n",
    "The way printing works is that Python wants classes to implement a `__repr__` and a `__str__` method. It will use inheritance to give the built-in `object`'s `__repr__` and `__str__` methods when these are not defined...but any class can define these. When an *instance* of such a class is interrogated with the `repr` or `str` function, then these underlying methods are called.\n",
    "\n",
    "Rules used (see http://stackoverflow.com/questions/1436703/difference-between-str-and-repr-in-python):\n",
    "\n",
    "- if you override `__repr__`, that's ALSO used for `__str__`, but not vice versa\n",
    "- `__str__` on a built-on container uses the contained objects `__repr__`\n",
    "\n",
    "Some advice on this I found useful:\n",
    "\n",
    "- From Alex Martelli: \n",
    ">So, my advice: focus on making __str__ reasonably human-readable, and __repr__ as unambiguous as you possibly can.\n",
    "\n",
    "From SO:\n",
    ">This means, in simple terms: almost every object you implement should have a functional __repr__ that’s usable for understanding the object. Implementing __str__ is optional: do that if you need a “pretty print” functionality\n",
    "\n",
    "Usually people will have the repr print out a constructor form. Ned Batchelder:\n",
    ">My rule of thumb:  __repr__ is for developers, __str__ is for customers.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. `__str__`\n",
    "\n",
    "Implement `__str__` for `class Animal` below to simply print \"Animal Jane\" for an Animal with name Jane. Keep your code as general as possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Animal():\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name=name\n",
    "\n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return \"%s(name=%r)\" % (class_name, self.name)\n",
    "    \n",
    "    #your code here\n",
    "    def __str__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return \"%s name = %s\" % (class_name, self.name)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A=Animal(\"Tom\")\n",
    "B=Animal(\"Jane\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Animal(name='Jane')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B#the ipython REPL uses __repr__ even if __str__ is defined "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal name = Jane\n"
     ]
    }
   ],
   "source": [
    "print(B)#printing uses __str__ if u defined it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal name = Jane\n",
      "Animal(name='Jane')\n"
     ]
    }
   ],
   "source": [
    "print(str(B)) # uses __str__ if u defined it else __repr__\n",
    "print(repr(B)) # uses __repr__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that printing things in a list uses the item's `__repr__`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Animal(name='Tom'), Animal(name='Jane')]\n"
     ]
    }
   ],
   "source": [
    "print([A, B])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import reprlib #reprlib.repr provides small size representations of object strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"[Animal(name='Tom'), Animal(name='Tom'), Animal(name='Tom'), Animal(name='Tom'), Animal(name='Tom'), Animal(name='Tom'), ...]\""
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reprlib.repr([A]*50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Properties, Descriptors, and Setters\n",
    "\n",
    "Our earlier `ComplexClass` gave direct access to both the `real` and `imaginary` parts of the complex number. But lets say we wanted to build a strange complex number which did not allow you to change the imaginary part of a complex number. We then use properties to \"encapsulate\" the actual values of the complex number. There is a `@property` decorator that does this for us. Its actually instantiates a class for us which is something called a `descriptor`, but that is a story for later. Currently we just treat it as a black box."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class ComplexClass():\n",
    "    \n",
    "    def __init__(self, a, b):\n",
    "        self.__real = a\n",
    "        self.__imaginary = b\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return \"%s(real=%r, imaginary=%r)\" % (class_name, self.__real, self.__imaginary)\n",
    "    \n",
    "    @property\n",
    "    def real(self):\n",
    "        return self.__real\n",
    "    \n",
    "    @real.setter\n",
    "    def real(self, value=None):\n",
    "        if value:\n",
    "            self.__real=value\n",
    "            \n",
    "    @property\n",
    "    def imaginary(self):\n",
    "        return self.__imaginary\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1 = ComplexClass(1,2)\n",
    "c1.real, c1.imaginary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that I can change the value of the real part and make it read-only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c1.real = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But I cannot change the value of the imaginary part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-12-57b57c76fb71>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mc1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimaginary\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "c1.imaginary = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q2. Add a class method\n",
    "\n",
    "Implement a class method `make_complex` that takes two arguments and constructs a complex number for us. Rewrite the class definition above with this method.\n",
    "\n",
    "Also add a `__str__` method to print out complex numbers in the usual form `1+2i`.\n",
    "\n",
    "Test (informally) that both your methods work (ie just show us examples)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#your code here\n",
    "\n",
    "class ComplexClass(object):\n",
    "    def __init__(self, a, b):\n",
    "        self.__real = a\n",
    "        self.__imaginary = b  \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return \"%s(real=%r, imaginary=%r)\" % (class_name, self.__real, self.__imaginary)    \n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"%d + %di\" % (self.__real, self.__imaginary)\n",
    "    \n",
    "    @classmethod\n",
    "    def make_complex(cls, a, b):\n",
    "        return cls(a, b)\n",
    "    \n",
    "    @property\n",
    "    def real(self):\n",
    "        return self.__real\n",
    "    \n",
    "    @real.setter\n",
    "    def real(self, value=None):\n",
    "        if value:\n",
    "            self.__real=value\n",
    "            \n",
    "    @property\n",
    "    def imaginary(self):\n",
    "        return self.__imaginary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 + 2i\n"
     ]
    }
   ],
   "source": [
    "# your code here\n",
    "c2 = ComplexClass.make_complex(1, 2)\n",
    "print(c2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ComplexClass(real=1, imaginary=2)'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# your code here\n",
    "repr(c2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that python marginally obfuscates variables with two leading underscores. But where are our properties?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'_ComplexClass__imaginary': 2, '_ComplexClass__real': 5}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(c1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tells us a bit about lookup with properties. When you do instance.attribute for something marked as a property, it is first looked up in instance.__class__ and only then in the instance specific dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'imaginary': <property object at 0x106411b38>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'ComplexClass' objects>, '__doc__': None, 'real': <property object at 0x106411b88>, '__init__': <function ComplexClass.__init__ at 0x106414598>, '__dict__': <attribute '__dict__' of 'ComplexClass' objects>, '__repr__': <function ComplexClass.__repr__ at 0x1064146a8>})"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(type(c1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The usual way in Python is exactly the reverse, a variable called as `self.x` is first looked up in the instance dictionary, and only then in the class dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A sequence for light curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#Field Tile Seq RA(hour) Dec(deg) Filter mean_Mag med_Mag mean_(B-R) med_(B-R)\r\n",
      "#1 3441 15 5.03111 -69.3896 B -9.765 -9.748 0.219 0.243\r\n",
      "#MJD Mag Err\r\n",
      "48823.477419 -9.332 0.012\r\n",
      "48823.487014 -9.396 0.01\r\n"
     ]
    }
   ],
   "source": [
    "!head -5 ./data/CEPH/lc_1.3441.15.B.mjd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def lc_reader(filename):\n",
    "    lclist=[]\n",
    "    with open(filename) as fp:\n",
    "        for line in fp:\n",
    "            if line.find('#')!=0:\n",
    "                lclist.append([float(f) for f in line.strip().split()])\n",
    "    return lclist\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[48823.477419, -9.332, 0.012],\n",
       " [48823.487014, -9.396, 0.01],\n",
       " [48823.496759, -9.358, 0.011],\n",
       " [48824.458206, -9.333, 0.003],\n",
       " [48824.467697, -9.333, 0.003]]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eg = lc_reader(\"./data/CEPH/lc_1.3441.15.B.mjd\")\n",
    "eg[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAt4AAAEACAYAAACESHGdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSAtQeBNCCCGEENIC/z897EY5xVJFHAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10641fac8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(12,4))\n",
    "plt.plot([x[0] for x in eg], [x[1] for x in eg],'.');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q3. Reader with metadata\n",
    "\n",
    "The first two lines of the file, after the `#` have facet names and facet values. These are in the same order and space separated. Change `lc_reader` ro parse these lines as well, returning both the list of list of values we had earlier, and a second dictionary of facetnames and facetvalues. (that is you will return a tuple `listoflist_of values, dict_of_facets`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "\n",
    "def lc_reader(filename):\n",
    "    lclist=[]\n",
    "    meta_data = []\n",
    "    with open(filename) as fp:\n",
    "        for line in fp:\n",
    "            if line.find('#')!=0:\n",
    "                lclist.append([float(f) for f in line.strip().split()])\n",
    "            else:\n",
    "                #read and store the sentences begin with '#'\n",
    "                temp = [f for f in line.strip().split()]\n",
    "                temp[0]=temp[0][1:]\n",
    "                meta_data.append(temp)\n",
    "    #parse the first two meaningful lines, facet names and facet values\n",
    "    facets_dict = dict(zip(meta_data[0], meta_data[1]))\n",
    "    return lclist, facets_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use your definition above to write a `LightCurve` class with a class method that reads the light curve from a file. \n",
    "\n",
    "### Q4. A Light Curve Class with properties\n",
    "\n",
    "Since data in a light-curve is read-once, we use properties to prevent any changes to the data. Add to the light curve class below read-only properties `time`, `amplitude` which correspond to `_time` and `_amplitude`, and also a read-only property `timeseries` which `zips` (see the documentation for `zip`) these together. Notice how `self.timeseries` is used in `__repr__` below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import itertools\n",
    "class LightCurve:\n",
    "    \n",
    "    def __init__(self, data, metadict):\n",
    "        self._time = [x[0] for x in data]\n",
    "        self._amplitude = [x[1] for x in data]\n",
    "        self._error = [x[2] for x in data]\n",
    "        self.metadata = metadict\n",
    "        self.filename = None\n",
    "        #add _timeseries \n",
    "        self._timeseries = list(zip(self._time, self._amplitude))\n",
    "    \n",
    "    @classmethod\n",
    "    def from_file(cls, filename):\n",
    "        lclist, metadict = lc_reader(filename)\n",
    "        instance = cls(lclist, metadict)\n",
    "        instance.filename = filename\n",
    "        return instance\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        components = reprlib.repr(list(itertools.islice(self.timeseries,0,10)))\n",
    "        components = components[components.find('['):]\n",
    "        return '{}({})'.format(class_name, components)        \n",
    "        \n",
    "    #your code here\n",
    "    @property\n",
    "    def time(self):\n",
    "        return self._time\n",
    "    \n",
    "    @property\n",
    "    def amplitude(self):\n",
    "        return self._amplitude\n",
    "    \n",
    "    # already add _timeseries in __init__\n",
    "    @property\n",
    "    def timeseries(self):\n",
    "        return self._timeseries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-1f713a4912e5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLightCurve\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_file\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./data/CEPH/lc_1.3441.15.B.mjd\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "l = LightCurve.from_file(\"./data/CEPH/lc_1.3441.15.B.mjd\")\n",
    "l\n",
    "l.time = [1,2,3,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q5. Make LightCurve a sequence\n",
    "\n",
    "But our Lightcurves class is not a sequence yet! It implements none of the sequence protocol. The `__repr__` above makes it look like one, but its your job to make it one! (Hint: use `self._time` and `self._amplitude` directly. Otherwise you will change the complexity of indexing...why is this? Read on how `zip` operates.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#your code here\n",
    "import itertools\n",
    "class LightCurve:\n",
    "    \n",
    "    def __init__(self, data, metadict):\n",
    "        self._time = [x[0] for x in data]\n",
    "        self._amplitude = [x[1] for x in data]\n",
    "        self._error = [x[2] for x in data]\n",
    "        self.metadata = metadict\n",
    "        self.filename = None\n",
    "        #add _timeseries \n",
    "        self._timeseries = list(zip(self._time, self._amplitude))\n",
    "    \n",
    "    @classmethod\n",
    "    def from_file(cls, filename):\n",
    "        lclist, metadict = lc_reader(filename)\n",
    "        instance = cls(lclist, metadict)\n",
    "        instance.filename = filename\n",
    "        return instance\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        components = reprlib.repr(list(itertools.islice(self.timeseries,0,10)))\n",
    "        components = components[components.find('['):]\n",
    "        return '{}({})'.format(class_name, components)        \n",
    "    \n",
    "    #add sequence protocol\n",
    "    def __getitem__(self, pos):\n",
    "        return self._timeseries[pos]\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self._timeseries)\n",
    "        \n",
    "    @property\n",
    "    def time(self):\n",
    "        return self._time\n",
    "    \n",
    "    @property\n",
    "    def amplitude(self):\n",
    "        return self._amplitude\n",
    "    \n",
    "    # already add _timeseries in __init__\n",
    "    @property\n",
    "    def timeseries(self):\n",
    "        return self._timeseries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LightCurve([(48823.477419, -9.332), (48823.487014, -9.396), (48823.496759, -9.358), (48824.458206, -9.333), (48824.467697, -9.333), (48824.477639, -9.349), ...])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l2 = LightCurve.from_file(\"./data/CEPH/lc_1.3441.15.B.mjd\")\n",
    "l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1233"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(48974.325278, -10.251)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l2[100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(48823.487014, -9.396), (48823.496759, -9.358)]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l2[1:3]# this will be not quite what we want given our __repr__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason for the above not being quite the result we expect is because we dont yet know how Python handles slices. We shall do this next week!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A database for light curves\n",
    "\n",
    "We now write a small little database class whose game is to read all light curves from a directory, store them in memory and construct an \"index\" on the field, tile, and color that these light-curves have.\n",
    "\n",
    "A light curve filename of the form `lc_1.3441.15.B.mjd` means that this data has `field` 1, `tile` 3441, `sequence` 15, and `color` 'B'. We'll parse the filenames below and store the indexed in internal attributes such as `self._field_index`. Note the use of `defaultdict` instead of a regular dictionary (look it up). Are we duplicating Light Curve objects in these indices?\n",
    "\n",
    "### Q6. \n",
    "\n",
    "Write a method `def retrieve(self, facet, value)` which retrieves a list of Light Curves corresponding to the given value of the facet. (like say facet is tile and value is 4661)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from collections import defaultdict\n",
    "class LightCurveDB:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self._collection={}\n",
    "        self._field_index=defaultdict(list)\n",
    "        self._tile_index=defaultdict(list)\n",
    "        self._color_index=defaultdict(list)\n",
    "    \n",
    "    def populate(self, folder):\n",
    "        for root,dirs,files in os.walk(folder): # DEPTH 1 ONLY\n",
    "            for file in files:\n",
    "                if file.find('.mjd')!=-1:\n",
    "                    the_path = root+\"/\"+file\n",
    "                    self._collection[file] = LightCurve.from_file(the_path)\n",
    "    \n",
    "    def index(self):\n",
    "        for f in self._collection:\n",
    "            lc, tilestring, seq, color, _ = f.split('.')\n",
    "            field = int(lc.split('_')[-1])\n",
    "            tile = int(tilestring)\n",
    "            self._field_index[field].append(self._collection[f])\n",
    "            self._tile_index[tile].append(self._collection[f])\n",
    "            self._color_index[color].append(self._collection[f])\n",
    "     \n",
    "    #different facets accoring the index type in _init_\n",
    "    def retrieve(self, facet, value):\n",
    "        if facet == 'tile':\n",
    "            return self._tile_index[value]\n",
    "        elif facet == 'field':\n",
    "            return self._field_index[value]\n",
    "        elif facet == 'color':\n",
    "            return self._color_index[value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ldb = LightCurveDB()\n",
    "ldb.populate(\"./data/CEPH\")\n",
    "ldb.index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[LightCurve([(48984.446505, -9.979), (48985.497512, -9.903), (48987.465058, -9.65), (48988.469595, -9.613), (48996.486991, -9.997), (48998.445995, -9.787), ...]),\n",
       " LightCurve([(48823.487014, -9.441), (48824.458206, -9.657), (48824.467697, -9.648), (48824.477639, -9.636), (48825.483183, -9.784), (48825.492847, -9.786), ...])]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ldb.retrieve('tile', 4661) # do this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q7. Module-arity\n",
    "\n",
    "Put your `lc_reader`, and `LightCurve` and `LightCurveDB` classes in a module: a separate file, named lc.py. Organize the imports at the top. The following code should then work here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import lc\n",
    "ldb2 = lc.LightCurveDB()\n",
    "ldb2.populate(\"./data/CEPH\")\n",
    "ldb2.index()\n",
    "#ldb2.retrieve('tile', 4661)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[LightCurve([(48984.446505, -9.979), (48985.497512, -9.903), (48987.465058, -9.65), (48988.469595, -9.613), (48996.486991, -9.997), (48998.445995, -9.787), ...]),\n",
       " LightCurve([(48823.487014, -9.441), (48824.458206, -9.657), (48824.467697, -9.648), (48824.477639, -9.636), (48825.483183, -9.784), (48825.492847, -9.786), ...])]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ldb2.retrieve('tile', 4661)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}