*Given a the k-correction lightcurve, convert it to a polynomial, plot if requested and dump to a separate file.*

    **Key Arguments:**
        - ``log`` -- logger
        - ``model`` -- the transient model name
        - ``pathToOutputDirectory`` -- path to the output directory (provided by the user)
        - ``redshift`` -- the redshift of the k-correction listing to plot
        - ``ffilter`` -- the k-correction rest frame filter
        - ``restFrameFilter`` -- the observed frame filter
        - ``kCorPolyOrder`` -- the order of the polynomial to fit
        - ``kCorMinimumDataPoints`` -- Minimum number of datapoints used to generate k-correction curve
        - ``plot`` -- plot the polynomial?

    **Return:**
        - None

def generate_single_kcorrection_polynomial(
        log,
        model,
        pathToOutputDirectory,
        redshift,
        ffilter,
        restFrameFilter,
        kCorPolyOrder=3,
        kCorMinimumDataPoints=3,
        plot=False):
    """
    *Given a the k-correction lightcurve, convert it to a polynomial, plot if requested and dump to a separate file.*

    **Key Arguments:**
        - ``log`` -- logger
        - ``model`` -- the transient model name
        - ``pathToOutputDirectory`` -- path to the output directory (provided by the user)
        - ``redshift`` -- the redshift of the k-correction listing to plot
        - ``ffilter`` -- the k-correction rest frame filter
        - ``restFrameFilter`` -- the observed frame filter
        - ``kCorPolyOrder`` -- the order of the polynomial to fit
        - ``kCorMinimumDataPoints`` -- Minimum number of datapoints used to generate k-correction curve
        - ``plot`` -- plot the polynomial?

    **Return:**
        - None
    """
    ################ > IMPORTS ################
    ## STANDARD LIB ##
    ## THIRD PARTY ##
    import numpy as np
    import yaml
    ## LOCAL APPLICATION ##
    import dryxPython.plotting as dp

    ################ >ACTION(S) ################
    strRed = "%0.3f" % (redshift,)
    dataDir = pathToOutputDirectory + "/k_corrections/%s/%s" % (model, ffilter)
    pathToYaml = dataDir + "/z" + str(strRed).replace(".", "pt") + ".yaml"
    fileName = pathToYaml
    stream = file(fileName, 'r')
    yamlList = yaml.load(stream)
    thisKcor = 'K_%s%s' % (restFrameFilter, ffilter)
    stream.close()

    kCor = []
    time = []

    if not yamlList:
        return

    try:
        log.debug(
            "attempting to generate a k-correction polynomial plot from the file: %s" %
            (fileName,))
        for item in yamlList:
            kCor.append(item[thisKcor])
            time.append(item['Rest Frame Days'])
    except Exception as e:
        log.warning(
            "could not generate a k-correction polynomial plot from the file %s:  - failed with this error: %s " %
            (fileName, str(e),))
        return -1

    if len(kCor) < kCorMinimumDataPoints:
        basename = os.path.basename(fileName)
        log.warning(
            'the k-correction file %s contains less than %s datapoints to convert from %s restframe to %s observed frame for the %s model - polynomial shall not be generated' %
            (basename, kCorMinimumDataPoints, restFrameFilter, ffilter, model))
        return

    kCorArray = np.array(kCor)
    timeArray = np.array(time)
    xMin = np.min(timeArray)
    xMax = np.max(timeArray)

    timeDist = 50
    timeDelta = 40
    for i in range(4):
        timeArray = np.append(timeArray, xMin - timeDist - i * timeDelta)
        timeArray = np.append(timeArray, xMax + timeDist + i * timeDelta)
        kCorArray = np.append(kCorArray, [0, 0])

    log.debug('timeArray: %s' % (timeArray,))
    log.debug('kCorArray: %s' % (kCorArray,))

    expand = 150
    xMin -= expand
    xMax += expand

    thisPoly = np.polyfit(timeArray, kCorArray, kCorPolyOrder)
    flatPoly = np.poly1d(thisPoly)
    polyDict = {}
    dataDict = {}
    polyDict[redshift] = flatPoly
    dataDict[redshift] = [timeArray, kCorArray]

    title = "k_%s%s at z = %s" % (restFrameFilter, ffilter, redshift)

    if plot:
        fileName = plot_polynomial(
            log,
            title=title,
            polynomialDict=polyDict,
            orginalDataDictionary=dataDict,
            pathToOutputPlotsFolder=dataDir + "/",
            xRange=[xMin, xMax],
            xAxisLimits=[xMin + 100, xMax - 100],
            yAxisLimits=[-5, 5],
            yAxisInvert=False,
            prependNum=False)

        # mdLog.write("""![%s_plot]\n\n[%s_plot]: %s\n\n""" % (title.replace(" ", "_"), title.replace(" ", "_"), fileName,))

    newFileName = dataDir + "/z" + \
        str(strRed).replace(".", "pt") + "_poly.yaml"
    stream = file(newFileName, 'w')
    yamlContent = {'polyCoeffs': flatPoly.coeffs}
    #log.debug('flatPoly.coeffs %s' % (flatPoly.coeffs,))
    yaml.dump(yamlContent, stream, default_flow_style=True)
    stream.close()

    return