bin/AdaoCatalogGenerator.py

   1 #-*- coding:utf-8 -*-
   2 #  Copyright (C) 2008-2009  EDF R&D
   3 #
   4 #  This library is free software; you can redistribute it and/or
   5 #  modify it under the terms of the GNU General Public
   6 #  License as published by the Free Software Foundation; either
   7 #  version 2.1 of the License.
   8 #
   9 #  This library is distributed in the hope that it will be useful,
  10 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 #  Lesser General Public License for more details.
  13 #
  14 #  You should have received a copy of the GNU Lesser General Public
  15 #  License along with this library; if not, write to the Free Software
  16 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # --
  19 # Author : André RIBES (EDF R&D)
  20 # --
  21
  22 import logging
  23 import traceback
  24 import sys
  25 import string
  26 import StringIO
  27
  28 logging.basicConfig(level=logging.DEBUG)
  29
  30 #----------- Templates Part ---------------#
  31 begin_catalog_file = """
  32 # -*- coding: utf-8 -*-
  33
  34 # --------------------------------------------------------
  35 # generated by AdaoCatalogGenerator at ${date}
  36 # --------------------------------------------------------
  37
  38 import Accas
  39 from Accas import *
  40
  41 JdC = JDC_CATA (code = 'ADAO',
  42                 execmodul = None,
  43                 regles = ( AU_MOINS_UN ('ASSIMILATION_STUDY'), AU_PLUS_UN ('ASSIMILATION_STUDY')),
  44                )
  45 """
  46
  47 data_method = """
  48 def F_${data_name}(statut) : return FACT(statut = statut,
  49                                          FROM = SIMP(statut = "o", typ = "TXM", into=(${data_into}), defaut=${data_default}),
  50                                          SCRIPT_DATA = BLOC ( condition = " FROM in ( 'Script', ) ",
  51
  52                                                       SCRIPT_FILE = SIMP(statut = "o", typ = "Fichier"),
  53                                                      ),
  54                                          STRING_DATA = BLOC ( condition = " FROM in ( 'String', ) ",
  55
  56                                                       STRING = SIMP(statut = "o", typ = "TXM"),
  57                                                      ),
  58                                          FUNCTIONDICT_DATA = BLOC ( condition = " FROM in ( 'FunctionDict', ) ",
  59
  60                                                       FUNCTIONDICT_FILE = SIMP(statut = "o", typ = "Fichier"),
  61                                                      ),
  62                                     )
  63 """
  64
  65 init_method = """
  66 def F_InitChoice() : return  ("Background",
  67                               "BackgroundError",
  68                               "Observation",
  69                               "ObservationError",
  70                               "ObservationOperator",
  71                               "AlgorithmParameters",
  72                               "UserPostAnalysis",
  73                              )
  74
  75 def F_Init(statut) : return FACT(statut = statut,
  76                                  INIT_FILE = SIMP(statut = "o", typ = "Fichier"),
  77                                  TARGET_LIST = SIMP(statut = "o", typ = "TXM", min=1, max="**", into=F_InitChoice(),  validators=(VerifExiste(2))),
  78                                 )
  79 """
  80
  81 assim_data_method = """
  82 def F_${assim_name}(statut) : return FACT(statut=statut,
  83                                           INPUT_TYPE = SIMP(statut="o", typ = "TXM", into=(${choices}), defaut=${default_choice}),
  84 ${decl_choices}
  85                                                 )
  86 """
  87
  88 assim_data_choice = """
  89                                                  ${choice_name} = BLOC ( condition = " INPUT_TYPE in ( '${choice_name}', ) ",
  90                                                  data = F_${choice_name}("o"),
  91                                                  ),
  92 """
  93
  94 assim_study = """
  95
  96 def F_variables(statut) : return FACT(statut=statut,
  97                                       regles = ( MEME_NOMBRE ('NAMES', 'SIZES')),
  98                                       NAMES = SIMP(statut="o", typ="TXM", max="**", validators=NoRepeat()),
  99                                       SIZES = SIMP(statut="o", typ="I", val_min=1, max="**")
 100                                       )
 101
 102 ASSIMILATION_STUDY = PROC(nom="ASSIMILATION_STUDY",
 103                           op=None,
 104                           repetable           = "n",
 105                           Study_name          = SIMP(statut="o", typ = "TXM"),
 106                           Study_repertory     = SIMP(statut="f", typ = "TXM"),
 107                           Debug               = SIMP(statut="o", typ = "I", into=(0, 1), defaut=0),
 108                           Algorithm           = SIMP(statut="o", typ = "TXM", into=(${algos_names})),
 109                           Background          = F_Background("o"),
 110                           BackgroundError     = F_BackgroundError("o"),
 111                           Observation         = F_Observation("o"),
 112                           ObservationError    = F_ObservationError("o"),
 113                           ObservationOperator = F_ObservationOperator("o"),
 114                           AlgorithmParameters = F_AlgorithmParameters("f"),
 115                           UserDataInit        = F_Init("f"),
 116                           UserPostAnalysis    = F_UserPostAnalysis("f"),
 117                           InputVariables      = F_variables("o"),
 118                           OutputVariables     = F_variables("o")
 119                          )
 120 """
 121
 122 begin_catalog_file = string.Template(begin_catalog_file)
 123 data_method = string.Template(data_method)
 124 assim_data_method = string.Template(assim_data_method)
 125 assim_data_choice = string.Template(assim_data_choice)
 126 assim_study = string.Template(assim_study)
 127
 128 #----------- End of Templates Part ---------------#
 129
 130
 131
 132 #----------- Begin generation script -----------#
 133 print "-- Starting AdaoCalatogGenerator.py --"
 134
 135 try:
 136   import daEficas
 137   import daYacsSchemaCreator
 138   import daCore.AssimilationStudy
 139   import daYacsSchemaCreator.infos_daComposant as infos
 140 except:
 141   logging.fatal("Import of ADAO python modules failed !" +
 142                 "\n add ADAO python installation directory in your PYTHONPATH")
 143   traceback.print_exc()
 144   sys.exit(1)
 145
 146 def check_args(args):
 147   logging.debug("Arguments are :" + str(args))
 148   if len(args) != 2:
 149     logging.fatal("Bad number of arguments: you have to provide two arguments (%d given)" % (len(args)))
 150     sys.exit(1)
 151
 152 # Parse arguments
 153 from optparse import OptionParser
 154 usage = "usage: %prog [options] catalog_path catalog_name"
 155 version="%prog 0.1"
 156 my_parser = OptionParser(usage=usage, version=version)
 157 (options, args) = my_parser.parse_args()
 158 check_args(args)
 159
 160 catalog_path =  args[0]
 161 catalog_name =  args[1]
 162
 163 # Generates into a string
 164 mem_file = StringIO.StringIO()
 165
 166 # Start file
 167 from time import strftime
 168 mem_file.write(begin_catalog_file.substitute(date=strftime("%Y-%m-%d %H:%M:%S")))
 169
 170 # Step 1: A partir des infos, on crée les fonctions qui vont permettre
 171 # d'entrer les données utilisateur
 172 for data_input_name in infos.DataTypeDict.keys():
 173   logging.debug('A data input Type is found: ' + data_input_name)
 174   data_name = data_input_name
 175   data_into = ""
 176   data_default = ""
 177
 178   # On récupère les différentes façon d'entrer les données
 179   for basic_type in infos.DataTypeDict[data_input_name]:
 180     data_into += "\"" + basic_type + "\", "
 181
 182   # On choisit le défault
 183   data_default = "\"" + infos.DataTypeDefaultDict[data_input_name] + "\""
 184
 185   mem_file.write(data_method.substitute(data_name    = data_name,
 186                                         data_into    = data_into,
 187                                         data_default = data_default))
 188
 189 # Step 2: On crée les fonctions qui permettent de rentrer les données des algorithmes
 190 for assim_data_input_name in infos.AssimDataDict.keys():
 191   logging.debug("An assimilation algorithm data input is found: " + assim_data_input_name)
 192   assim_name = assim_data_input_name
 193   choices = ""
 194   default_choice = ""
 195   decl_choices = ""
 196   decl_opts = ""
 197   for choice in infos.AssimDataDict[assim_data_input_name]:
 198     choices += "\"" + choice + "\", "
 199     decl_choices += assim_data_choice.substitute(choice_name = choice)
 200   default_choice = "\"" + infos.AssimDataDefaultDict[assim_data_input_name] + "\""
 201
 202   mem_file.write(assim_data_method.substitute(assim_name = assim_name,
 203                                               choices = choices,
 204                                               decl_choices = decl_choices,
 205                                               default_choice=default_choice))
 206
 207 # Step 3: On ajoute les fonctions représentant les options possibles
 208 for opt_name in infos.OptDict.keys():
 209   logging.debug("An optional node is found: " + opt_name)
 210   data_name = opt_name
 211   data_into = ""
 212   data_default = ""
 213
 214   for choice in infos.OptDict[opt_name]:
 215     data_into += "\"" + choice + "\", "
 216   data_default = "\"" + infos.OptDefaultDict[opt_name] + "\""
 217
 218   mem_file.write(data_method.substitute(data_name = data_name,
 219                                         data_into = data_into,
 220                                         data_default = data_default))
 221
 222 # Step 4: On ajoute la méthode optionnelle init
 223 # TODO uniformiser avec le step 3
 224 mem_file.write(init_method)
 225
 226 # Final step: Add algorithm and assim_study
 227 algos_names = ""
 228 decl_algos = ""
 229
 230 assim_study_object = daCore.AssimilationStudy.AssimilationStudy()
 231 algos_list = assim_study_object.get_available_algorithms()
 232 for algo_name in algos_list:
 233   logging.debug("An assimilation algorithm is found: " + algo_name)
 234   algos_names += "\"" + algo_name + "\", "
 235
 236 mem_file.write(assim_study.substitute(algos_names=algos_names,
 237                                       decl_algos=decl_algos))
 238 # Write file
 239 final_file = open(catalog_path + "/" + catalog_name, "wr")
 240 final_file.write(mem_file.getvalue())
 241 mem_file.close()
 242 final_file.close()
 243