Instruction:
Can you generate the documentation for the following Python 3 function
def Statistics(season=None, clobber=False, model='nPLD', injection=False,
               compare_to='kepler', plot=True, cadence='lc', planets=False,
               **kwargs):
    '''
    Computes and plots the CDPP statistics comparison between `model`
    and `compare_to` for all long cadence light curves in a given campaign

    :param season: The campaign number or list of campaign numbers. \
           Default is to plot all campaigns
    :param bool clobber: Overwrite existing files? Default :py:obj:`False`
    :param str model: The :py:obj:`everest` model name
    :param str compare_to: The :py:obj:`everest` model name or other \
           K2 pipeline name
    :param bool plot: Default :py:obj:`True`
    :param bool injection: Statistics for injection tests? Default \
           :py:obj:`False`
    :param bool planets: Statistics for known K2 planets? \
           Default :py:obj:`False`

    '''

    # Multi-mission compatibility
    campaign = season

    # Is this short cadence?
    if cadence == 'sc':
        return ShortCadenceStatistics(campaign=campaign, clobber=clobber,
                                      model=model, plot=plot, **kwargs)

    # Check the campaign
    if campaign is None:
        campaign = 0

    # Planet hosts only?
    if planets:
        return PlanetStatistics(model=model, compare_to=compare_to, **kwargs)

    # Is this an injection run?
    if injection:
        return InjectionStatistics(campaign=campaign, clobber=clobber,
                                   model=model, plot=plot, **kwargs)

    # Compute the statistics
    sub = np.array([s[0] for s in GetK2Campaign(campaign)], dtype=int)
    outfile = os.path.join(EVEREST_SRC, 'missions', 'k2',
                           'tables', 'c%02d_%s.cdpp' % (int(campaign), model))
    if clobber or not os.path.exists(outfile):
        with open(outfile, 'w') as f:
            print("EPIC               Kp           Raw CDPP     Everest CDPP" +
                  "      Validation        Outliers[1]     Outliers[2]     " +
                  "Datapoints     Saturated", file=f)
            print("---------          ------       ---------    ------------" +
                  "      ----------        -----------     -----------     " +
                  "----------     ---------", file=f)
            all = GetK2Campaign(int(campaign))
            stars = np.array([s[0] for s in all], dtype=int)
            kpmgs = np.array([s[1] for s in all], dtype=float)
            for i, _ in enumerate(stars):
                sys.stdout.write('\rProcessing target %d/%d...' %
                                 (i + 1, len(stars)))
                sys.stdout.flush()
                nf = os.path.join(EVEREST_DAT, 'k2', 'c%02d' % campaign,
                                  ('%09d' % stars[i])[:4] + '00000',
                                  ('%09d' % stars[i])[4:], model + '.npz')
                try:
                    data = np.load(nf)

                    # Remove NaNs and flagged cadences
                    flux = np.delete(data['fraw'] - data['model'], np.array(
                        list(set(np.concatenate([data['nanmask'],
                                                 data['badmask']])))))
                    # Iterative sigma clipping to get 5 sigma outliers
                    inds = np.array([], dtype=int)
                    m = 1
                    while len(inds) < m:
                        m = len(inds)
                        ff = SavGol(np.delete(flux, inds))
                        med = np.nanmedian(ff)
                        MAD = 1.4826 * np.nanmedian(np.abs(ff - med))
                        inds = np.append(inds, np.where(
                            (ff > med + 5. * MAD) | (ff < med - 5. * MAD))[0])
                    nout = len(inds)
                    ntot = len(flux)

                    # HACK: Backwards compatibility fix
                    try:
                        cdpp = data['cdpp'][()]
                    except KeyError:
                        cdpp = data['cdpp6'][()]

                    print("{:>09d} {:>15.3f} {:>15.3f} {:>15.3f} {:>15.3f} {:>15d} {:>15d} {:>15d} {:>15d}".format(
                          stars[i], kpmgs[i], data['cdppr'][()], cdpp,
                          data['cdppv'][()], len(data['outmask']), nout,
                          ntot, int(data['saturated'])), file=f)
                except:
                    print("{:>09d} {:>15.3f} {:>15.3f} {:>15.3f} {:>15.3f} {:>15d} {:>15d} {:>15d} {:>15d}".format(
                          stars[i], kpmgs[i], np.nan, np.nan,
                          np.nan, 0, 0, 0, 0), file=f)
            print("")

    if plot:

        # Load all stars
        epic, kp, cdpp6r, cdpp6, cdpp6v, _, out, tot, saturated = np.loadtxt(
            outfile, unpack=True, skiprows=2)
        epic = np.array(epic, dtype=int)
        out = np.array(out, dtype=int)
        tot = np.array(tot, dtype=int)
        saturated = np.array(saturated, dtype=int)

        # Get only stars in this subcampaign
        inds = np.array([e in sub for e in epic])
        epic = epic[inds]
        kp = kp[inds]
        # HACK: Campaign 0 magnitudes are reported only to the nearest tenth,
        # so let's add a little noise to spread them out for nicer plotting
        kp = kp + 0.1 * (0.5 - np.random.random(len(kp)))
        cdpp6r = cdpp6r[inds]
        cdpp6 = cdpp6[inds]
        cdpp6v = cdpp6v[inds]
        out = out[inds]
        tot = tot[inds]
        saturated = saturated[inds]
        sat = np.where(saturated == 1)
        unsat = np.where(saturated == 0)
        if not np.any([not np.isnan(x) for x in cdpp6]):
            raise Exception("No targets to plot.")

        # Control transparency
        alpha_kepler = 0.03
        alpha_unsat = min(0.1, 2000. / (1 + len(unsat[0])))
        alpha_sat = min(1., 180. / (1 + len(sat[0])))

        # Get the comparison model stats
        if compare_to.lower() == 'everest1':
            epic_1, cdpp6_1 = np.loadtxt(
                              os.path.join(EVEREST_SRC, 'missions', 'k2',
                                           'tables', 'c%02d_everest1.cdpp'
                                           % int(campaign)), unpack=True)
            cdpp6_1 = sort_like(cdpp6_1, epic, epic_1)
            # Outliers
            epic_1, out_1, tot_1 = np.loadtxt(
                                   os.path.join(EVEREST_SRC, 'missions', 'k2',
                                                'tables', 'c%02d_everest1.out'
                                                % int(campaign)), unpack=True)
            out_1 = sort_like(out_1, epic, epic_1)
            tot_1 = sort_like(tot_1, epic, epic_1)
        elif compare_to.lower() == 'k2sc':
            epic_1, cdpp6_1 = np.loadtxt(
                              os.path.join(EVEREST_SRC, 'missions', 'k2',
                                           'tables', 'c%02d_k2sc.cdpp' %
                                           int(campaign)), unpack=True)
            cdpp6_1 = sort_like(cdpp6_1, epic, epic_1)
            # Outliers
            epic_1, out_1, tot_1 = np.loadtxt(
                                   os.path.join(EVEREST_SRC, 'missions', 'k2',
                                                'tables', 'c%02d_k2sc.out'
                                                % int(campaign)), unpack=True)
            out_1 = sort_like(out_1, epic, epic_1)
            tot_1 = sort_like(tot_1, epic, epic_1)
        elif compare_to.lower() == 'k2sff':
            epic_1, cdpp6_1 = np.loadtxt(
                              os.path.join(EVEREST_SRC, 'missions', 'k2',
                                           'tables', 'c%02d_k2sff.cdpp'
                                           % int(campaign)), unpack=True)
            cdpp6_1 = sort_like(cdpp6_1, epic, epic_1)
            # Outliers
            epic_1, out_1, tot_1 = np.loadtxt(
                                   os.path.join(EVEREST_SRC, 'missions', 'k2',
                                                'tables', 'c%02d_k2sff.out'
                                                % int(campaign)), unpack=True)
            out_1 = sort_like(out_1, epic, epic_1)
            tot_1 = sort_like(tot_1, epic, epic_1)
        elif compare_to.lower() == 'kepler':
            kic, kepler_kp, kepler_cdpp6 = np.loadtxt(
                                           os.path.join(EVEREST_SRC,
                                                        'missions', 'k2',
                                                        'tables',
                                                        'kepler.cdpp'),
                                           unpack=True)
        else:
            compfile = os.path.join(EVEREST_SRC, 'missions', 'k2',
                                    'tables', 'c%02d_%s.cdpp' %
                                    (int(campaign), compare_to))

            epic_1, _, _, cdpp6_1, _, _, out_1, tot_1, saturated = np.loadtxt(
                compfile, unpack=True, skiprows=2)
            epic_1 = np.array(epic_1, dtype=int)
            inds = np.array([e in sub for e in epic_1])
            epic_1 = epic_1[inds]
            cdpp6_1 = cdpp6_1[inds]
            out_1 = out_1[inds]
            tot_1 = tot_1[inds]
            cdpp6_1 = sort_like(cdpp6_1, epic, epic_1)
            out_1 = sort_like(out_1, epic, epic_1)
            tot_1 = sort_like(tot_1, epic, epic_1)

        # ------ 1. Plot cdpp vs. mag
        if compare_to.lower() != 'kepler':
            fig = pl.figure(figsize=(16, 5))
            ax = [pl.subplot2grid((120, 120), (0,  0), colspan=35,
                                  rowspan=120),
                  pl.subplot2grid((120, 120), (0,  40),
                                  colspan=35, rowspan=120),
                  pl.subplot2grid((120, 120), (0,  80),
                                  colspan=35, rowspan=55),
                  pl.subplot2grid((120, 120), (65,  80), colspan=35,
                                  rowspan=55)]
        else:
            fig = pl.figure(figsize=(12, 5))
            ax = [pl.subplot2grid((120, 75), (0,  0), colspan=35, rowspan=120),
                  None,
                  pl.subplot2grid((120, 75), (0,  40), colspan=35, rowspan=55),
                  pl.subplot2grid((120, 75), (65,  40), colspan=35,
                                  rowspan=55)]
        fig.canvas.set_window_title(
            'K2 Campaign %s: %s versus %s' % (campaign, model, compare_to))
        fig.subplots_adjust(left=0.05, right=0.95, bottom=0.125, top=0.9)
        bins = np.arange(7.5, 18.5, 0.5)
        if compare_to.lower() != 'kepler':
            ax[0].scatter(kp[unsat], cdpp6_1[unsat], color='y',
                          marker='.', alpha=alpha_unsat)
            ax[0].scatter(kp[sat], cdpp6_1[sat], color='y',
                          marker='s', alpha=alpha_sat, s=5)
            ax[0].scatter(kp[unsat], cdpp6[unsat], color='b',
                          marker='.', alpha=alpha_unsat, picker=True)
            ax[0].scatter(kp[sat], cdpp6[sat], color='b',
                          marker='s', alpha=alpha_sat, s=5, picker=True)
            for y, style in zip([cdpp6_1, cdpp6], ['yo', 'bo']):
                by = np.zeros_like(bins) * np.nan
                for b, bin in enumerate(bins):
                    i = np.where((y > -np.inf) & (y < np.inf) &
                                 (kp >= bin - 0.5) & (kp < bin + 0.5))[0]
                    if len(i) > 10:
                        by[b] = np.median(y[i])
                ax[0].plot(bins, by, style, markeredgecolor='w')
        else:
            ax[0].scatter(kepler_kp, kepler_cdpp6, color='y',
                          marker='.', alpha=alpha_kepler)
            ax[0].scatter(kp, cdpp6, color='b', marker='.',
                          alpha=alpha_unsat, picker=True)
            for x, y, style in zip([kepler_kp, kp], [kepler_cdpp6, cdpp6],
                                   ['yo', 'bo']):
                by = np.zeros_like(bins) * np.nan
                for b, bin in enumerate(bins):
                    i = np.where((y > -np.inf) & (y < np.inf) &
                                 (x >= bin - 0.5) & (x < bin + 0.5))[0]
                    if len(i) > 10:
                        by[b] = np.median(y[i])
                ax[0].plot(bins, by, style, markeredgecolor='w')
        ax[0].set_ylim(-10, 500)
        ax[0].set_xlim(8, 18)
        ax[0].set_xlabel('Kepler Magnitude', fontsize=18)
        ax[0].set_title('CDPP6 (ppm)', fontsize=18)

        # ------ 2. Plot the equivalent of the Aigrain+16 figure
        if compare_to.lower() != 'kepler':
            x = kp
            y = (cdpp6 - cdpp6_1) / cdpp6_1
            yv = (cdpp6v - cdpp6_1) / cdpp6_1
            ax[1].scatter(x[unsat], y[unsat], color='b', marker='.',
                          alpha=alpha_unsat, zorder=-1, picker=True)
            ax[1].scatter(x[sat], y[sat], color='r', marker='.',
                          alpha=alpha_sat, zorder=-1, picker=True)
            ax[1].set_ylim(-1, 1)
            ax[1].set_xlim(8, 18)
            ax[1].axhline(0, color='gray', lw=2, zorder=-99, alpha=0.5)
            ax[1].axhline(0.5, color='gray', ls='--',
                          lw=2, zorder=-99, alpha=0.5)
            ax[1].axhline(-0.5, color='gray', ls='--',
                          lw=2, zorder=-99, alpha=0.5)
            bins = np.arange(7.5, 18.5, 0.5)
            # Bin the CDPP
            by = np.zeros_like(bins) * np.nan
            for b, bin in enumerate(bins):
                i = np.where((y > -np.inf) & (y < np.inf) &
                             (x >= bin - 0.5) & (x < bin + 0.5))[0]
                if len(i) > 10:
                    by[b] = np.median(y[i])
            ax[1].plot(bins[:9], by[:9], 'k--', lw=2)
            ax[1].plot(bins[8:], by[8:], 'k-', lw=2)
            ax[1].set_title(r'Relative CDPP', fontsize=18)
            ax[1].set_xlabel('Kepler Magnitude', fontsize=18)

        # ------ 3. Plot the outliers
        i = np.argsort(out)
        a = int(0.95 * len(out))
        omax = out[i][a]
        if compare_to.lower() != 'kepler':
            j = np.argsort(out_1)
            b = int(0.95 * len(out_1))
            omax = max(omax, out_1[j][b])
        ax[2].hist(out, 25, range=(0, omax), histtype='step', color='b')
        if compare_to.lower() != 'kepler':
            ax[2].hist(out_1, 25, range=(0, omax), histtype='step', color='y')
        ax[2].margins(0, None)
        ax[2].set_title('Number of Outliers', fontsize=18)

        # Plot the total number of data points
        i = np.argsort(tot)
        a = int(0.05 * len(tot))
        b = int(0.95 * len(tot))
        tmin = tot[i][a]
        tmax = tot[i][b]
        if compare_to.lower() != 'kepler':
            j = np.argsort(tot_1)
            c = int(0.05 * len(tot_1))
            d = int(0.95 * len(tot_1))
            tmin = min(tmin, tot_1[j][c])
            tmax = max(tmax, tot_1[j][d])
        ax[3].hist(tot, 25, range=(tmin, tmax), histtype='step', color='b')
        if compare_to.lower() != 'kepler':
            ax[3].hist(tot_1, 25, range=(tmin, tmax),
                       histtype='step', color='y')
        ax[3].margins(0, None)
        ax[3].set_xlabel('Number of Data Points', fontsize=18)

        # Pickable points
        Picker = StatsPicker([ax[0], ax[1]], [kp, kp], [
                             cdpp6, y], epic, model=model,
                             compare_to=compare_to, campaign=campaign)
        fig.canvas.mpl_connect('pick_event', Picker)

        # Show
        pl.show()

