#!/usr/bin/python
import os
from ecflow import *
from datetime import date,timedelta

lmp_envir = "test"
gfsmos_envir = "prod"
nammos_envir = "prod"
hrrr_envir = "para"
rap_envir = "para"
nammos_envir = "prod"

#TODO:
# Any jobs within the same environment (prod/para/test) as the lmp/glmp should be added to
# the suite definition instead of being defined as externs.
# Should we also make all triggers within the same suite relative?

def zpad(i): return str(i).zfill(2)

def build_lmp_run(hour, minute):
    previous_hour = ( hour + 23 ) % 24
    # assume 6-hour cycles
    current_cycle = hour - (hour % 6)
    previous_cycle = previous_hour - (previous_hour % 6)

    # The hrrr_prep job is triggered by the finish of the 15th projection of the
    # previous HRRR cycle and the 1hcnvltg_hrrrprep job is triggered by the finish
    # of the 18th projection of the previous HRRR cycle, where "previous HRRR cycle"
    # is prev_hr-1 for 30m and 45m runs and prev_hr-2 for 00m and 15m runs.
    # 24*60 - (1*60 + 30) = 1350
    hrrr_hour =  int(( (hour*60 + minute) + 1350 ) % 1440 / 60)
    hrrr_cycle = int(hrrr_hour - (hrrr_hour % 6))

    # LMP refreshes GFSMOS/NAMMOS model outputs 4 times a day, namely 04z, 10z, 16z
    # and 22z, where 04z refers to the base 0430z run, etc.  So 04-09z shouldn't run
    # unless the 00z GFSMOS and 00z NAMMOS finish, 10z-15z LMP shouldn't run unless
    # the 06z MOSes finish, and so on.
    # 24*60 - (4*60 + 30) = 1170
