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
39 from daCore import ExtendedLogging ; ExtendedLogging.ExtendedLogging() # A importer en premier
42 # ==============================================================================
44 """ ADAO Internal Data Structure Model """
46 "__name", "__objname", "__directory", "__case", "__parent",
47 "__adaoObject", "__StoredInputs", "__PostAnalysis", "__Concepts",
50 def __init__(self, name = "", addViewers=None):
51 self.__name = str(name)
53 self.__directory = None
54 self.__case = CaseLogger(self.__name, "case", addViewers)
56 self.__adaoObject = {}
57 self.__StoredInputs = {}
58 self.__PostAnalysis = []
60 self.__Concepts = [ # Liste exhaustive
61 "AlgorithmParameters",
75 "ObservationOperator",
77 "RegulationParameters",
78 "SupplementaryParameters",
82 for ename in self.__Concepts:
83 self.__adaoObject[ename] = None
84 for ename in ("ObservationOperator", "EvolutionModel", "ControlModel"):
85 self.__adaoObject[ename] = {}
86 for ename in ("BackgroundError", "ObservationError"):
87 self.__adaoObject[ename] = Covariance(ename, asEyeByScalar = 1.)
88 for ename in ("EvolutionError",):
89 self.__adaoObject[ename] = Covariance(ename, asEyeByScalar = 1.e-16)
90 for ename in ("Observer", "UserPostAnalysis"):
91 self.__adaoObject[ename] = []
92 self.__StoredInputs[ename] = [] # Vide par defaut
93 self.__StoredInputs["Name"] = self.__name
94 self.__StoredInputs["Directory"] = self.__directory
96 # Récupère le chemin du répertoire parent et l'ajoute au path
97 # (Cela complète l'action de la classe PathManagement dans PlatformInfo,
98 # qui est activée dans Persistence)
99 self.__parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
100 sys.path.insert(0, self.__parent)
101 sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
104 Concept = None, # Premier argument
111 DiagonalSparseMatrix = None,
112 ExtraArguments = None,
114 InputFunctionAsMulti = False,
116 ObjectFunction = None,
120 PerformanceProfile = None,
121 ScalarSparseMatrix = None,
127 ThreeFunctions = None,
132 "Interface unique de définition de variables d'entrées par argument"
133 self.__case.register("set",dir(),locals(),None,True)
135 if Concept in ("Background", "CheckingPoint", "ControlInput", "Observation"):
136 commande = getattr(self,"set"+Concept)
137 commande(Vector, VectorSerie, Script, DataFile, ColNames, ColMajor, Stored, Scheduler, Checked )
138 elif Concept in ("BackgroundError", "ObservationError", "EvolutionError"):
139 commande = getattr(self,"set"+Concept)
140 commande(Matrix, ScalarSparseMatrix, DiagonalSparseMatrix,
141 Script, Stored, ObjectMatrix, Checked )
142 elif Concept == "AlgorithmParameters":
143 self.setAlgorithmParameters( Algorithm, Parameters, Script )
144 elif Concept == "RegulationParameters":
145 self.setRegulationParameters( Algorithm, Parameters, Script )
146 elif Concept == "Name":
148 elif Concept == "Directory":
149 self.setDirectory(String)
150 elif Concept == "Debug":
152 elif Concept == "NoDebug":
154 elif Concept == "Observer":
155 self.setObserver( Variable, Template, String, Script, Info, ObjectFunction, Scheduler )
156 elif Concept == "UserPostAnalysis":
157 self.setUserPostAnalysis( Template, String, Script )
158 elif Concept == "SupplementaryParameters":
159 self.setSupplementaryParameters( Parameters, Script )
160 elif Concept == "ObservationOperator":
161 self.setObservationOperator(
162 Matrix, OneFunction, ThreeFunctions, AppliedInXb,
163 Parameters, Script, ExtraArguments,
164 Stored, PerformanceProfile, InputFunctionAsMulti, Checked )
165 elif Concept in ("EvolutionModel", "ControlModel"):
166 commande = getattr(self,"set"+Concept)
168 Matrix, OneFunction, ThreeFunctions,
169 Parameters, Script, Scheduler, ExtraArguments,
170 Stored, PerformanceProfile, InputFunctionAsMulti, Checked )
172 raise ValueError("the variable named '%s' is not allowed."%str(Concept))
173 except Exception as e:
174 if isinstance(e, SyntaxError): msg = " at %s: %s"%(e.offset, e.text)
176 raise ValueError(("during settings, the following error occurs:\n"+\
177 "\n%s%s\n\nSee also the potential messages, "+\
178 "which can show the origin of the above error, "+\
179 "in the launching terminal.")%(str(e),msg))
181 # -----------------------------------------------------------
183 def setBackground(self,
193 "Définition d'un concept de calcul"
194 Concept = "Background"
195 self.__case.register("set"+Concept, dir(), locals())
196 self.__adaoObject[Concept] = State(
199 asPersistentVector = VectorSerie,
200 asScript = self.__with_directory(Script),
201 asDataFile = DataFile,
204 scheduledBy = Scheduler,
205 toBeChecked = Checked,
208 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
211 def setCheckingPoint(self,
221 "Définition d'un concept de calcul"
222 Concept = "CheckingPoint"
223 self.__case.register("set"+Concept, dir(), locals())
224 self.__adaoObject[Concept] = State(
227 asPersistentVector = VectorSerie,
228 asScript = self.__with_directory(Script),
229 asDataFile = DataFile,
232 scheduledBy = Scheduler,
233 toBeChecked = Checked,
236 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
239 def setControlInput(self,
249 "Définition d'un concept de calcul"
250 Concept = "ControlInput"
251 self.__case.register("set"+Concept, dir(), locals())
252 self.__adaoObject[Concept] = State(
255 asPersistentVector = VectorSerie,
256 asScript = self.__with_directory(Script),
257 asDataFile = DataFile,
260 scheduledBy = Scheduler,
261 toBeChecked = Checked,
264 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
267 def setObservation(self,
277 "Définition d'un concept de calcul"
278 Concept = "Observation"
279 self.__case.register("set"+Concept, dir(), locals())
280 self.__adaoObject[Concept] = State(
283 asPersistentVector = VectorSerie,
284 asScript = self.__with_directory(Script),
285 asDataFile = DataFile,
288 scheduledBy = Scheduler,
289 toBeChecked = Checked,
292 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
295 def setBackgroundError(self,
297 ScalarSparseMatrix = None,
298 DiagonalSparseMatrix = None,
303 "Définition d'un concept de calcul"
304 Concept = "BackgroundError"
305 self.__case.register("set"+Concept, dir(), locals())
306 self.__adaoObject[Concept] = Covariance(
308 asCovariance = Matrix,
309 asEyeByScalar = ScalarSparseMatrix,
310 asEyeByVector = DiagonalSparseMatrix,
311 asCovObject = ObjectMatrix,
312 asScript = self.__with_directory(Script),
313 toBeChecked = Checked,
316 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
319 def setObservationError(self,
321 ScalarSparseMatrix = None,
322 DiagonalSparseMatrix = None,
327 "Définition d'un concept de calcul"
328 Concept = "ObservationError"
329 self.__case.register("set"+Concept, dir(), locals())
330 self.__adaoObject[Concept] = Covariance(
332 asCovariance = Matrix,
333 asEyeByScalar = ScalarSparseMatrix,
334 asEyeByVector = DiagonalSparseMatrix,
335 asCovObject = ObjectMatrix,
336 asScript = self.__with_directory(Script),
337 toBeChecked = Checked,
340 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
343 def setEvolutionError(self,
345 ScalarSparseMatrix = None,
346 DiagonalSparseMatrix = None,
351 "Définition d'un concept de calcul"
352 Concept = "EvolutionError"
353 self.__case.register("set"+Concept, dir(), locals())
354 self.__adaoObject[Concept] = Covariance(
356 asCovariance = Matrix,
357 asEyeByScalar = ScalarSparseMatrix,
358 asEyeByVector = DiagonalSparseMatrix,
359 asCovObject = ObjectMatrix,
360 asScript = self.__with_directory(Script),
361 toBeChecked = Checked,
364 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
367 def setObservationOperator(self,
370 ThreeFunctions = None,
374 ExtraArguments = None,
376 PerformanceProfile = None,
377 InputFunctionAsMulti = False,
379 "Définition d'un concept de calcul"
380 Concept = "ObservationOperator"
381 self.__case.register("set"+Concept, dir(), locals())
382 self.__adaoObject[Concept] = FullOperator(
385 asOneFunction = OneFunction,
386 asThreeFunctions = ThreeFunctions,
387 asScript = self.__with_directory(Script),
389 appliedInX = AppliedInXb,
390 extraArguments = ExtraArguments,
391 performancePrf = PerformanceProfile,
392 inputAsMF = InputFunctionAsMulti,
394 toBeChecked = Checked,
397 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
400 def setEvolutionModel(self,
403 ThreeFunctions = None,
407 ExtraArguments = None,
409 PerformanceProfile = None,
410 InputFunctionAsMulti = False,
412 "Définition d'un concept de calcul"
413 Concept = "EvolutionModel"
414 self.__case.register("set"+Concept, dir(), locals())
415 self.__adaoObject[Concept] = FullOperator(
418 asOneFunction = OneFunction,
419 asThreeFunctions = ThreeFunctions,
420 asScript = self.__with_directory(Script),
423 extraArguments = ExtraArguments,
424 performancePrf = PerformanceProfile,
425 inputAsMF = InputFunctionAsMulti,
426 scheduledBy = Scheduler,
427 toBeChecked = Checked,
430 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
433 def setControlModel(self,
436 ThreeFunctions = None,
440 ExtraArguments = None,
442 PerformanceProfile = None,
443 InputFunctionAsMulti = False,
445 "Définition d'un concept de calcul"
446 Concept = "ControlModel"
447 self.__case.register("set"+Concept, dir(), locals())
448 self.__adaoObject[Concept] = FullOperator(
451 asOneFunction = OneFunction,
452 asThreeFunctions = ThreeFunctions,
453 asScript = self.__with_directory(Script),
456 extraArguments = ExtraArguments,
457 performancePrf = PerformanceProfile,
458 inputAsMF = InputFunctionAsMulti,
459 scheduledBy = Scheduler,
460 toBeChecked = Checked,
463 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
466 def setName(self, String=None):
467 "Définition d'un concept de calcul"
468 self.__case.register("setName",dir(),locals())
469 if String is not None:
470 self.__name = str(String)
473 self.__StoredInputs["Name"] = self.__name
475 def setDirectory(self, String=None):
476 "Définition d'un concept de calcul"
477 self.__case.register("setDirectory",dir(),locals())
478 if os.path.isdir(os.path.abspath(str(String))):
479 self.__directory = os.path.abspath(str(String))
481 self.__directory = None
482 self.__StoredInputs["Directory"] = self.__directory
484 def setDebug(self, __level = 10):
485 "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
486 self.__case.register("setDebug",dir(),locals())
487 log = logging.getLogger()
488 log.setLevel( __level )
489 self.__StoredInputs["Debug"] = __level
490 self.__StoredInputs["NoDebug"] = False
493 def setNoDebug(self):
494 "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
495 self.__case.register("setNoDebug",dir(),locals())
496 log = logging.getLogger()
497 log.setLevel( logging.WARNING )
498 self.__StoredInputs["Debug"] = logging.WARNING
499 self.__StoredInputs["NoDebug"] = True
502 def setAlgorithmParameters(self,
506 "Définition d'un concept de calcul"
507 Concept = "AlgorithmParameters"
508 self.__case.register("set"+Concept, dir(), locals())
509 self.__adaoObject[Concept] = AlgorithmAndParameters(
511 asAlgorithm = Algorithm,
513 asScript = self.__with_directory(Script),
517 def updateAlgorithmParameters(self,
520 "Mise à jour d'un concept de calcul"
521 Concept = "AlgorithmParameters"
522 if Concept not in self.__adaoObject or self.__adaoObject[Concept] is None:
523 raise ValueError("\n\nNo algorithm registred, set one before updating parameters or executing\n")
524 self.__adaoObject[Concept].updateParameters(
526 asScript = self.__with_directory(Script),
531 def setRegulationParameters(self,
535 "Définition d'un concept de calcul"
536 Concept = "RegulationParameters"
537 self.__case.register("set"+Concept, dir(), locals())
538 self.__adaoObject[Concept] = RegulationAndParameters(
540 asAlgorithm = Algorithm,
542 asScript = self.__with_directory(Script),
546 def setSupplementaryParameters(self,
549 "Définition d'un concept de calcul"
550 Concept = "SupplementaryParameters"
551 self.__case.register("set"+Concept, dir(), locals())
552 self.__adaoObject[Concept] = ExternalParameters(
555 asScript = self.__with_directory(Script),
559 def updateSupplementaryParameters(self,
562 "Mise à jour d'un concept de calcul"
563 Concept = "SupplementaryParameters"
564 if Concept not in self.__adaoObject or self.__adaoObject[Concept] is None:
565 self.__adaoObject[Concept] = ExternalParameters(name = Concept)
566 self.__adaoObject[Concept].updateParameters(
568 asScript = self.__with_directory(Script),
572 def setObserver(self,
578 ObjectFunction = None,
580 "Définition d'un concept de calcul"
582 self.__case.register("set"+Concept, dir(), locals())
583 self.__adaoObject[Concept].append( DataObserver(
585 onVariable = Variable,
586 asTemplate = Template,
588 asScript = self.__with_directory(Script),
589 asObsObject = ObjectFunction,
591 scheduledBy = Scheduler,
592 withAlgo = self.__adaoObject["AlgorithmParameters"]
596 def removeObserver(self,
598 ObjectFunction = None,
600 "Permet de retirer un observer à une ou des variable nommées"
601 if "AlgorithmParameters" not in self.__adaoObject:
602 raise ValueError("No algorithm registred, ask for one before removing observers")
604 # Vérification du nom de variable et typage
605 # -----------------------------------------
606 if isinstance(Variable, str):
607 VariableNames = (Variable,)
608 elif isinstance(Variable, list):
609 VariableNames = tuple(map( str, Variable ))
611 raise ValueError("The observer requires a name or a list of names of variables.")
613 # Association interne de l'observer à la variable
614 # -----------------------------------------------
615 for ename in VariableNames:
616 if ename not in self.__adaoObject["AlgorithmParameters"]:
617 raise ValueError("An observer requires to be removed on a variable named %s which does not exist."%ename)
619 return self.__adaoObject["AlgorithmParameters"].removeObserver( ename, ObjectFunction )
621 def setUserPostAnalysis(self,
625 "Définition d'un concept de calcul"
626 Concept = "UserPostAnalysis"
627 self.__case.register("set"+Concept, dir(), locals())
628 self.__adaoObject[Concept].append( repr(UserScript(
630 asTemplate = Template,
632 asScript = self.__with_directory(Script),
636 # -----------------------------------------------------------
638 def get(self, Concept=None, noDetails=True ):
639 "Récupération d'une sortie du calcul"
640 if Concept is not None:
642 self.__case.register("get", dir(), locals(), Concept) # Break pickle in Python 2
645 if Concept in self.__StoredInputs:
646 return self.__StoredInputs[Concept]
648 elif self.__adaoObject["AlgorithmParameters"] is not None and Concept == "AlgorithmParameters":
649 return self.__adaoObject["AlgorithmParameters"].get()
651 elif self.__adaoObject["AlgorithmParameters"] is not None and Concept in self.__adaoObject["AlgorithmParameters"]:
652 return self.__adaoObject["AlgorithmParameters"].get( Concept )
654 elif Concept == "AlgorithmRequiredParameters" and self.__adaoObject["AlgorithmParameters"] is not None:
655 return self.__adaoObject["AlgorithmParameters"].getAlgorithmRequiredParameters(noDetails)
657 elif Concept == "AlgorithmRequiredInputs" and self.__adaoObject["AlgorithmParameters"] is not None:
658 return self.__adaoObject["AlgorithmParameters"].getAlgorithmInputArguments()
660 elif Concept == "AlgorithmAttributes" and self.__adaoObject["AlgorithmParameters"] is not None:
661 return self.__adaoObject["AlgorithmParameters"].getAlgorithmAttributes()
663 elif self.__adaoObject["SupplementaryParameters"] is not None and Concept == "SupplementaryParameters":
664 return self.__adaoObject["SupplementaryParameters"].get()
666 elif self.__adaoObject["SupplementaryParameters"] is not None and Concept in self.__adaoObject["SupplementaryParameters"]:
667 return self.__adaoObject["SupplementaryParameters"].get( Concept )
670 raise ValueError("The requested key \"%s\" does not exists as an input or a stored variable."%Concept)
673 allvariables.update( {"AlgorithmParameters":self.__adaoObject["AlgorithmParameters"].get()} )
674 if self.__adaoObject["SupplementaryParameters"] is not None:
675 allvariables.update( {"SupplementaryParameters":self.__adaoObject["SupplementaryParameters"].get()} )
676 # allvariables.update( self.__adaoObject["AlgorithmParameters"].get() )
677 allvariables.update( self.__StoredInputs )
678 allvariables.pop('Observer', None)
679 allvariables.pop('UserPostAnalysis', None)
682 # -----------------------------------------------------------
684 def __get_available_variables(self):
686 Renvoie les variables potentiellement utilisables pour l'étude,
687 initialement stockées comme données d'entrées ou dans les algorithmes,
688 identifiés par les chaînes de caractères. L'algorithme doit avoir été
689 préalablement choisi sinon la méthode renvoie "None".
691 if len(list(self.__adaoObject["AlgorithmParameters"].keys())) == 0 and \
692 len(list(self.__StoredInputs.keys())) == 0:
696 if len(list(self.__adaoObject["AlgorithmParameters"].keys())) > 0:
697 variables.extend(list(self.__adaoObject["AlgorithmParameters"].keys()))
698 if self.__adaoObject["SupplementaryParameters"] is not None and \
699 len(list(self.__adaoObject["SupplementaryParameters"].keys())) > 0:
700 variables.extend(list(self.__adaoObject["SupplementaryParameters"].keys()))
701 if len(list(self.__StoredInputs.keys())) > 0:
702 variables.extend( list(self.__StoredInputs.keys()) )
703 variables.remove('Observer')
704 variables.remove('UserPostAnalysis')
708 def __get_available_algorithms(self):
710 Renvoie la liste des algorithmes potentiellement utilisables, identifiés
711 par les chaînes de caractères.
714 for directory in sys.path:
715 trypath = os.path.join(directory,"daAlgorithms")
716 if os.path.isdir(trypath):
717 for fname in os.listdir(trypath):
718 if os.path.isfile(os.path.join(trypath,fname)):
719 root, ext = os.path.splitext(fname)
720 if ext != ".py": continue
721 with open(os.path.join(trypath,fname)) as fc:
722 iselal = bool("class ElementaryAlgorithm" in fc.read())
723 if iselal and ext == '.py' and root != '__init__':
728 def __get_algorithms_main_path(self):
730 Renvoie le chemin pour le répertoire principal contenant les algorithmes
734 def __add_algorithms_path(self, Path=None):
736 Ajoute au chemin de recherche des algorithmes un répertoire dans lequel
737 se trouve un sous-répertoire "daAlgorithms"
739 if not os.path.isdir(Path):
740 raise ValueError("The given "+Path+" argument must exist as a directory")
741 if not os.path.isdir(os.path.join(Path,"daAlgorithms")):
742 raise ValueError("The given \""+Path+"\" argument must contain a subdirectory named \"daAlgorithms\"")
743 if not os.path.isfile(os.path.join(Path,"daAlgorithms","__init__.py")):
744 raise ValueError("The given \""+Path+"/daAlgorithms\" path must contain a file named \"__init__.py\"")
745 sys.path.insert(0, os.path.abspath(Path))
746 sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
749 # -----------------------------------------------------------
751 def execute(self, Executor=None, SaveCaseInFile=None, nextStep=False):
752 "Lancement du calcul"
753 self.__case.register("execute",dir(),locals(),None,True)
754 self.updateAlgorithmParameters(Parameters={"nextStep":bool(nextStep)})
755 if not nextStep: Operator.CM.clearCache()
757 if Executor == "YACS": self.__executeYACSScheme( SaveCaseInFile )
758 else: self.__executePythonScheme( SaveCaseInFile )
759 except Exception as e:
760 if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
762 raise ValueError(("during execution, the following error occurs:\n"+\
763 "\n%s %s\n\nSee also the potential messages, "+\
764 "which can show the origin of the above error, "+\
765 "in the launching terminal.\n")%(str(e),msg))
768 def __executePythonScheme(self, FileName=None):
769 "Lancement du calcul"
770 self.__case.register("executePythonScheme", dir(), locals())
771 if FileName is not None:
772 self.dump( FileName, "TUI")
773 self.__adaoObject["AlgorithmParameters"].executePythonScheme( self.__adaoObject )
774 if "UserPostAnalysis" in self.__adaoObject and len(self.__adaoObject["UserPostAnalysis"])>0:
775 self.__objname = self.__retrieve_objname()
776 for __UpaOne in self.__adaoObject["UserPostAnalysis"]:
777 __UpaOne = eval(str(__UpaOne))
778 exec(__UpaOne, {}, {'self':self, 'ADD':self, 'case':self, 'adaopy':self, self.__objname:self})
781 def __executeYACSScheme(self, FileName=None):
782 "Lancement du calcul"
783 self.__case.register("executeYACSScheme", dir(), locals())
784 self.dump( FileName, "YACS")
785 self.__adaoObject["AlgorithmParameters"].executeYACSScheme( FileName )
788 # -----------------------------------------------------------
790 def dump(self, FileName=None, Formater="TUI"):
791 "Restitution normalisée des commandes"
792 __Upa = "\n".join(self.__PostAnalysis)
793 return self.__case.dump(FileName, Formater, __Upa)
795 def load(self, FileName=None, Content=None, Object=None, Formater="TUI"):
796 "Chargement normalisé des commandes"
797 __commands = self.__case.load(FileName, Content, Object, Formater)
798 from numpy import array, matrix
799 for __command in __commands:
800 if (__command.find("set")>-1 and __command.find("set_")<0) or 'UserPostAnalysis' in __command:
801 exec("self."+__command, {}, locals())
803 self.__PostAnalysis.append(__command)
807 FileNameFrom=None, ContentFrom=None, ObjectFrom=None, FormaterFrom="TUI",
808 FileNameTo=None, FormaterTo="TUI",
810 "Conversion normalisée des commandes"
812 FileName=FileNameFrom, Content=ContentFrom, Object=ObjectFrom, Formater=FormaterFrom
814 FileName=FileNameTo, Formater=FormaterTo
818 "Effacement du contenu du cas en cours"
819 self.__init__(self.__name)
821 # -----------------------------------------------------------
823 def __with_directory(self, __filename=None):
824 if os.path.exists(str(__filename)):
825 __fullpath = __filename
826 elif os.path.exists(os.path.join(str(self.__directory), str(__filename))):
827 __fullpath = os.path.join(self.__directory, str(__filename))
829 __fullpath = __filename
832 def __retrieve_objname(self):
833 "Ne pas utiliser dans le __init__, la variable appelante n'existe pas encore"
835 for level in reversed(inspect.stack()):
836 __names += [name for name, value in level.frame.f_locals.items() if value is self]
837 __names += [name for name, value in globals().items() if value is self]
838 while 'self' in __names: __names.remove('self') # Devrait toujours être trouvé, donc pas d'erreur
840 self.__objname = __names[0]
842 self.__objname = "ADD"
843 return self.__objname
846 "Clarifie la visibilité des méthodes"
847 return ['set', 'get', 'execute', 'dump', 'load', '__doc__', '__init__', '__module__']
850 "Représentation pour impression (mais pas repr)"
851 msg = self.dump(None, "SimpleReportInPlainTxt")
854 def prepare_to_pickle(self):
855 "Retire les variables non pickelisables, avec recopie efficace"
856 if self.__adaoObject['AlgorithmParameters'] is not None:
857 for k in self.__adaoObject['AlgorithmParameters'].keys():
858 if k == "Algorithm": continue
859 if k in self.__StoredInputs:
860 raise ValueError("The key \"%s\" to be transfered for pickling will overwrite an existing one."%(k,))
861 if self.__adaoObject['AlgorithmParameters'].hasObserver( k ):
862 self.__adaoObject['AlgorithmParameters'].removeObserver( k, "", True )
863 self.__StoredInputs[k] = self.__adaoObject['AlgorithmParameters'].pop(k, None)
864 if sys.version_info[0] == 2:
865 del self.__adaoObject # Because it breaks pickle in Python 2. Not required for Python 3
866 del self.__case # Because it breaks pickle in Python 2. Not required for Python 3
867 if sys.version_info.major < 3:
870 return self.__StoredInputs
872 # ==============================================================================
873 if __name__ == "__main__":
874 print('\n AUTODIAGNOSTIC\n')