X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FdaComposant%2FdaCore%2FInterfaces.py;h=bc25f135c1215f1f983e07d53c41fc5272e6661f;hb=e0656540c715b3fa57adb5771421935a63e5284b;hp=be7a61203a1b9c797e3616f1ace7e8f194541ae0;hpb=74317cd7f824debd820996462f7929c015abd061;p=modules%2Fadao.git diff --git a/src/daComposant/daCore/Interfaces.py b/src/daComposant/daCore/Interfaces.py index be7a612..bc25f13 100644 --- a/src/daComposant/daCore/Interfaces.py +++ b/src/daComposant/daCore/Interfaces.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (C) 2008-2018 EDF R&D +# Copyright (C) 2008-2022 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -28,17 +28,19 @@ __all__ = [] import os import sys +import numpy +import mimetypes import logging import copy -import numpy from daCore import Persistence from daCore import PlatformInfo from daCore import Templates +from daCore import Reporting # ============================================================================== class GenericCaseViewer(object): """ - Gestion des commandes de creation d'une vue de cas + Gestion des commandes de création d'une vue de cas """ def __init__(self, __name="", __objname="case", __content=None, __object=None): "Initialisation et enregistrement de l'entete" @@ -51,15 +53,20 @@ class GenericCaseViewer(object): self._object = __object self._missing = """raise ValueError("This case requires beforehand to import or define the variable named <%s>. When corrected, remove this command, correct and uncomment the following one.")\n# """ def _append(self, *args): - "Transformation de commande individuelle en enregistrement" + "Transformation d'une commande individuelle en un enregistrement" raise NotImplementedError() def _extract(self, *args): - "Transformation d'enregistrement en commande individuelle" + "Transformation d'enregistrement(s) en commande(s) individuelle(s)" raise NotImplementedError() def _finalize(self, __upa=None): "Enregistrement du final" - if __upa is not None and len(__upa)>0: + __hasNotExecute = True + for l in self._lineSerie: + if "%s.execute"%(self._objname,) in l: __hasNotExecute = False + if __hasNotExecute: self._lineSerie.append("%s.execute()"%(self._objname,)) + if __upa is not None and len(__upa)>0: + __upa = __upa.replace("ADD",str(self._objname)) self._lineSerie.append(__upa) def _addLine(self, line=""): "Ajoute un enregistrement individuel" @@ -92,7 +99,7 @@ class GenericCaseViewer(object): class _TUIViewer(GenericCaseViewer): """ - Etablissement des commandes d'un cas ADAO TUI (Cas<->TUI) + Établissement des commandes d'un cas ADAO TUI (Cas<->TUI) """ def __init__(self, __name="", __objname="case", __content=None, __object=None): "Initialisation et enregistrement de l'entete" @@ -100,7 +107,7 @@ class _TUIViewer(GenericCaseViewer): self._addLine("# -*- coding: utf-8 -*-") self._addLine("#\n# Python script using ADAO TUI\n#") self._addLine("from numpy import array, matrix") - self._addLine("import adaoBuilder") + self._addLine("from adao import adaoBuilder") self._addLine("%s = adaoBuilder.New('%s')"%(self._objname, self._name)) if self._content is not None: for command in self._content: @@ -108,6 +115,8 @@ class _TUIViewer(GenericCaseViewer): def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False): "Transformation d'une commande individuelle en un enregistrement" if __command is not None and __keys is not None and __local is not None: + if "Concept" in __keys: + logging.debug("TUI Order processed: %s"%(__local["Concept"],)) __text = "" if __pre is not None: __text += "%s = "%__pre @@ -115,12 +124,16 @@ class _TUIViewer(GenericCaseViewer): if "self" in __keys: __keys.remove("self") if __command not in ("set","get") and "Concept" in __keys: __keys.remove("Concept") for k in __keys: + if k not in __local: continue __v = __local[k] if __v is None: continue - if k == "Checked" and not __v: continue - if k == "Stored" and not __v: continue - if k == "AvoidRC" and __v: continue - if k == "noDetails": continue + if k == "Checked" and not __v: continue + if k == "Stored" and not __v: continue + if k == "ColMajor" and not __v: continue + if k == "InputFunctionAsMulti" and not __v: continue + if k == "nextStep" and not __v: continue + if k == "PerformanceProfile" and __v: continue + if k == "noDetails": continue if isinstance(__v,Persistence.Persistence): __v = __v.values() if callable(__v): __text = self._missing%__v.__name__+__text if isinstance(__v,dict): @@ -129,11 +142,11 @@ class _TUIViewer(GenericCaseViewer): numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15) __text += "%s=%s, "%(k,repr(__v)) numpy.set_printoptions(precision=8,threshold=1000,linewidth=75) - __text.rstrip(", ") - __text += ")" + __text = __text.rstrip(", ") + __text += " )" self._addLine(__text) def _extract(self, __multilines="", __object=None): - "Transformation un enregistrement en une commande individuelle" + "Transformation d'enregistrement(s) en commande(s) individuelle(s)" __is_case = False __commands = [] __multilines = __multilines.replace("\r\n","\n") @@ -150,146 +163,9 @@ class _TUIViewer(GenericCaseViewer): logging.debug("TUI Extracted command: %s"%(__commands[-1],)) return __commands -class _EPDViewer(GenericCaseViewer): - """ - Etablissement des commandes d'un cas EPD (Eficas Python Dictionnary/Cas<-EPD) - """ - def __init__(self, __name="", __objname="case", __content=None, __object=None): - "Initialisation et enregistrement de l'entete" - GenericCaseViewer.__init__(self, __name, __objname, __content, __object) - self._observerIndex = 0 - self._addLine("# -*- coding: utf-8 -*-") - self._addLine("#\n# Python script using ADAO EPD\n#") - self._addLine("from numpy import array, matrix") - self._addLine("#") - self._addLine("%s = {}"%__objname) - if self._content is not None: - for command in self._content: - self._append(*command) - def _extract(self, __multilines=None, __object=None): - "Transformation un enregistrement en une commande individuelle" - if __multilines is not None: - __multilines = __multilines.replace("\r\n","\n") - exec(__multilines) - self._objdata = None - __getlocals = locals() - for k in __getlocals: - try: - if type(__getlocals[k]) is dict: - if 'ASSIMILATION_STUDY' in __getlocals[k]: - self._objname = k - self._objdata = __getlocals[k]['ASSIMILATION_STUDY'] - if 'CHECKING_STUDY' in __getlocals[k]: - self._objname = k - self._objdata = __getlocals[k]['CHECKING_STUDY'] - except: - continue - elif __multilines is None and __object is not None and type(__object) is dict: - self._objname = "case" - self._objdata = None - if 'ASSIMILATION_STUDY' in __object: - self._objdata = __object['ASSIMILATION_STUDY'] - if 'CHECKING_STUDY' in __object: - self._objdata = __object['CHECKING_STUDY'] - else: - self._objdata = None - # - if self._objdata is None or not(type(self._objdata) is dict) or not('AlgorithmParameters' in self._objdata): - raise ValueError("Impossible to load given content as an ADAO EPD one (no dictionnary or no 'AlgorithmParameters' key found).") - # ---------------------------------------------------------------------- - logging.debug("EPD Extracting commands of '%s' object..."%(self._objname,)) - __commands = [] - __UserPostAnalysis = "" - for k,r in self._objdata.items(): - __command = k - logging.debug("EPD Extracted command: %s:%s"%(k, r)) - if __command == "StudyName" and len(str(r))>0: - __commands.append( "set( Concept='Name', String='%s')"%(str(r),) ) - elif __command == "StudyRepertory": - __commands.append( "set( Concept='Directory', String='%s')"%(str(r),) ) - # - elif __command == "UserPostAnalysis" and type(r) is dict: - if 'STRING_DATA' in r: - __UserPostAnalysis = r['STRING_DATA']['STRING'] - elif 'SCRIPT_DATA' in r and os.path.exists(r['SCRIPT_DATA']['SCRIPT_FILE']): - __UserPostAnalysis = open(r['SCRIPT_DATA']['SCRIPT_FILE'],'r').read() - elif 'TEMPLATE_DATA' in r: - # AnalysisPrinter... - __itempl = r['TEMPLATE_DATA']['Template'] - __UserPostAnalysis = r['TEMPLATE_DATA'][__itempl]['ValueTemplate'] - else: - __UserPostAnalysis = "" - __UserPostAnalysis = __UserPostAnalysis.replace("ADD",self._objname) - # - elif __command == "AlgorithmParameters" and type(r) is dict and 'Algorithm' in r: - if 'Parameters%s'%(r['Algorithm'],) in r and r['Parameters'] == 'Defaults': - __Dict = r['Parameters%s'%(r['Algorithm'],)] - if 'SetSeed' in __Dict:__Dict['SetSeed'] = int(__Dict['SetSeed']) - if 'BoxBounds' in __Dict and type(__Dict['BoxBounds']) is str: - __Dict['BoxBounds'] = eval(__Dict['BoxBounds']) - __parameters = ', Parameters=%s'%(repr(__Dict),) - elif 'Dict' in r and r['Parameters'] == 'Dict': - __from = r['Dict']['data'] - if 'STRING_DATA' in __from: - __parameters = ", Parameters=%s"%(repr(eval(__from['STRING_DATA']['STRING'])),) - elif 'SCRIPT_DATA' in __from and os.path.exists(__from['SCRIPT_DATA']['SCRIPT_FILE']): - __parameters = ", Script='%s'"%(__from['SCRIPT_DATA']['SCRIPT_FILE'],) - else: - __parameters = "" - __commands.append( "set( Concept='AlgorithmParameters', Algorithm='%s'%s )"%(r['Algorithm'],__parameters) ) - # - elif __command == "Observers" and type(r) is dict and 'SELECTION' in r: - if type(r['SELECTION']) is str: - __selection = (r['SELECTION'],) - else: - __selection = tuple(r['SELECTION']) - for sk in __selection: - __idata = r[sk]['%s_data'%sk] - if __idata['NodeType'] == 'Template' and 'Template' in __idata['ObserverTemplate']: - __template =__idata['ObserverTemplate']['Template'] - __commands.append( "set( Concept='Observer', Variable='%s', Template='%s' )"%(sk,__template) ) - if __idata['NodeType'] == 'String' and 'Value' in __idata: - __value =__idata['Value'] - __commands.append( "set( Concept='Observer', Variable='%s', String='%s' )"%(sk,__value) ) - # - # Background, ObservationError, ObservationOperator... - elif type(r) is dict: - __argumentsList = [] - if 'Stored' in r and bool(r['Stored']): - __argumentsList.append(['Stored',True]) - if 'INPUT_TYPE' in r and r['INPUT_TYPE'] in r: - # Vector, Matrix, ScalarSparseMatrix, DiagonalSparseMatrix, Function - __itype = r['INPUT_TYPE'] - __idata = r[__itype]['data'] - if 'FROM' in __idata and __idata['FROM'].upper()+'_DATA' in __idata: - # String, Script, Template, ScriptWithOneFunction, ScriptWithFunctions - __ifrom = __idata['FROM'] - if __ifrom == 'String' or __ifrom == 'Template': - __argumentsList.append([__itype,__idata['STRING_DATA']['STRING']]) - if __ifrom == 'Script': - __argumentsList.append([__itype,True]) - __argumentsList.append(['Script',__idata['SCRIPT_DATA']['SCRIPT_FILE']]) - if __ifrom == 'ScriptWithOneFunction': - __argumentsList.append(['OneFunction',True]) - __argumentsList.append(['Script',__idata['SCRIPTWITHONEFUNCTION_DATA'].pop('SCRIPTWITHONEFUNCTION_FILE')]) - if len(__idata['SCRIPTWITHONEFUNCTION_DATA'])>0: - __argumentsList.append(['Parameters',__idata['SCRIPTWITHONEFUNCTION_DATA']]) - if __ifrom == 'ScriptWithFunctions': - __argumentsList.append(['ThreeFunctions',True]) - __argumentsList.append(['Script',__idata['SCRIPTWITHFUNCTIONS_DATA'].pop('SCRIPTWITHFUNCTIONS_FILE')]) - if len(__idata['SCRIPTWITHFUNCTIONS_DATA'])>0: - __argumentsList.append(['Parameters',__idata['SCRIPTWITHFUNCTIONS_DATA']]) - __arguments = ["%s = %s"%(k,repr(v)) for k,v in __argumentsList] - __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments))) - # - # ---------------------------------------------------------------------- - __commands.sort() # Pour commencer par 'AlgorithmParameters' - __commands.append(__UserPostAnalysis) - return __commands - class _COMViewer(GenericCaseViewer): """ - Etablissement des commandes d'un cas COMM (Eficas Native Format/Cas<-COM) + Établissement des commandes d'un cas COMM (Eficas Native Format/Cas<-COM) """ def __init__(self, __name="", __objname="case", __content=None, __object=None): "Initialisation et enregistrement de l'entete" @@ -304,12 +180,33 @@ class _COMViewer(GenericCaseViewer): for command in self._content: self._append(*command) def _extract(self, __multilines=None, __object=None): - "Transformation un enregistrement en une commande individuelle" + "Transformation d'enregistrement(s) en commande(s) individuelle(s)" + __suppparameters = {} if __multilines is not None: - __multilines = __multilines.replace("ASSIMILATION_STUDY","dict") - __multilines = __multilines.replace("CHECKING_STUDY", "dict") + if 'adaoBuilder' in __multilines: + raise ValueError("Impossible to load given content as an ADAO COMM one (Hint: it's perhaps not a COMM input, but a TUI one).") + if "ASSIMILATION_STUDY" in __multilines: + __suppparameters.update({'StudyType':"ASSIMILATION_STUDY"}) + __multilines = __multilines.replace("ASSIMILATION_STUDY","dict") + elif "OPTIMIZATION_STUDY" in __multilines: + __suppparameters.update({'StudyType':"ASSIMILATION_STUDY"}) + __multilines = __multilines.replace("OPTIMIZATION_STUDY", "dict") + elif "REDUCTION_STUDY" in __multilines: + __suppparameters.update({'StudyType':"ASSIMILATION_STUDY"}) + __multilines = __multilines.replace("REDUCTION_STUDY", "dict") + elif "CHECKING_STUDY" in __multilines: + __suppparameters.update({'StudyType':"CHECKING_STUDY"}) + __multilines = __multilines.replace("CHECKING_STUDY", "dict") + else: + __multilines = __multilines.replace("ASSIMILATION_STUDY","dict") + # __multilines = __multilines.replace("_F(", "dict(") __multilines = __multilines.replace(",),);", ",),)") + __fulllines = "" + for line in __multilines.split("\n"): + if len(line) < 1: continue + __fulllines += line + "\n" + __multilines = __fulllines self._objname = "case" self._objdata = None exec("self._objdata = "+__multilines) @@ -327,35 +224,52 @@ class _COMViewer(GenericCaseViewer): __commands.append( "set( Concept='Name', String='%s')"%(str(r),) ) elif __command == "StudyRepertory": __commands.append( "set( Concept='Directory', String='%s')"%(str(r),) ) + elif __command == "Debug" and str(r) == "0": + __commands.append( "set( Concept='NoDebug' )" ) + elif __command == "Debug" and str(r) == "1": + __commands.append( "set( Concept='Debug' )" ) + elif __command == "ExecuteInContainer": + __suppparameters.update({'ExecuteInContainer':r}) # elif __command == "UserPostAnalysis" and type(r) is dict: if 'STRING' in r: - __UserPostAnalysis = r['STRING'] + __UserPostAnalysis = r['STRING'].replace("ADD",str(self._objname)) + __commands.append( "set( Concept='UserPostAnalysis', String=\"\"\"%s\"\"\" )"%(__UserPostAnalysis,) ) elif 'SCRIPT_FILE' in r and os.path.exists(r['SCRIPT_FILE']): __UserPostAnalysis = open(r['SCRIPT_FILE'],'r').read() - elif 'Template' in r and 'ValueTemplate' in r: + __commands.append( "set( Concept='UserPostAnalysis', Script='%s' )"%(r['SCRIPT_FILE'],) ) + elif 'Template' in r and not 'ValueTemplate' in r: # AnalysisPrinter... + if r['Template'] not in Templates.UserPostAnalysisTemplates: + raise ValueError("User post-analysis template \"%s\" does not exist."%(r['Template'],)) + else: + __UserPostAnalysis = Templates.UserPostAnalysisTemplates[r['Template']] + __commands.append( "set( Concept='UserPostAnalysis', Template='%s' )"%(r['Template'],) ) + elif 'Template' in r and 'ValueTemplate' in r: + # Le template ayant pu être modifié, donc on ne prend que le ValueTemplate... __UserPostAnalysis = r['ValueTemplate'] + __commands.append( "set( Concept='UserPostAnalysis', String=\"\"\"%s\"\"\" )"%(__UserPostAnalysis,) ) else: __UserPostAnalysis = "" - __UserPostAnalysis = __UserPostAnalysis.replace("ADD",self._objname) # elif __command == "AlgorithmParameters" and type(r) is dict and 'Algorithm' in r: - if 'Parameters' in r and r['Parameters'] == 'Defaults': - __Dict = copy.deepcopy(r) - __Dict.pop('Algorithm') - if 'SetSeed' in __Dict:__Dict['SetSeed'] = int(__Dict['SetSeed']) - if 'BoxBounds' in __Dict and type(__Dict['BoxBounds']) is str: - __Dict['BoxBounds'] = eval(__Dict['BoxBounds']) - __parameters = ', Parameters=%s'%(repr(__Dict),) - elif 'data' in r and r['Parameters'] == 'Dict': + if 'data' in r and r['Parameters'] == 'Dict': __from = r['data'] if 'STRING' in __from: __parameters = ", Parameters=%s"%(repr(eval(__from['STRING'])),) elif 'SCRIPT_FILE' in __from and os.path.exists(__from['SCRIPT_FILE']): __parameters = ", Script='%s'"%(__from['SCRIPT_FILE'],) - else: - __parameters = "" + else: # if 'Parameters' in r and r['Parameters'] == 'Defaults': + __Dict = copy.deepcopy(r) + __Dict.pop('Algorithm','') + __Dict.pop('Parameters','') + if 'SetSeed' in __Dict:__Dict['SetSeed'] = int(__Dict['SetSeed']) + if 'BoxBounds' in __Dict and type(__Dict['BoxBounds']) is str: + __Dict['BoxBounds'] = eval(__Dict['BoxBounds']) + if len(__Dict) > 0: + __parameters = ', Parameters=%s'%(repr(__Dict),) + else: + __parameters = "" __commands.append( "set( Concept='AlgorithmParameters', Algorithm='%s'%s )"%(r['Algorithm'],__parameters) ) # elif __command == "Observers" and type(r) is dict and 'SELECTION' in r: @@ -368,13 +282,13 @@ class _COMViewer(GenericCaseViewer): if __idata['NodeType'] == 'Template' and 'Template' in __idata: __template = __idata['Template'] if 'Info' in __idata: - __info = ", Info='%s'"%(__idata['Info'],) + __info = ", Info=\"\"\"%s\"\"\""%(__idata['Info'],) else: __info = "" - __commands.append( "set( Concept='Observer', Variable='%s', Template='%s'%s )"%(sk,__template,__info) ) + __commands.append( "set( Concept='Observer', Variable='%s', Template=\"\"\"%s\"\"\"%s )"%(sk,__template,__info) ) if __idata['NodeType'] == 'String' and 'Value' in __idata: __value =__idata['Value'] - __commands.append( "set( Concept='Observer', Variable='%s', String='%s' )"%(sk,__value) ) + __commands.append( "set( Concept='Observer', Variable='%s', String=\"\"\"%s\"\"\" )"%(sk,__value) ) # # Background, ObservationError, ObservationOperator... elif type(r) is dict: @@ -386,13 +300,17 @@ class _COMViewer(GenericCaseViewer): __itype = r['INPUT_TYPE'] __idata = r['data'] if 'FROM' in __idata: - # String, Script, Template, ScriptWithOneFunction, ScriptWithFunctions + # String, Script, DataFile, Template, ScriptWithOneFunction, ScriptWithFunctions __ifrom = __idata['FROM'] + __idata.pop('FROM','') if __ifrom == 'String' or __ifrom == 'Template': __argumentsList.append([__itype,__idata['STRING']]) if __ifrom == 'Script': __argumentsList.append([__itype,True]) __argumentsList.append(['Script',__idata['SCRIPT_FILE']]) + if __ifrom == 'DataFile': + __argumentsList.append([__itype,True]) + __argumentsList.append(['DataFile',__idata['DATA_FILE']]) if __ifrom == 'ScriptWithOneFunction': __argumentsList.append(['OneFunction',True]) __argumentsList.append(['Script',__idata.pop('SCRIPTWITHONEFUNCTION_FILE')]) @@ -406,105 +324,39 @@ class _COMViewer(GenericCaseViewer): __arguments = ["%s = %s"%(k,repr(v)) for k,v in __argumentsList] __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments))) # + __commands.append( "set( Concept='%s', Parameters=%s )"%('SupplementaryParameters', repr(__suppparameters))) + # # ---------------------------------------------------------------------- __commands.sort() # Pour commencer par 'AlgorithmParameters' __commands.append(__UserPostAnalysis) return __commands -class _DCTViewer(GenericCaseViewer): - """ - Etablissement des commandes d'un cas DCT (Cas<->DCT) - """ - def __init__(self, __name="", __objname="case", __content=None, __object=None): - "Initialisation et enregistrement de l'entete" - GenericCaseViewer.__init__(self, __name, __objname, __content, __object) - self._observerIndex = 0 - self._addLine("# -*- coding: utf-8 -*-") - self._addLine("#\n# Python script using ADAO DCT\n#") - self._addLine("from numpy import array, matrix") - self._addLine("#") - self._addLine("%s = {}"%__objname) - if self._content is not None: - for command in self._content: - self._append(*command) - def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False): - "Transformation d'une commande individuelle en un enregistrement" - if __command is not None and __keys is not None and __local is not None: - __text = "" - if "execute" in __command: return - if "self" in __keys: __keys.remove("self") - if __command in ("set","get") and "Concept" in __keys: - __key = __local["Concept"] - __keys.remove("Concept") - else: - __key = __command.replace("set","").replace("get","") - if "Observer" in __key and 'Variable' in __keys: - self._observerIndex += 1 - __key += "_%i"%self._observerIndex - __text += "%s['%s'] = {"%(self._objname,str(__key)) - for k in __keys: - __v = __local[k] - if __v is None: continue - if k == "Checked" and not __v: continue - if k == "Stored" and not __v: continue - if k == "AvoidRC" and __v: continue - if k == "noDetails": continue - if isinstance(__v,Persistence.Persistence): __v = __v.values() - if callable(__v): __text = self._missing%__v.__name__+__text - if isinstance(__v,dict): - for val in __v.values(): - if callable(val): __text = self._missing%val.__name__+__text - numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15) - __text += "'%s':%s, "%(k,repr(__v)) - numpy.set_printoptions(precision=8,threshold=1000,linewidth=75) - __text.rstrip(", ").rstrip() - __text += "}" - if __text[-2:] == "{}": return # Supprime les *Debug et les variables - self._addLine(__text) - def _extract(self, __multilines="", __object=None): - "Transformation un enregistrement en une commande individuelle" - __multilines = __multilines.replace("\r\n","\n") - exec(__multilines) - self._objdata = None - __getlocals = locals() - for k in __getlocals: - try: - if 'AlgorithmParameters' in __getlocals[k] and type(__getlocals[k]) is dict: - self._objname = k - self._objdata = __getlocals[k] - except: - continue - if self._objdata is None: - raise ValueError("Impossible to load given content as an ADAO DCT one (no 'AlgorithmParameters' key found).") - # ---------------------------------------------------------------------- - logging.debug("DCT Extracting commands of '%s' object..."%(self._objname,)) - __commands = [] - for k in self._objdata: - if 'Observer_' in k: - __command = k.split('_',1)[0] - else: - __command = k - __arguments = ["%s = %s"%(k,repr(v)) for k,v in self._objdata[k].items()] - __commands.append( "set( Concept='%s', %s )"%(__command, ", ".join(__arguments))) - __commands.sort() # Pour commencer par 'AlgorithmParameters' - return __commands - class _SCDViewer(GenericCaseViewer): """ - Etablissement des commandes d'un cas SCD (Study Config Dictionary/Cas->SCD) + Établissement des commandes d'un cas SCD (Study Config Dictionary/Cas->SCD) + + Remarque : le fichier généré est différent de celui obtenu par EFICAS """ def __init__(self, __name="", __objname="case", __content=None, __object=None): - "Initialisation et enregistrement de l'entete" + "Initialisation et enregistrement de l'entête" GenericCaseViewer.__init__(self, __name, __objname, __content, __object) + # + if __content is not None: + for command in __content: + if command[0] == "set": __command = command[2]["Concept"] + else: __command = command[0].replace("set", "", 1) + if __command == 'Name': + self._name = command[2]["String"] + # + self.__DebugCommandNotSet = True + self.__ObserverCommandNotSet = True + self.__UserPostAnalysisNotSet = True + # self._addLine("# -*- coding: utf-8 -*-") - self._addLine("#\n# Input for ADAO converter to YACS\n#") - self._addLine("from numpy import array, matrix") + self._addLine("#\n# Input for ADAO converter to SCD\n#") self._addLine("#") self._addLine("study_config = {}") - self._addLine("study_config['StudyType'] = 'ASSIMILATION_STUDY'") self._addLine("study_config['Name'] = '%s'"%self._name) - self._addLine("observers = {}") - self._addLine("study_config['Observers'] = observers") self._addLine("#") self._addLine("inputvariables_config = {}") self._addLine("inputvariables_config['Order'] =['adao_default']") @@ -522,15 +374,24 @@ class _SCDViewer(GenericCaseViewer): "Transformation d'une commande individuelle en un enregistrement" if __command == "set": __command = __local["Concept"] else: __command = __command.replace("set", "", 1) + logging.debug("SCD Order processed: %s"%(__command)) # __text = None if __command in (None, 'execute', 'executePythonScheme', 'executeYACSScheme', 'get', 'Name'): return + elif __command in ['Directory',]: + __text = "#\nstudy_config['Repertory'] = %s"%(repr(__local['String'])) elif __command in ['Debug', 'setDebug']: __text = "#\nstudy_config['Debug'] = '1'" + self.__DebugCommandNotSet = False elif __command in ['NoDebug', 'setNoDebug']: __text = "#\nstudy_config['Debug'] = '0'" + self.__DebugCommandNotSet = False elif __command in ['Observer', 'setObserver']: + if self.__ObserverCommandNotSet: + self._addLine("observers = {}") + self._addLine("study_config['Observers'] = observers") + self.__ObserverCommandNotSet = False __obs = __local['Variable'] self._numobservers += 1 __text = "#\n" @@ -549,21 +410,50 @@ class _SCDViewer(GenericCaseViewer): else: __text += "observers['%s']['info'] = \"\"\"%s\"\"\"\n"%(__obs, __obs) __text += "observers['%s']['number'] = %s"%(__obs, self._numobservers) + elif __command in ['UserPostAnalysis', 'setUserPostAnalysis']: + __text = "#\n" + __text += "Analysis_config = {}\n" + if __local['String'] is not None: + __text += "Analysis_config['From'] = 'String'\n" + __text += "Analysis_config['Data'] = \"\"\"%s\"\"\"\n"%(__local['String'],) + if __local['Script'] is not None: + __text += "Analysis_config['From'] = 'Script'\n" + __text += "Analysis_config['Data'] = \"\"\"%s\"\"\"\n"%(__local['Script'],) + if __local['Template'] is not None and __local['Template'] in Templates.UserPostAnalysisTemplates: + __text += "Analysis_config['From'] = 'String'\n" + __text += "Analysis_config['Data'] = \"\"\"%s\"\"\"\n"%(Templates.UserPostAnalysisTemplates[__local['Template']],) + __text += "study_config['UserPostAnalysis'] = Analysis_config" + self.__UserPostAnalysisNotSet = False elif __local is not None: # __keys is not None and numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15) __text = "#\n" __text += "%s_config = {}\n"%__command - if 'self' in __local: __local.pop('self') + __local.pop('self','') __to_be_removed = [] + __vectorIsDataFile = False + __vectorIsScript = False for __k,__v in __local.items(): if __v is None: __to_be_removed.append(__k) for __k in __to_be_removed: __local.pop(__k) for __k,__v in __local.items(): if __k == "Concept": continue - if __k in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix','OneFunction','ThreeFunctions'] and 'Script' in __local: continue + if __k in ['ScalarSparseMatrix','DiagonalSparseMatrix','Matrix','OneFunction','ThreeFunctions'] and 'Script' in __local and __local['Script'] is not None: continue + if __k in ['Vector','VectorSerie'] and 'DataFile' in __local and __local['DataFile'] is not None: continue + if __k == 'Parameters' and not (__command in ['AlgorithmParameters','SupplementaryParameters']): continue if __k == 'Algorithm': __text += "study_config['Algorithm'] = %s\n"%(repr(__v)) + elif __k == 'DataFile': + __k = 'Vector' + __f = 'DataFile' + __v = "'"+repr(__v)+"'" + for __lk in ['Vector','VectorSerie']: + if __lk in __local and __local[__lk]: __k = __lk + __text += "%s_config['Type'] = '%s'\n"%(__command,__k) + __text += "%s_config['From'] = '%s'\n"%(__command,__f) + __text += "%s_config['Data'] = %s\n"%(__command,__v) + __text = __text.replace("''","'") + __vectorIsDataFile = True elif __k == 'Script': __k = 'Vector' __f = 'Script' @@ -597,13 +487,16 @@ class _SCDViewer(GenericCaseViewer): __text += "%s_config['From'] = '%s'\n"%(__command,__f) __text += "%s_config['Data'] = %s\n"%(__command,__v) __text = __text.replace("''","'") - elif __k in ('Stored', 'Checked'): + __vectorIsScript = True + elif __k in ('Stored', 'Checked', 'ColMajor', 'InputFunctionAsMulti', 'nextStep'): if bool(__v): __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v))) - elif __k in ('AvoidRC', 'noDetails'): + elif __k in ('PerformanceProfile', 'noDetails'): if not bool(__v): __text += "%s_config['%s'] = '%s'\n"%(__command,__k,int(bool(__v))) else: + if __k == 'Vector' and __vectorIsScript: continue + if __k == 'Vector' and __vectorIsDataFile: continue if __k == 'Parameters': __k = "Dict" if isinstance(__v,Persistence.Persistence): __v = __v.values() if callable(__v): __text = self._missing%__v.__name__+__text @@ -622,13 +515,16 @@ class _SCDViewer(GenericCaseViewer): self._switchoff = False def _finalize(self, *__args): self.__loadVariablesByScript() - self._addLine("#") - self._addLine("Analysis_config = {}") - self._addLine("Analysis_config['From'] = 'String'") - self._addLine("Analysis_config['Data'] = \"\"\"import numpy") - self._addLine("xa=numpy.ravel(ADD.get('Analysis')[-1])") - self._addLine("print 'Analysis:',xa\"\"\"") - self._addLine("study_config['UserPostAnalysis'] = Analysis_config") + if self.__DebugCommandNotSet: + self._addLine("#\nstudy_config['Debug'] = '0'") + if self.__UserPostAnalysisNotSet: + self._addLine("#") + self._addLine("Analysis_config = {}") + self._addLine("Analysis_config['From'] = 'String'") + self._addLine("Analysis_config['Data'] = \"\"\"import numpy") + self._addLine("xa=ADD.get('Analysis')[-1]") + self._addLine("print('Analysis:',xa)\"\"\"") + self._addLine("study_config['UserPostAnalysis'] = Analysis_config") def __loadVariablesByScript(self): __ExecVariables = {} # Necessaire pour recuperer la variable exec("\n".join(self._lineSerie), __ExecVariables) @@ -658,17 +554,22 @@ class _SCDViewer(GenericCaseViewer): __text += "AlgorithmParameters_config['From'] = 'String'\n" __text += "AlgorithmParameters_config['Data'] = '{}'\n" self._addLine(__text) + if 'SupplementaryParameters' in study_config and \ + isinstance(study_config['SupplementaryParameters'], dict) and \ + "From" in study_config['SupplementaryParameters'] and \ + study_config['SupplementaryParameters']["From"] == 'String' and \ + "Data" in study_config['SupplementaryParameters']: + __dict = eval(study_config['SupplementaryParameters']["Data"]) + if 'ExecuteInContainer' in __dict: + self._addLine("#\nstudy_config['ExecuteInContainer'] = '%s'"%__dict['ExecuteInContainer']) + else: + self._addLine("#\nstudy_config['ExecuteInContainer'] = 'No'") + if 'StudyType' in __dict: + self._addLine("#\nstudy_config['StudyType'] = '%s'"%__dict['StudyType']) + if 'StudyType' in __dict and __dict['StudyType'] != "ASSIMILATION_STUDY": + self.__UserPostAnalysisNotSet = False del study_config -class _XMLViewer(GenericCaseViewer): - """ - Etablissement des commandes d'un cas XML - """ - def __init__(self, __name="", __objname="case", __content=None, __object=None): - "Initialisation et enregistrement de l'entete" - GenericCaseViewer.__init__(self, __name, __objname, __content, __object) - raise NotImplementedError() - class _YACSViewer(GenericCaseViewer): """ Etablissement des commandes d'un cas YACS (Cas->SCD->YACS) @@ -678,38 +579,27 @@ class _YACSViewer(GenericCaseViewer): GenericCaseViewer.__init__(self, __name, __objname, __content, __object) self.__internalSCD = _SCDViewer(__name, __objname, __content, __object) self._append = self.__internalSCD._append - def dump(self, __filename=None, __convertSCDinMemory=True): + def dump(self, __filename=None, __upa=None): "Restitution normalisée des commandes" - self.__internalSCD._finalize() # ----- if __filename is None: raise ValueError("A file name has to be given for YACS XML output.") + else: + __file = os.path.abspath(__filename) + if os.path.isfile(__file) or os.path.islink(__file): + os.remove(__file) # ----- if not PlatformInfo.has_salome or \ not PlatformInfo.has_adao: raise ImportError( - "Unable to get SALOME or ADAO environnement variables for YACS conversion.\n"+\ - "Please load the right environnement before trying to use it.") - elif __convertSCDinMemory: - __file = os.path.abspath(__filename) - __SCDdump = self.__internalSCD.dump() - if os.path.isfile(__file) or os.path.islink(__file): - os.remove(__file) - from daYacsSchemaCreator.run import create_schema_from_content - create_schema_from_content(__SCDdump, __file) + "Unable to get SALOME or ADAO environnement for YACS conversion.\n"+\ + "Please load the right SALOME environnement before trying to use it.") else: - __file = os.path.abspath(__filename) - __SCDfile = __file[:__file.rfind(".")] + '_SCD.py' - __SCDdump = self.__internalSCD.dump(__SCDfile) - if os.path.isfile(__file) or os.path.islink(__file): - os.remove(__file) - __converterExe = os.path.join(os.environ["ADAO_ROOT_DIR"], "bin/salome", "AdaoYacsSchemaCreator.py") - __args = ["python", __converterExe, __SCDfile, __file] - import subprocess - __p = subprocess.Popen(__args) - (__stdoutdata, __stderrdata) = __p.communicate() - __p.terminate() - os.remove(__SCDfile) + from daYacsSchemaCreator.run import create_schema_from_content + # ----- + self.__internalSCD._finalize(__upa) + __SCDdump = self.__internalSCD.dump() + create_schema_from_content(__SCDdump, __file) # ----- if not os.path.exists(__file): __msg = "An error occured during the ADAO YACS Schema build for\n" @@ -723,41 +613,605 @@ class _YACSViewer(GenericCaseViewer): __fid.close() return __text +# ============================================================================== +class _ReportViewer(GenericCaseViewer): + """ + Partie commune de restitution simple + """ + def __init__(self, __name="", __objname="case", __content=None, __object=None): + "Initialisation et enregistrement de l'entete" + GenericCaseViewer.__init__(self, __name, __objname, __content, __object) + self._r = Reporting.ReportStorage() + self._r.clear() + if self._name == "": + self._r.append("ADAO Study report", "title") + else: + self._r.append(str(self._name), "title") + if self._content is not None: + for command in self._content: + self._append(*command) + def _append(self, __command=None, __keys=None, __local=None, __pre=None, __switchoff=False): + "Transformation d'une commande individuelle en un enregistrement" + if __command is not None and __keys is not None and __local is not None: + if __command in ("set","get") and "Concept" in __keys: __command = __local["Concept"] + __text = "" + __text += "%s command has been set"%str(__command.replace("set","")) + __ktext = "" + for k in __keys: + if k not in __local: continue + __v = __local[k] + if __v is None: continue + if k == "Checked" and not __v: continue + if k == "Stored" and not __v: continue + if k == "ColMajor" and not __v: continue + if k == "InputFunctionAsMulti" and not __v: continue + if k == "nextStep" and not __v: continue + if k == "PerformanceProfile" and __v: continue + if k == "noDetails": continue + if k == "Concept": continue + if k == "self": continue + if isinstance(__v,Persistence.Persistence): __v = __v.values() + numpy.set_printoptions(precision=15,threshold=1000000,linewidth=1000*15) + __ktext += "\n %s = %s, "%(k,repr(__v)) + numpy.set_printoptions(precision=8,threshold=1000,linewidth=75) + if len(__ktext) > 0: + __text += " with values:" + __ktext + __text = __text.rstrip(", ") + self._r.append(__text, "uli") + def _finalize(self, __upa=None): + "Enregistrement du final" + raise NotImplementedError() + +class _SimpleReportInRstViewer(_ReportViewer): + """ + Restitution simple en RST + """ + def _finalize(self, __upa=None): + self._lineSerie.append(Reporting.ReportViewInRst(self._r).__str__()) + +class _SimpleReportInHtmlViewer(_ReportViewer): + """ + Restitution simple en HTML + """ + def _finalize(self, __upa=None): + self._lineSerie.append(Reporting.ReportViewInHtml(self._r).__str__()) + +class _SimpleReportInPlainTxtViewer(_ReportViewer): + """ + Restitution simple en TXT + """ + def _finalize(self, __upa=None): + self._lineSerie.append(Reporting.ReportViewInPlainTxt(self._r).__str__()) + +# ============================================================================== class ImportFromScript(object): """ - Obtention d'une variable nommee depuis un fichier script importe + Obtention d'une variable nommee depuis un fichier script importé """ + __slots__ = ("__basename", "__filenspace", "__filestring") def __init__(self, __filename=None): "Verifie l'existence et importe le script" if __filename is None: raise ValueError("The name of the file, containing the variable to be read, has to be specified.") if not os.path.isfile(__filename): - raise ValueError("The file containing the variable to be imported doesn't seem to exist. Please check the file. The given file name is:\n \"%s\""%__filename) + raise ValueError("The file containing the variable to be imported doesn't seem to exist. Please check the file. The given file name is:\n \"%s\""%str(__filename)) if os.path.dirname(__filename) != '': sys.path.insert(0, os.path.dirname(__filename)) __basename = os.path.basename(__filename).rstrip(".py") else: __basename = __filename.rstrip(".py") + PlatformInfo.checkFileNameImportability( __basename+".py" ) self.__basename = __basename - self.__scriptfile = __import__(__basename, globals(), locals(), []) - self.__scriptstring = open(__filename,'r').read() + try: + self.__filenspace = __import__(__basename, globals(), locals(), []) + except NameError: + self.__filenspace = "" + with open(__filename,'r') as fid: + self.__filestring = fid.read() def getvalue(self, __varname=None, __synonym=None ): - "Renvoie la variable demandee" + "Renvoie la variable demandee par son nom ou son synonyme" if __varname is None: raise ValueError("The name of the variable to be read has to be specified. Please check the content of the file and the syntax.") - if not hasattr(self.__scriptfile, __varname): + if not hasattr(self.__filenspace, __varname): if __synonym is None: raise ValueError("The imported script file \"%s\" doesn't contain the mandatory variable \"%s\" to be read. Please check the content of the file and the syntax."%(str(self.__basename)+".py",__varname)) - elif not hasattr(self.__scriptfile, __synonym): + elif not hasattr(self.__filenspace, __synonym): raise ValueError("The imported script file \"%s\" doesn't contain the mandatory variable \"%s\" to be read. Please check the content of the file and the syntax."%(str(self.__basename)+".py",__synonym)) else: - return getattr(self.__scriptfile, __synonym) + return getattr(self.__filenspace, __synonym) else: - return getattr(self.__scriptfile, __varname) + return getattr(self.__filenspace, __varname) def getstring(self): "Renvoie le script complet" - return self.__scriptstring + return self.__filestring + +# ============================================================================== +class ImportDetector(object): + """ + Détection des caractéristiques de fichiers ou objets en entrée + """ + __slots__ = ( + "__url", "__usr", "__root", "__end") + def __enter__(self): return self + def __exit__(self, exc_type, exc_val, exc_tb): return False + # + def __init__(self, __url, UserMime=""): + if __url is None: + raise ValueError("The name or url of the file object has to be specified.") + if __url is bytes: + self.__url = __url.decode() + else: + self.__url = str(__url) + if UserMime is bytes: + self.__usr = UserMime.decode().lower() + else: + self.__usr = str(UserMime).lower() + (self.__root, self.__end) = os.path.splitext(self.__url) + # + mimetypes.add_type('application/numpy.npy', '.npy') + mimetypes.add_type('application/numpy.npz', '.npz') + mimetypes.add_type('application/dymola.sdf', '.sdf') + if sys.platform.startswith("win"): + mimetypes.add_type('text/plain', '.txt') + mimetypes.add_type('text/csv', '.csv') + mimetypes.add_type('text/tab-separated-values', '.tsv') + # + # File related tests + # ------------------ + def is_local_file(self): + if os.path.isfile(os.path.realpath(self.__url)): + return True + else: + return False + def is_not_local_file(self): + if not os.path.isfile(os.path.realpath(self.__url)): + return True + else: + return False + def raise_error_if_not_local_file(self): + if not os.path.isfile(os.path.realpath(self.__url)): + raise ValueError("The name or the url of the file object doesn't seem to exist. The given name is:\n \"%s\""%str(self.__url)) + else: + return False + # + # Directory related tests + # ----------------------- + def is_local_dir(self): + if os.path.isdir(self.__url): + return True + else: + return False + def is_not_local_dir(self): + if not os.path.isdir(self.__url): + return True + else: + return False + def raise_error_if_not_local_dir(self): + if not os.path.isdir(self.__url): + raise ValueError("The name or the url of the directory object doesn't seem to exist. The given name is:\n \"%s\""%str(self.__url)) + else: + return False + # + # Mime related functions + # ------------------------ + def get_standard_mime(self): + (__mtype, __encoding) = mimetypes.guess_type(self.__url, strict=False) + return __mtype + def get_user_mime(self): + __fake = "fake."+self.__usr.lower() + (__mtype, __encoding) = mimetypes.guess_type(__fake, strict=False) + return __mtype + def get_comprehensive_mime(self): + if self.get_standard_mime() is not None: + return self.get_standard_mime() + elif self.get_user_mime() is not None: + return self.get_user_mime() + else: + return None + # + # Name related functions + # ---------------------- + def get_user_name(self): + return self.__url + def get_absolute_name(self): + return os.path.abspath(os.path.realpath(self.__url)) + def get_extension(self): + return self.__end + +class ImportFromFile(object): + """ + Obtention de variables disrétisées en 1D, définies par une ou des variables + nommées, et sous la forme d'une série de points éventuellement indexés. La + lecture d'un fichier au format spécifié (ou intuité) permet de charger ces + fonctions depuis : + - des fichiers textes en colonnes de type TXT, CSV, TSV... + - des fichiers de données binaires NPY, NPZ, SDF... + La lecture du fichier complet ne se fait que si nécessaire, pour assurer la + performance tout en disposant de l'interprétation du contenu. Les fichiers + textes doivent présenter en première ligne (hors commentaire ou ligne vide) + les noms des variables de colonnes. Les commentaires commencent par un "#". + """ + __slots__ = ( + "_filename", "_colnames", "_colindex", "_varsline", "_format", + "_delimiter", "_skiprows", "__url", "__filestring", "__header", + "__allowvoid", "__binaryformats", "__supportedformats") + def __enter__(self): return self + def __exit__(self, exc_type, exc_val, exc_tb): return False + # + def __init__(self, Filename=None, ColNames=None, ColIndex=None, Format="Guess", AllowVoidNameList=True): + """ + Verifie l'existence et les informations de définition du fichier. Les + noms de colonnes ou de variables sont ignorées si le format ne permet + pas de les indiquer. + Arguments : + - Filename : nom du fichier + - ColNames : noms de la ou des colonnes/variables à lire + - ColIndex : nom unique de la colonne/variable servant d'index + - Format : format du fichier et/ou des données inclues + - AllowVoidNameList : permet, si la liste de noms est vide, de + prendre par défaut toutes les colonnes + """ + self.__binaryformats =( + "application/numpy.npy", + "application/numpy.npz", + "application/dymola.sdf", + ) + self.__url = ImportDetector( Filename, Format) + self.__url.raise_error_if_not_local_file() + self._filename = self.__url.get_absolute_name() + PlatformInfo.checkFileNameConformity( self._filename ) + # + self._format = self.__url.get_comprehensive_mime() + # + self.__header, self._varsline, self._skiprows = self.__getentete() + # + if self._format == "text/csv" or Format.upper() == "CSV": + self._format = "text/csv" + self.__filestring = "".join(self.__header) + if self.__filestring.count(",") > 1: + self._delimiter = "," + elif self.__filestring.count(";") > 1: + self._delimiter = ";" + else: + self._delimiter = None + elif self._format == "text/tab-separated-values" or Format.upper() == "TSV": + self._format = "text/tab-separated-values" + self._delimiter = "\t" + else: + self._delimiter = None + # + if ColNames is not None: self._colnames = tuple(ColNames) + else: self._colnames = None + # + if ColIndex is not None: self._colindex = str(ColIndex) + else: self._colindex = None + # + self.__allowvoid = bool(AllowVoidNameList) + + def __getentete(self, __nblines = 3): + "Lit l'entête du fichier pour trouver la définition des variables" + # La première ligne non vide non commentée est toujours considérée + # porter les labels de colonne, donc pas des valeurs + __header, __varsline, __skiprows = [], "", 1 + if self._format in self.__binaryformats: + pass + else: + with open(self._filename,'r') as fid: + __line = fid.readline().strip() + while "#" in __line or len(__line) < 1: + __header.append(__line) + __skiprows += 1 + __line = fid.readline().strip() + __varsline = __line + for i in range(max(0,__nblines)): + __header.append(fid.readline()) + return (__header, __varsline, __skiprows) + + def __getindices(self, __colnames, __colindex, __delimiter=None ): + "Indices de colonnes correspondants à l'index et aux variables" + if __delimiter is None: + __varserie = self._varsline.strip('#').strip().split() + else: + __varserie = self._varsline.strip('#').strip().split(str(__delimiter)) + # + if __colnames is not None: + __usecols = [] + __colnames = tuple(__colnames) + for v in __colnames: + for i, n in enumerate(__varserie): + if v == n: __usecols.append(i) + __usecols = tuple(__usecols) + if len(__usecols) == 0: + if self.__allowvoid: + __usecols = None + else: + raise ValueError("Can not found any column corresponding to the required names %s"%(__colnames,)) + else: + __usecols = None + # + if __colindex is not None: + __useindex = None + __colindex = str(__colindex) + for i, n in enumerate(__varserie): + if __colindex == n: __useindex = i + else: + __useindex = None + # + return (__usecols, __useindex) + + def getsupported(self): + self.__supportedformats = {} + self.__supportedformats["text/plain"] = True + self.__supportedformats["text/csv"] = True + self.__supportedformats["text/tab-separated-values"] = True + self.__supportedformats["application/numpy.npy"] = True + self.__supportedformats["application/numpy.npz"] = True + self.__supportedformats["application/dymola.sdf"] = PlatformInfo.has_sdf + return self.__supportedformats + + def getvalue(self, ColNames=None, ColIndex=None ): + "Renvoie la ou les variables demandees par la liste de leurs noms" + # Uniquement si mise à jour + if ColNames is not None: self._colnames = tuple(ColNames) + if ColIndex is not None: self._colindex = str(ColIndex) + # + __index = None + if self._format == "application/numpy.npy": + __columns = numpy.load(self._filename) + # + elif self._format == "application/numpy.npz": + __columns = None + with numpy.load(self._filename) as __allcolumns: + if self._colnames is None: + self._colnames = __allcolumns.files + for nom in self._colnames: # Si une variable demandée n'existe pas + if nom not in __allcolumns.files: + self._colnames = tuple( __allcolumns.files ) + for nom in self._colnames: + if nom in __allcolumns.files: + if __columns is not None: + # Attention : toutes les variables doivent avoir la même taille + __columns = numpy.vstack((__columns, numpy.reshape(__allcolumns[nom], (1,-1)))) + else: + # Première colonne + __columns = numpy.reshape(__allcolumns[nom], (1,-1)) + if self._colindex is not None and self._colindex in __allcolumns.files: + __index = numpy.array(numpy.reshape(__allcolumns[self._colindex], (1,-1)), dtype=bytes) + elif self._format == "text/plain": + __usecols, __useindex = self.__getindices(self._colnames, self._colindex) + __columns = numpy.loadtxt(self._filename, usecols = __usecols, skiprows=self._skiprows) + if __useindex is not None: + __index = numpy.loadtxt(self._filename, dtype = bytes, usecols = (__useindex,), skiprows=self._skiprows) + if __usecols is None: # Si une variable demandée n'existe pas + self._colnames = None + # + elif self._format == "application/dymola.sdf" and PlatformInfo.has_sdf: + import sdf + __content = sdf.load(self._filename) + __columns = None + if self._colnames is None: + self._colnames = [__content.datasets[i].name for i in range(len(__content.datasets))] + for nom in self._colnames: + if nom in __content: + if __columns is not None: + # Attention : toutes les variables doivent avoir la même taille + __columns = numpy.vstack((__columns, numpy.reshape(__content[nom].data, (1,-1)))) + else: + # Première colonne + __columns = numpy.reshape(__content[nom].data, (1,-1)) + if self._colindex is not None and self._colindex in __content: + __index = __content[self._colindex].data + # + elif self._format == "text/csv": + __usecols, __useindex = self.__getindices(self._colnames, self._colindex, self._delimiter) + __columns = numpy.loadtxt(self._filename, usecols = __usecols, delimiter = self._delimiter, skiprows=self._skiprows) + if __useindex is not None: + __index = numpy.loadtxt(self._filename, dtype = bytes, usecols = (__useindex,), delimiter = self._delimiter, skiprows=self._skiprows) + if __usecols is None: # Si une variable demandée n'existe pas + self._colnames = None + # + elif self._format == "text/tab-separated-values": + __usecols, __useindex = self.__getindices(self._colnames, self._colindex, self._delimiter) + __columns = numpy.loadtxt(self._filename, usecols = __usecols, delimiter = self._delimiter, skiprows=self._skiprows) + if __useindex is not None: + __index = numpy.loadtxt(self._filename, dtype = bytes, usecols = (__useindex,), delimiter = self._delimiter, skiprows=self._skiprows) + if __usecols is None: # Si une variable demandée n'existe pas + self._colnames = None + else: + raise ValueError("Unkown file format \"%s\" or no reader available"%self._format) + if __columns is None: __columns = () + # + def toString(value): + try: + return value.decode() + except ValueError: + return value + if __index is not None: + __index = tuple([toString(v) for v in __index]) + # + return (self._colnames, __columns, self._colindex, __index) + + def getstring(self): + "Renvoie le fichier texte complet" + if self._format in self.__binaryformats: + return "" + else: + with open(self._filename,'r') as fid: + return fid.read() + + def getformat(self): + return self._format + +class ImportScalarLinesFromFile(ImportFromFile): + """ + Importation de fichier contenant des variables scalaires nommées. Le + fichier comporte soit 2, soit 4 colonnes, obligatoirement nommées "Name", + "Value", "Minimum", "Maximum" si les noms sont précisés. Sur chaque ligne + est indiqué le nom, la valeur, et éventuelement deux bornes min et max (ou + None si nécessaire pour une borne). + + Seule la méthode "getvalue" est changée. + """ + def __enter__(self): return self + def __exit__(self, exc_type, exc_val, exc_tb): return False + # + def __init__(self, Filename=None, ColNames=None, ColIndex=None, Format="Guess"): + ImportFromFile.__init__(self, Filename, ColNames, ColIndex, Format) + if self._format not in ["text/plain", "text/csv", "text/tab-separated-values"]: + raise ValueError("Unkown file format \"%s\""%self._format) + # + def getvalue(self, VarNames = None, HeaderNames=()): + "Renvoie la ou les variables demandees par la liste de leurs noms" + if VarNames is not None: __varnames = tuple(VarNames) + else: __varnames = None + # + if "Name" in self._varsline and "Value" in self._varsline and "Minimum" in self._varsline and "Maximum" in self._varsline: + __ftype = "NamValMinMax" + __dtypes = {'names' : ('Name', 'Value', 'Minimum', 'Maximum'), + 'formats': ('S128', 'g', 'g', 'g')} + __usecols = (0, 1, 2, 3) + def __replaceNoneN( s ): + if s.strip() == b'None': return numpy.NINF + else: return s + def __replaceNoneP( s ): + if s.strip() == b'None': return numpy.PINF + else: return s + __converters = {2: __replaceNoneN, 3: __replaceNoneP} + elif "Name" in self._varsline and "Value" in self._varsline and ("Minimum" not in self._varsline or "Maximum" not in self._varsline): + __ftype = "NamVal" + __dtypes = {'names' : ('Name', 'Value'), + 'formats': ('S128', 'g')} + __converters = None + __usecols = (0, 1) + elif len(HeaderNames)>0 and numpy.all([kw in self._varsline for kw in HeaderNames]): + __ftype = "NamLotOfVals" + __dtypes = {'names' : HeaderNames, + 'formats': tuple(['S128',]+['g']*(len(HeaderNames)-1))} + __usecols = tuple(range(len(HeaderNames))) + def __replaceNone( s ): + if s.strip() == b'None': return numpy.NAN + else: return s + __converters = dict() + for i in range(1,len(HeaderNames)): + __converters[i] = __replaceNone + else: + raise ValueError("Can not find names of columns for initial values. Wrong first line is:\n \"%s\""%__firstline) + # + if self._format == "text/plain": + __content = numpy.loadtxt(self._filename, dtype = __dtypes, usecols = __usecols, skiprows = self._skiprows, converters = __converters) + elif self._format in ["text/csv", "text/tab-separated-values"]: + __content = numpy.loadtxt(self._filename, dtype = __dtypes, usecols = __usecols, skiprows = self._skiprows, converters = __converters, delimiter = self._delimiter) + else: + raise ValueError("Unkown file format \"%s\""%self._format) + # + __names, __thevalue, __bounds = [], [], [] + for sub in __content: + if len(__usecols) == 4: + na, va, mi, ma = sub + if numpy.isneginf(mi): mi = None # Réattribue les variables None + elif numpy.isnan(mi): mi = None # Réattribue les variables None + if numpy.isposinf(ma): ma = None # Réattribue les variables None + elif numpy.isnan(ma): ma = None # Réattribue les variables None + elif len(__usecols) == 2 and __ftype == "NamVal": + na, va = sub + mi, ma = None, None + else: + nsub = list(sub) + na = sub[0] + for i, v in enumerate(nsub[1:]): + if numpy.isnan(v): nsub[i+1] = None + va = nsub[1:] + mi, ma = None, None + na = na.decode() + if (__varnames is None or na in __varnames) and (na not in __names): + # Ne stocke que la premiere occurence d'une variable + __names.append(na) + __thevalue.append(va) + __bounds.append((mi,ma)) + # + __names = tuple(__names) + __thevalue = numpy.array(__thevalue) + __bounds = tuple(__bounds) + # + return (__names, __thevalue, __bounds) + +# ============================================================================== +class EficasGUI(object): + """ + Lancement autonome de l'interface EFICAS/ADAO + """ + def __init__(self, __addpath = None): + # Chemin pour l'installation (ordre important) + self.__msg = "" + self.__path_settings_ok = False + #---------------- + if "EFICAS_ROOT" in os.environ: + __EFICAS_ROOT = os.environ["EFICAS_ROOT"] + __path_ok = True + else: + self.__msg += "\nKeyError:\n"+\ + " the required environment variable EFICAS_ROOT is unknown.\n"+\ + " You have either to be in SALOME environment, or to set\n"+\ + " this variable in your environment to the right path \"<...>\"\n"+\ + " to find an installed EFICAS application. For example:\n"+\ + " EFICAS_ROOT=\"<...>\" command\n" + __path_ok = False + try: + import adao + __path_ok = True and __path_ok + except ImportError: + self.__msg += "\nImportError:\n"+\ + " the required ADAO library can not be found to be imported.\n"+\ + " You have either to be in ADAO environment, or to be in SALOME\n"+\ + " environment, or to set manually in your Python 3 environment the\n"+\ + " right path \"<...>\" to find an installed ADAO application. For\n"+\ + " example:\n"+\ + " PYTHONPATH=\"<...>:${PYTHONPATH}\" command\n" + __path_ok = False + try: + import PyQt5 + __path_ok = True and __path_ok + except ImportError: + self.__msg += "\nImportError:\n"+\ + " the required PyQt5 library can not be found to be imported.\n"+\ + " You have either to have a raisonable up-to-date Python 3\n"+\ + " installation (less than 5 years), or to be in SALOME environment.\n" + __path_ok = False + #---------------- + if not __path_ok: + self.__msg += "\nWarning:\n"+\ + " It seems you have some troubles with your installation.\n"+\ + " Be aware that some other errors may exist, that are not\n"+\ + " explained as above, like some incomplete or obsolete\n"+\ + " Python 3, or incomplete module installation.\n"+\ + " \n"+\ + " Please correct the above error(s) before launching the\n"+\ + " standalone EFICAS/ADAO interface.\n" + logging.debug("Some of the ADAO/EFICAS/QT5 paths have not been found") + self.__path_settings_ok = False + else: + logging.debug("All the ADAO/EFICAS/QT5 paths have been found") + self.__path_settings_ok = True + #---------------- + if self.__path_settings_ok: + sys.path.insert(0,__EFICAS_ROOT) + sys.path.insert(0,os.path.join(adao.adao_py_dir,"daEficas")) + if __addpath is not None and os.path.exists(os.path.abspath(__addpath)): + sys.path.insert(0,os.path.abspath(__addpath)) + logging.debug("All the paths have been correctly set up") + else: + print(self.__msg) + logging.debug("Errors in path settings have been found") + + def gui(self): + if self.__path_settings_ok: + logging.debug("Launching standalone EFICAS/ADAO interface...") + from daEficas import prefs + from InterfaceQT4 import eficas_go + eficas_go.lanceEficas(code=prefs.code) + else: + logging.debug("Can not launch standalone EFICAS/ADAO interface for path errors.") # ============================================================================== if __name__ == "__main__": - print('\n AUTODIAGNOSTIC \n') + print('\n AUTODIAGNOSTIC\n')