Response: Compute the CDPP statistics for all long cadence light curves in a given season.


Instruction:
Can you tell what is the following Python 3 function doing
def HasShortCadence(EPIC, season=None):
    '''
    Returns `True` if short cadence data is available for this target.

    :param int EPIC: The EPIC ID number
    :param int season: The campaign number. Default :py:obj:`None`

    '''

    if season is None:
        season = Campaign(EPIC)
        if season is None:
            return None
    stars = GetK2Campaign(season)
    i = np.where([s[0] == EPIC for s in stars])[0]
    if len(i):
        return stars[i[0]][3]
    else:
        return None

Response: Returns True if short cadence data is available for this target.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def InjectionStatistics(campaign=0, clobber=False, model='nPLD', plot=True,
                        show=True, **kwargs):
    '''
    Computes and plots the statistics for injection/recovery tests.

    :param int campaign: The campaign number. Default 0
    :param str model: The :py:obj:`everest` model name
    :param bool plot: Default :py:obj:`True`
    :param bool show: Show the plot? Default :py:obj:`True`. \
           If :py:obj:`False`, returns the `fig, ax` instances.
    :param bool clobber: Overwrite existing files? Default :py:obj:`False`

    '''

    # Compute the statistics
    stars = GetK2Campaign(campaign, epics_only=True)
    if type(campaign) is int:
        outfile = os.path.join(EVEREST_SRC, 'missions', 'k2',
                               'tables', 'c%02d_%s.inj' % (campaign, model))
    else:
        outfile = os.path.join(EVEREST_SRC, 'missions', 'k2',
                               'tables', 'c%04.1f_%s.inj' % (campaign, model))
    if clobber or not os.path.exists(outfile):
        with open(outfile, 'w') as f:
            print("EPIC         Depth         UControl      URecovered"+
                  "    MControl      MRecovered", file=f)
            print("---------    ----------    ----------    ----------"+
                  "    ----------    ----------", file=f)
            for i, _ in enumerate(stars):
                sys.stdout.write('\rProcessing target %d/%d...' %
                                 (i + 1, len(stars)))
                sys.stdout.flush()
                path = os.path.join(EVEREST_DAT, 'k2', 'c%02d' % int(campaign),
                                    ('%09d' % stars[i])[:4] + '00000',
                                    ('%09d' % stars[i])[4:])

                # Loop over all depths
                for depth in [0.01, 0.001, 0.0001]:

                    try:

                        # Unmasked
                        data = np.load(os.path.join(
                            path, '%s_Inject_U%g.npz' % (model, depth)))
                        assert depth == data['inject'][()]['depth'], ""
                        ucontrol = data['inject'][()]['rec_depth_control']
                        urecovered = data['inject'][()]['rec_depth']

                        # Masked
                        data = np.load(os.path.join(
                            path, '%s_Inject_M%g.npz' % (model, depth)))
                        assert depth == data['inject'][()]['depth'], ""
                        mcontrol = data['inject'][()]['rec_depth_control']
                        mrecovered = data['inject'][()]['rec_depth']

                        # Log it
                        print("{:>09d} {:>13.8f} {:>13.8f} {:>13.8f} {:>13.8f} {:>13.8f}".format(
                              stars[i], depth, ucontrol, urecovered, mcontrol,
                              mrecovered), file=f)

                    except:
                        pass

            print("")

    if plot:

        # Load the statistics
        try:
            epic, depth, ucontrol, urecovered, mcontrol, mrecovered = \
                np.loadtxt(outfile, unpack=True, skiprows=2)
        except ValueError:
            raise Exception("No targets to plot.")

        # Normalize to the injected depth
        ucontrol /= depth
        urecovered /= depth
        mcontrol /= depth
        mrecovered /= depth

        # Set up the plot
        fig, ax = pl.subplots(3, 2, figsize=(9, 12))
        fig.subplots_adjust(hspace=0.29)
        ax[0, 0].set_title(r'Unmasked', fontsize=18)
        ax[0, 1].set_title(r'Masked', fontsize=18)
        ax[0, 0].set_ylabel(
            r'$D_0 = 10^{-2}$', rotation=90, fontsize=18, labelpad=10)
        ax[1, 0].set_ylabel(
            r'$D_0 = 10^{-3}$', rotation=90, fontsize=18, labelpad=10)
        ax[2, 0].set_ylabel(
            r'$D_0 = 10^{-4}$', rotation=90, fontsize=18, labelpad=10)

        # Define some useful stuff for plotting
        depths = [1e-2, 1e-3, 1e-4]
        ranges = [(0.75, 1.25), (0.5, 1.5), (0., 2.)]
        nbins = [30, 30, 20]
        ymax = [0.4, 0.25, 0.16]
        xticks = [[0.75, 0.875, 1., 1.125, 1.25], [
            0.5, 0.75, 1., 1.25, 1.5], [0., 0.5, 1., 1.5, 2.0]]

        # Plot
        for i in range(3):

            # Indices for this plot
            idx = np.where(depth == depths[i])

            for j, control, recovered in zip([0, 1], [ucontrol[idx],
                                                      mcontrol[idx]],
                                                     [urecovered[idx],
                                                      mrecovered[idx]]):

                # Control
                ax[i, j].hist(control, bins=nbins[i], range=ranges[i],
                              color='r', histtype='step',
                              weights=np.ones_like(control) / len(control))

                # Recovered
                ax[i, j].hist(recovered, bins=nbins[i], range=ranges[i],
                              color='b', histtype='step',
                              weights=np.ones_like(recovered) / len(recovered))

                # Indicate center
                ax[i, j].axvline(1., color='k', ls='--')

                # Indicate the fraction above and below
                if len(recovered):
                    au = len(np.where(recovered > ranges[i][1])[
                             0]) / len(recovered)
                    al = len(np.where(recovered < ranges[i][0])[
                             0]) / len(recovered)
                    ax[i, j].annotate('%.2f' % al, xy=(0.01, 0.93),
                                      xycoords='axes fraction',
                                      xytext=(0.1, 0.93), ha='left',
                                      va='center', color='b',
                                      arrowprops=dict(arrowstyle="->",
                                      color='b'))
                    ax[i, j].annotate('%.2f' % au, xy=(0.99, 0.93),
                                      xycoords='axes fraction',
                                      xytext=(0.9, 0.93), ha='right',
                                      va='center', color='b',
                                      arrowprops=dict(arrowstyle="->",
                                      color='b'))
                if len(control):
                    cu = len(np.where(control > ranges[i][1])[
                             0]) / len(control)
                    cl = len(np.where(control < ranges[i][0])[
                             0]) / len(control)
                    ax[i, j].annotate('%.2f' % cl, xy=(0.01, 0.86),
                                      xycoords='axes fraction',
                                      xytext=(0.1, 0.86), ha='left',
                                      va='center', color='r',
                                      arrowprops=dict(arrowstyle="->",
                                      color='r'))
                    ax[i, j].annotate('%.2f' % cu, xy=(0.99, 0.86),
                                      xycoords='axes fraction',
                                      xytext=(0.9, 0.86), ha='right',
                                      va='center', color='r',
                                      arrowprops=dict(arrowstyle="->",
                                      color='r'))

                # Indicate the median
                if len(recovered):
                    ax[i, j].annotate('M = %.2f' % np.median(recovered),
                                      xy=(0.35, 0.5), ha='right',
                                      xycoords='axes fraction', color='b',
                                      fontsize=16)
                if len(control):
                    ax[i, j].annotate('M = %.2f' % np.median(control),
                                      xy=(0.65, 0.5), ha='left',
                                      xycoords='axes fraction',
                                      color='r', fontsize=16)

                # Tweaks
                ax[i, j].set_xticks(xticks[i])
                ax[i, j].set_xlim(xticks[i][0], xticks[i][-1])
                ax[i, j].set_ylim(-0.005, ymax[i])
                ax[i, j].set_xlabel(r'$D/D_0$', fontsize=16)

                ax[i, j].get_yaxis().set_major_locator(MaxNLocator(5))
                for tick in ax[i, j].get_xticklabels() + \
                        ax[i, j].get_yticklabels():
                    tick.set_fontsize(14)

        if show:
            pl.show()
        else:
            return fig, ax