#    mos_cycle = int(( ( (hour*60 + minute) + 1170 ) % 1440 / 360 ) * 6)
    mos_cycle = int(hrrr_hour - (hrrr_hour % 6))

    lmp_run_family = Family(zpad(minute))

    ##########################
    # Tasks for all lmp runs #
    ##########################

    # prep job requires that the previous cycle of the gfsmos and lmp (of the same
    # "minute" run) be complete
    prep = lmp_run_family.add_task("lmp_prep")
    if previous_cycle == current_cycle:
      lmp_trigger = "../../{0}z/{1} == complete".format(zpad(previous_hour), zpad(minute))
    elif lmp_envir == "test":
      lmp_trigger = "/test/lmp{0}/{1}z/{2} == complete".format(zpad(previous_cycle), zpad(previous_hour), zpad(minute))
    else:
      lmp_trigger = "/{0}{1}/lmp/{2}z/{3} == complete".format(lmp_envir, zpad(previous_cycle), zpad(previous_hour), zpad(minute))
    prep.add_trigger("/{0}{1}/gfs/mos/prdgen/jgfsmos_prdgen == complete and {2}".format(gfsmos_envir, zpad(mos_cycle), lmp_trigger))

    # hrrr_prep requires the previous cycle of the hrrr
    hrrr_prep = lmp_run_family.add_task("lmp_hrrr_prep")
    hrrr_prep.add_trigger("/{0}{1}/hrrr/{2}z/conus/post/post/jhrrr_post_f18 == complete".format(hrrr_envir, zpad(hrrr_cycle), zpad(hrrr_hour)))

    rap_prep = lmp_run_family.add_task("lmp_rap_prep")
    rap_prep.add_trigger("/{0}{1}/hrrr/{2}z/conus/post/post/jhrrr_post_f18 == complete and /{3}{1}/rap/{2}z/post/post/jrap_post_f21:wrfgrib2_ready".format(hrrr_envir, zpad(hrrr_cycle), zpad(hrrr_hour), rap_envir))

    cigvis_mosfcst = lmp_run_family.add_task("lmp_cigvis_mosfcst")
    cigvis_mosfcst.add_trigger("lmp_prep == complete")

    raphrrr_fcst = lmp_run_family.add_task("lmp_raphrrr_fcst")
    raphrrr_fcst.add_trigger("lmp_hrrr_prep == complete and lmp_rap_prep == complete")

    station_fcst = lmp_run_family.add_task("lmp_station_fcst")
    station_fcst.add_trigger("lmp_prep == complete and lmp_raphrrr_fcst == complete and lmp_cigvis_mosfcst == complete")

    # for main cycle, also triggers off of cnv and ltg families
    prdgen = Task("lmp_prdgen")
    if minute == 30:
        prdgen.add_trigger("lmp_station_fcst == complete and cnv == complete and ltg == complete and pop == complete and lmp_akcnvltg_prdgen == complete")
    else:
        prdgen.add_trigger("lmp_station_fcst == complete")

    ########################################
    # Tasks for main lmp runs only (HH:30) #
    ########################################

    if minute == 30:

        # pop family
        pop_family = Family("pop")

        pop_rapprep = pop_family.add_task("lmp_pop_rapprep")
        pop_rapprep.add_trigger("/{0}{1}/rap/{2}z/post/post/jrap_post_f21 == complete".format(rap_envir, zpad(hrrr_cycle), zpad(hrrr_hour)))

        pop_mosfcst = pop_family.add_task("lmp_pop_mosfcst")
        pop_mosfcst.add_trigger("lmp_pop_rapprep == complete and ../lmp_1hcnvltg_hrrrprep == complete")

        pop_blmpfcst = pop_family.add_task("lmp_pop_blmpfcst")
        pop_blmpfcst.add_trigger("../lmp_1hcnvltg_radltgprep == complete and lmp_pop_mosfcst == complete")

        pop_meldfcst = pop_family.add_task("lmp_pop_meldfcst")
        pop_meldfcst.add_trigger("lmp_pop_blmpfcst == complete")

        pop_prdgen = pop_family.add_task("lmp_pop_prdgen")
        pop_prdgen.add_trigger("lmp_pop_meldfcst == complete")

        #cnv/ltg family

        cnv_family = Family("cnv")
        ltg_family = Family("ltg")

        # cnvltg_prep is run separately for cnv and ltg
        cl_prep_trigger = "/{0}{1}/nam/tm00/mos/jnam_mos == complete and ../lmp_prep == complete and /{2}{3}/gfs/mos/forecast/jgfsmos_fcst == complete".format(nammos_envir, zpad(mos_cycle), gfsmos_envir, zpad(mos_cycle))
        cl_prep = cnv_family.add_task("lmp_cnvltg_prep")
        cl_prep.add_trigger(cl_prep_trigger)
        cl_prep = ltg_family.add_task("lmp_cnvltg_prep")
        cl_prep.add_trigger(cl_prep_trigger)

        # cnvltg_fcst is run separately for cnv and ltg
        cl_fcst = cnv_family.add_task("lmp_cnvltg_fcst")
        cl_fcst.add_trigger("lmp_cnvltg_prep == complete")
        cl_fcst = ltg_family.add_task("lmp_cnvltg_fcst")
        cl_fcst.add_trigger("lmp_cnvltg_prep == complete")

        # cnvltg_prdgen is run separately for cnv and ltg
        cl_prdgen = cnv_family.add_task("lmp_cnvltg_prdgen")
        cl_prdgen.add_trigger("lmp_cnvltg_fcst == complete")
        cl_prdgen = ltg_family.add_task("lmp_cnvltg_prdgen")
        cl_prdgen.add_trigger("lmp_cnvltg_fcst == complete")

        hcl_mrmsprep = lmp_run_family.add_task("lmp_1hcnvltg_mrmsprep")
        hcl_mrmsprep.add_trigger("/{0}{1}/gfs/mos/prep/jgfsmos_prep == complete".format(gfsmos_envir, zpad(mos_cycle)))

        hcl_hrrrprep = lmp_run_family.add_task("lmp_1hcnvltg_hrrrprep")
        hcl_hrrrprep.add_trigger("/{0}{1}/hrrr/{2}z/conus/post/post/jhrrr_post_f18 == complete".format(hrrr_envir, zpad(hrrr_cycle), zpad(hrrr_hour)))

        hcl_radltgprep = lmp_run_family.add_task("lmp_1hcnvltg_radltgprep")
        hcl_radltgprep.add_trigger("lmp_1hcnvltg_mrmsprep == complete and lmp_1hcnvltg_hrrrprep == complete")

        hcl_mosfcst = lmp_run_family.add_task("lmp_1hcnvltg_mosfcst")
        hcl_mosfcst.add_trigger("/{0}{1}/nam/tm00/mos/jnam_mos_prep == complete and /{2}{3}/gfs/mos/prep/jgfsmos_stn_prep == complete".format(nammos_envir, zpad(mos_cycle), gfsmos_envir, zpad(mos_cycle)))

        # 1hcnvltg_mospreds is run separately for cnv and ltg
        hcl_mospreds = cnv_family.add_task("lmp_1hcnvltg_mospreds")
        hcl_mospreds.add_trigger("../lmp_1hcnvltg_mosfcst == complete")
        hcl_mospreds = ltg_family.add_task("lmp_1hcnvltg_mospreds")
        hcl_mospreds.add_trigger("../lmp_1hcnvltg_mosfcst == complete")

        hcl_fcst = lmp_run_family.add_task("lmp_1hcnvltg_fcst")
        hcl_fcst.add_trigger("lmp_1hcnvltg_radltgprep == complete and cnv/lmp_1hcnvltg_mospreds == complete and ltg/lmp_1hcnvltg_mospreds == complete")

        # 1hcnvltg_prdgen is run separately for cnv and ltg
        hcl_prdgen = cnv_family.add_task("lmp_1hcnvltg_prdgen")
        hcl_prdgen.add_trigger("../lmp_1hcnvltg_fcst == complete")
        hcl_prdgen = ltg_family.add_task("lmp_1hcnvltg_prdgen")
        hcl_prdgen.add_trigger("../lmp_1hcnvltg_fcst == complete")

        # Alaska cnvltg
        akcl_rapprep = lmp_run_family.add_task("lmp_akcnvltg_rapprep")
        akcl_rapprep.add_trigger("/{0}{1}/rap/{2}z/post/post/jrap_post_f21 == complete".format(rap_envir, zpad(hrrr_cycle), zpad(hrrr_hour)))
               
        akcl_mrmsprep = lmp_run_family.add_task("lmp_akcnvltg_mrmsprep")

        akcl_radltgprep = lmp_run_family.add_task("lmp_akcnvltg_radltgprep")
        akcl_radltgprep.add_trigger("lmp_akcnvltg_mrmsprep == complete")

        akcl_mosfcst = lmp_run_family.add_task("lmp_akcnvltg_mosfcst")
        akcl_mosfcst.add_trigger("lmp_akcnvltg_rapprep == complete")

        akcl_blmpfcst = lmp_run_family.add_task("lmp_akcnvltg_blmpfcst")
        akcl_blmpfcst.add_trigger("lmp_akcnvltg_radltgprep == complete and lmp_akcnvltg_mosfcst == complete")

        akcl_meldfcst = lmp_run_family.add_task("lmp_akcnvltg_meldfcst")
        akcl_meldfcst.add_trigger("lmp_akcnvltg_blmpfcst == complete")

        akcl_prdgen = lmp_run_family.add_task("lmp_akcnvltg_prdgen")
        akcl_prdgen.add_trigger("lmp_akcnvltg_meldfcst == complete")

        lmp_run_family.add_family(cnv_family)
        lmp_run_family.add_family(ltg_family)
        lmp_run_family.add_family(pop_family)

        ak_prdgen = lmp_run_family.add_task("lmp_ak_prdgen")
        if lmp_envir == "test":
           ak_prdgen.add_trigger("../../../glmp{0}/{1}z/{2}/cig/glmp_meld_prdgen_ak == complete and ../../../glmp{0}/{1}z/{2}/vis/glmp_meld_prdgen_ak == complete".format(zpad(current_cycle), zpad(hour), zpad(minute)))
        else:
           ak_prdgen.add_trigger("../../../glmp/{0}z/{1}/cig/glmp_meld_prdgen_ak == complete and ../../../glmp/{0}z/{1}/vis/glmp_meld_prdgen_ak == complete".format(zpad(hour), zpad(minute)))

    lmp_run_family.add_task(prdgen)

    # the run actually starts 3 minutes before the "run time"
    if minute == 0:
        lmp_run_family.add_time("{0}:{1}".format(zpad(previous_hour), "57"))
    else:
        lmp_run_family.add_time("{0}:{1}".format(zpad(hour), zpad(minute-3)))

    return lmp_run_family

