src/daSalome/adaoBuilder.py

   1 #-*-coding:iso-8859-1-*-
   2 #
   3 # Copyright (C) 2008-2016 EDF R&D
   4 #
   5 # This library is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU Lesser General Public
   7 # License as published by the Free Software Foundation; either
   8 # version 2.1 of the License.
   9 #
  10 # This library is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 # Lesser General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU Lesser General Public
  16 # License along with this library; if not, write to the Free Software
  17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 #
  19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 #
  21 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  22
  23 """
  24     Interface de scripting pour une étude ADAO
  25 """
  26 __author__ = "Jean-Philippe ARGAUD"
  27 __all__ = ["New"]
  28
  29 import os
  30 from daCore import AssimilationStudy, Templates
  31
  32 # ==============================================================================
  33 class New(object):
  34     """
  35     Creation TUI d'un cas ADAO
  36     """
  37     def __init__(self, name = ""):
  38         self.__adaoStudy = AssimilationStudy.AssimilationStudy(name)
  39         self.__dumper = _DumpLogger(name)
  40
  41     # -----------------------------------------------------------
  42
  43     def set(
  44             self,
  45             Concept              = None,
  46             Algorithm            = None,
  47             DiagonalSparseMatrix = None,
  48             Info                 = None,
  49             Matrix               = None,
  50             OneFunction          = None,
  51             Parameters           = None,
  52             ScalarSparseMatrix   = None,
  53             Script               = None,
  54             Stored               = False,
  55             String               = None,
  56             Template             = None,
  57             ThreeFunctions       = None,
  58             AppliedInXb          = None,
  59             Variable             = None,
  60             Vector               = None,
  61             VectorSerie          = None):
  62         "Interface unique de définition de variables d'entrées par argument"
  63         self.__dumper.register("set",dir(),locals(),None,True)
  64         try:
  65             if   Concept == "Background":
  66                 self.setBackground(Vector,VectorSerie,Script,Stored)
  67             elif Concept == "BackgroundError":
  68                 self.setBackgroundError(Matrix,ScalarSparseMatrix,
  69                                         DiagonalSparseMatrix,Script,Stored)
  70             elif Concept == "CheckingPoint":
  71                 self.setCheckingPoint(Vector,VectorSerie,Script,Stored)
  72             elif Concept == "ControlModel":
  73                 self.setControlModel(Matrix,OneFunction,ThreeFunctions,
  74                                      Parameters,Script,Stored)
  75             elif Concept == "ControlInput":
  76                 self.setControlInput(Vector,VectorSerie,Script,Stored)
  77             elif Concept == "EvolutionError":
  78                 self.setEvolutionError(Matrix,ScalarSparseMatrix,
  79                                        DiagonalSparseMatrix,Script,Stored)
  80             elif Concept == "EvolutionModel":
  81                 self.setEvolutionModel(Matrix,OneFunction,ThreeFunctions,
  82                                        Parameters,Script,Stored)
  83             elif Concept == "Observation":
  84                 self.setObservation(Vector,VectorSerie,Script,Stored)
  85             elif Concept == "ObservationError":
  86                 self.setObservationError(Matrix,ScalarSparseMatrix,
  87                                          DiagonalSparseMatrix,Script,Stored)
  88             elif Concept == "ObservationOperator":
  89                 self.setObservationOperator(Matrix,OneFunction,ThreeFunctions,
  90                                             AppliedInXb, Parameters,Script,Stored)
  91             elif Concept == "AlgorithmParameters":
  92                 self.setAlgorithmParameters(Algorithm,Parameters,Script)
  93             elif Concept == "Debug":
  94                 self.setDebug()
  95             elif Concept == "NoDebug":
  96                 self.setNoDebug()
  97             elif Concept == "Observer":
  98                 self.setObserver(Variable,Template,String,Script,Info)
  99             else:
 100                 raise ValueError("the variable named '%s' is not allowed."%str(Concept))
 101         except Exception as e:
 102             if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
 103             else: msg = ""
 104             raise ValueError("during settings, the following error occurs:\n\n%s %s\n\nSee also the potential messages, which can show the origin of the above error, in the launching terminal."%(str(e),msg))
 105
 106     # -----------------------------------------------------------
 107
 108     def setBackground(
 109             self,
 110             Vector         = None,
 111             VectorSerie    = None,
 112             Script         = None,
 113             Stored         = False):
 114         "Définition d'une entrée de calcul"
 115         self.__dumper.register("setBackground", dir(), locals())
 116         if Script is not None:
 117             __Vector, __PersistentVector = None, None
 118             if VectorSerie:
 119                 __PersistentVector = _ImportFromScript(Script).getvalue( "Background" )
 120             else:
 121                 __Vector = _ImportFromScript(Script).getvalue( "Background" )
 122         else:
 123             __Vector, __PersistentVector = Vector, VectorSerie
 124         #
 125         self.__adaoStudy.setBackground(
 126             asVector           = __Vector,
 127             asPersistentVector = __PersistentVector,
 128             toBeStored         = Stored,
 129             )
 130
 131     def setBackgroundError(
 132             self,
 133             Matrix               = None,
 134             ScalarSparseMatrix   = None,
 135             DiagonalSparseMatrix = None,
 136             Script               = None,
 137             Stored               = False):
 138         "Définition d'une entrée de calcul"
 139         self.__dumper.register("setBackgroundError", dir(), locals())
 140         if Script is not None:
 141             __Covariance, __Scalar, __Vector = None, None, None
 142             if ScalarSparseMatrix:
 143                 __Scalar = _ImportFromScript(Script).getvalue( "BackgroundError" )
 144             elif DiagonalSparseMatrix:
 145                 __Vector = _ImportFromScript(Script).getvalue( "BackgroundError" )
 146             else:
 147                 __Covariance = _ImportFromScript(Script).getvalue( "BackgroundError" )
 148         else:
 149             __Covariance, __Scalar, __Vector = Matrix, ScalarSparseMatrix, DiagonalSparseMatrix
 150         #
 151         self.__adaoStudy.setBackgroundError(
 152             asCovariance  = __Covariance,
 153             asEyeByScalar = __Scalar,
 154             asEyeByVector = __Vector,
 155             toBeStored    = Stored,
 156             )
 157
 158     def setCheckingPoint(
 159             self,
 160             Vector         = None,
 161             VectorSerie    = None,
 162             Script         = None,
 163             Stored         = False):
 164         "Définition d'une entrée de vérification"
 165         self.__dumper.register("setCheckingPoint", dir(), locals())
 166         if Script is not None:
 167             __Vector, __PersistentVector = None, None
 168             if VectorSerie:
 169                 __PersistentVector = _ImportFromScript(Script).getvalue( "CheckingPoint" )
 170             else:
 171                 __Vector = _ImportFromScript(Script).getvalue( "CheckingPoint" )
 172         else:
 173             __Vector, __PersistentVector = Vector, VectorSerie
 174         #
 175         self.__adaoStudy.setBackground(
 176             asVector           = __Vector,
 177             asPersistentVector = __PersistentVector,
 178             toBeStored         = Stored,
 179             )
 180
 181     def setControlModel(
 182             self,
 183             Matrix         = None,
 184             OneFunction    = None,
 185             ThreeFunctions = None,
 186             Parameters     = None,
 187             Script         = None,
 188             Stored         = False):
 189         "Définition d'une entrée de calcul"
 190         self.__dumper.register("setControlModel", dir(), locals())
 191         __Parameters = {}
 192         if (Parameters is not None) and isinstance(Parameters, dict):
 193             if "DifferentialIncrement" in Parameters:
 194                 __Parameters["withIncrement"] = Parameters["DifferentialIncrement"]
 195             if "CenteredFiniteDifference" in Parameters:
 196                 __Parameters["withCenteredDF"] = Parameters["CenteredFiniteDifference"]
 197         if Script is not None:
 198             __Matrix, __Function = None, None
 199             if Matrix:
 200                 __Matrix = _ImportFromScript(Script).getvalue( "ObservationOperator" )
 201             elif OneFunction:
 202                 __Function = { "Direct":_ImportFromScript(Script).getvalue( "DirectOperator" ) }
 203                 __Function.update({"useApproximatedDerivatives":True})
 204                 __Function.update(__Parameters)
 205             elif ThreeFunctions:
 206                 __Function = {
 207                     "Direct" :_ImportFromScript(Script).getvalue( "DirectOperator" ),
 208                     "Tangent":_ImportFromScript(Script).getvalue( "TangentOperator" ),
 209                     "Adjoint":_ImportFromScript(Script).getvalue( "AdjointOperator" ),
 210                     }
 211                 __Function.update(__Parameters)
 212         else:
 213             __Matrix = Matrix
 214             if OneFunction is not None:
 215                 __Function = { "Direct":OneFunction }
 216                 __Function.update({"useApproximatedDerivatives":True})
 217                 __Function.update(__Parameters)
 218             elif ThreeFunctions is not None:
 219                 if (not isinstance(ThreeFunctions, dict)) or \
 220                    "Direct"  not in ThreeFunctions or \
 221                    "Tangent" not in ThreeFunctions or \
 222                    "Adjoint" not in ThreeFunctions:
 223                     raise ValueError("ThreeFunctions has to be a dictionnary and to have the 3 keys Direct, Tangent, Adjoint")
 224                 __Function = ThreeFunctions
 225                 __Function.update(__Parameters)
 226             else:
 227                 __Function = None
 228         #
 229         self.__adaoStudy.setControlModel(
 230             asFunction = __Function,
 231             asMatrix   = __Matrix,
 232             toBeStored = Stored,
 233             )
 234
 235     def setControlInput(
 236             self,
 237             Vector         = None,
 238             VectorSerie    = None,
 239             Script         = None,
 240             Stored         = False):
 241         "Définition d'une entrée de calcul"
 242         self.__dumper.register("setControlInput", dir(), locals())
 243         if Script is not None:
 244             __Vector, __PersistentVector = None, None
 245             if VectorSerie:
 246                 __PersistentVector = _ImportFromScript(Script).getvalue( "ControlInput" )
 247             else:
 248                 __Vector = _ImportFromScript(Script).getvalue( "ControlInput" )
 249         else:
 250             __Vector, __PersistentVector = Vector, VectorSerie
 251         #
 252         self.__adaoStudy.setControlInput(
 253             asVector           = __Vector,
 254             asPersistentVector = __PersistentVector,
 255             toBeStored         = Stored,
 256             )
 257
 258     def setEvolutionError(
 259             self,
 260             Matrix               = None,
 261             ScalarSparseMatrix   = None,
 262             DiagonalSparseMatrix = None,
 263             Script               = None,
 264             Stored               = False):
 265         "Définition d'une entrée de calcul"
 266         self.__dumper.register("setEvolutionError", dir(), locals())
 267         if Script is not None:
 268             __Covariance, __Scalar, __Vector = None, None, None
 269             if ScalarSparseMatrix:
 270                 __Scalar = _ImportFromScript(Script).getvalue( "EvolutionError" )
 271             elif DiagonalSparseMatrix:
 272                 __Vector = _ImportFromScript(Script).getvalue( "EvolutionError" )
 273             else:
 274                 __Covariance = _ImportFromScript(Script).getvalue( "EvolutionError" )
 275         else:
 276             __Covariance, __Scalar, __Vector = Matrix, ScalarSparseMatrix, DiagonalSparseMatrix
 277         #
 278         self.__adaoStudy.setEvolutionError(
 279             asCovariance  = __Covariance,
 280             asEyeByScalar = __Scalar,
 281             asEyeByVector = __Vector,
 282             toBeStored    = Stored,
 283             )
 284
 285     def setEvolutionModel(
 286             self,
 287             Matrix         = None,
 288             OneFunction    = None,
 289             ThreeFunctions = None,
 290             Parameters     = None,
 291             Script         = None,
 292             Stored         = False):
 293         "Définition d'une entrée de calcul"
 294         self.__dumper.register("setEvolutionModel", dir(), locals())
 295         __Parameters = {}
 296         if (Parameters is not None) and isinstance(Parameters, dict):
 297             if "DifferentialIncrement" in Parameters:
 298                 __Parameters["withIncrement"] = Parameters["DifferentialIncrement"]
 299             if "CenteredFiniteDifference" in Parameters:
 300                 __Parameters["withCenteredDF"] = Parameters["CenteredFiniteDifference"]
 301             if "EnableMultiProcessing" in Parameters:
 302                 __Parameters["withmpEnabled"] = Parameters["EnableMultiProcessing"]
 303             if "NumberOfProcesses" in Parameters:
 304                 __Parameters["withmpWorkers"] = Parameters["NumberOfProcesses"]
 305         if Script is not None:
 306             __Matrix, __Function = None, None
 307             if Matrix:
 308                 __Matrix = _ImportFromScript(Script).getvalue( "ObservationOperator" )
 309             elif OneFunction:
 310                 __Function = { "Direct":_ImportFromScript(Script).getvalue( "DirectOperator" ) }
 311                 __Function.update({"useApproximatedDerivatives":True})
 312                 __Function.update(__Parameters)
 313             elif ThreeFunctions:
 314                 __Function = {
 315                     "Direct" :_ImportFromScript(Script).getvalue( "DirectOperator" ),
 316                     "Tangent":_ImportFromScript(Script).getvalue( "TangentOperator" ),
 317                     "Adjoint":_ImportFromScript(Script).getvalue( "AdjointOperator" ),
 318                     }
 319                 __Function.update(__Parameters)
 320         else:
 321             __Matrix = Matrix
 322             if OneFunction is not None:
 323                 __Function = { "Direct":OneFunction }
 324                 __Function.update({"useApproximatedDerivatives":True})
 325                 __Function.update(__Parameters)
 326             elif ThreeFunctions is not None:
 327                 if (not isinstance(ThreeFunctions, dict)) or \
 328                    "Direct"  not in ThreeFunctions or \
 329                    "Tangent" not in ThreeFunctions or \
 330                    "Adjoint" not in ThreeFunctions:
 331                     raise ValueError("ThreeFunctions has to be a dictionnary and to have the 3 keys Direct, Tangent, Adjoint")
 332                 __Function = ThreeFunctions
 333                 __Function.update(__Parameters)
 334             else:
 335                 __Function = None
 336         #
 337         self.__adaoStudy.setEvolutionModel(
 338             asFunction = __Function,
 339             asMatrix   = __Matrix,
 340             toBeStored = Stored,
 341             )
 342
 343     def setObservation(
 344             self,
 345             Vector         = None,
 346             VectorSerie    = None,
 347             Script         = None,
 348             Stored         = False):
 349         "Définition d'une entrée de calcul"
 350         self.__dumper.register("setObservation", dir(), locals())
 351         if Script is not None:
 352             __Vector, __PersistentVector = None, None
 353             if VectorSerie:
 354                 __PersistentVector = _ImportFromScript(Script).getvalue( "Observation" )
 355             else:
 356                 __Vector = _ImportFromScript(Script).getvalue( "Observation" )
 357         else:
 358             __Vector, __PersistentVector = Vector, VectorSerie
 359         #
 360         self.__adaoStudy.setObservation(
 361             asVector           = __Vector,
 362             asPersistentVector = __PersistentVector,
 363             toBeStored         = Stored,
 364             )
 365
 366     def setObservationError(
 367             self,
 368             Matrix               = None,
 369             ScalarSparseMatrix   = None,
 370             DiagonalSparseMatrix = None,
 371             Script               = None,
 372             Stored               = False):
 373         "Définition d'une entrée de calcul"
 374         self.__dumper.register("setObservationError", dir(), locals())
 375         if Script is not None:
 376             __Covariance, __Scalar, __Vector = None, None, None
 377             if ScalarSparseMatrix:
 378                 __Scalar = _ImportFromScript(Script).getvalue( "ObservationError" )
 379             elif DiagonalSparseMatrix:
 380                 __Vector = _ImportFromScript(Script).getvalue( "ObservationError" )
 381             else:
 382                 __Covariance = _ImportFromScript(Script).getvalue( "ObservationError" )
 383         else:
 384             __Covariance, __Scalar, __Vector = Matrix, ScalarSparseMatrix, DiagonalSparseMatrix
 385         #
 386         self.__adaoStudy.setObservationError(
 387             asCovariance  = __Covariance,
 388             asEyeByScalar = __Scalar,
 389             asEyeByVector = __Vector,
 390             toBeStored    = Stored,
 391             )
 392
 393     def setObservationOperator(
 394             self,
 395             Matrix         = None,
 396             OneFunction    = None,
 397             ThreeFunctions = None,
 398             AppliedInXb    = None,
 399             Parameters     = None,
 400             Script         = None,
 401             Stored         = False):
 402         "Définition d'une entrée de calcul"
 403         self.__dumper.register("setObservationOperator", dir(), locals())
 404         __Parameters = {}
 405         if (Parameters is not None) and isinstance(Parameters, dict):
 406             if "DifferentialIncrement" in Parameters:
 407                 __Parameters["withIncrement"] = Parameters["DifferentialIncrement"]
 408             if "CenteredFiniteDifference" in Parameters:
 409                 __Parameters["withCenteredDF"] = Parameters["CenteredFiniteDifference"]
 410             if "EnableMultiProcessing" in Parameters:
 411                 __Parameters["EnableMultiProcessing"] = Parameters["EnableMultiProcessing"]
 412                 __Parameters["withmpEnabled"]         = Parameters["EnableMultiProcessing"]
 413             if "NumberOfProcesses" in Parameters:
 414                 __Parameters["NumberOfProcesses"] = Parameters["NumberOfProcesses"]
 415                 __Parameters["withmpWorkers"]     = Parameters["NumberOfProcesses"]
 416         if Script is not None:
 417             __Matrix, __Function = None, None
 418             if Matrix:
 419                 __Matrix = _ImportFromScript(Script).getvalue( "ObservationOperator" )
 420             elif OneFunction:
 421                 __Function = { "Direct":_ImportFromScript(Script).getvalue( "DirectOperator" ) }
 422                 __Function.update({"useApproximatedDerivatives":True})
 423                 __Function.update(__Parameters)
 424             elif ThreeFunctions:
 425                 __Function = {
 426                     "Direct" :_ImportFromScript(Script).getvalue( "DirectOperator" ),
 427                     "Tangent":_ImportFromScript(Script).getvalue( "TangentOperator" ),
 428                     "Adjoint":_ImportFromScript(Script).getvalue( "AdjointOperator" ),
 429                     }
 430                 __Function.update(__Parameters)
 431         else:
 432             __Matrix = Matrix
 433             if OneFunction is not None:
 434                 __Function = { "Direct":OneFunction }
 435                 __Function.update({"useApproximatedDerivatives":True})
 436                 __Function.update(__Parameters)
 437             elif ThreeFunctions is not None:
 438                 if (not isinstance(ThreeFunctions, dict)) or \
 439                    "Direct"  not in ThreeFunctions or \
 440                    "Tangent" not in ThreeFunctions or \
 441                    "Adjoint" not in ThreeFunctions:
 442                     raise ValueError("ThreeFunctions has to be a dictionnary and to have the 3 keys Direct, Tangent, Adjoint")
 443                 __Function = ThreeFunctions
 444                 __Function.update(__Parameters)
 445             else:
 446                 __Function = None
 447         if AppliedInXb is not None:
 448             __appliedToX = {"HXb":AppliedInXb}
 449         else:
 450             __appliedToX = None
 451         #
 452         self.__adaoStudy.setObservationOperator(
 453             asFunction = __Function,
 454             asMatrix   = __Matrix,
 455             appliedToX = __appliedToX,
 456             toBeStored = Stored,
 457             )
 458
 459     # -----------------------------------------------------------
 460
 461     def setAlgorithmParameters(
 462             self,
 463             Algorithm  = None,
 464             Parameters = None,
 465             Script     = None):
 466         "Définition d'un paramétrage du calcul"
 467         self.__dumper.register("setAlgorithmParameters", dir(), locals())
 468         if Script is not None:
 469             __Algorithm  = _ImportFromScript(Script).getvalue( "Algorithm" )
 470             __Parameters = _ImportFromScript(Script).getvalue( "AlgorithmParameters", "Parameters" )
 471         else:
 472             __Algorithm  = Algorithm
 473             __Parameters = Parameters
 474         self.__adaoStudy.setAlgorithm( choice = __Algorithm )
 475         self.__adaoStudy.setAlgorithmParameters( asDico = __Parameters )
 476
 477     def setDebug(self):
 478         "Définition d'un paramétrage du calcul"
 479         self.__dumper.register("setDebug",dir(),locals())
 480         return self.__adaoStudy.setDebug()
 481
 482     def setNoDebug(self):
 483         "Définition d'un paramétrage du calcul"
 484         self.__dumper.register("setNoDebug",dir(),locals())
 485         return self.__adaoStudy.unsetDebug()
 486
 487     def setObserver(
 488             self,
 489             Variable = None,
 490             Template = None,
 491             String   = None,
 492             Script   = None,
 493             Info     = None):
 494         "Définition d'un paramétrage du calcul"
 495         self.__dumper.register("setObserver", dir(), locals())
 496         if Variable is None:
 497             raise ValueError("setting an observer has to be done over a variable name, not over None.")
 498         else:
 499             __Variable = str(Variable)
 500             if Info is None:
 501                 __Info = str(Variable)
 502             else:
 503                 __Info = str(Info)
 504         #
 505         if String is not None:
 506             __FunctionText = String
 507         elif (Template is not None) and (Template in Templates.ObserverTemplates):
 508             __FunctionText = Templates.ObserverTemplates[Template]
 509         elif Script is not None:
 510             __FunctionText = _ImportFromScript(Script).getstring()
 511         else:
 512             __FunctionText = ""
 513         __Function = _ObserverF(__FunctionText)
 514         #
 515         self.__adaoStudy.setDataObserver(
 516             VariableName   = __Variable,
 517             HookFunction   = __Function.getfunc(),
 518             HookParameters = __Info,
 519             )
 520
 521     # -----------------------------------------------------------
 522
 523     def executePythonScheme(self):
 524         "Lancement du calcul"
 525         self.__dumper.register("executePythonScheme", dir(), locals())
 526         try:
 527             self.__adaoStudy.analyze()
 528         except Exception as e:
 529             if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
 530             else: msg = ""
 531             raise ValueError("during execution, the following error occurs:\n\n%s %s\n\nSee also the potential messages, which can show the origin of the above error, in the launching terminal."%(str(e),msg))
 532
 533     execute = executePythonScheme
 534
 535     def executeYACSScheme(self, File=None):
 536         "Lancement du calcul"
 537         self.__dumper.register("executeYACSScheme", dir(), locals())
 538         raise NotImplementedError()
 539
 540     # -----------------------------------------------------------
 541
 542     def get(self, Concept=None):
 543         "Récupération d'une sortie du calcul"
 544         self.__dumper.register("get",dir(),locals(),Concept)
 545         return self.__adaoStudy.get(Concept)
 546
 547     def dumpNormalizedCommands(self, filename=None):
 548         "Récupération de la liste des commandes du cas"
 549         return self.__dumper.dump(filename)
 550
 551     def __dir__(self):
 552         return ['set', 'get', 'execute', '__doc__', '__init__', '__module__']
 553
 554 class _DumpLogger(object):
 555     """
 556     Conservation des commandes de création d'un cas
 557     """
 558     def __init__(self, __name="", __objname="case"):
 559         self.__name     = str(__name)
 560         self.__objname  = str(__objname)
 561         self.__logSerie = []
 562         self.__switchoff = False
 563         self.__logSerie.append("#\n# Python script for ADAO TUI\n#")
 564         self.__logSerie.append("from numpy import array, matrix")
 565         self.__logSerie.append("import adaoBuilder")
 566         self.__logSerie.append("%s = adaoBuilder.New('%s')"%(self.__objname, self.__name))
 567     def register(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False):
 568         "Enregistrement d'une commande individuelle"
 569         if __command is not None and __keys is not None and __local is not None and not self.__switchoff:
 570             __text  = ""
 571             if __pre is not None:
 572                 __text += "%s = "%__pre
 573             __text += "%s.%s( "%(self.__objname,str(__command))
 574             __keys.remove("self")
 575             for k in __keys:
 576                 __v = __local[k]
 577                 if __v is None: continue
 578                 __text += "%s=%s, "%(k,repr(__v))
 579             __text += ")"
 580             self.__logSerie.append(__text)
 581             if __switchoff:
 582                 self.__switchoff = True
 583         if not __switchoff:
 584             self.__switchoff = False
 585     def dump(self, __filename=None):
 586         "Restitution de la liste des commandes de création d'un cas"
 587         __text = "\n".join(self.__logSerie)
 588         if __filename is not None:
 589             fid = open(__filename,"w")
 590             fid.write(__text)
 591             fid.close()
 592         return __text
 593
 594 class _ObserverF(object):
 595     """
 596     Création d'une fonction d'observateur à partir de son texte
 597     """
 598     def __init__(self, corps=""):
 599         self.__corps = corps
 600     def func(self,var,info):
 601         "Fonction d'observation"
 602         exec(self.__corps)
 603     def getfunc(self):
 604         "Restitution du pointeur de fonction dans l'objet"
 605         return self.func
 606
 607 class _ImportFromScript(object):
 608     """
 609     Obtention d'une variable nommée depuis un fichier script importé
 610     """
 611     def __init__(self, __filename=None):
 612         "Verifie l'existence et importe le script"
 613         __filename = __filename.rstrip(".py")
 614         if __filename is None:
 615             raise ValueError("The name of the file containing the variable to be imported has to be specified.")
 616         if not os.path.isfile(str(__filename)+".py"):
 617             raise ValueError("The file containing the variable to be imported doesn't seem to exist. The given file name is:\n  \"%s\""%__filename)
 618         self.__scriptfile = __import__(__filename, globals(), locals(), [])
 619         self.__scriptstring = open(__filename+".py",'r').read()
 620     def getvalue(self, __varname=None, __synonym=None ):
 621         "Renvoie la variable demandee"
 622         if __varname is None:
 623             raise ValueError("The name of the variable to be imported has to be specified.")
 624         if not hasattr(self.__scriptfile, __varname):
 625             if __synonym is None:
 626                 raise ValueError("The imported script file doesn't contain the specified variable \"%s\"."%__varname)
 627             elif not hasattr(self.__scriptfile, __synonym):
 628                 raise ValueError("The imported script file doesn't contain the specified variable \"%s\"."%__synonym)
 629             else:
 630                 return getattr(self.__scriptfile, __synonym)
 631         else:
 632             return getattr(self.__scriptfile, __varname)
 633     def getstring(self):
 634         "Renvoie le script complet"
 635         return self.__scriptstring
 636
 637 # ==============================================================================
 638 if __name__ == "__main__":
 639     print '\n AUTODIAGNOSTIC \n'