Response: Compute the injection statistics for the given campaign and model.


Instruction:
Given the following Python 3 function, write the documentation
def HDUCards(headers, hdu=0):
    '''
    Generates HDU cards for inclusion in the de-trended light curve FITS file.
    Used internally.

    '''

    if headers is None:
        return []

    if hdu == 0:
        # Get info from the TPF Primary HDU Header
        tpf_header = headers[0]
        entries = ['TELESCOP', 'INSTRUME', 'OBJECT', 'KEPLERID', 'CHANNEL',
                   'MODULE', 'OUTPUT', 'CAMPAIGN', 'DATA_REL', 'OBSMODE',
                   'TTABLEID', 'RADESYS', 'RA_OBJ', 'DEC_OBJ',  'EQUINOX',
                   'KEPMAG']
    elif (hdu == 1) or (hdu == 6):
        # Get info from the TPF BinTable HDU Header
        tpf_header = headers[1]
        entries = ['WCSN4P', 'WCAX4P', '1CTY4P', '2CTY4P',
                   '1CUN4P', '2CUN4P', '1CRV4P',
                   '2CRV4P', '1CDL4P', '2CDL4P', '1CRP4P',
                   '2CRP4P', 'WCAX4', '1CTYP4',
                   '2CTYP4', '1CRPX4', '2CRPX4', '1CRVL4',
                   '2CRVL4', '1CUNI4', '2CUNI4',
                   '1CDLT4', '2CDLT4', '11PC4', '12PC4',
                   '21PC4', '22PC4', 'WCSN5P',
                   'WCAX5P', '1CTY5P', '2CTY5P', '1CUN5P',
                   '2CUN5P', '1CRV5P', '2CRV5P',
                   '1CDL5P', '2CDL5P', '1CRP5P', '2CRP5P',
                   'WCAX5', '1CTYP5', '2CTYP5',
                   '1CRPX5', '2CRPX5', '1CRVL5', '2CRVL5',
                   '1CUNI5', '2CUNI5', '1CDLT5',
                   '2CDLT5', '11PC5', '12PC5', '21PC5',
                   '22PC5', 'WCSN6P', 'WCAX6P',
                   '1CTY6P', '2CTY6P', '1CUN6P', '2CUN6P',
                   '1CRV6P', '2CRV6P', '1CDL6P',
                   '2CDL6P', '1CRP6P', '2CRP6P', 'WCAX6',
                   '1CTYP6', '2CTYP6', '1CRPX6',
                   '2CRPX6', '1CRVL6', '2CRVL6', '1CUNI6',
                   '2CUNI6', '1CDLT6', '2CDLT6',
                   '11PC6', '12PC6', '21PC6', '22PC6',
                   'WCSN7P', 'WCAX7P', '1CTY7P',
                   '2CTY7P', '1CUN7P', '2CUN7P', '1CRV7P',
                   '2CRV7P', '1CDL7P', '2CDL7P',
                   '1CRP7P', '2CRP7P', 'WCAX7', '1CTYP7',
                   '2CTYP7', '1CRPX7', '2CRPX7',
                   '1CRVL7', '2CRVL7', '1CUNI7', '2CUNI7',
                   '1CDLT7', '2CDLT7', '11PC7',
                   '12PC7', '21PC7', '22PC7', 'WCSN8P',
                   'WCAX8P', '1CTY8P', '2CTY8P',
                   '1CUN8P', '2CUN8P', '1CRV8P', '2CRV8P',
                   '1CDL8P', '2CDL8P', '1CRP8P',
                   '2CRP8P', 'WCAX8', '1CTYP8', '2CTYP8',
                   '1CRPX8', '2CRPX8', '1CRVL8',
                   '2CRVL8', '1CUNI8', '2CUNI8', '1CDLT8',
                   '2CDLT8', '11PC8', '12PC8',
                   '21PC8', '22PC8', 'WCSN9P', 'WCAX9P',
                   '1CTY9P', '2CTY9P', '1CUN9P',
                   '2CUN9P', '1CRV9P', '2CRV9P', '1CDL9P',
                   '2CDL9P', '1CRP9P', '2CRP9P',
                   'WCAX9', '1CTYP9', '2CTYP9', '1CRPX9',
                   '2CRPX9', '1CRVL9', '2CRVL9',
                   '1CUNI9', '2CUNI9', '1CDLT9', '2CDLT9',
                   '11PC9', '12PC9', '21PC9',
                   '22PC9', 'INHERIT', 'EXTNAME', 'EXTVER',
                   'TELESCOP', 'INSTRUME',
                   'OBJECT', 'KEPLERID', 'RADESYS', 'RA_OBJ',
                   'DEC_OBJ', 'EQUINOX',
                   'EXPOSURE', 'TIMEREF', 'TASSIGN', 'TIMESYS',
                   'BJDREFI', 'BJDREFF',
                   'TIMEUNIT', 'TELAPSE', 'LIVETIME', 'TSTART',
                   'TSTOP', 'LC_START',
                   'LC_END', 'DEADC', 'TIMEPIXR', 'TIERRELA',
                   'INT_TIME', 'READTIME',
                   'FRAMETIM', 'NUM_FRM', 'TIMEDEL', 'DATE-OBS',
                   'DATE-END', 'BACKAPP',
                   'DEADAPP', 'VIGNAPP', 'GAIN', 'READNOIS',
                   'NREADOUT', 'TIMSLICE',
                   'MEANBLCK', 'LCFXDOFF', 'SCFXDOFF']
    elif (hdu == 3) or (hdu == 4) or (hdu == 5):
        # Get info from the TPF BinTable HDU Header
        tpf_header = headers[2]
        entries = ['TELESCOP', 'INSTRUME', 'OBJECT', 'KEPLERID', 'RADESYS',
                   'RA_OBJ', 'DEC_OBJ', 'EQUINOX', 'WCSAXES', 'CTYPE1',
                   'CTYPE2', 'CRPIX1', 'CRPIX2', 'CRVAL1', 'CRVAL2',
                   'CUNIT1', 'CUNIT2', 'CDELT1', 'CDELT2', 'PC1_1',
                   'PC1_2', 'PC2_1', 'PC2_2', 'WCSNAMEP', 'WCSAXESP',
                   'CTYPE1P', 'CUNIT1P', 'CRPIX1P', 'CRVAL1P', 'CDELT1P',
                   'CTYPE2P', 'CUNIT2P', 'CRPIX2P', 'CRVAL2P', 'CDELT2P',
                   'NPIXSAP', 'NPIXMISS']
    else:
        return []

    cards = []
    cards.append(('COMMENT', '************************'))
    cards.append(('COMMENT', '*     MISSION INFO     *'))
    cards.append(('COMMENT', '************************'))
    for entry in entries:
        try:
            cards.append(tuple(tpf_header[entry]))
        except KeyError:
            pass
    return cards

Response: Generates HDU cards for inclusion in the de - trended light curve FITS file.


Instruction:
Can you create a Python 3 function that
returns the location of theeverest data on disk for a given target.

Response:
def TargetDirectory(ID, season, relative=False, **kwargs):
    '''
    Returns the location of the :py:mod:`everest` data on disk
    for a given target.

    :param ID: The target ID
    :param int season: The target season number
    :param bool relative: Relative path? Default :py:obj:`False`

    '''

    if season is None:
        return None
    if relative:
        path = ''
    else:
        path = EVEREST_DAT
    return os.path.join(path, 'k2', 'c%02d' % season,
                        ('%09d' % ID)[:4] + '00000',
                        ('%09d' % ID)[4:])


Instruction:
Write a Python 3 script to
return the name of the DVS PDF for a given target.

Response:
def DVSFile(ID, season, cadence='lc'):
    '''
    Returns the name of the DVS PDF for a given target.

    :param ID: The target ID
    :param int season: The target season number
    :param str cadence: The cadence type. Default `lc`

    '''

    if cadence == 'sc':
        strcadence = '_sc'
    else:
        strcadence = ''
    return 'hlsp_everest_k2_llc_%d-c%02d_kepler_v%s_dvs%s.pdf' \
           % (ID, season, EVEREST_MAJOR_MINOR, strcadence)


Instruction:
How would you explain what the following Python 3 function does
def GetTargetCBVs(model):
    '''
    Returns the design matrix of CBVs for the given target.

    :param model: An instance of the :py:obj:`everest` model for the target

    '''

    # Get the info
    season = model.season
    name = model.name

    # We use the LC light curves as CBVs; there aren't
    # enough SC light curves to get a good set
    if name.endswith('.sc'):
        name = name[:-3]

    model.XCBV = sysrem.GetCBVs(season, model=name,
                                niter=model.cbv_niter,
                                sv_win=model.cbv_win,
                                sv_order=model.cbv_order)

Response: Returns the design matrix of CBVs for the given target.