def build_glmp_run(hour, minute):
    previous_hour = ( hour + 23 ) % 24
    # assume 6-hour cycles
    current_cycle = hour - (hour % 6)
    previous_cycle = previous_hour - (previous_hour % 6)

    # GLMP refreshes GFSMOS model outputs twice a day, namely 06z and 18z, where 06z
    # refers to the main 0630z run, etc.  So 06z-17z shouldn't run unless the 00z
    # GFSMOS is complete and 18z-05z GLMP shouldn't run unless the 12z MOS is finished
    # 24*60 - (6*60 + 30) = 1050
#    mos_cycle = ( ( (hour*60 + minute) + 1050 ) % 1440 / 720 ) * 12

    rap_hour =  int(( (hour*60 + minute) + 1350 ) % 1440 / 60)
    rap_cycle = int(rap_hour - (rap_hour % 6))

    mos_cycle = int(rap_hour - (rap_hour % 6))

    glmp_run_family = Family(zpad(minute))

    ###########################
    # Tasks for all glmp runs #
    ###########################

    obs_prep = glmp_run_family.add_task("glmp_obs_prep")

#    hrrr_prep = glmp_run_family.add_task("glmp_hrrr_prep")
#    if lmp_envir == "test":
#      hrrr_prep.add_trigger("../../../lmp{0}/{1}z/{2}/lmp_hrrr_prep == complete".format(zpad(current_cycle), zpad(hour), zpad(minute)))
#    else:
#      hrrr_prep.add_trigger("../../../lmp/{0}z/{1}/lmp_hrrr_prep == complete".format(zpad(hour), zpad(minute)))

    raphrrr_fcst = glmp_run_family.add_task("glmp_raphrrr_fcst")
    if lmp_envir == "test":
       raphrrr_fcst.add_trigger("../../../lmp{0}/{1}z/{2}/lmp_hrrr_prep == complete".format(zpad(current_cycle), zpad(hour), zpad(minute)))
    else:
       raphrrr_fcst.add_trigger("../../../lmp/{0}z/{1}/lmp_hrrr_prep == complete".format(zpad(hour), zpad(minute)))

    rap1h_prep = glmp_run_family.add_task("glmp_rap1h_prep")
    rap1h_prep.add_trigger("/{0}{1}/rap/{2}z/post/post/jrap_post_f21 == complete".format(rap_envir, zpad(rap_cycle), zpad(rap_hour)))

    fcst_rap3 = glmp_run_family.add_task("glmp_fcst_rap3")
    if lmp_envir == "test":
       fcst_rap3.add_trigger("../../../lmp{0}/{1}z/{2}/lmp_rap_prep == complete and /{3}{4}/rap/{5}z/post/post/jrap_post_f21 == complete".format(zpad(current_cycle), zpad(hour), zpad(minute), rap_envir, zpad(rap_cycle), zpad(rap_hour)))
    else:
       fcst_rap3.add_trigger("../../../lmp/{0}z/{1}/lmp_rap_prep == complete and /{2}{3}/rap/{4}z/post/post/jrap_post_f21 == complete".format(zpad(hour), zpad(minute), rap_envir, zpad(rap_cycle), zpad(rap_hour)))

    vis_family = glmp_run_family.add_family("vis")
    sky_family = glmp_run_family.add_family("sky")
    cig_family = glmp_run_family.add_family("cig")

    obs_granalysis = vis_family.add_task("glmp_obs_granalysis")
    obs_granalysis.add_trigger("../glmp_obs_prep == complete and ../glmp_rap1h_prep == complete")
    obs_granalysis = sky_family.add_task("glmp_obs_granalysis")
    obs_granalysis.add_trigger("../glmp_obs_prep == complete and ../glmp_rap1h_prep == complete")
    obs_granalysis = cig_family.add_task("glmp_obs_granalysis")
    obs_granalysis.add_trigger("../glmp_obs_prep == complete and ../glmp_rap1h_prep == complete")

    obs_granalysis_ak = cig_family.add_task("glmp_obs_granalysis_ak")
    obs_granalysis_ak.add_trigger("../glmp_obs_prep == complete and ../glmp_rap1h_prep == complete")
    obs_granalysis_ak = vis_family.add_task("glmp_obs_granalysis_ak")
    obs_granalysis_ak.add_trigger("../glmp_obs_prep == complete and ../glmp_rap1h_prep == complete")

    obs_prdgen = vis_family.add_task("glmp_obs_prdgen")
    obs_prdgen.add_trigger("glmp_obs_granalysis == complete")
    obs_prdgen = sky_family.add_task("glmp_obs_prdgen")
    obs_prdgen.add_trigger("glmp_obs_granalysis == complete")
    obs_prdgen = cig_family.add_task("glmp_obs_prdgen")
    obs_prdgen.add_trigger("glmp_obs_granalysis == complete")

    obs_prdgen_ak = vis_family.add_task("glmp_obs_prdgen_ak")
    obs_prdgen_ak.add_trigger("glmp_obs_granalysis_ak == complete")
    obs_prdgen_ak = cig_family.add_task("glmp_obs_prdgen_ak")
    obs_prdgen_ak.add_trigger("glmp_obs_granalysis_ak == complete")

    if lmp_envir == "test":
      fcst_granalysis_p_trigger = "../../../../lmp{0}/{1}z/{2}/lmp_prdgen == complete and ../glmp_raphrrr_fcst == complete".format(zpad(current_cycle), zpad(hour), zpad(minute))
      fcst_granalysis_p_ak_trigger = "../../../../lmp{0}/{1}z/{2}/lmp_prdgen == complete and ../glmp_fcst_rap3 == complete".format(zpad(current_cycle), zpad(hour), zpad(minute))
      fcst_granalysis_trigger = "../../../../lmp{0}/{1}z/{2}/lmp_prdgen == complete and ../glmp_obs_prep == complete".format(zpad(current_cycle), zpad(hour), zpad(minute))
    else:
      fcst_granalysis_p_trigger = "../../../../lmp/{0}z/{1}/lmp_prdgen == complete and ../glmp_raphrrr_fcst == complete".format(zpad(hour), zpad(minute))
      fcst_granalysis_p_ak_trigger = "../../../../lmp/{0}z/{1}/lmp_prdgen == complete and ../glmp_fcst_rap3 == complete".format(zpad(hour), zpad(minute))
      fcst_granalysis_trigger = "../../../../lmp/{0}z/{1}/lmp_prdgen == complete and ../glmp_obs_prep == complete".format(zpad(hour), zpad(minute))

    fcst_granalysis_p = vis_family.add_task("glmp_fcst_granalysis_p")
    fcst_granalysis_p.add_trigger(fcst_granalysis_p_trigger)
    fcst_granalysis_p = cig_family.add_task("glmp_fcst_granalysis_p")
    fcst_granalysis_p.add_trigger(fcst_granalysis_p_trigger)
    fcst_granalysis_p = sky_family.add_task("glmp_fcst_granalysis_p")
    fcst_granalysis_p.add_trigger(fcst_granalysis_p_ak_trigger)
    fcst_granalysis = sky_family.add_task("glmp_fcst_granalysis")
    fcst_granalysis.add_trigger(fcst_granalysis_trigger)

    fcst_granalysis_p_ak = vis_family.add_task("glmp_fcst_granalysis_p_ak")
    fcst_granalysis_p_ak.add_trigger(fcst_granalysis_p_ak_trigger)
    fcst_granalysis_p_ak = cig_family.add_task("glmp_fcst_granalysis_p_ak")
    fcst_granalysis_p_ak.add_trigger(fcst_granalysis_p_ak_trigger)

    fcst_meld = vis_family.add_task("glmp_fcst_meld")
    fcst_meld.add_trigger("../glmp_raphrrr_fcst == complete and glmp_fcst_granalysis_p == complete and glmp_obs_granalysis == complete")
    fcst_meld = cig_family.add_task("glmp_fcst_meld")
    fcst_meld.add_trigger("../glmp_raphrrr_fcst == complete and glmp_fcst_granalysis_p == complete and glmp_obs_granalysis == complete")

    fcst_meld_ak = vis_family.add_task("glmp_fcst_meld_ak")
    fcst_meld_ak.add_trigger("glmp_fcst_granalysis_p_ak == complete and glmp_obs_granalysis_ak == complete")
    fcst_meld_ak = cig_family.add_task("glmp_fcst_meld_ak")
    fcst_meld_ak.add_trigger("glmp_fcst_granalysis_p_ak == complete and glmp_obs_granalysis_ak == complete")

    meld_prdgen = vis_family.add_task("glmp_meld_prdgen")
    meld_prdgen.add_trigger("glmp_fcst_meld == complete")
    meld_prdgen = cig_family.add_task("glmp_meld_prdgen")
    meld_prdgen.add_trigger("glmp_fcst_meld == complete")

    meld_prdgen_ak = vis_family.add_task("glmp_meld_prdgen_ak")
    meld_prdgen_ak.add_trigger("glmp_fcst_meld_ak == complete")
    meld_prdgen_ak = cig_family.add_task("glmp_meld_prdgen_ak")
    meld_prdgen_ak.add_trigger("glmp_fcst_meld_ak == complete")

    fcst_prdgen = sky_family.add_task("glmp_fcst_prdgen")
    fcst_prdgen.add_trigger("glmp_fcst_granalysis == complete and ../cig/glmp_meld_prdgen == complete")
    fcst_prdgen_p = sky_family.add_task("glmp_fcst_prdgen_p")
    fcst_prdgen_p.add_trigger("glmp_fcst_granalysis_p == complete")

    #########################################
    # Tasks for main glmp runs only (HH:30) #
    #########################################

    if minute == 30:
        glmp_mos_prdgen = glmp_run_family.add_task("glmp_mos_prep")
        glmp_mos_prdgen.add_trigger("/{0}{1}/gfs/mos/prdgen/jgfsmos_ext_prdgen == complete".format(gfsmos_envir, zpad(mos_cycle)))

        tdp_family = glmp_run_family.add_family("tdp")
        wsg_family = glmp_run_family.add_family("wsg")

        obs_granalysis = tdp_family.add_task("glmp_obs_granalysis")
        obs_granalysis.add_trigger("../glmp_obs_prep == complete and ../glmp_mos_prep == complete")
        obs_granalysis = wsg_family.add_task("glmp_obs_granalysis")
        obs_granalysis.add_trigger("../glmp_obs_prep == complete and ../glmp_mos_prep == complete")

        obs_prdgen = tdp_family.add_task("glmp_obs_prdgen")
        obs_prdgen.add_trigger("glmp_obs_granalysis == complete")
        obs_prdgen = wsg_family.add_task("glmp_obs_prdgen")
        obs_prdgen.add_trigger("glmp_obs_granalysis == complete")

        if lmp_envir == "test":
          fcst_granalysis_trigger = "../../../../lmp{0}/{1}z/{2}/lmp_prdgen == complete and glmp_obs_granalysis == complete".format(zpad(current_cycle), zpad(hour), zpad(minute))
        else:
          fcst_granalysis_trigger = "../../../../lmp/{0}z/{1}/lmp_prdgen == complete and glmp_obs_granalysis == complete".format(zpad(hour), zpad(minute))

        fcst_granalysis = tdp_family.add_task("glmp_fcst_granalysis")
        fcst_granalysis.add_trigger(fcst_granalysis_trigger)
        fcst_granalysis = wsg_family.add_task("glmp_fcst_granalysis")
        fcst_granalysis.add_trigger(fcst_granalysis_trigger)

        fcst_prdgen = tdp_family.add_task("glmp_fcst_prdgen")
        fcst_prdgen.add_trigger("glmp_fcst_granalysis == complete")
        fcst_prdgen = wsg_family.add_task("glmp_fcst_prdgen")
        fcst_prdgen.add_trigger("glmp_fcst_granalysis == complete")

        glmp_prdgen_nomads = glmp_run_family.add_task("glmp_prdgen_nomads")
        glmp_prdgen_nomads.add_trigger("vis/glmp_meld_prdgen == complete and vis/glmp_meld_prdgen_ak == complete and cig/glmp_meld_prdgen == complete and cig/glmp_meld_prdgen_ak == complete and sky/glmp_fcst_prdgen == complete")

    # the run actually starts 4 minutes before the "run time"
    if minute == 0:
        glmp_run_family.add_time("{0}:{1}".format(zpad(previous_hour), "56"))
    else:
        glmp_run_family.add_time("{0}:{1}".format(zpad(hour), zpad(minute-4)))

    return glmp_run_family


