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"
32 from daCore.BasicObjects import State, Covariance, FullOperator, Operator
33 from daCore.BasicObjects import AlgorithmAndParameters, DataObserver
34 from daCore.BasicObjects import RegulationAndParameters, CaseLogger
35 from daCore.BasicObjects import UserScript, ExternalParameters
36 from daCore import PlatformInfo
38 from daCore import ExtendedLogging ; ExtendedLogging.ExtendedLogging() # A importer en premier
41 # ==============================================================================
43 """ ADAO Internal Data Structure Model """
44 def __init__(self, name = "", addViewers=None):
45 self.__name = str(name)
46 self.__directory = None
47 self.__case = CaseLogger(self.__name, "case", addViewers)
49 self.__adaoObject = {}
50 self.__StoredInputs = {}
51 self.__PostAnalysis = []
53 self.__Concepts = [ # Liste exhaustive
54 "AlgorithmParameters",
68 "ObservationOperator",
70 "RegulationParameters",
71 "SupplementaryParameters",
75 for ename in self.__Concepts:
76 self.__adaoObject[ename] = None
77 for ename in ("ObservationOperator", "EvolutionModel", "ControlModel"):
78 self.__adaoObject[ename] = {}
79 for ename in ("Observer", "UserPostAnalysis"):
80 self.__adaoObject[ename] = []
81 self.__StoredInputs[ename] = [] # Vide par defaut
82 self.__StoredInputs["Name"] = self.__name
83 self.__StoredInputs["Directory"] = self.__directory
85 # Récupère le chemin du répertoire parent et l'ajoute au path
86 # (Cela complète l'action de la classe PathManagement dans PlatformInfo,
87 # qui est activée dans Persistence)
88 self.__parent = os.path.abspath(os.path.join(os.path.dirname(__file__),".."))
89 sys.path.insert(0, self.__parent)
90 sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
93 Concept = None, # Premier argument
101 DiagonalSparseMatrix = None,
102 ExtraArguments = None,
104 InputFunctionAsMulti = False,
106 ObjectFunction = None,
110 ScalarSparseMatrix = None,
116 ThreeFunctions = None,
121 "Interface unique de definition de variables d'entrees par argument"
122 self.__case.register("set",dir(),locals(),None,True)
124 if Concept in ("Background", "CheckingPoint", "ControlInput", "Observation"):
125 commande = getattr(self,"set"+Concept)
126 commande(Vector, VectorSerie, Script, DataFile, ColNames, ColMajor, Stored, Scheduler, Checked )
127 elif Concept in ("BackgroundError", "ObservationError", "EvolutionError"):
128 commande = getattr(self,"set"+Concept)
129 commande(Matrix, ScalarSparseMatrix, DiagonalSparseMatrix,
130 Script, Stored, ObjectMatrix, Checked )
131 elif Concept == "AlgorithmParameters":
132 self.setAlgorithmParameters( Algorithm, Parameters, Script )
133 elif Concept == "RegulationParameters":
134 self.setRegulationParameters( Algorithm, Parameters, Script )
135 elif Concept == "Name":
137 elif Concept == "Directory":
138 self.setDirectory(String)
139 elif Concept == "Debug":
141 elif Concept == "NoDebug":
143 elif Concept == "Observer":
144 self.setObserver( Variable, Template, String, Script, Info, ObjectFunction, Scheduler )
145 elif Concept == "UserPostAnalysis":
146 self.setUserPostAnalysis( Template, String, Script )
147 elif Concept == "SupplementaryParameters":
148 self.setSupplementaryParameters( Parameters, Script )
149 elif Concept == "ObservationOperator":
150 self.setObservationOperator(
151 Matrix, OneFunction, ThreeFunctions, AppliedInXb,
152 Parameters, Script, ExtraArguments,
153 Stored, AvoidRC, InputFunctionAsMulti, Checked )
154 elif Concept in ("EvolutionModel", "ControlModel"):
155 commande = getattr(self,"set"+Concept)
157 Matrix, OneFunction, ThreeFunctions,
158 Parameters, Script, Scheduler, ExtraArguments,
159 Stored, AvoidRC, InputFunctionAsMulti, Checked )
161 raise ValueError("the variable named '%s' is not allowed."%str(Concept))
162 except Exception as e:
163 if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
165 raise ValueError(("during settings, the following error occurs:\n"+\
166 "\n%s %s\n\nSee also the potential messages, "+\
167 "which can show the origin of the above error, "+\
168 "in the launching terminal.")%(str(e),msg))
170 # -----------------------------------------------------------
172 def setBackground(self,
182 "Definition d'un concept de calcul"
183 Concept = "Background"
184 self.__case.register("set"+Concept, dir(), locals())
185 self.__adaoObject[Concept] = State(
188 asPersistentVector = VectorSerie,
189 asScript = self.__with_directory(Script),
190 asDataFile = DataFile,
193 scheduledBy = Scheduler,
194 toBeChecked = Checked,
197 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
200 def setCheckingPoint(self,
210 "Definition d'un concept de calcul"
211 Concept = "CheckingPoint"
212 self.__case.register("set"+Concept, dir(), locals())
213 self.__adaoObject[Concept] = State(
216 asPersistentVector = VectorSerie,
217 asScript = self.__with_directory(Script),
218 asDataFile = DataFile,
221 scheduledBy = Scheduler,
222 toBeChecked = Checked,
225 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
228 def setControlInput(self,
238 "Definition d'un concept de calcul"
239 Concept = "ControlInput"
240 self.__case.register("set"+Concept, dir(), locals())
241 self.__adaoObject[Concept] = State(
244 asPersistentVector = VectorSerie,
245 asScript = self.__with_directory(Script),
246 asDataFile = DataFile,
249 scheduledBy = Scheduler,
250 toBeChecked = Checked,
253 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
256 def setObservation(self,
266 "Definition d'un concept de calcul"
267 Concept = "Observation"
268 self.__case.register("set"+Concept, dir(), locals())
269 self.__adaoObject[Concept] = State(
272 asPersistentVector = VectorSerie,
273 asScript = self.__with_directory(Script),
274 asDataFile = DataFile,
277 scheduledBy = Scheduler,
278 toBeChecked = Checked,
281 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
284 def setBackgroundError(self,
286 ScalarSparseMatrix = None,
287 DiagonalSparseMatrix = None,
292 "Definition d'un concept de calcul"
293 Concept = "BackgroundError"
294 self.__case.register("set"+Concept, dir(), locals())
295 self.__adaoObject[Concept] = Covariance(
297 asCovariance = Matrix,
298 asEyeByScalar = ScalarSparseMatrix,
299 asEyeByVector = DiagonalSparseMatrix,
300 asCovObject = ObjectMatrix,
301 asScript = self.__with_directory(Script),
302 toBeChecked = Checked,
305 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
308 def setObservationError(self,
310 ScalarSparseMatrix = None,
311 DiagonalSparseMatrix = None,
316 "Definition d'un concept de calcul"
317 Concept = "ObservationError"
318 self.__case.register("set"+Concept, dir(), locals())
319 self.__adaoObject[Concept] = Covariance(
321 asCovariance = Matrix,
322 asEyeByScalar = ScalarSparseMatrix,
323 asEyeByVector = DiagonalSparseMatrix,
324 asCovObject = ObjectMatrix,
325 asScript = self.__with_directory(Script),
326 toBeChecked = Checked,
329 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
332 def setEvolutionError(self,
334 ScalarSparseMatrix = None,
335 DiagonalSparseMatrix = None,
340 "Definition d'un concept de calcul"
341 Concept = "EvolutionError"
342 self.__case.register("set"+Concept, dir(), locals())
343 self.__adaoObject[Concept] = Covariance(
345 asCovariance = Matrix,
346 asEyeByScalar = ScalarSparseMatrix,
347 asEyeByVector = DiagonalSparseMatrix,
348 asCovObject = ObjectMatrix,
349 asScript = self.__with_directory(Script),
350 toBeChecked = Checked,
353 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
356 def setObservationOperator(self,
359 ThreeFunctions = None,
363 ExtraArguments = None,
366 InputFunctionAsMulti = False,
368 "Definition d'un concept de calcul"
369 Concept = "ObservationOperator"
370 self.__case.register("set"+Concept, dir(), locals())
371 self.__adaoObject[Concept] = FullOperator(
374 asOneFunction = OneFunction,
375 asThreeFunctions = ThreeFunctions,
376 asScript = self.__with_directory(Script),
378 appliedInX = AppliedInXb,
379 extraArguments = ExtraArguments,
381 inputAsMF = InputFunctionAsMulti,
383 toBeChecked = Checked,
386 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
389 def setEvolutionModel(self,
392 ThreeFunctions = None,
396 ExtraArguments = None,
399 InputFunctionAsMulti = False,
401 "Definition d'un concept de calcul"
402 Concept = "EvolutionModel"
403 self.__case.register("set"+Concept, dir(), locals())
404 self.__adaoObject[Concept] = FullOperator(
407 asOneFunction = OneFunction,
408 asThreeFunctions = ThreeFunctions,
409 asScript = self.__with_directory(Script),
412 extraArguments = ExtraArguments,
414 inputAsMF = InputFunctionAsMulti,
415 scheduledBy = Scheduler,
416 toBeChecked = Checked,
419 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
422 def setControlModel(self,
425 ThreeFunctions = None,
429 ExtraArguments = None,
432 InputFunctionAsMulti = False,
434 "Definition d'un concept de calcul"
435 Concept = "ControlModel"
436 self.__case.register("set"+Concept, dir(), locals())
437 self.__adaoObject[Concept] = FullOperator(
440 asOneFunction = OneFunction,
441 asThreeFunctions = ThreeFunctions,
442 asScript = self.__with_directory(Script),
445 extraArguments = ExtraArguments,
447 inputAsMF = InputFunctionAsMulti,
448 scheduledBy = Scheduler,
449 toBeChecked = Checked,
452 self.__StoredInputs[Concept] = self.__adaoObject[Concept].getO()
455 def setName(self, String=None):
456 "Definition d'un concept de calcul"
457 self.__case.register("setName",dir(),locals())
458 if String is not None:
459 self.__name = str(String)
462 self.__StoredInputs["Name"] = self.__name
464 def setDirectory(self, String=None):
465 "Definition d'un concept de calcul"
466 self.__case.register("setDirectory",dir(),locals())
467 if os.path.isdir(os.path.abspath(str(String))):
468 self.__directory = os.path.abspath(str(String))
470 self.__directory = None
471 self.__StoredInputs["Directory"] = self.__directory
473 def setDebug(self, __level = 10):
474 "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
475 self.__case.register("setDebug",dir(),locals())
476 log = logging.getLogger()
477 log.setLevel( __level )
478 self.__StoredInputs["Debug"] = __level
479 self.__StoredInputs["NoDebug"] = False
482 def setNoDebug(self):
483 "NOTSET=0 < DEBUG=10 < INFO=20 < WARNING=30 < ERROR=40 < CRITICAL=50"
484 self.__case.register("setNoDebug",dir(),locals())
485 log = logging.getLogger()
486 log.setLevel( logging.WARNING )
487 self.__StoredInputs["Debug"] = logging.WARNING
488 self.__StoredInputs["NoDebug"] = True
491 def setAlgorithmParameters(self,
495 "Definition d'un concept de calcul"
496 Concept = "AlgorithmParameters"
497 self.__case.register("set"+Concept, dir(), locals())
498 self.__adaoObject[Concept] = AlgorithmAndParameters(
500 asAlgorithm = Algorithm,
502 asScript = self.__with_directory(Script),
506 def updateAlgorithmParameters(self,
509 "Mise a jour d'un concept de calcul"
510 Concept = "AlgorithmParameters"
511 if Concept not in self.__adaoObject or self.__adaoObject[Concept] is None:
512 raise ValueError("\n\nNo algorithm registred, set one before updating parameters or executing\n")
513 self.__adaoObject[Concept].updateParameters(
515 asScript = self.__with_directory(Script),
520 def setRegulationParameters(self,
524 "Definition d'un concept de calcul"
525 Concept = "RegulationParameters"
526 self.__case.register("set"+Concept, dir(), locals())
527 self.__adaoObject[Concept] = RegulationAndParameters(
529 asAlgorithm = Algorithm,
531 asScript = self.__with_directory(Script),
535 def setSupplementaryParameters(self,
538 "Definition d'un concept de calcul"
539 Concept = "SupplementaryParameters"
540 self.__case.register("set"+Concept, dir(), locals())
541 self.__adaoObject[Concept] = ExternalParameters(
544 asScript = self.__with_directory(Script),
548 def updateSupplementaryParameters(self,
551 "Mise a jour d'un concept de calcul"
552 Concept = "SupplementaryParameters"
553 if Concept not in self.__adaoObject or self.__adaoObject[Concept] is None:
554 self.__adaoObject[Concept] = ExternalParameters(name = Concept)
555 self.__adaoObject[Concept].updateParameters(
557 asScript = self.__with_directory(Script),
561 def setObserver(self,
567 ObjectFunction = None,
569 "Definition d'un concept de calcul"
571 self.__case.register("set"+Concept, dir(), locals())
572 self.__adaoObject[Concept].append( DataObserver(
574 onVariable = Variable,
575 asTemplate = Template,
577 asScript = self.__with_directory(Script),
578 asObsObject = ObjectFunction,
580 scheduledBy = Scheduler,
581 withAlgo = self.__adaoObject["AlgorithmParameters"]
585 def removeObserver(self,
587 ObjectFunction = None,
589 "Permet de retirer un observer à une ou des variable nommée"
590 if "AlgorithmParameters" not in self.__adaoObject:
591 raise ValueError("No algorithm registred, ask for one before removing observers")
593 # Vérification du nom de variable et typage
594 # -----------------------------------------
595 if isinstance(Variable, str):
596 VariableNames = (Variable,)
597 elif isinstance(Variable, list):
598 VariableNames = tuple(map( str, Variable ))
600 raise ValueError("The observer requires a name or a list of names of variables.")
602 # Association interne de l'observer à la variable
603 # -----------------------------------------------
604 for ename in VariableNames:
605 if ename not in self.__adaoObject["AlgorithmParameters"]:
606 raise ValueError("An observer requires to be removed on a variable named %s which does not exist."%ename)
608 return self.__adaoObject["AlgorithmParameters"].removeObserver( ename, ObjectFunction )
610 def setUserPostAnalysis(self,
614 "Definition d'un concept de calcul"
615 Concept = "UserPostAnalysis"
616 self.__case.register("set"+Concept, dir(), locals())
617 self.__adaoObject[Concept].append( repr(UserScript(
619 asTemplate = Template,
621 asScript = self.__with_directory(Script),
624 # -----------------------------------------------------------
626 def get(self, Concept=None, noDetails=True ):
627 "Recuperation d'une sortie du calcul"
628 if Concept is not None:
630 self.__case.register("get", dir(), locals(), Concept) # Break pickle in Python 2
633 if Concept in self.__StoredInputs:
634 return self.__StoredInputs[Concept]
636 elif self.__adaoObject["AlgorithmParameters"] is not None and Concept == "AlgorithmParameters":
637 return self.__adaoObject["AlgorithmParameters"].get()
639 elif self.__adaoObject["AlgorithmParameters"] is not None and Concept in self.__adaoObject["AlgorithmParameters"]:
640 return self.__adaoObject["AlgorithmParameters"].get( Concept )
642 elif Concept == "AlgorithmRequiredParameters" and self.__adaoObject["AlgorithmParameters"] is not None:
643 return self.__adaoObject["AlgorithmParameters"].getAlgorithmRequiredParameters(noDetails)
645 elif Concept == "AlgorithmRequiredInputs" and self.__adaoObject["AlgorithmParameters"] is not None:
646 return self.__adaoObject["AlgorithmParameters"].getAlgorithmInputArguments()
648 elif Concept == "AlgorithmAttributes" and self.__adaoObject["AlgorithmParameters"] is not None:
649 return self.__adaoObject["AlgorithmParameters"].getAlgorithmAttributes()
651 elif self.__adaoObject["SupplementaryParameters"] is not None and Concept == "SupplementaryParameters":
652 return self.__adaoObject["SupplementaryParameters"].get()
654 elif self.__adaoObject["SupplementaryParameters"] is not None and Concept in self.__adaoObject["SupplementaryParameters"]:
655 return self.__adaoObject["SupplementaryParameters"].get( Concept )
658 raise ValueError("The requested key \"%s\" does not exists as an input or a stored variable."%Concept)
661 allvariables.update( {"AlgorithmParameters":self.__adaoObject["AlgorithmParameters"].get()} )
662 if self.__adaoObject["SupplementaryParameters"] is not None:
663 allvariables.update( {"SupplementaryParameters":self.__adaoObject["SupplementaryParameters"].get()} )
664 # allvariables.update( self.__adaoObject["AlgorithmParameters"].get() )
665 allvariables.update( self.__StoredInputs )
666 allvariables.pop('Observer', None)
667 allvariables.pop('UserPostAnalysis', None)
670 # -----------------------------------------------------------
672 def get_available_variables(self):
674 Renvoie les variables potentiellement utilisables pour l'étude,
675 initialement stockées comme données d'entrées ou dans les algorithmes,
676 identifiés par les chaînes de caractères. L'algorithme doit avoir été
677 préalablement choisi sinon la méthode renvoie "None".
679 if len(list(self.__adaoObject["AlgorithmParameters"].keys())) == 0 and \
680 len(list(self.__StoredInputs.keys())) == 0:
684 if len(list(self.__adaoObject["AlgorithmParameters"].keys())) > 0:
685 variables.extend(list(self.__adaoObject["AlgorithmParameters"].keys()))
686 if self.__adaoObject["SupplementaryParameters"] is not None and \
687 len(list(self.__adaoObject["SupplementaryParameters"].keys())) > 0:
688 variables.extend(list(self.__adaoObject["SupplementaryParameters"].keys()))
689 if len(list(self.__StoredInputs.keys())) > 0:
690 variables.extend( list(self.__StoredInputs.keys()) )
691 variables.remove('Observer')
692 variables.remove('UserPostAnalysis')
696 def get_available_algorithms(self):
698 Renvoie la liste des algorithmes potentiellement utilisables, identifiés
699 par les chaînes de caractères.
702 for directory in sys.path:
703 trypath = os.path.join(directory,"daAlgorithms")
704 if os.path.isdir(trypath):
705 for fname in os.listdir(trypath):
706 if os.path.isfile(os.path.join(trypath,fname)):
707 root, ext = os.path.splitext(fname)
708 if ext != ".py": continue
709 with open(os.path.join(trypath,fname)) as fc:
710 iselal = bool("class ElementaryAlgorithm" in fc.read())
711 if iselal and ext == '.py' and root != '__init__':
716 def get_algorithms_main_path(self):
718 Renvoie le chemin pour le répertoire principal contenant les algorithmes
722 def add_algorithms_path(self, Path=None):
724 Ajoute au chemin de recherche des algorithmes un répertoire dans lequel
725 se trouve un sous-répertoire "daAlgorithms"
727 if not os.path.isdir(Path):
728 raise ValueError("The given "+Path+" argument must exist as a directory")
729 if not os.path.isdir(os.path.join(Path,"daAlgorithms")):
730 raise ValueError("The given \""+Path+"\" argument must contain a subdirectory named \"daAlgorithms\"")
731 if not os.path.isfile(os.path.join(Path,"daAlgorithms","__init__.py")):
732 raise ValueError("The given \""+Path+"/daAlgorithms\" path must contain a file named \"__init__.py\"")
733 sys.path.insert(0, os.path.abspath(Path))
734 sys.path = PlatformInfo.uniq( sys.path ) # Conserve en unique exemplaire chaque chemin
737 # -----------------------------------------------------------
739 def execute(self, Executor=None, SaveCaseInFile=None, nextStep=False):
740 "Lancement du calcul"
741 self.__case.register("execute",dir(),locals(),None,True)
742 self.updateAlgorithmParameters(Parameters={"nextStep":bool(nextStep)})
743 if not nextStep: Operator.CM.clearCache()
745 if Executor == "YACS": self.__executeYACSScheme( SaveCaseInFile )
746 else: self.__executePythonScheme( SaveCaseInFile )
747 except Exception as e:
748 if isinstance(e, SyntaxError): msg = "at %s: %s"%(e.offset, e.text)
750 raise ValueError(("during execution, the following error occurs:\n"+\
751 "\n%s %s\n\nSee also the potential messages, "+\
752 "which can show the origin of the above error, "+\
753 "in the launching terminal.\n")%(str(e),msg))
756 def __executePythonScheme(self, FileName=None):
757 "Lancement du calcul"
758 self.__case.register("executePythonScheme", dir(), locals())
759 if FileName is not None:
760 self.dump( FileName, "TUI")
761 self.__adaoObject["AlgorithmParameters"].executePythonScheme( self.__adaoObject )
764 def __executeYACSScheme(self, FileName=None):
765 "Lancement du calcul"
766 self.__case.register("executeYACSScheme", dir(), locals())
767 self.dump( FileName, "YACS")
768 self.__adaoObject["AlgorithmParameters"].executeYACSScheme( FileName )
771 # -----------------------------------------------------------
773 def dump(self, FileName=None, Formater="TUI"):
774 "Restitution normalisée des commandes"
775 __Upa = "\n".join(self.__PostAnalysis)
776 return self.__case.dump(FileName, Formater, __Upa)
778 def load(self, FileName=None, Content=None, Object=None, Formater="TUI"):
779 "Chargement normalisé des commandes"
780 __commands = self.__case.load(FileName, Content, Object, Formater)
781 from numpy import array, matrix
782 for __command in __commands:
783 if (__command.find("set")>-1 and __command.find("set_")<0) or 'UserPostAnalysis' in __command:
784 exec("self."+__command)
786 self.__PostAnalysis.append(__command)
790 FileNameFrom=None, ContentFrom=None, ObjectFrom=None, FormaterFrom="TUI",
791 FileNameTo=None, FormaterTo="TUI",
793 "Conversion normalisée des commandes"
795 FileName=FileNameFrom, Content=ContentFrom, Object=ObjectFrom, Formater=FormaterFrom
797 FileName=FileNameTo, Formater=FormaterTo
801 "Effacement du contenu du cas en cours"
802 self.__init__(self.__name)
804 # -----------------------------------------------------------
806 def __with_directory(self, __filename=None):
807 if os.path.exists(str(__filename)):
808 __fullpath = __filename
809 elif os.path.exists(os.path.join(str(self.__directory), str(__filename))):
810 __fullpath = os.path.join(self.__directory, str(__filename))
812 __fullpath = __filename
816 "Clarifie la visibilité des méthodes"
817 return ['set', 'get', 'execute', 'dump', 'load', '__doc__', '__init__', '__module__']
820 "Représentation pour impression (mais pas repr)"
821 msg = self.dump(None, "SimpleReportInPlainTxt")
824 def prepare_to_pickle(self):
825 "Retire les variables non pickelisables, avec recopie efficace"
826 if self.__adaoObject['AlgorithmParameters'] is not None:
827 for k in self.__adaoObject['AlgorithmParameters'].keys():
828 if k == "Algorithm": continue
829 if k in self.__StoredInputs:
830 raise ValueError("The key \"%s\" to be transfered for pickling will overwrite an existing one."%(k,))
831 if self.__adaoObject['AlgorithmParameters'].hasObserver( k ):
832 self.__adaoObject['AlgorithmParameters'].removeObserver( k, "", True )
833 self.__StoredInputs[k] = self.__adaoObject['AlgorithmParameters'].pop(k, None)
834 if sys.version_info[0] == 2:
835 del self.__adaoObject # Because it breaks pickle in Python 2. Not required for Python 3
836 del self.__case # Because it breaks pickle in Python 2. Not required for Python 3
837 if sys.version_info.major < 3:
840 return self.__StoredInputs
842 # ==============================================================================
843 if __name__ == "__main__":
844 print('\n AUTODIAGNOSTIC\n')