Instruction:
Can you generate the documentation for the following Python 3 function
def FitCBVs(model):
    '''
    Fits the CBV design matrix to the de-trended flux of a given target. This
    is called internally whenever the user accesses the :py:attr:`fcor`
    attribute.

    :param model: An instance of the :py:obj:`everest` model for the target

    '''

    # Get cbvs?
    if model.XCBV is None:
        GetTargetCBVs(model)

    # The number of CBVs to use
    ncbv = model.cbv_num

    # Need to treat short and long cadences differently
    if model.cadence == 'lc':

        # Loop over all the light curve segments
        m = [None for b in range(len(model.breakpoints))]
        weights = [None for b in range(len(model.breakpoints))]
        for b in range(len(model.breakpoints)):

            # Get the indices for this light curve segment
            inds = model.get_chunk(b, pad=False)
            masked_inds = model.get_masked_chunk(b, pad=False)

            # Regress
            mX = model.XCBV[masked_inds, :ncbv + 1]
            A = np.dot(mX.T, mX)
            B = np.dot(mX.T, model.flux[masked_inds])
            try:
                weights[b] = np.linalg.solve(A, B)
            except np.linalg.linalg.LinAlgError:
                # Singular matrix
                log.warn('Singular matrix!')
                weights[b] = np.zeros(mX.shape[1])

            m[b] = np.dot(model.XCBV[inds, :ncbv + 1], weights[b])

            # Vertical alignment
            if b == 0:
                m[b] -= np.nanmedian(m[b])
            else:
                # Match the first finite model point on either side of the
                # break
                # We could consider something more elaborate in the future
                i0 = -1 - np.argmax([np.isfinite(m[b - 1][-i])
                                     for i in range(1, len(m[b - 1]) - 1)])
                i1 = np.argmax([np.isfinite(m[b][i])
                                for i in range(len(m[b]))])
                m[b] += (m[b - 1][i0] - m[b][i1])

        # Join model and normalize
        m = np.concatenate(m)
        m -= np.nanmedian(m)

    else:

        # Interpolate over outliers so we don't have to worry
        # about masking the arrays below
        flux = Interpolate(model.time, model.mask, model.flux)

        # Get downbinned light curve
        newsize = len(model.time) // 30
        time = Downbin(model.time, newsize, operation='mean')
        flux = Downbin(flux, newsize, operation='mean')

        # Get LC breakpoints
        breakpoints = list(Breakpoints(
            model.ID, season=model.season, cadence='lc'))
        breakpoints += [len(time) - 1]

        # Loop over all the light curve segments
        m = [None for b in range(len(breakpoints))]
        weights = [None for b in range(len(breakpoints))]
        for b in range(len(breakpoints)):

            # Get the indices for this light curve segment
            M = np.arange(len(time))
            if b > 0:
                inds = M[(M > breakpoints[b - 1]) & (M <= breakpoints[b])]
            else:
                inds = M[M <= breakpoints[b]]

            # Regress
            A = np.dot(model.XCBV[inds, :ncbv + 1].T,
                       model.XCBV[inds, :ncbv + 1])
            B = np.dot(model.XCBV[inds, :ncbv + 1].T, flux[inds])
            weights[b] = np.linalg.solve(A, B)
            m[b] = np.dot(model.XCBV[inds, :ncbv + 1], weights[b])

            # Vertical alignment
            if b == 0:
                m[b] -= np.nanmedian(m[b])
            else:
                # Match the first finite model point on either side of the
                # break
                # We could consider something more elaborate in the future
                i0 = -1 - np.argmax([np.isfinite(m[b - 1][-i])
                                     for i in range(1, len(m[b - 1]) - 1)])
                i1 = np.argmax([np.isfinite(m[b][i])
                                for i in range(len(m[b]))])
                m[b] += (m[b - 1][i0] - m[b][i1])

        # Join model and normalize
        m = np.concatenate(m)
        m -= np.nanmedian(m)

        # Finally, interpolate back to short cadence
        m = np.interp(model.time, time, m)

    return m

Response: Fits the CBV design matrix to the de - trended flux of a given target.


Instruction:
Write a Python 3 script for
generating the CSV file used in the search database for the documentation.

Response:
def StatsToCSV(campaign, model='nPLD'):
    '''
    Generate the CSV file used in the search database for the documentation.
    '''
    statsfile = os.path.join(EVEREST_SRC, 'missions', 'k2',
                             'tables', 'c%02d_%s.cdpp' % (campaign, model))
    csvfile = os.path.join(os.path.dirname(EVEREST_SRC), 'docs',
                           'c%02d.csv' % campaign)
    epic, kp, cdpp6r, cdpp6, _, _, _, _, saturated = \
        np.loadtxt(statsfile, unpack=True, skiprows=2)

    with open(csvfile, 'w') as f:
        print('c%02d' % campaign, file=f)
        for i in range(len(epic)):
            print('%09d,%.3f,%.3f,%.3f,%d' % (epic[i], kp[i],
                                              cdpp6r[i], cdpp6[i],
                                              int(saturated[i])),
                                              file=f)


Instruction:
How would you explain what the following Python 3 function does
def remove(self, item):
        '''Remove ``item`` for the :class:`zset` it it exists.
If found it returns the score of the item removed.'''
        score = self._dict.pop(item, None)
        if score is not None:
            self._sl.remove(score)
            return score

Response: Remove an item from the set.


Instruction:
Write a Python 3 script to
return a tuple of ordered fields for this : class : ColumnTS.

Response:
def fields(self):
        '''Return a tuple of ordered fields for this :class:`ColumnTS`.'''
        key = self.id + ':fields'
        encoding = self.client.encoding
        return tuple(sorted((f.decode(encoding)
                             for f in self.client.smembers(key))))


Instruction:
Make a summary of the following Python 3 code
def do_pending_lookups(event, sender, **kwargs):
    key = (sender._meta.app_label, sender._meta.name)
    for callback in pending_lookups.pop(key, []):
        callback(sender)

Response:
Handle any pending relations to the sending model.
Sent from class_prepared.


Instruction:
Can you tell what is the following Python 3 function doing
def Many2ManyThroughModel(field):
    '''Create a Many2Many through model with two foreign key fields and a
CompositeFieldId depending on the two foreign keys.'''
    from stdnet.odm import ModelType, StdModel, ForeignKey, CompositeIdField
    name_model = field.model._meta.name
    name_relmodel = field.relmodel._meta.name
    # The two models are the same.
    if name_model == name_relmodel:
        name_relmodel += '2'
    through = field.through
    # Create the through model
    if through is None:
        name = '{0}_{1}'.format(name_model, name_relmodel)

        class Meta:
            app_label = field.model._meta.app_label
        through = ModelType(name, (StdModel,), {'Meta': Meta})
        field.through = through
    # The first field
    field1 = ForeignKey(field.model,
                        related_name=field.name,
                        related_manager_class=makeMany2ManyRelatedManager(
                            field.relmodel,
                            name_model,
                            name_relmodel)
                        )
    field1.register_with_model(name_model, through)
    # The second field
    field2 = ForeignKey(field.relmodel,
                        related_name=field.related_name,
                        related_manager_class=makeMany2ManyRelatedManager(
                            field.model,
                            name_relmodel,
                            name_model)
                        )
    field2.register_with_model(name_relmodel, through)
    pk = CompositeIdField(name_model, name_relmodel)
    pk.register_with_model('id', through)

Response:
Create a Many2Many through model with two foreign key fields and a
CompositeFieldId depending on the two foreign keys.


Instruction:
How would you explain what the following Python 3 function does
def makeMany2ManyRelatedManager(formodel, name_relmodel, name_formodel):
    '''formodel is the model which the manager .'''

    class _Many2ManyRelatedManager(Many2ManyRelatedManager):
        pass

    _Many2ManyRelatedManager.formodel = formodel
    _Many2ManyRelatedManager.name_relmodel = name_relmodel
    _Many2ManyRelatedManager.name_formodel = name_formodel
    return _Many2ManyRelatedManager

Response: Creates a new Many2ManyRelatedManager class.


Instruction:
Implement a Python 3 function for
overriding this. manager. session so that the manager can retrieve the session from the related_instance.

Response:
def session(self, session=None):
        '''Override :meth:`Manager.session` so that this
        :class:`RelatedManager` can retrieve the session from the
        :attr:`related_instance` if available.
        '''
        if self.related_instance:
            session = self.related_instance.session
        # we have a session, we either create a new one return the same session
        if session is None:
            raise QuerySetError('Related manager can be accessed only from\
 a loaded instance of its related model.')
        return session


Instruction:
Can you create a Python 3 function that
adds value an instance of Model to the Model.

Response:
def add(self, value, session=None, **kwargs):
        '''Add ``value``, an instance of :attr:`formodel` to the
:attr:`through` model. This method can only be accessed by an instance of the
model for which this related manager is an attribute.'''
        s, instance = self.session_instance('add', value, session, **kwargs)
        return s.add(instance)


Instruction:
Can you generate a brief explanation for the following Python 3 code
def remove(self, value, session=None):
        '''Remove *value*, an instance of ``self.model`` from the set of
elements contained by the field.'''
        s, instance = self.session_instance('remove', value, session)
        # update state so that the instance does look persistent
        instance.get_state(iid=instance.pkvalue(), action='update')
        return s.delete(instance)

Response:
Remove value from the set of
elements contained by the field.


Instruction:
Can you generate the documentation for the following Python 3 function
def metaphone_processor(words):
    '''Double metaphone word processor.'''
    for word in words:
        for w in double_metaphone(word):
            if w:
                w = w.strip()
                if w:
                    yield w

Response: Double metaphone word processor.


Instruction:
Can you write a function in Python 3 where it
doubles metaphone word processor slightly modified so that when no noMagicWords are returned by the algorithm the original word is returned.

Response:
def tolerant_metaphone_processor(words):
    '''Double metaphone word processor slightly modified so that when no
words are returned by the algorithm, the original word is returned.'''
    for word in words:
        r = 0
        for w in double_metaphone(word):
            if w:
                w = w.strip()
                if w:
                    r += 1
                    yield w
        if not r:
            yield word


Instruction:
Here you have a function in Python 3, explain what it does
def stemming_processor(words):
    '''Porter Stemmer word processor'''
    stem = PorterStemmer().stem
    for word in words:
        word = stem(word, 0, len(word)-1)
        yield word

Response: Porter Stemmer word processor


Instruction:
Create a Python 3 function for
returning a new instance of the specified pool.

Response:
def Pool(pool='AnyPool', **kwargs):
    '''
    Chooses between the different pools.
    If ``pool == 'AnyPool'``, chooses based on availability.

    '''

    if pool == 'MPIPool':
        return MPIPool(**kwargs)
    elif pool == 'MultiPool':
        return MultiPool(**kwargs)
    elif pool == 'SerialPool':
        return SerialPool(**kwargs)
    elif pool == 'AnyPool':
        if MPIPool.enabled():
            return MPIPool(**kwargs)
        elif MultiPool.enabled():
            return MultiPool(**kwargs)
        else:
            return SerialPool(**kwargs)
    else:
        raise ValueError('Invalid pool ``%s``.' % pool)


Instruction:
How would you implement a function in Python 3 that
waits for a new job to be executed and return it asynchronously.