defs = Defs()

if lmp_envir == "test":
    suite = defs.add_suite("test")

for cycle in range(0, 24, 6):
    if lmp_envir != "test":
      suite = defs.add_suite("{0}{1}".format(lmp_envir, zpad(cycle)))
    lmp_family = suite.add_family("lmp" if lmp_envir != "test" else "lmp{0}".format(zpad(cycle)))
#    lmp_family = suite.add_family("lmp")
    lmp_family.add_variable('PROJ', 'LAMP')
    lmp_family.add_variable('QUEUE', 'prod' if lmp_envir == "prod" else 'preprod')
    if lmp_envir == "prod":
       lmp_family.add_variable('ECF_FILES', '/ecf/ecfnets/scripts/lmp')
    else:
       lmp_family.add_variable('ECF_FILES', '/ecf/ecfnets/scripts/{0}/lmp'.format(lmp_envir))

    for hour in range(cycle, cycle+6):
        hourly_lmp_family = lmp_family.add_family("{0}z".format(zpad(hour)))
        hourly_lmp_family.add_variable('CYC', zpad(hour))
        for minute in range(0, 60, 15):
            minute_lmp_family = hourly_lmp_family.add_family(build_lmp_run(hour, minute))
            minute_lmp_family.add_variable('MIN', zpad(minute))

    glmp_family = suite.add_family("glmp" if lmp_envir != "test" else "glmp{0}".format(zpad(cycle)))
