src/daSalome/adaoBuilder.py

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