Response:
def wait(self):
        """
        If this isn't the master process, wait for instructions.

        """
        if self.is_master():
            raise RuntimeError("Master node told to await jobs.")

        status = MPI.Status()

        while True:
            # Event loop.
            # Sit here and await instructions.
            if self.debug:
                print("Worker {0} waiting for task.".format(self.rank))

            # Blocking receive to wait for instructions.
            task = self.comm.recv(source=0, tag=MPI.ANY_TAG, status=status)

            if self.debug:
                print("Worker {0} got task {1} with tag {2}."
                      .format(self.rank, type(task), status.tag))

            # Check if message is special sentinel signaling end.
            # If so, stop.
            if isinstance(task, _close_pool_message):
                if self.debug:
                    print("Worker {0} told to quit.".format(self.rank))
                break

            # Check if message is special type containing new function
            # to be applied
            if isinstance(task, _function_wrapper):
                self.function = task.function
                if self.debug:
                    print("Worker {0} replaced its task function: {1}."
                          .format(self.rank, self.function))
                continue

            # If not a special message, just run the known function on
            # the input and return it asynchronously.
            result = self.function(task)
            if self.debug:
                print("Worker {0} sending answer {1} with tag {2}."
                      .format(self.rank, type(result), status.tag))
            self.comm.isend(result, dest=0, tag=status.tag)

        # Kill the process?
        if self.exit_on_end:
            sys.exit()


Instruction:
Explain what the following Python 3 code does
def map(self, function, tasks):
        ntask = len(tasks)

        # If not the master just wait for instructions.
        if not self.is_master():
            self.wait()
            return

        if function is not self.function:
            if self.debug:
                print("Master replacing pool function with {0}."
                      .format(function))

            self.function = function
            F = _function_wrapper(function)

            # Tell all the workers what function to use.
            requests = []
            for i in range(self.size):
                r = self.comm.isend(F, dest=i + 1)
                requests.append(r)

            # Wait until all of the workers have responded. See:
            #       https://gist.github.com/4176241
            MPI.Request.waitall(requests)

        if (not self.loadbalance) or (ntask <= self.size):
            # Do not perform load-balancing - the default load-balancing
            # scheme emcee uses.

            # Send all the tasks off and wait for them to be received.
            # Again, see the bug in the above gist.
            requests = []
            for i, task in enumerate(tasks):
                worker = i % self.size + 1
                if self.debug:
                    print("Sent task {0} to worker {1} with tag {2}."
                          .format(type(task), worker, i))
                r = self.comm.isend(task, dest=worker, tag=i)
                requests.append(r)

            MPI.Request.waitall(requests)

            # Now wait for the answers.
            results = []
            for i in range(ntask):
                worker = i % self.size + 1
                if self.debug:
                    print("Master waiting for worker {0} with tag {1}"
                          .format(worker, i))
                result = self.comm.recv(source=worker, tag=i)

                results.append(result)

            return results

        else:
            # Perform load-balancing. The order of the results are likely to
            # be different from the previous case.
            for i, task in enumerate(tasks[0:self.size]):
                worker = i + 1
                if self.debug:
                    print("Sent task {0} to worker {1} with tag {2}."
                          .format(type(task), worker, i))
                # Send out the tasks asynchronously.
                self.comm.isend(task, dest=worker, tag=i)

            ntasks_dispatched = self.size
            results = [None] * ntask
            for itask in range(ntask):
                status = MPI.Status()
                # Receive input from workers.
                try:
                    result = self.comm.recv(source=MPI.ANY_SOURCE,
                                            tag=MPI.ANY_TAG, status=status)
                except Exception as e:
                    self.close()
                    raise e

                worker = status.source
                i = status.tag
                results[i] = result
                if self.debug:
                    print("Master received from worker {0} with tag {1}"
                          .format(worker, i))

                # Now send the next task to this idle worker (if there are any
                # left).
                if ntasks_dispatched < ntask:
                    task = tasks[ntasks_dispatched]
                    i = ntasks_dispatched
                    if self.debug:
                        print("Sent task {0} to worker {1} with tag {2}."
                              .format(type(task), worker, i))
                    # Send out the tasks asynchronously.
                    self.comm.isend(task, dest=worker, tag=i)
                    ntasks_dispatched += 1

            return results

Response: This function is a wrapper for the function to apply a function to all the values in a list and return the list of results.


Instruction:
Write a Python 3 function that can
send a close_pool_message to all the members which contains the special _close_pool_message sentinel.

Response:
def close(self):
        """
        Just send a message off to all the pool members which contains
        the special :class:`_close_pool_message` sentinel.

        """
        if self.is_master():
            for i in range(self.size):
                self.comm.isend(_close_pool_message(), dest=i + 1)


Instruction:
Implement a function in Python 3 to
return the : class : stdnet. BackendStructure.

Response:
def backend(self):
        '''Returns the :class:`stdnet.BackendStructure`.
        '''
        session = self.session
        if session is not None:
            if self._field:
                return session.model(self._field.model).backend
            else:
                return session.model(self).backend


Instruction:
Can you create a Python 3 function that
returns the : class : stdnet. BackendStructure.

Response:
def read_backend(self):
        '''Returns the :class:`stdnet.BackendStructure`.
        '''
        session = self.session
        if session is not None:
            if self._field:
                return session.model(self._field.model).read_backend
            else:
                return session.model(self).read_backend


Instruction:
How would you explain what the following Python 3 function does
def size(self):
        '''Number of elements in the :class:`Structure`.'''
        if self.cache.cache is None:
            return self.read_backend_structure().size()
        else:
            return len(self.cache.cache)

Response: Returns the size of the elements in the structure.


Instruction:
Here you have a function in Python 3, explain what it does
def load_data(self, data, callback=None):
        '''Load ``data`` from the :class:`stdnet.BackendDataServer`.'''
        return self.backend.execute(
            self.value_pickler.load_iterable(data, self.session), callback)

Response: Load data from the backend data server.


Instruction:
Explain what the following Python 3 code does
def values(self):
        '''Iteratir over values of :class:`PairMixin`.'''
        if self.cache.cache is None:
            backend = self.read_backend
            return backend.execute(backend.structure(self).values(),
                                   self.load_values)
        else:
            return self.cache.cache.values()

Response: Iteratir over values of PairMixin.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def pair(self, pair):
        '''Add a *pair* to the structure.'''
        if len(pair) == 1:
            # if only one value is passed, the value must implement a
            # score function which retrieve the first value of the pair
            # (score in zset, timevalue in timeseries, field value in
            # hashtable)
            return (pair[0].score(), pair[0])
        elif len(pair) != 2:
            raise TypeError('add expected 2 arguments, got {0}'
                            .format(len(pair)))
        else:
            return pair

Response: Add a pair to the structure.


Instruction:
Write a Python 3 function that can
remove the specified keys from the key - value container.

Response:
def remove(self, *keys):
        '''Remove *keys* from the key-value container.'''
        dumps = self.pickler.dumps
        self.cache.remove([dumps(v) for v in keys])


Instruction:
Given the following Python 3 function, write the documentation
def count(self, start, stop):
        '''Count the number of elements bewteen *start* and *stop*.'''
        s1 = self.pickler.dumps(start)
        s2 = self.pickler.dumps(stop)
        return self.backend_structure().count(s1, s2)

Response: Count the number of elements bewteen start and stop.


Instruction:
Can you generate the documentation for the following Python 3 function
def irange(self, start=0, end=-1, callback=None, withscores=True,
               **options):
        '''Return the range by rank between start and end.'''
        backend = self.read_backend
        res = backend.structure(self).irange(start, end,
                                             withscores=withscores,
                                             **options)
        if not callback:
            callback = self.load_data if withscores else self.load_values
        return backend.execute(res, callback)

Response: Return the range by rank between start and end.


Instruction:
Given the following Python 3 function, write the documentation
def pop_range(self, start, stop, callback=None, withscores=True):
        '''pop a range by score from the :class:`OrderedMixin`'''
        s1 = self.pickler.dumps(start)
        s2 = self.pickler.dumps(stop)
        backend = self.backend
        res = backend.structure(self).pop_range(s1, s2, withscores=withscores)
        if not callback:
            callback = self.load_data if withscores else self.load_values
        return backend.execute(res, callback)

Response: pop a range by score from the OrderedMixin


Instruction:
Explain what the following Python 3 code does
def ipop_range(self, start=0, stop=-1, callback=None, withscores=True):
        '''pop a range from the :class:`OrderedMixin`'''
        backend = self.backend
        res = backend.structure(self).ipop_range(start, stop,
                                                 withscores=withscores)
        if not callback:
            callback = self.load_data if withscores else self.load_values
        return backend.execute(res, callback)

Response: pop a range from the OrderedMixin


Instruction:
How would you implement a function in Python 3 that
appends a copy of value at the end of the Sequence.

Response:
def push_back(self, value):
        '''Appends a copy of *value* at the end of the :class:`Sequence`.'''
        self.cache.push_back(self.value_pickler.dumps(value))
        return self


Instruction:
Write a Python 3 function that can
remove the last element from the Sequence.

Response:
def pop_back(self):
        '''Remove the last element from the :class:`Sequence`.'''
        backend = self.backend
        return backend.execute(backend.structure(self).pop_back(),
                               self.value_pickler.loads)


Instruction:
Can you tell what is the following Python 3 function doing
def add(self, value):
        '''Add *value* to the set'''
        return self.cache.update((self.value_pickler.dumps(value),))

Response: Add value to the set


Instruction:
Can you create a Python 3 function that
adds iterable values to the set

Response:
def update(self, values):
        '''Add iterable *values* to the set'''
        d = self.value_pickler.dumps
        return self.cache.update(tuple((d(v) for v in values)))


Instruction:
Given the following Python 3 function, write the documentation
def discard(self, value):
        '''Remove an element *value* from a set if it is a member.'''
        return self.cache.remove((self.value_pickler.dumps(value),))

Response: Remove an element value from a set if it is a member.


Instruction:
Can you create a Python 3 function that
removes an iterable of values from the set.

Response:
def difference_update(self, values):
        '''Remove an iterable of *values* from the set.'''
        d = self.value_pickler.dumps
        return self.cache.remove(tuple((d(v) for v in values)))


Instruction:
How would you implement a function in Python 3 that
removes the first element from the list.

Response:
def pop_front(self):
        '''Remove the first element from of the list.'''
        backend = self.backend
        return backend.execute(backend.structure(self).pop_front(),
                               self.value_pickler.loads)


Instruction:
Here you have a function in Python 3, explain what it does
def block_pop_back(self, timeout=10):
        '''Remove the last element from of the list. If no elements are
available, blocks for at least ``timeout`` seconds.'''
        value = yield self.backend_structure().block_pop_back(timeout)
        if value is not None:
            yield self.value_pickler.loads(value)

Response: Remove the last element from the list.


Instruction:
Make a summary of the following Python 3 code
def block_pop_front(self, timeout=10):
        '''Remove the first element from of the list. If no elements are
available, blocks for at least ``timeout`` seconds.'''
        value = yield self.backend_structure().block_pop_front(timeout)
        if value is not None:
            yield self.value_pickler.loads(value)

Response: Remove the first element from the list.


Instruction:
Given the following Python 3 function, write the documentation
def push_front(self, value):
        '''Appends a copy of ``value`` to the beginning of the list.'''
        self.cache.push_front(self.value_pickler.dumps(value))

