1 # -*- coding: utf-8 -*-
3 # Copyright (C) 2008-2021 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 """
45 def __init__(self, name = "", addViewers=None):
46 self.__name = str(name)
48 self.__directory = None
49 self.__case = CaseLogger(self.__name, "case", addViewers)
51 self.__adaoObject = {}
52 self.__StoredInputs = {}
53 self.__PostAnalysis = []
55 self.__Concepts = [ # Liste exhaustive
56 "AlgorithmParameters",
70 "ObservationOperator",
72 "RegulationParameters",
73 "SupplementaryParameters",
77 for ename in self.__Concepts:
78 self.__adaoObject[ename] = None
79 for ename in ("ObservationOperator", "EvolutionModel", "ControlModel"):
80 self.__adaoObject[ename] = {}
81 for ename in ("BackgroundError", "ObservationError"):
82 self.__adaoObject[ename] = Covariance(ename, asEyeByScalar = 1.)
83 for ename in ("EvolutionError",):
84 self.__adaoObject[ename] = Covariance(ename, asEyeByScalar = 1.e-16)
85 for ename in ("Observer", "UserPostAnalysis"):
86 self.__adaoObject[ename] = []
87 self.__StoredInputs[ename] = [] # Vide par defaut
88 self.__StoredInputs["Name"] = self.__name
89 self.__StoredInputs["Directory"] = self.__directory
91 # Récupère le chemin du répertoire parent et l'ajoute au path
92 # (Cela complète l'action de la classe PathManagement dans PlatformInfo,
93 # qui est activée dans Persistence)
94 self.__parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
95 sys.path.insert(0, self.__parent)
96 sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
99 Concept = None, # Premier argument
106 DiagonalSparseMatrix = None,
107 ExtraArguments = None,
109 InputFunctionAsMulti = False,
111 ObjectFunction = None,
115 PerformanceProfile = None,
116 ScalarSparseMatrix = None,
122 ThreeFunctions = None,
127 "Interface unique de definition de variables d'entrees par argument"
128 self.__case.register("set",dir(),locals(),None,True)
130 if Concept in ("Background", "CheckingPoint", "ControlInput", "Observation"):
131 commande = getattr(self,"set"+Concept)
132 commande(Vector, VectorSerie, Script, DataFile, ColNames, ColMajor, Stored, Scheduler, Checked )
133 elif Concept in ("BackgroundError", "ObservationError", "EvolutionError"):
134 commande = getattr(self,"set"+Concept)
135 commande(Matrix, ScalarSparseMatrix, DiagonalSparseMatrix,
136 Script, Stored, ObjectMatrix, Checked )
137 elif Concept == "AlgorithmParameters":
138 self.setAlgorithmParameters( Algorithm, Parameters, Script )
139 elif Concept == "RegulationParameters":
140 self.setRegulationParameters( Algorithm, Parameters, Script )
141 elif Concept == "Name":
143 elif Concept == "Directory":
144 self.setDirectory(String)
145 elif Concept == "Debug":
147 elif Concept == "NoDebug":
149 elif Concept == "Observer":
150 self.setObserver( Variable, Template, String, Script, Info, ObjectFunction, Scheduler )
151 elif Concept == "UserPostAnalysis":
152 self.setUserPostAnalysis( Template, String, Script )
153 elif Concept == "SupplementaryParameters":
154 self.setSupplementaryParameters( Parameters, Script )
155 elif Concept == "ObservationOperator":
156 self.setObservationOperator(
157 Matrix, OneFunction, ThreeFunctions, AppliedInXb,
158 Parameters, Script, ExtraArguments,
159 Stored, PerformanceProfile, InputFunctionAsMulti, Checked )
160 elif Concept in ("EvolutionModel", "ControlModel"):
161 commande = getattr(self,"set"+Concept)
163 Matrix, OneFunction, ThreeFunctions,
164 Parameters, Script, Scheduler, ExtraArguments,
165 Stored, PerformanceProfile, InputFunctionAsMulti, Checked )
167 raise ValueError("the variable named '%s' is not allowed."%str(Concept))
168 except Exception as e:
169 if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
171 raise ValueError(("during settings, the following error occurs:\n"+\
172 "\n%s %s\n\nSee also the potential messages, "+\
173 "which can show the origin of the above error, "+\
174 "in the launching terminal.")%(str(e),msg))
176 # -----------------------------------------------------------
178 def setBackground(self,
188 "Definition d'un concept de calcul"
189 Concept = "Background"
190 self.__case.register("set"+Concept, dir(), locals())
191 self.__adaoObject[Concept] = State(
194 asPersistentVector = VectorSerie,
195 asScript = self.__with_directory(Script),
196 asDataFile = DataFile,
199 scheduledBy = Scheduler,
200 toBeChecked = Checked,
203 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
206 def setCheckingPoint(self,
216 "Definition d'un concept de calcul"
217 Concept = "CheckingPoint"
218 self.__case.register("set"+Concept, dir(), locals())
219 self.__adaoObject[Concept] = State(
222 asPersistentVector = VectorSerie,
223 asScript = self.__with_directory(Script),
224 asDataFile = DataFile,
227 scheduledBy = Scheduler,
228 toBeChecked = Checked,
231 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
234 def setControlInput(self,
244 "Definition d'un concept de calcul"
245 Concept = "ControlInput"
246 self.__case.register("set"+Concept, dir(), locals())
247 self.__adaoObject[Concept] = State(
250 asPersistentVector = VectorSerie,
251 asScript = self.__with_directory(Script),
252 asDataFile = DataFile,
255 scheduledBy = Scheduler,
256 toBeChecked = Checked,
259 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
262 def setObservation(self,
272 "Definition d'un concept de calcul"
273 Concept = "Observation"
274 self.__case.register("set"+Concept, dir(), locals())
275 self.__adaoObject[Concept] = State(
278 asPersistentVector = VectorSerie,
279 asScript = self.__with_directory(Script),
280 asDataFile = DataFile,
283 scheduledBy = Scheduler,
284 toBeChecked = Checked,
287 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
290 def setBackgroundError(self,
292 ScalarSparseMatrix = None,
293 DiagonalSparseMatrix = None,
298 "Definition d'un concept de calcul"
299 Concept = "BackgroundError"
300 self.__case.register("set"+Concept, dir(), locals())
301 self.__adaoObject[Concept] = Covariance(
303 asCovariance = Matrix,
304 asEyeByScalar = ScalarSparseMatrix,
305 asEyeByVector = DiagonalSparseMatrix,
306 asCovObject = ObjectMatrix,
307 asScript = self.__with_directory(Script),
308 toBeChecked = Checked,
311 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
314 def setObservationError(self,
316 ScalarSparseMatrix = None,
317 DiagonalSparseMatrix = None,
322 "Definition d'un concept de calcul"
323 Concept = "ObservationError"
324 self.__case.register("set"+Concept, dir(), locals())
325 self.__adaoObject[Concept] = Covariance(
327 asCovariance = Matrix,
328 asEyeByScalar = ScalarSparseMatrix,
329 asEyeByVector = DiagonalSparseMatrix,
330 asCovObject = ObjectMatrix,
331 asScript = self.__with_directory(Script),
332 toBeChecked = Checked,
335 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
338 def setEvolutionError(self,
340 ScalarSparseMatrix = None,
341 DiagonalSparseMatrix = None,
346 "Definition d'un concept de calcul"
347 Concept = "EvolutionError"
348 self.__case.register("set"+Concept, dir(), locals())
349 self.__adaoObject[Concept] = Covariance(
351 asCovariance = Matrix,
352 asEyeByScalar = ScalarSparseMatrix,
353 asEyeByVector = DiagonalSparseMatrix,
354 asCovObject = ObjectMatrix,
355 asScript = self.__with_directory(Script),
356 toBeChecked = Checked,
359 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
362 def setObservationOperator(self,
365 ThreeFunctions = None,
369 ExtraArguments = None,
371 PerformanceProfile = None,
372 InputFunctionAsMulti = False,
374 "Definition d'un concept de calcul"
375 Concept = "ObservationOperator"
376 self.__case.register("set"+Concept, dir(), locals())
377 self.__adaoObject[Concept] = FullOperator(
380 asOneFunction = OneFunction,
381 asThreeFunctions = ThreeFunctions,
382 asScript = self.__with_directory(Script),
384 appliedInX = AppliedInXb,
385 extraArguments = ExtraArguments,
386 performancePrf = PerformanceProfile,
387 inputAsMF = InputFunctionAsMulti,
389 toBeChecked = Checked,
392 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
395 def setEvolutionModel(self,
398 ThreeFunctions = None,
402 ExtraArguments = None,
404 PerformanceProfile = None,
405 InputFunctionAsMulti = False,
407 "Definition d'un concept de calcul"
408 Concept = "EvolutionModel"
409 self.__case.register("set"+Concept, dir(), locals())
410 self.__adaoObject[Concept] = FullOperator(
413 asOneFunction = OneFunction,
414 asThreeFunctions = ThreeFunctions,
415 asScript = self.__with_directory(Script),
418 extraArguments = ExtraArguments,
419 performancePrf = PerformanceProfile,
420 inputAsMF = InputFunctionAsMulti,
421 scheduledBy = Scheduler,
422 toBeChecked = Checked,
425 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
428 def setControlModel(self,
431 ThreeFunctions = None,
435 ExtraArguments = None,
437 PerformanceProfile = None,
438 InputFunctionAsMulti = False,
440 "Definition d'un concept de calcul"
441 Concept = "ControlModel"
442 self.__case.register("set"+Concept, dir(), locals())
443 self.__adaoObject[Concept] = FullOperator(
446 asOneFunction = OneFunction,
447 asThreeFunctions = ThreeFunctions,
448 asScript = self.__with_directory(Script),
451 extraArguments = ExtraArguments,
452 performancePrf = PerformanceProfile,
453 inputAsMF = InputFunctionAsMulti,
454 scheduledBy = Scheduler,
455 toBeChecked = Checked,
458 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
461 def setName(self, String=None):
462 "Definition d'un concept de calcul"
463 self.__case.register("setName",dir(),locals())
464 if String is not None:
465 self.__name = str(String)
468 self.__StoredInputs["Name"] = self.__name
470 def setDirectory(self, String=None):
471 "Definition d'un concept de calcul"
472 self.__case.register("setDirectory",dir(),locals())
473 if os.path.isdir(os.path.abspath(str(String))):
474 self.__directory = os.path.abspath(str(String))
476 self.__directory = None
477 self.__StoredInputs["Directory"] = self.__directory
479 def setDebug(self, __level = 10):
480 "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
481 self.__case.register("setDebug",dir(),locals())
482 log = logging.getLogger()
483 log.setLevel( __level )
484 self.__StoredInputs["Debug"] = __level
485 self.__StoredInputs["NoDebug"] = False
488 def setNoDebug(self):
489 "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
490 self.__case.register("setNoDebug",dir(),locals())
491 log = logging.getLogger()
492 log.setLevel( logging.WARNING )
493 self.__StoredInputs["Debug"] = logging.WARNING
494 self.__StoredInputs["NoDebug"] = True
497 def setAlgorithmParameters(self,
501 "Definition d'un concept de calcul"
502 Concept = "AlgorithmParameters"
503 self.__case.register("set"+Concept, dir(), locals())
504 self.__adaoObject[Concept] = AlgorithmAndParameters(
506 asAlgorithm = Algorithm,
508 asScript = self.__with_directory(Script),
512 def updateAlgorithmParameters(self,
515 "Mise a jour d'un concept de calcul"
516 Concept = "AlgorithmParameters"
517 if Concept not in self.__adaoObject or self.__adaoObject[Concept] is None:
518 raise ValueError("\n\nNo algorithm registred, set one before updating parameters or executing\n")
519 self.__adaoObject[Concept].updateParameters(
521 asScript = self.__with_directory(Script),
526 def setRegulationParameters(self,
530 "Definition d'un concept de calcul"
531 Concept = "RegulationParameters"
532 self.__case.register("set"+Concept, dir(), locals())
533 self.__adaoObject[Concept] = RegulationAndParameters(
535 asAlgorithm = Algorithm,
537 asScript = self.__with_directory(Script),
541 def setSupplementaryParameters(self,
544 "Definition d'un concept de calcul"
545 Concept = "SupplementaryParameters"
546 self.__case.register("set"+Concept, dir(), locals())
547 self.__adaoObject[Concept] = ExternalParameters(
550 asScript = self.__with_directory(Script),
554 def updateSupplementaryParameters(self,
557 "Mise a jour d'un concept de calcul"
558 Concept = "SupplementaryParameters"
559 if Concept not in self.__adaoObject or self.__adaoObject[Concept] is None:
560 self.__adaoObject[Concept] = ExternalParameters(name = Concept)
561 self.__adaoObject[Concept].updateParameters(
563 asScript = self.__with_directory(Script),
567 def setObserver(self,
573 ObjectFunction = None,
575 "Definition d'un concept de calcul"
577 self.__case.register("set"+Concept, dir(), locals())
578 self.__adaoObject[Concept].append( DataObserver(
580 onVariable = Variable,
581 asTemplate = Template,
583 asScript = self.__with_directory(Script),
584 asObsObject = ObjectFunction,
586 scheduledBy = Scheduler,
587 withAlgo = self.__adaoObject["AlgorithmParameters"]
591 def removeObserver(self,
593 ObjectFunction = None,
595 "Permet de retirer un observer à une ou des variable nommée"
596 if "AlgorithmParameters" not in self.__adaoObject:
597 raise ValueError("No algorithm registred, ask for one before removing observers")
599 # Vérification du nom de variable et typage
600 # -----------------------------------------
601 if isinstance(Variable, str):
602 VariableNames = (Variable,)
603 elif isinstance(Variable, list):
604 VariableNames = tuple(map( str, Variable ))
606 raise ValueError("The observer requires a name or a list of names of variables.")
608 # Association interne de l'observer à la variable
609 # -----------------------------------------------
610 for ename in VariableNames:
611 if ename not in self.__adaoObject["AlgorithmParameters"]:
612 raise ValueError("An observer requires to be removed on a variable named %s which does not exist."%ename)
614 return self.__adaoObject["AlgorithmParameters"].removeObserver( ename, ObjectFunction )
616 def setUserPostAnalysis(self,
620 "Definition d'un concept de calcul"
621 Concept = "UserPostAnalysis"
622 self.__case.register("set"+Concept, dir(), locals())
623 self.__adaoObject[Concept].append( repr(UserScript(
625 asTemplate = Template,
627 asScript = self.__with_directory(Script),
631 # -----------------------------------------------------------
633 def get(self, Concept=None, noDetails=True ):
634 "Recuperation d'une sortie du calcul"
635 if Concept is not None:
637 self.__case.register("get", dir(), locals(), Concept) # Break pickle in Python 2
640 if Concept in self.__StoredInputs:
641 return self.__StoredInputs[Concept]
643 elif self.__adaoObject["AlgorithmParameters"] is not None and Concept == "AlgorithmParameters":
644 return self.__adaoObject["AlgorithmParameters"].get()
646 elif self.__adaoObject["AlgorithmParameters"] is not None and Concept in self.__adaoObject["AlgorithmParameters"]:
647 return self.__adaoObject["AlgorithmParameters"].get( Concept )
649 elif Concept == "AlgorithmRequiredParameters" and self.__adaoObject["AlgorithmParameters"] is not None:
650 return self.__adaoObject["AlgorithmParameters"].getAlgorithmRequiredParameters(noDetails)
652 elif Concept == "AlgorithmRequiredInputs" and self.__adaoObject["AlgorithmParameters"] is not None:
653 return self.__adaoObject["AlgorithmParameters"].getAlgorithmInputArguments()
655 elif Concept == "AlgorithmAttributes" and self.__adaoObject["AlgorithmParameters"] is not None:
656 return self.__adaoObject["AlgorithmParameters"].getAlgorithmAttributes()
658 elif self.__adaoObject["SupplementaryParameters"] is not None and Concept == "SupplementaryParameters":
659 return self.__adaoObject["SupplementaryParameters"].get()
661 elif self.__adaoObject["SupplementaryParameters"] is not None and Concept in self.__adaoObject["SupplementaryParameters"]:
662 return self.__adaoObject["SupplementaryParameters"].get( Concept )
665 raise ValueError("The requested key \"%s\" does not exists as an input or a stored variable."%Concept)
668 allvariables.update( {"AlgorithmParameters":self.__adaoObject["AlgorithmParameters"].get()} )
669 if self.__adaoObject["SupplementaryParameters"] is not None:
670 allvariables.update( {"SupplementaryParameters":self.__adaoObject["SupplementaryParameters"].get()} )
671 # allvariables.update( self.__adaoObject["AlgorithmParameters"].get() )
672 allvariables.update( self.__StoredInputs )
673 allvariables.pop('Observer', None)
674 allvariables.pop('UserPostAnalysis', None)
677 # -----------------------------------------------------------
679 def get_available_variables(self):
681 Renvoie les variables potentiellement utilisables pour l'étude,
682 initialement stockées comme données d'entrées ou dans les algorithmes,
683 identifiés par les chaînes de caractères. L'algorithme doit avoir été
684 préalablement choisi sinon la méthode renvoie "None".
686 if len(list(self.__adaoObject["AlgorithmParameters"].keys())) == 0 and \
687 len(list(self.__StoredInputs.keys())) == 0:
691 if len(list(self.__adaoObject["AlgorithmParameters"].keys())) > 0:
692 variables.extend(list(self.__adaoObject["AlgorithmParameters"].keys()))
693 if self.__adaoObject["SupplementaryParameters"] is not None and \
694 len(list(self.__adaoObject["SupplementaryParameters"].keys())) > 0:
695 variables.extend(list(self.__adaoObject["SupplementaryParameters"].keys()))
696 if len(list(self.__StoredInputs.keys())) > 0:
697 variables.extend( list(self.__StoredInputs.keys()) )
698 variables.remove('Observer')
699 variables.remove('UserPostAnalysis')
703 def get_available_algorithms(self):
705 Renvoie la liste des algorithmes potentiellement utilisables, identifiés
706 par les chaînes de caractères.
709 for directory in sys.path:
710 trypath = os.path.join(directory,"daAlgorithms")
711 if os.path.isdir(trypath):
712 for fname in os.listdir(trypath):
713 if os.path.isfile(os.path.join(trypath,fname)):
714 root, ext = os.path.splitext(fname)
715 if ext != ".py": continue
716 with open(os.path.join(trypath,fname)) as fc:
717 iselal = bool("class ElementaryAlgorithm" in fc.read())
718 if iselal and ext == '.py' and root != '__init__':
723 def get_algorithms_main_path(self):
725 Renvoie le chemin pour le répertoire principal contenant les algorithmes
729 def add_algorithms_path(self, Path=None):
731 Ajoute au chemin de recherche des algorithmes un répertoire dans lequel
732 se trouve un sous-répertoire "daAlgorithms"
734 if not os.path.isdir(Path):
735 raise ValueError("The given "+Path+" argument must exist as a directory")
736 if not os.path.isdir(os.path.join(Path,"daAlgorithms")):
737 raise ValueError("The given \""+Path+"\" argument must contain a subdirectory named \"daAlgorithms\"")
738 if not os.path.isfile(os.path.join(Path,"daAlgorithms","__init__.py")):
739 raise ValueError("The given \""+Path+"/daAlgorithms\" path must contain a file named \"__init__.py\"")
740 sys.path.insert(0, os.path.abspath(Path))
741 sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
744 # -----------------------------------------------------------
746 def execute(self, Executor=None, SaveCaseInFile=None, nextStep=False):
747 "Lancement du calcul"
748 self.__case.register("execute",dir(),locals(),None,True)
749 self.updateAlgorithmParameters(Parameters={"nextStep":bool(nextStep)})
750 if not nextStep: Operator.CM.clearCache()
752 if Executor == "YACS": self.__executeYACSScheme( SaveCaseInFile )
753 else: self.__executePythonScheme( SaveCaseInFile )
754 except Exception as e:
755 if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
757 raise ValueError(("during execution, the following error occurs:\n"+\
758 "\n%s %s\n\nSee also the potential messages, "+\
759 "which can show the origin of the above error, "+\
760 "in the launching terminal.\n")%(str(e),msg))
763 def __executePythonScheme(self, FileName=None):
764 "Lancement du calcul"
765 self.__case.register("executePythonScheme", dir(), locals())
766 if FileName is not None:
767 self.dump( FileName, "TUI")
768 self.__adaoObject["AlgorithmParameters"].executePythonScheme( self.__adaoObject )
769 if "UserPostAnalysis" in self.__adaoObject and len(self.__adaoObject["UserPostAnalysis"])>0:
770 self.__objname = self.__retrieve_objname()
771 for __UpaOne in self.__adaoObject["UserPostAnalysis"]:
772 __UpaOne = eval(str(__UpaOne))
773 exec(__UpaOne, {}, {'self':self, 'ADD':self, 'case':self, 'adaopy':self, self.__objname:self})
776 def __executeYACSScheme(self, FileName=None):
777 "Lancement du calcul"
778 self.__case.register("executeYACSScheme", dir(), locals())
779 self.dump( FileName, "YACS")
780 self.__adaoObject["AlgorithmParameters"].executeYACSScheme( FileName )
783 # -----------------------------------------------------------
785 def dump(self, FileName=None, Formater="TUI"):
786 "Restitution normalisée des commandes"
787 __Upa = "\n".join(self.__PostAnalysis)
788 return self.__case.dump(FileName, Formater, __Upa)
790 def load(self, FileName=None, Content=None, Object=None, Formater="TUI"):
791 "Chargement normalisé des commandes"
792 __commands = self.__case.load(FileName, Content, Object, Formater)
793 from numpy import array, matrix
794 for __command in __commands:
795 if (__command.find("set")>-1 and __command.find("set_")<0) or 'UserPostAnalysis' in __command:
796 exec("self."+__command, {}, locals())
798 self.__PostAnalysis.append(__command)
802 FileNameFrom=None, ContentFrom=None, ObjectFrom=None, FormaterFrom="TUI",
803 FileNameTo=None, FormaterTo="TUI",
805 "Conversion normalisée des commandes"
807 FileName=FileNameFrom, Content=ContentFrom, Object=ObjectFrom, Formater=FormaterFrom
809 FileName=FileNameTo, Formater=FormaterTo
813 "Effacement du contenu du cas en cours"
814 self.__init__(self.__name)
816 # -----------------------------------------------------------
818 def __with_directory(self, __filename=None):
819 if os.path.exists(str(__filename)):
820 __fullpath = __filename
821 elif os.path.exists(os.path.join(str(self.__directory), str(__filename))):
822 __fullpath = os.path.join(self.__directory, str(__filename))
824 __fullpath = __filename
827 def __retrieve_objname(self):
828 "Ne pas utiliser dans le __init__, la variable appelante n'existe pas encore"
830 for level in reversed(inspect.stack()):
831 __names += [name for name, value in level.frame.f_locals.items() if value is self]
832 __names += [name for name, value in globals().items() if value is self]
833 while 'self' in __names: __names.remove('self') # Devrait toujours être trouvé, donc pas d'erreur
835 self.__objname = __names[0]
837 self.__objname = "ADD"
838 return self.__objname
841 "Clarifie la visibilité des méthodes"
842 return ['set', 'get', 'execute', 'dump', 'load', '__doc__', '__init__', '__module__']
845 "Représentation pour impression (mais pas repr)"
846 msg = self.dump(None, "SimpleReportInPlainTxt")
849 def prepare_to_pickle(self):
850 "Retire les variables non pickelisables, avec recopie efficace"
851 if self.__adaoObject['AlgorithmParameters'] is not None:
852 for k in self.__adaoObject['AlgorithmParameters'].keys():
853 if k == "Algorithm": continue
854 if k in self.__StoredInputs:
855 raise ValueError("The key \"%s\" to be transfered for pickling will overwrite an existing one."%(k,))
856 if self.__adaoObject['AlgorithmParameters'].hasObserver( k ):
857 self.__adaoObject['AlgorithmParameters'].removeObserver( k, "", True )
858 self.__StoredInputs[k] = self.__adaoObject['AlgorithmParameters'].pop(k, None)
859 if sys.version_info[0] == 2:
860 del self.__adaoObject # Because it breaks pickle in Python 2. Not required for Python 3
861 del self.__case # Because it breaks pickle in Python 2. Not required for Python 3
862 if sys.version_info.major < 3:
865 return self.__StoredInputs
867 # ==============================================================================
868 if __name__ == "__main__":
869 print('\n AUTODIAGNOSTIC\n')