#    glmp_family = suite.add_family("glmp")
    glmp_family.add_variable('PROJ', 'LAMP')
    glmp_family.add_variable('QUEUE', 'prod' if lmp_envir == "prod" else 'preprod')
    if lmp_envir != "prod":
        glmp_family.add_variable('COMPATH', '/gpfs/dell1/nco/ops/com/lmp/{0}'.format(lmp_envir))

    if lmp_envir == "prod":
       glmp_family.add_variable('ECF_FILES', '/ecf/ecfnets/scripts/glmp')
    else:
       glmp_family.add_variable('ECF_FILES', '/ecf/ecfnets/scripts/{0}/glmp'.format(lmp_envir))

    for hour in range(cycle, cycle+6):
        hourly_glmp_family = glmp_family.add_family("{0}z".format(zpad(hour)))
        hourly_glmp_family.add_variable('CYC', zpad(hour))
        for minute in range(0, 60, 15):
            minute_glmp_family = hourly_glmp_family.add_family(build_glmp_run(hour, minute))
            minute_glmp_family.add_variable('MIN', zpad(minute))

    defs.auto_add_externs(False)
#    defs.auto_add_externs(True)
    defs.save_as_defs("lmp_{0}{1}.def".format(lmp_envir, zpad(cycle)))

#try:
    #cli = Client()

#except RuntimeError, e:
#    print str(e)