Response: Appends a copy of value to the beginning of the list.


Instruction:
Create a Python 3 function for
returning the rank of a given dte in the timeseries

Response:
def rank(self, dte):
        '''The rank of a given *dte* in the timeseries'''
        timestamp = self.pickler.dumps(dte)
        return self.backend_structure().rank(timestamp)


Instruction:
Write a Python 3 script to
pop a value at index from the : class:`TS. Return None if no such value is found.

Response:
def ipop(self, index):
        '''Pop a value at *index* from the :class:`TS`. Return ``None`` if
index is not out of bound.'''
        backend = self.backend
        res = backend.structure(self).ipop(index)
        return backend.execute(res,
                               lambda r: self._load_get_data(r, index, None))


Instruction:
Can you generate the documentation for the following Python 3 function
def times(self, start, stop, callback=None, **kwargs):
        '''The times between times *start* and *stop*.'''
        s1 = self.pickler.dumps(start)
        s2 = self.pickler.dumps(stop)
        backend = self.read_backend
        res = backend.structure(self).times(s1, s2, **kwargs)
        return backend.execute(res, callback or self.load_keys)

Response: The times between times start and stop.


Instruction:
Here you have a function in Python 3, explain what it does
def itimes(self, start=0, stop=-1, callback=None, **kwargs):
        '''The times between rank *start* and *stop*.'''
        backend = self.read_backend
        res = backend.structure(self).itimes(start, stop, **kwargs)
        return backend.execute(res, callback or self.load_keys)

Response: The times between rank start and stop.


Instruction:
Here you have a function in Python 3, explain what it does
def get_field(self, field):
        '''A :class:`Q` performs a series of operations and ultimately
generate of set of matched elements ``ids``. If on the other hand, a
different field is required, it can be specified with the :meth:`get_field`
method. For example, lets say a model has a field called ``object_id``
which contains ids of another model, we could use::

    qs = session.query(MyModel).get_field('object_id')

to obtain a set containing the values of matched elements ``object_id``
fields.

:parameter field: the name of the field which will be used to obtained the
    matched elements value. Must be an index.
:rtype: a new :class:`Q` instance.
'''
        if field != self._get_field:
            if field not in self._meta.dfields:
                raise QuerySetError('Model "{0}" has no field "{1}".'
                                    .format(self._meta, field))
            q = self._clone()
            q.data['get_field'] = field
            return q
        else:
            return self

Response: A method to obtain a new instance of the same field as the current one.


Instruction:
Here you have a function in Python 3, explain what it does
def filter(self, **kwargs):
        '''Create a new :class:`Query` with additional clauses corresponding to
``where`` or ``limit`` in a ``SQL SELECT`` statement.

:parameter kwargs: dictionary of limiting clauses.
:rtype: a new :class:`Query` instance.

For example::

    qs = session.query(MyModel)
    result = qs.filter(group = 'planet')
'''
        if kwargs:
            q = self._clone()
            if self.fargs:
                kwargs = update_dictionary(self.fargs.copy(), kwargs)
            q.fargs = kwargs
            return q
        else:
            return self

Response:
Create a new Query instance with additional clauses corresponding to
 where or limit in a SQL SELECT statement.


Instruction:
Given the following Python 3 function, write the documentation
def exclude(self, **kwargs):
        '''Returns a new :class:`Query` with additional clauses corresponding
to ``EXCEPT`` in a ``SQL SELECT`` statement.

:parameter kwargs: dictionary of limiting clauses.
:rtype: a new :class:`Query` instance.

Using an equivalent example to the :meth:`filter` method::

    qs = session.query(MyModel)
    result1 = qs.exclude(group = 'planet')
    result2 = qs.exclude(group__in = ('planet','stars'))

'''
        if kwargs:
            q = self._clone()
            if self.eargs:
                kwargs = update_dictionary(self.eargs.copy(), kwargs)
            q.eargs = kwargs
            return q
        else:
            return self

Response:
Returns a new Query instance with additional clauses corresponding
to EXCEPT in a SQL SELECT statement.


Instruction:
Given the following Python 3 function, write the documentation
def union(self, *queries):
        '''Return a new :class:`Query` obtained form the union of this
:class:`Query` with one or more *queries*.
For example, lets say we want to have the union
of two queries obtained from the :meth:`filter` method::

    query = session.query(MyModel)
    qs = query.filter(field1 = 'bla').union(query.filter(field2 = 'foo'))
'''
        q = self._clone()
        q.unions += queries
        return q

Response: Return a new Query that obtained form the union of this Query with one or more queries*.


Instruction:
Write a Python 3 script for
returning a new Query obtained form the intersection of this Query with one or more queries. Workds the same way as the union of this Query with one or more queries*. Workds the same way as the union of this Query.

Response:
def intersect(self, *queries):
        '''Return a new :class:`Query` obtained form the intersection of this
:class:`Query` with one or more *queries*. Workds the same way as
the :meth:`union` method.'''
        q = self._clone()
        q.intersections += queries
        return q


Instruction:
Write a Python 3 function that can
sort the query by the given field name.

Response:
def sort_by(self, ordering):
        '''Sort the query by the given field

:parameter ordering: a string indicating the class:`Field` name to sort by.
    If prefixed with ``-``, the sorting will be in descending order, otherwise
    in ascending order.
:return type: a new :class:`Query` instance.
'''
        if ordering:
            ordering = self._meta.get_sorting(ordering, QuerySetError)
        q = self._clone()
        q.data['ordering'] = ordering
        return q


Instruction:
Given the following Python 3 function, write the documentation
def search(self, text, lookup=None):
        '''Search *text* in model. A search engine needs to be installed
for this function to be available.

:parameter text: a string to search.
:return type: a new :class:`Query` instance.
'''
        q = self._clone()
        q.text = (text, lookup)
        return q

Response:
Search *text* in model. A search engine needs to be installed
for this function to be available.

:parameter text: a string to search.
:return type: a new :class:`Query` instance.


Instruction:
Given the following Python 3 function, write the documentation
def where(self, code, load_only=None):
        '''For :ref:`backend <db-index>` supporting scripting, it is possible
to construct complex queries which execute the scripting *code* against
each element in the query. The *coe* should reference an instance of
:attr:`model` by ``this`` keyword.

:parameter code: a valid expression in the scripting language of the database.
:parameter load_only: Load only the selected fields when performing the query
    (this is different from the :meth:`load_only` method which is used when
    fetching data from the database). This field is an optimization which is
    used by the :ref:`redis backend <redis-server>` only and can be safely
    ignored in most use-cases.
:return: a new :class:`Query`
'''
        if code:
            q = self._clone()
            q.data['where'] = (code, load_only)
            return q
        else:
            return self

Response: Returns a new Query object with the data set where code = code.


Instruction:
How would you explain what the following Python 3 function does
def search_queries(self, q):
        '''Return a new :class:`QueryElem` for *q* applying a text search.'''
        if self.text:
            searchengine = self.session.router.search_engine
            if searchengine:
                return searchengine.search_model(q, *self.text)
            else:
                raise QuerySetError('Search not available for %s' % self._meta)
        else:
            return q

Response: Return a new : class : QueryElem for *q* applying a text search.


Instruction:
Can you generate the documentation for the following Python 3 function
def load_related(self, related, *related_fields):
        '''It returns a new :class:`Query` that automatically
follows the foreign-key relationship ``related``.

:parameter related: A field name corresponding to a :class:`ForeignKey`
    in :attr:`Query.model`.
:parameter related_fields: optional :class:`Field` names for the ``related``
    model to load. If not provided, all fields will be loaded.

This function is :ref:`performance boost <performance-loadrelated>` when
accessing the related fields of all (most) objects in your query.

If Your model contains more than one foreign key, you can use this function
in a generative way::

    qs = myquery.load_related('rel1').load_related('rel2','field1','field2')

:rtype: a new :class:`Query`.'''
        field = self._get_related_field(related)
        if not field:
            raise FieldError('"%s" is not a related field for "%s"' %
                             (related, self._meta))
        q = self._clone()
        return q._add_to_load_related(field, *related_fields)

Response: Returns a new : class:`Query` that automatically follows the foreign - key relationship related.


Instruction:
Can you generate the documentation for the following Python 3 function
def load_only(self, *fields):
        '''This is provides a :ref:`performance boost <increase-performance>`
in cases when you need to load a subset of fields of your model. The boost
achieved is less than the one obtained when using
:meth:`Query.load_related`, since it does not reduce the number of requests
to the database. However, it can save you lots of bandwidth when excluding
data intensive fields you don't need.
'''
        q = self._clone()
        new_fields = []
        for field in fields:
            if JSPLITTER in field:
                bits = field.split(JSPLITTER)
                related = self._get_related_field(bits[0])
                if related:
                    q._add_to_load_related(related, JSPLITTER.join(bits[1:]))
                    continue
            new_fields.append(field)
        if fields and not new_fields:
            # if we added a field to the load_related list and not fields are
            # are left we add the primary key so that other firls are not
            # loaded.
            new_fields.append(self._meta.pkname())
        fs = unique_tuple(q.fields, new_fields)
        q.data['fields'] = fs if fs else None
        return q

Response: Returns a new instance of this model with only the specified fields.


Instruction:
How would you code a function in Python 3 to
return a new QuerySet with only the specified fields but not the ones in fields.

Response:
def dont_load(self, *fields):
        '''Works like :meth:`load_only` to provides a
:ref:`performance boost <increase-performance>` in cases when you need
to load all fields except a subset specified by *fields*.
'''
        q = self._clone()
        fs = unique_tuple(q.exclude_fields, fields)
        q.exclude_fields = fs if fs else None
        return q


Instruction:
How would you explain what the following Python 3 function does
def get(self, **kwargs):
        '''Return an instance of a model matching the query. A special case is
the query on ``id`` which provides a direct access to the :attr:`session`
instances. If the given primary key is present in the session, the object
is returned directly without performing any query.'''
        return self.filter(**kwargs).items(
            callback=self.model.get_unique_instance)

Response: Return an instance of a model matching the query.


Instruction:
Implement a function in Python 3 to
build the : class:`QueryElement` representing this query.

Response:
def construct(self):
        '''Build the :class:`QueryElement` representing this query.'''
        if self.__construct is None:
            self.__construct = self._construct()
        return self.__construct


Instruction:
Write a Python 3 script to
build and return the : class : stdnet. utils. async. BackendQuery.

Response:
def backend_query(self, **kwargs):
        '''Build and return the :class:`stdnet.utils.async.BackendQuery`.
This is a lazy method in the sense that it is evaluated once only and its
result stored for future retrieval.'''
        q = self.construct()
        return q if isinstance(q, EmptyQuery) else q.backend_query(**kwargs)


Instruction:
Here you have a function in Python 3, explain what it does
def aggregate(self, kwargs):
        '''Aggregate lookup parameters.'''
        meta = self._meta
        fields = meta.dfields
        field_lookups = {}
        for name, value in iteritems(kwargs):
            bits = name.split(JSPLITTER)
            field_name = bits.pop(0)
            if field_name not in fields:
                raise QuerySetError('Could not filter on model "{0}".\
 Field "{1}" does not exist.'.format(meta, field_name))
            field = fields[field_name]
            attname = field.attname
            lookup = None
            if bits:
                bits = [n.lower() for n in bits]
                if bits[-1] == 'in':
                    bits.pop()
                elif bits[-1] in range_lookups:
                    lookup = bits.pop()
                remaining = JSPLITTER.join(bits)
                if lookup:  # this is a range lookup
                    attname, nested = field.get_lookup(remaining,
                                                       QuerySetError)
                    lookups = get_lookups(attname, field_lookups)
                    lookups.append(lookup_value(lookup, (value, nested)))
                    continue
                elif remaining:   # Not a range lookup, must be a nested filter
                    value = field.filter(self.session, remaining, value)
            lookups = get_lookups(attname, field_lookups)
            # If we are here the field must be an index
            if not field.index:
                raise QuerySetError("%s %s is not an index. Cannot query." %
                                    (field.__class__.__name__, field_name))
            if not iterable(value):
                value = (value,)
            for v in value:
                if isinstance(v, Q):
                    v = lookup_value('set', v.construct())
                else:
                    v = lookup_value('value', field.serialise(v, lookup))
                lookups.append(v)
        #
        return [queryset(self, name=name, underlying=field_lookups[name])
                for name in sorted(field_lookups)]

Response: Aggregate the values of the related objects in the model.


Instruction:
Can you generate a brief explanation for the following Python 3 code
def model_iterator(application, include_related=True, exclude=None):
    '''A generator of :class:`StdModel` classes found in *application*.

:parameter application: A python dotted path or an iterable over python
    dotted-paths where models are defined.

Only models defined in these paths are considered.

For example::

    from stdnet.odm import model_iterator

    APPS = ('stdnet.contrib.searchengine',
            'stdnet.contrib.timeseries')

    for model in model_iterator(APPS):
        ...

'''
    if exclude is None:
        exclude = set()
    application = native_str(application)
    if ismodule(application) or isinstance(application, str):
        if ismodule(application):
            mod, application = application, application.__name__
        else:
            try:
                mod = import_module(application)
            except ImportError:
                # the module is not there
                mod = None
        if mod:
            label = application.split('.')[-1]
            try:
                mod_models = import_module('.models', application)
            except ImportError:
                mod_models = mod
            label = getattr(mod_models, 'app_label', label)
            models = set()
            for name in dir(mod_models):
                value = getattr(mod_models, name)
                meta = getattr(value, '_meta', None)
                if isinstance(value, ModelType) and meta:
                    for model in models_from_model(
                            value, include_related=include_related,
                            exclude=exclude):
                        if (model._meta.app_label == label
                                and model not in models):
                            models.add(model)
                            yield model
    else:
        for app in application:
            for m in model_iterator(app):
                yield m

Response: A generator of : class : StdModel classes found in application.


Instruction:
Create a Python 3 function to
set the search engine for this router.

Response:
def set_search_engine(self, engine):
        '''Set the search ``engine`` for this :class:`Router`.'''
        self._search_engine = engine
        self._search_engine.set_router(self)


Instruction:
How would you explain what the following Python 3 function does
def register(self, model, backend=None, read_backend=None,
                 include_related=True, **params):
        '''Register a :class:`Model` with this :class:`Router`. If the
model was already registered it does nothing.

:param model: a :class:`Model` class.
:param backend: a :class:`stdnet.BackendDataServer` or a
    :ref:`connection string <connection-string>`.
:param read_backend: Optional :class:`stdnet.BackendDataServer` for read
    operations. This is useful when the server has a master/slave
    configuration, where the master accept write and read operations
    and the ``slave`` read only operations.
:param include_related: ``True`` if related models to ``model`` needs to be
    registered. Default ``True``.
:param params: Additional parameters for the :func:`getdb` function.
:return: the number of models registered.
'''
        backend = backend or self._default_backend
        backend = getdb(backend=backend, **params)
        if read_backend:
            read_backend = getdb(read_backend)
        registered = 0
        if isinstance(model, Structure):
            self._structures[model] = StructureManager(model, backend,
                                                       read_backend, self)
            return model
        for model in models_from_model(model, include_related=include_related):
            if model in self._registered_models:
                continue
            registered += 1
            default_manager = backend.default_manager or Manager
            manager_class = getattr(model, 'manager_class', default_manager)
            manager = manager_class(model, backend, read_backend, self)
            self._registered_models[model] = manager
            if isinstance(model, ModelType):
                attr_name = model._meta.name
            else:
                attr_name = model.__name__.lower()
            if attr_name not in self._registered_names:
                self._registered_names[attr_name] = manager
            if self._install_global:
                model.objects = manager
        if registered:
            return backend

Response: Register a model with this Router.


Instruction:
Can you generate the documentation for the following Python 3 function
def from_uuid(self, uuid, session=None):
        '''Retrieve a :class:`Model` from its universally unique identifier
``uuid``. If the ``uuid`` does not match any instance an exception will raise.
'''
        elems = uuid.split('.')
        if len(elems) == 2:
            model = get_model_from_hash(elems[0])
            if not model:
                raise Model.DoesNotExist(
                    'model id "{0}" not available'.format(elems[0]))
            if not session or session.router is not self:
                session = self.session()
            return session.query(model).get(id=elems[1])
        raise Model.DoesNotExist('uuid "{0}" not recognized'.format(uuid))

Response:
Retrieve a : class:`Model` from its universally unique identifier
uuid.


Instruction:
Explain what the following Python 3 code does
def flush(self, exclude=None, include=None, dryrun=False):
        '''Flush :attr:`registered_models`.

        :param exclude: optional list of model names to exclude.
        :param include: optional list of model names to include.
        :param dryrun: Doesn't remove anything, simply collect managers
            to flush.
        :return:
        '''
        exclude = exclude or []
        results = []
        for manager in self._registered_models.values():
            m = manager._meta
            if include is not None and not (m.modelkey in include or
                                            m.app_label in include):
                continue
            if not (m.modelkey in exclude or m.app_label in exclude):
                if dryrun:
                    results.append(manager)
                else:
                    results.append(manager.flush())
        return results

Response: Flush all the managers that have the same app_label.


Instruction:
Explain what the following Python 3 code does
def register_applications(self, applications, models=None, backends=None):
        '''A higher level registration functions for group of models located
on application modules.
It uses the :func:`model_iterator` function to iterate
through all :class:`Model` models available in ``applications``
and register them using the :func:`register` low level method.

:parameter applications: A String or a list of strings representing
    python dotted paths where models are implemented.
:parameter models: Optional list of models to include. If not provided
    all models found in *applications* will be included.
:parameter backends: optional dictionary which map a model or an
    application to a backend :ref:`connection string <connection-string>`.
:rtype: A list of registered :class:`Model`.

For example::

    mapper.register_application_models('mylib.myapp')
    mapper.register_application_models(['mylib.myapp', 'another.path'])
    mapper.register_application_models(pythonmodule)
    mapper.register_application_models(['mylib.myapp',pythonmodule])

'''
        return list(self._register_applications(applications, models,
                                                backends))

Response:
A higher level registration function for group of models located
on application modules.


Instruction:
Can you tell what is the following Python 3 function doing
def execute_script(self, name, keys, *args, **options):
        '''Execute a script.

        makes sure all required scripts are loaded.
        '''
        script = get_script(name)
        if not script:
            raise redis.RedisError('No such script "%s"' % name)
        address = self.address()
        if address not in all_loaded_scripts:
            all_loaded_scripts[address] = set()
        loaded = all_loaded_scripts[address]
        toload = script.required_scripts.difference(loaded)
        for name in toload:
            s = get_script(name)
            yield self.script_load(s.script)
        loaded.update(toload)
        yield script(self, keys, args, options)

Response: Execute a script. This is a generator that yields all the required scripts that are loaded.


Instruction:
How would you implement a function in Python 3 that
registers a new model with this search engine.

Response:
def register(self, model, related=None):
        '''Register a :class:`StdModel` with this search :class:`SearchEngine`.
When registering a model, every time an instance is created, it will be
indexed by the search engine.

:param model: a :class:`StdModel` class.
:param related: a list of related fields to include in the index.
'''
        update_model = UpdateSE(self, related)
        self.REGISTERED_MODELS[model] = update_model
        self.router.post_commit.bind(update_model, model)
        self.router.post_delete.bind(update_model, model)


Instruction:
Explain what the following Python 3 code does
def words_from_text(self, text, for_search=False):
        '''Generator of indexable words in *text*.
This functions loop through the :attr:`word_middleware` attribute
to process the text.

:param text: string from which to extract words.
:param for_search: flag indicating if the the words will be used for search
    or to index the database. This flug is used in conjunction with the
    middleware flag *for_search*. If this flag is ``True`` (i.e. we need to
    search the database for the words in *text*), only the
    middleware functions in :attr:`word_middleware` enabled for searching are
    used.

    Default: ``False``.

return a *list* of cleaned words.
'''
        if not text:
            return []
        word_gen = self.split_text(text)
        for middleware, fors in self.word_middleware:
            if for_search and not fors:
                continue
            word_gen = middleware(word_gen)
        if isgenerator(word_gen):
            word_gen = list(word_gen)
        return word_gen

Response: Generator of indexable words in text*.


Instruction:
Can you tell what is the following Python 3 function doing
def add_word_middleware(self, middleware, for_search=True):
        '''Add a *middleware* function to the list of :attr:`word_middleware`,
for preprocessing words to be indexed.

:param middleware: a callable receving an iterable over words.
:param for_search: flag indicating if the *middleware* can be used for the
    text to search. Default: ``True``.
'''
        if hasattr(middleware, '__call__'):
            self.word_middleware.append((middleware, for_search))

Response: Add a middleware function to the list of word_middleware functions that will be called when the word is indexed.


Instruction:
Make a summary of the following Python 3 code
def query(self, model):
        '''Return a query for ``model`` when it needs to be indexed.
        '''
        session = self.router.session()
        fields = tuple((f.name for f in model._meta.scalarfields
                        if f.type == 'text'))
        qs = session.query(model).load_only(*fields)
        for related in self.get_related_fields(model):
            qs = qs.load_related(related)
        return qs

Response: Return a query for model when it needs to be indexed.


Instruction:
Can you implement a function in Python 3 that
returns a PEP 386 - compliant version number from *version*.

Response:
def get_version(version):
    "Returns a PEP 386-compliant version number from *version*."
    assert len(version) == 5
    assert version[3] in ('alpha', 'beta', 'rc', 'final')
    parts = 2 if version[2] == 0 else 3
    main = '.'.join(map(str, version[:parts]))
    sub = ''
    if version[3] == 'alpha' and version[4] == 0:
        git_changeset = get_git_changeset()
        if git_changeset:
            sub = '.dev%s' % git_changeset
    elif version[3] != 'final':
        mapping = {'alpha': 'a', 'beta': 'b', 'rc': 'c'}
        sub = mapping[version[3]] + str(version[4])
    return main + sub


Instruction:
Explain what the following Python 3 code does
def Get_RpRs(d, **kwargs):
    '''
    Returns the value of the planet radius over the stellar radius
    for a given depth :py:obj:`d`, given
    the :py:class:`everest.pysyzygy` transit :py:obj:`kwargs`.

    '''
    if ps is None:
            raise Exception("Unable to import `pysyzygy`.")

    def Depth(RpRs, **kwargs):
        return 1 - ps.Transit(RpRs=RpRs, **kwargs)([kwargs.get('t0', 0.)])

    def DiffSq(r):
        return 1.e10 * (d - Depth(r, **kwargs)) ** 2

    return fmin(DiffSq, [np.sqrt(d)], disp=False)

Response:
Returns the value of the planet radius over the stellar radius
    for a given depth.


Instruction:
Can you implement a function in Python 3 that
returns the value of the stellar density for a given transit duration dur.

Response:
def Get_rhos(dur, **kwargs):
    '''
    Returns the value of the stellar density for a given transit
    duration :py:obj:`dur`, given
    the :py:class:`everest.pysyzygy` transit :py:obj:`kwargs`.

    '''
    if ps is None:
            raise Exception("Unable to import `pysyzygy`.")

    assert dur >= 0.01 and dur <= 0.5, "Invalid value for the duration."

    def Dur(rhos, **kwargs):
        t0 = kwargs.get('t0', 0.)
        time = np.linspace(t0 - 0.5, t0 + 0.5, 1000)
        try:
            t = time[np.where(ps.Transit(rhos=rhos, **kwargs)(time) < 1)]
        except:
            return 0.
        return t[-1] - t[0]

    def DiffSq(rhos):
        return (dur - Dur(rhos, **kwargs)) ** 2

    return fmin(DiffSq, [0.2], disp=False)


Instruction:
Can you generate the documentation for the following Python 3 function
def Transit(time, t0=0., dur=0.1, per=3.56789, depth=0.001, **kwargs):
    '''
    A `Mandel-Agol <http://adsabs.harvard.edu/abs/2002ApJ...580L.171M>`_
    transit model, but with the depth and the duration as primary
    input variables.

    :param numpy.ndarray time: The time array
    :param float t0: The time of first transit in units of \
           :py:obj:`BJD` - 2454833.
    :param float dur: The transit duration in days. Don't go too crazy on \
           this one -- very small or very large values will break the \
           inverter. Default 0.1
    :param float per: The orbital period in days. Default 3.56789
    :param float depth: The fractional transit depth. Default 0.001
    :param dict kwargs: Any additional keyword arguments, passed directly \
           to :py:func:`pysyzygy.Transit`
    :returns tmod: The transit model evaluated at the same times as the \
                   :py:obj:`time` array

    '''
    if ps is None:
        raise Exception("Unable to import `pysyzygy`.")

    # Note that rhos can affect RpRs, so we should really do this iteratively,
    # but the effect is pretty negligible!
    RpRs = Get_RpRs(depth, t0=t0, per=per, **kwargs)
    rhos = Get_rhos(dur, t0=t0, per=per, **kwargs)
    return ps.Transit(t0=t0, per=per, RpRs=RpRs, rhos=rhos, **kwargs)(time)

Response: Returns a transit model evaluated at the specified time.


Instruction:
Create a Python 3 function to
evaluate the date intervals from which data is not available. It returns a list of two - dimensional tuples containing start and end dates for the interval.

Response:
def intervals(self, startdate, enddate, parseinterval=None):
        '''Given a ``startdate`` and an ``enddate`` dates, evaluate the
        date intervals from which data is not available. It return a list
        of two-dimensional tuples containing start and end date for the
        interval. The list could contain 0, 1 or 2 tuples.'''
        return missing_intervals(startdate, enddate, self.data_start,
                                 self.data_end, dateconverter=self.todate,
                                 parseinterval=parseinterval)


Instruction:
How would you implement a function in Python 3 that
returns the front pair of the structure

Response:
def front(self, *fields):
        '''Return the front pair of the structure'''
        v, f = tuple(self.irange(0, 0, fields=fields))
        if v:
            return (v[0], dict(((field, f[field][0]) for field in f)))


Instruction:
Here you have a function in Python 3, explain what it does
def istats(self, start=0, end=-1, fields=None):
        '''Perform a multivariate statistic calculation of this
