1 # -*- coding: utf-8 -*-
3 # Copyright (C) 2008-2023 EDF R&D
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.
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.
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
19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 # Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
24 Normalized interface for ADAO scripting (generic API).
26 __author__ = "Jean-Philippe ARGAUD"
33 from daCore.BasicObjects import State, Covariance, FullOperator, Operator
34 from daCore.BasicObjects import AlgorithmAndParameters, DataObserver
35 from daCore.BasicObjects import RegulationAndParameters, CaseLogger
36 from daCore.BasicObjects import UserScript, ExternalParameters
37 from daCore import PlatformInfo
38 from daCore import version
40 from daCore import ExtendedLogging ; ExtendedLogging.ExtendedLogging() # A importer en premier
43 # ==============================================================================
45 """ ADAO Internal Data Structure Model """
47 "__name", "__objname", "__directory", "__case", "__parent",
48 "__adaoObject", "__StoredInputs", "__PostAnalysis", "__Concepts",
51 def __init__(self, name = "", addViewers=None):
52 self.__name = str(name)
54 self.__directory = None
55 self.__case = CaseLogger(self.__name, "case", addViewers)
57 self.__adaoObject = {}
58 self.__StoredInputs = {}
59 self.__PostAnalysis = []
61 self.__Concepts = [ # Liste exhaustive
62 "AlgorithmParameters",
76 "ObservationOperator",
78 "RegulationParameters",
79 "SupplementaryParameters",
83 for ename in self.__Concepts:
84 self.__adaoObject[ename] = None
85 for ename in ("ObservationOperator", "EvolutionModel", "ControlModel"):
86 self.__adaoObject[ename] = {}
87 for ename in ("BackgroundError", "ObservationError"):
88 self.__adaoObject[ename] = Covariance(ename, asEyeByScalar = 1.)
89 for ename in ("EvolutionError",):
90 self.__adaoObject[ename] = Covariance(ename, asEyeByScalar = 1.e-16)
91 for ename in ("Observer", "UserPostAnalysis"):
92 self.__adaoObject[ename] = []
93 self.__StoredInputs[ename] = [] # Vide par defaut
94 self.__StoredInputs["Name"] = self.__name
95 self.__StoredInputs["Directory"] = self.__directory
97 # Récupère le chemin du répertoire parent et l'ajoute au path
98 # (Cela complète l'action de la classe PathManagement dans PlatformInfo,
99 # qui est activée dans Persistence)
100 self.__parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
101 sys.path.insert(0, self.__parent)
102 sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
105 Concept = None, # Premier argument
112 DiagonalSparseMatrix = None,
113 ExtraArguments = None,
115 InputFunctionAsMulti = False,
117 ObjectFunction = None,
121 PerformanceProfile = None,
122 ScalarSparseMatrix = None,
128 ThreeFunctions = None,
133 "Interface unique de définition de variables d'entrées par argument"
134 self.__case.register("set",dir(),locals(),None,True)
136 if Concept in ("Background", "CheckingPoint", "ControlInput", "Observation"):
137 commande = getattr(self,"set"+Concept)
138 commande(Vector, VectorSerie, Script, DataFile, ColNames, ColMajor, Stored, Scheduler, Checked )
139 elif Concept in ("BackgroundError", "ObservationError", "EvolutionError"):
140 commande = getattr(self,"set"+Concept)
141 commande(Matrix, ScalarSparseMatrix, DiagonalSparseMatrix,
142 Script, Stored, ObjectMatrix, Checked )
143 elif Concept == "AlgorithmParameters":
144 self.setAlgorithmParameters( Algorithm, Parameters, Script )
145 elif Concept == "RegulationParameters":
146 self.setRegulationParameters( Algorithm, Parameters, Script )
147 elif Concept == "Name":
149 elif Concept == "Directory":
150 self.setDirectory(String)
151 elif Concept == "Debug":
153 elif Concept == "NoDebug":
155 elif Concept == "Observer":
156 self.setObserver( Variable, Template, String, Script, Info, ObjectFunction, Scheduler )
157 elif Concept == "UserPostAnalysis":
158 self.setUserPostAnalysis( Template, String, Script )
159 elif Concept == "SupplementaryParameters":
160 self.setSupplementaryParameters( Parameters, Script )
161 elif Concept == "ObservationOperator":
162 self.setObservationOperator(
163 Matrix, OneFunction, ThreeFunctions, AppliedInXb,
164 Parameters, Script, ExtraArguments,
165 Stored, PerformanceProfile, InputFunctionAsMulti, Checked )
166 elif Concept in ("EvolutionModel", "ControlModel"):
167 commande = getattr(self,"set"+Concept)
169 Matrix, OneFunction, ThreeFunctions,
170 Parameters, Script, Scheduler, ExtraArguments,
171 Stored, PerformanceProfile, InputFunctionAsMulti, Checked )
173 raise ValueError("the variable named '%s' is not allowed."%str(Concept))
174 except Exception as e:
175 if isinstance(e, SyntaxError): msg = " at %s: %s"%(e.offset, e.text)
177 raise ValueError(("during settings, the following error occurs:\n"+\
178 "\n%s%s\n\nSee also the potential messages, "+\
179 "which can show the origin of the above error, "+\
180 "in the launching terminal.")%(str(e),msg))
182 # -----------------------------------------------------------
184 def setBackground(self,
194 "Définition d'un concept de calcul"
195 Concept = "Background"
196 self.__case.register("set"+Concept, dir(), locals())
197 self.__adaoObject[Concept] = State(
200 asPersistentVector = VectorSerie,
201 asScript = self.__with_directory(Script),
202 asDataFile = DataFile,
205 scheduledBy = Scheduler,
206 toBeChecked = Checked,
209 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
212 def setCheckingPoint(self,
222 "Définition d'un concept de calcul"
223 Concept = "CheckingPoint"
224 self.__case.register("set"+Concept, dir(), locals())
225 self.__adaoObject[Concept] = State(
228 asPersistentVector = VectorSerie,
229 asScript = self.__with_directory(Script),
230 asDataFile = DataFile,
233 scheduledBy = Scheduler,
234 toBeChecked = Checked,
237 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
240 def setControlInput(self,
250 "Définition d'un concept de calcul"
251 Concept = "ControlInput"
252 self.__case.register("set"+Concept, dir(), locals())
253 self.__adaoObject[Concept] = State(
256 asPersistentVector = VectorSerie,
257 asScript = self.__with_directory(Script),
258 asDataFile = DataFile,
261 scheduledBy = Scheduler,
262 toBeChecked = Checked,
265 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
268 def setObservation(self,
278 "Définition d'un concept de calcul"
279 Concept = "Observation"
280 self.__case.register("set"+Concept, dir(), locals())
281 self.__adaoObject[Concept] = State(
284 asPersistentVector = VectorSerie,
285 asScript = self.__with_directory(Script),
286 asDataFile = DataFile,
289 scheduledBy = Scheduler,
290 toBeChecked = Checked,
293 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
296 def setBackgroundError(self,
298 ScalarSparseMatrix = None,
299 DiagonalSparseMatrix = None,
304 "Définition d'un concept de calcul"
305 Concept = "BackgroundError"
306 self.__case.register("set"+Concept, dir(), locals())
307 self.__adaoObject[Concept] = Covariance(
309 asCovariance = Matrix,
310 asEyeByScalar = ScalarSparseMatrix,
311 asEyeByVector = DiagonalSparseMatrix,
312 asCovObject = ObjectMatrix,
313 asScript = self.__with_directory(Script),
314 toBeChecked = Checked,
317 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
320 def setObservationError(self,
322 ScalarSparseMatrix = None,
323 DiagonalSparseMatrix = None,
328 "Définition d'un concept de calcul"
329 Concept = "ObservationError"
330 self.__case.register("set"+Concept, dir(), locals())
331 self.__adaoObject[Concept] = Covariance(
333 asCovariance = Matrix,
334 asEyeByScalar = ScalarSparseMatrix,
335 asEyeByVector = DiagonalSparseMatrix,
336 asCovObject = ObjectMatrix,
337 asScript = self.__with_directory(Script),
338 toBeChecked = Checked,
341 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
344 def setEvolutionError(self,
346 ScalarSparseMatrix = None,
347 DiagonalSparseMatrix = None,
352 "Définition d'un concept de calcul"
353 Concept = "EvolutionError"
354 self.__case.register("set"+Concept, dir(), locals())
355 self.__adaoObject[Concept] = Covariance(
357 asCovariance = Matrix,
358 asEyeByScalar = ScalarSparseMatrix,
359 asEyeByVector = DiagonalSparseMatrix,
360 asCovObject = ObjectMatrix,
361 asScript = self.__with_directory(Script),
362 toBeChecked = Checked,
365 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
368 def setObservationOperator(self,
371 ThreeFunctions = None,
375 ExtraArguments = None,
377 PerformanceProfile = None,
378 InputFunctionAsMulti = False,
380 "Définition d'un concept de calcul"
381 Concept = "ObservationOperator"
382 self.__case.register("set"+Concept, dir(), locals())
383 self.__adaoObject[Concept] = FullOperator(
386 asOneFunction = OneFunction,
387 asThreeFunctions = ThreeFunctions,
388 asScript = self.__with_directory(Script),
390 appliedInX = AppliedInXb,
391 extraArguments = ExtraArguments,
392 performancePrf = PerformanceProfile,
393 inputAsMF = InputFunctionAsMulti,
395 toBeChecked = Checked,
398 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
401 def setEvolutionModel(self,
404 ThreeFunctions = None,
408 ExtraArguments = None,
410 PerformanceProfile = None,
411 InputFunctionAsMulti = False,
413 "Définition d'un concept de calcul"
414 Concept = "EvolutionModel"
415 self.__case.register("set"+Concept, dir(), locals())
416 self.__adaoObject[Concept] = FullOperator(
419 asOneFunction = OneFunction,
420 asThreeFunctions = ThreeFunctions,
421 asScript = self.__with_directory(Script),
424 extraArguments = ExtraArguments,
425 performancePrf = PerformanceProfile,
426 inputAsMF = InputFunctionAsMulti,
427 scheduledBy = Scheduler,
428 toBeChecked = Checked,
431 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
434 def setControlModel(self,
437 ThreeFunctions = None,
441 ExtraArguments = None,
443 PerformanceProfile = None,
444 InputFunctionAsMulti = False,
446 "Définition d'un concept de calcul"
447 Concept = "ControlModel"
448 self.__case.register("set"+Concept, dir(), locals())
449 self.__adaoObject[Concept] = FullOperator(
452 asOneFunction = OneFunction,
453 asThreeFunctions = ThreeFunctions,
454 asScript = self.__with_directory(Script),
457 extraArguments = ExtraArguments,
458 performancePrf = PerformanceProfile,
459 inputAsMF = InputFunctionAsMulti,
460 scheduledBy = Scheduler,
461 toBeChecked = Checked,
464 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
467 def setName(self, String=None):
468 "Définition d'un concept de calcul"
469 self.__case.register("setName",dir(),locals())
470 if String is not None:
471 self.__name = str(String)
474 self.__StoredInputs["Name"] = self.__name
476 def setDirectory(self, String=None):
477 "Définition d'un concept de calcul"
478 self.__case.register("setDirectory",dir(),locals())
479 if os.path.isdir(os.path.abspath(str(String))):
480 self.__directory = os.path.abspath(str(String))
482 self.__directory = None
483 self.__StoredInputs["Directory"] = self.__directory
485 def setDebug(self, __level = 10):
486 "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
487 self.__case.register("setDebug",dir(),locals())
488 log = logging.getLogger()
489 log.setLevel( __level )
490 logging.debug("Mode debug initialisé avec %s %s"%(version.name, version.version))
491 self.__StoredInputs["Debug"] = __level
492 self.__StoredInputs["NoDebug"] = False
495 def setNoDebug(self):
496 "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
497 self.__case.register("setNoDebug",dir(),locals())
498 log = logging.getLogger()
499 log.setLevel( logging.WARNING )
500 self.__StoredInputs["Debug"] = logging.WARNING
501 self.__StoredInputs["NoDebug"] = True
504 def setAlgorithmParameters(self,
508 "Définition d'un concept de calcul"
509 Concept = "AlgorithmParameters"
510 self.__case.register("set"+Concept, dir(), locals())
511 self.__adaoObject[Concept] = AlgorithmAndParameters(
513 asAlgorithm = Algorithm,
515 asScript = self.__with_directory(Script),
519 def updateAlgorithmParameters(self,
522 "Mise à jour d'un concept de calcul"
523 Concept = "AlgorithmParameters"
524 if Concept not in self.__adaoObject or self.__adaoObject[Concept] is None:
525 raise ValueError("\n\nNo algorithm registred, set one before updating parameters or executing\n")
526 self.__adaoObject[Concept].updateParameters(
528 asScript = self.__with_directory(Script),
533 def setRegulationParameters(self,
537 "Définition d'un concept de calcul"
538 Concept = "RegulationParameters"
539 self.__case.register("set"+Concept, dir(), locals())
540 self.__adaoObject[Concept] = RegulationAndParameters(
542 asAlgorithm = Algorithm,
544 asScript = self.__with_directory(Script),
548 def setSupplementaryParameters(self,
551 "Définition d'un concept de calcul"
552 Concept = "SupplementaryParameters"
553 self.__case.register("set"+Concept, dir(), locals())
554 self.__adaoObject[Concept] = ExternalParameters(
557 asScript = self.__with_directory(Script),
561 def updateSupplementaryParameters(self,
564 "Mise à jour d'un concept de calcul"
565 Concept = "SupplementaryParameters"
566 if Concept not in self.__adaoObject or self.__adaoObject[Concept] is None:
567 self.__adaoObject[Concept] = ExternalParameters(name = Concept)
568 self.__adaoObject[Concept].updateParameters(
570 asScript = self.__with_directory(Script),
574 def setObserver(self,
580 ObjectFunction = None,
582 "Définition d'un concept de calcul"
584 self.__case.register("set"+Concept, dir(), locals())
585 self.__adaoObject[Concept].append( DataObserver(
587 onVariable = Variable,
588 asTemplate = Template,
590 asScript = self.__with_directory(Script),
591 asObsObject = ObjectFunction,
593 scheduledBy = Scheduler,
594 withAlgo = self.__adaoObject["AlgorithmParameters"]
598 def removeObserver(self,
600 ObjectFunction = None,
602 "Permet de retirer un observer à une ou des variable nommées"
603 if "AlgorithmParameters" not in self.__adaoObject:
604 raise ValueError("No algorithm registred, ask for one before removing observers")
606 # Vérification du nom de variable et typage
607 # -----------------------------------------
608 if isinstance(Variable, str):
609 VariableNames = (Variable,)
610 elif isinstance(Variable, list):
611 VariableNames = tuple(map( str, Variable ))
613 raise ValueError("The observer requires a name or a list of names of variables.")
615 # Association interne de l'observer à la variable
616 # -----------------------------------------------
617 for ename in VariableNames:
618 if ename not in self.__adaoObject["AlgorithmParameters"]:
619 raise ValueError("An observer requires to be removed on a variable named %s which does not exist."%ename)
621 return self.__adaoObject["AlgorithmParameters"].removeObserver( ename, ObjectFunction )
623 def setUserPostAnalysis(self,
627 "Définition d'un concept de calcul"
628 Concept = "UserPostAnalysis"
629 self.__case.register("set"+Concept, dir(), locals())
630 self.__adaoObject[Concept].append( repr(UserScript(
632 asTemplate = Template,
634 asScript = self.__with_directory(Script),
638 # -----------------------------------------------------------
640 def get(self, Concept=None, noDetails=True ):
641 "Récupération d'une sortie du calcul"
642 if Concept is not None:
644 self.__case.register("get", dir(), locals(), Concept) # Break pickle in Python 2
647 if Concept in self.__StoredInputs:
648 return self.__StoredInputs[Concept]
650 elif self.__adaoObject["AlgorithmParameters"] is not None and Concept == "AlgorithmParameters":
651 return self.__adaoObject["AlgorithmParameters"].get()
653 elif self.__adaoObject["AlgorithmParameters"] is not None and Concept in self.__adaoObject["AlgorithmParameters"]:
654 return self.__adaoObject["AlgorithmParameters"].get( Concept )
656 elif Concept == "AlgorithmRequiredParameters" and self.__adaoObject["AlgorithmParameters"] is not None:
657 return self.__adaoObject["AlgorithmParameters"].getAlgorithmRequiredParameters(noDetails)
659 elif Concept == "AlgorithmRequiredInputs" and self.__adaoObject["AlgorithmParameters"] is not None:
660 return self.__adaoObject["AlgorithmParameters"].getAlgorithmInputArguments()
662 elif Concept == "AlgorithmAttributes" and self.__adaoObject["AlgorithmParameters"] is not None:
663 return self.__adaoObject["AlgorithmParameters"].getAlgorithmAttributes()
665 elif self.__adaoObject["SupplementaryParameters"] is not None and Concept == "SupplementaryParameters":
666 return self.__adaoObject["SupplementaryParameters"].get()
668 elif self.__adaoObject["SupplementaryParameters"] is not None and Concept in self.__adaoObject["SupplementaryParameters"]:
669 return self.__adaoObject["SupplementaryParameters"].get( Concept )
672 raise ValueError("The requested key \"%s\" does not exists as an input or a stored variable."%Concept)
675 allvariables.update( {"AlgorithmParameters":self.__adaoObject["AlgorithmParameters"].get()} )
676 if self.__adaoObject["SupplementaryParameters"] is not None:
677 allvariables.update( {"SupplementaryParameters":self.__adaoObject["SupplementaryParameters"].get()} )
678 # allvariables.update( self.__adaoObject["AlgorithmParameters"].get() )
679 allvariables.update( self.__StoredInputs )
680 allvariables.pop('Observer', None)
681 allvariables.pop('UserPostAnalysis', None)
684 # -----------------------------------------------------------
686 def __get_available_variables(self):
688 Renvoie les variables potentiellement utilisables pour l'étude,
689 initialement stockées comme données d'entrées ou dans les algorithmes,
690 identifiés par les chaînes de caractères. L'algorithme doit avoir été
691 préalablement choisi sinon la méthode renvoie "None".
693 if len(list(self.__adaoObject["AlgorithmParameters"].keys())) == 0 and \
694 len(list(self.__StoredInputs.keys())) == 0:
698 if len(list(self.__adaoObject["AlgorithmParameters"].keys())) > 0:
699 variables.extend(list(self.__adaoObject["AlgorithmParameters"].keys()))
700 if self.__adaoObject["SupplementaryParameters"] is not None and \
701 len(list(self.__adaoObject["SupplementaryParameters"].keys())) > 0:
702 variables.extend(list(self.__adaoObject["SupplementaryParameters"].keys()))
703 if len(list(self.__StoredInputs.keys())) > 0:
704 variables.extend( list(self.__StoredInputs.keys()) )
705 variables.remove('Observer')
706 variables.remove('UserPostAnalysis')
710 def __get_available_algorithms(self):
712 Renvoie la liste des algorithmes potentiellement utilisables, identifiés
713 par les chaînes de caractères.
716 for directory in sys.path:
717 trypath = os.path.join(directory,"daAlgorithms")
718 if os.path.isdir(trypath):
719 for fname in os.listdir(trypath):
720 if os.path.isfile(os.path.join(trypath,fname)):
721 root, ext = os.path.splitext(fname)
722 if ext != ".py": continue
723 with open(os.path.join(trypath,fname)) as fc:
724 iselal = bool("class ElementaryAlgorithm" in fc.read())
725 if iselal and ext == '.py' and root != '__init__':
730 def __get_algorithms_main_path(self):
732 Renvoie le chemin pour le répertoire principal contenant les algorithmes
736 def __add_algorithms_path(self, Path=None):
738 Ajoute au chemin de recherche des algorithmes un répertoire dans lequel
739 se trouve un sous-répertoire "daAlgorithms"
741 if not os.path.isdir(Path):
742 raise ValueError("The given "+Path+" argument must exist as a directory")
743 if not os.path.isdir(os.path.join(Path,"daAlgorithms")):
744 raise ValueError("The given \""+Path+"\" argument must contain a subdirectory named \"daAlgorithms\"")
745 if not os.path.isfile(os.path.join(Path,"daAlgorithms","__init__.py")):
746 raise ValueError("The given \""+Path+"/daAlgorithms\" path must contain a file named \"__init__.py\"")
747 sys.path.insert(0, os.path.abspath(Path))
748 sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
751 # -----------------------------------------------------------
753 def execute(self, Executor=None, SaveCaseInFile=None, nextStep=False):
754 "Lancement du calcul"
755 self.__case.register("execute",dir(),locals(),None,True)
756 self.updateAlgorithmParameters(Parameters={"nextStep":bool(nextStep)})
757 if not nextStep: Operator.CM.clearCache()
759 if Executor == "YACS": self.__executeYACSScheme( SaveCaseInFile )
760 else: self.__executePythonScheme( SaveCaseInFile )
761 except Exception as e:
762 if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
764 raise ValueError(("during execution, the following error occurs:\n"+\
765 "\n%s %s\n\nSee also the potential messages, "+\
766 "which can show the origin of the above error, "+\
767 "in the launching terminal.\n")%(str(e),msg))
770 def __executePythonScheme(self, FileName=None):
771 "Lancement du calcul"
772 self.__case.register("executePythonScheme", dir(), locals())
773 if FileName is not None:
774 self.dump( FileName, "TUI")
775 self.__adaoObject["AlgorithmParameters"].executePythonScheme( self.__adaoObject )
776 if "UserPostAnalysis" in self.__adaoObject and len(self.__adaoObject["UserPostAnalysis"])>0:
777 self.__objname = self.__retrieve_objname()
778 for __UpaOne in self.__adaoObject["UserPostAnalysis"]:
779 __UpaOne = eval(str(__UpaOne))
780 exec(__UpaOne, {}, {'self':self, 'ADD':self, 'case':self, 'adaopy':self, self.__objname:self})
783 def __executeYACSScheme(self, FileName=None):
784 "Lancement du calcul"
785 self.__case.register("executeYACSScheme", dir(), locals())
786 self.dump( FileName, "YACS")
787 self.__adaoObject["AlgorithmParameters"].executeYACSScheme( FileName )
790 # -----------------------------------------------------------
792 def dump(self, FileName=None, Formater="TUI"):
793 "Restitution normalisée des commandes"
794 __Upa = "\n".join(self.__PostAnalysis)
795 return self.__case.dump(FileName, Formater, __Upa)
797 def load(self, FileName=None, Content=None, Object=None, Formater="TUI"):
798 "Chargement normalisé des commandes"
799 __commands = self.__case.load(FileName, Content, Object, Formater)
800 from numpy import array, matrix
801 for __command in __commands:
802 if (__command.find("set")>-1 and __command.find("set_")<0) or 'UserPostAnalysis' in __command:
803 exec("self."+__command, {}, locals())
805 self.__PostAnalysis.append(__command)
809 FileNameFrom=None, ContentFrom=None, ObjectFrom=None, FormaterFrom="TUI",
810 FileNameTo=None, FormaterTo="TUI",
812 "Conversion normalisée des commandes"
814 FileName=FileNameFrom, Content=ContentFrom, Object=ObjectFrom, Formater=FormaterFrom
816 FileName=FileNameTo, Formater=FormaterTo
820 "Effacement du contenu du cas en cours"
821 self.__init__(self.__name)
823 # -----------------------------------------------------------
825 def __with_directory(self, __filename=None):
826 if os.path.exists(str(__filename)):
827 __fullpath = __filename
828 elif os.path.exists(os.path.join(str(self.__directory), str(__filename))):
829 __fullpath = os.path.join(self.__directory, str(__filename))
831 __fullpath = __filename
834 def __retrieve_objname(self):
835 "Ne pas utiliser dans le __init__, la variable appelante n'existe pas encore"
837 for level in reversed(inspect.stack()):
838 __names += [name for name, value in level.frame.f_locals.items() if value is self]
839 __names += [name for name, value in globals().items() if value is self]
840 while 'self' in __names: __names.remove('self') # Devrait toujours être trouvé, donc pas d'erreur
842 self.__objname = __names[0]
844 self.__objname = "ADD"
845 return self.__objname
848 "Clarifie la visibilité des méthodes"
849 return ['set', 'get', 'execute', 'dump', 'load', '__doc__', '__init__', '__module__']
852 "Représentation pour impression (mais pas repr)"
853 msg = self.dump(None, "SimpleReportInPlainTxt")
856 def sysinfo(self, title=""):
857 msg = PlatformInfo.PlatformInfo().getAllInformation(" ", title)
860 def prepare_to_pickle(self):
861 "Retire les variables non pickelisables, avec recopie efficace"
862 if self.__adaoObject['AlgorithmParameters'] is not None:
863 for k in self.__adaoObject['AlgorithmParameters'].keys():
864 if k == "Algorithm": continue
865 if k in self.__StoredInputs:
866 raise ValueError("The key \"%s\" to be transfered for pickling will overwrite an existing one."%(k,))
867 if self.__adaoObject['AlgorithmParameters'].hasObserver( k ):
868 self.__adaoObject['AlgorithmParameters'].removeObserver( k, "", True )
869 self.__StoredInputs[k] = self.__adaoObject['AlgorithmParameters'].pop(k, None)
870 if sys.version_info[0] == 2:
871 del self.__adaoObject # Because it breaks pickle in Python 2. Not required for Python 3
872 del self.__case # Because it breaks pickle in Python 2. Not required for Python 3
873 if sys.version_info.major < 3:
876 return self.__StoredInputs
878 # ==============================================================================
879 if __name__ == "__main__":
880 print("\n AUTODIAGNOSTIC\n")