:class:`ColumnTS` from *start* to *end*.

:param start: Optional index (rank) where to start the analysis.
:param end: Optional index (rank) where to end the analysis.
:param fields: Optional subset of :meth:`fields` to perform analysis on.
    If not provided all fields are included in the analysis.
'''
        backend = self.read_backend
        return backend.execute(
            backend.structure(self).istats(start, end, fields), self._stats)

Response:
Perform a multivariate statistic calculation of this
            from start to end.


Instruction:
Can you create a Python 3 function that
performs a multivariate statistic calculation of this Taxonomy object from a start date to an end date.

Response:
def stats(self, start, end, fields=None):
        '''Perform a multivariate statistic calculation of this
:class:`ColumnTS` from a *start*  date/datetime to an
*end* date/datetime.

:param start: Start date for analysis.
:param end: End date for analysis.
:param fields: Optional subset of :meth:`fields` to perform analysis on.
    If not provided all fields are included in the analysis.
'''
        start = self.pickler.dumps(start)
        end = self.pickler.dumps(end)
        backend = self.read_backend
        return backend.execute(
            backend.structure(self).stats(start, end, fields), self._stats)


Instruction:
Explain what the following Python 3 code does
def imulti_stats(self, start=0, end=-1, series=None, fields=None,
                     stats=None):
        '''Perform cross multivariate statistics calculation of
this :class:`ColumnTS` and other optional *series* from *start*
to *end*.

:parameter start: the start rank.
:parameter start: the end rank
:parameter field: name of field to perform multivariate statistics.
:parameter series: a list of two elements tuple containing the id of the
    a :class:`columnTS` and a field name.
:parameter stats: list of statistics to evaluate.
    Default: ['covariance']
'''
        stats = stats or self.default_multi_stats
        backend = self.read_backend
        return backend.execute(
            backend.structure(self).imulti_stats(start, end, fields, series,
                                                 stats), self._stats)

Response:
Perform cross multivariate statistics calculation of
 this object and other optional fields from start to end.


Instruction:
Create a Python 3 function to
merge this : class : ColumnTS with several other series.

Response:
def merge(self, *series, **kwargs):
        '''Merge this :class:`ColumnTS` with several other *series*.

:parameters series: a list of tuples where the nth element is a tuple
    of the form::

    (wight_n, ts_n1, ts_n2, ..., ts_nMn)

The result will be calculated using the formula::

    ts = weight_1*ts_11*ts_12*...*ts_1M1 + weight_2*ts_21*ts_22*...*ts_2M2 +
         ...
'''
        session = self.session
        if not session:
            raise SessionNotAvailable('No session available')
        self.check_router(session.router, *series)
        return self._merge(*series, **kwargs)


Instruction:
Can you write a function in Python 3 where it
merges series and return the results without storing data in the backend server.

Response:
def merged_series(cls, *series, **kwargs):
        '''Merge ``series`` and return the results without storing data
in the backend server.'''
        router, backend = cls.check_router(None, *series)
        if backend:
            target = router.register(cls(), backend)
            router.session().add(target)
            target._merge(*series, **kwargs)
            backend = target.backend
            return backend.execute(
                backend.structure(target).irange_and_delete(),
                target.load_data)


Instruction:
Can you tell what is the following Python 3 function doing
def rank(self, score):
        '''Return the 0-based index (rank) of ``score``. If the score is not
available it returns a negative integer which absolute score is the
left most closest index with score less than *score*.'''
        node = self.__head
        rank = 0
        for i in range(self.__level-1, -1, -1):
            while node.next[i] and node.next[i].score <= score:
                rank += node.width[i]
                node = node.next[i]
        if node.score == score:
            return rank - 1
        else:
            return -1 - rank

Response: Return the 0 - based index of score.


Instruction:
Can you create a Python 3 function that
creates a new instance of model from a state tuple.

Response:
def make_object(self, state=None, backend=None):
        '''Create a new instance of :attr:`model` from a *state* tuple.'''
        model = self.model
        obj = model.__new__(model)
        self.load_state(obj, state, backend)
        return obj


Instruction:
Create a Python 3 function for
performing validation for the given instance and stores serialized data indexes and errors into local cache. Returns True if the instance is ready to be saved to database.

Response:
def is_valid(self, instance):
        '''Perform validation for *instance* and stores serialized data,
indexes and errors into local cache.
Return ``True`` if the instance is ready to be saved to database.'''
        dbdata = instance.dbdata
        data = dbdata['cleaned_data'] = {}
        errors = dbdata['errors'] = {}
        #Loop over scalar fields first
        for field, value in instance.fieldvalue_pairs():
            name = field.attname
            try:
                svalue = field.set_get_value(instance, value)
            except Exception as e:
                errors[name] = str(e)
            else:
                if (svalue is None or svalue is '') and field.required:
                    errors[name] = ("Field '{0}' is required for '{1}'."
                                    .format(name, self))
                else:
                    if isinstance(svalue, dict):
                        data.update(svalue)
                    elif svalue is not None:
                        data[name] = svalue
        return len(errors) == 0


Instruction:
How would you code a function in Python 3 to
return a two elements tuple containing a list of field names and a list of field attribute names.

Response:
def backend_fields(self, fields):
        '''Return a two elements tuple containing a list
of fields names and a list of field attribute names.'''
        dfields = self.dfields
        processed = set()
        names = []
        atts = []
        pkname = self.pkname()
        for name in fields:
            if name == pkname or name in processed:
                continue
            elif name in dfields:
                processed.add(name)
                field = dfields[name]
                names.append(field.name)
                atts.append(field.attname)
            else:
                bname = name.split(JSPLITTER)[0]
                if bname in dfields:
                    field = dfields[bname]
                    if field.type in ('json object', 'related object'):
                        processed.add(name)
                        names.append(name)
                        atts.append(name)
        return names, atts


Instruction:
Write a Python 3 function for
returning the model metadata in a dictionary

Response:
def as_dict(self):
        '''Model metadata in a dictionary'''
        pk = self.pk
        id_type = 3
        if pk.type == 'auto':
            id_type = 1
        return {'id_name': pk.name,
                'id_type': id_type,
                'sorted': bool(self.ordering),
                'autoincr': self.ordering and self.ordering.auto,
                'multi_fields': [field.name for field in self.multifields],
                'indices': dict(((idx.attname, idx.unique)
                                 for idx in self.indices))}


Instruction:
How would you implement a function in Python 3 that
returns the current state for this model.

Response:
def get_state(self, **kwargs):
        '''Return the current :class:`ModelState` for this :class:`Model`.
If ``kwargs`` parameters are passed a new :class:`ModelState` is created,
otherwise it returns the cached value.'''
        dbdata = self.dbdata
        if 'state' not in dbdata or kwargs:
            dbdata['state'] = ModelState(self, **kwargs)
        return dbdata['state']