# -*- coding: utf-8 -*-
#
-# Copyright (C) 2008-2022 EDF R&D
+# Copyright (C) 2008-2023 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
"""
Gestion des commandes de création d'une vue de cas
"""
+ __slots__ = (
+ "_name", "_objname", "_lineSerie", "_switchoff", "_content",
+ "_numobservers", "_object", "_missing")
+ #
def __init__(self, __name="", __objname="case", __content=None, __object=None):
"Initialisation et enregistrement de l'entete"
self._name = str(__name)
for k,v in __translation.items():
__multilines = __multilines.replace(k,v)
return __multilines
+ #
def _finalize(self, __upa=None):
"Enregistrement du final"
__hasNotExecute = True
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"
self._lineSerie.append(line)
+ #
def _get_objname(self):
return self._objname
+ #
def dump(self, __filename=None, __upa=None):
"Restitution normalisée des commandes"
self._finalize(__upa)
__fid.write(__text)
__fid.close()
return __text
+ #
def load(self, __filename=None, __content=None, __object=None):
"Chargement normalisé des commandes"
if __filename is not None and os.path.exists(__filename):
"""
Établissement des commandes d'un cas ADAO TUI (Cas<->TUI)
"""
+ __slots__ = ()
+ #
def __init__(self, __name="", __objname="case", __content=None, __object=None):
"Initialisation et enregistrement de l'entete"
GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
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 = __text.rstrip(", ")
__text += " )"
self._addLine(__text)
+ #
def _extract(self, __multilines="", __object=None):
"Transformation d'enregistrement(s) en commande(s) individuelle(s)"
__is_case = False
"""
Établissement des commandes d'un cas COMM (Eficas Native Format/Cas<-COM)
"""
+ __slots__ = ("_observerIndex", "_objdata")
+ #
def __init__(self, __name="", __objname="case", __content=None, __object=None):
"Initialisation et enregistrement de l'entete"
GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
if self._content is not None:
for command in self._content:
self._append(*command)
+ #
def _extract(self, __multilines=None, __object=None):
"Transformation d'enregistrement(s) en commande(s) individuelle(s)"
__suppparameters = {}
Remarque : le fichier généré est différent de celui obtenu par EFICAS
"""
+ __slots__ = (
+ "__DebugCommandNotSet", "__ObserverCommandNotSet",
+ "__UserPostAnalysisNotSet", "__hasAlgorithm")
+ #
def __init__(self, __name="", __objname="case", __content=None, __object=None):
"Initialisation et enregistrement de l'entête"
GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
if __content is not None:
for command in __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 == "set": __command = __local["Concept"]
if __text is not None: self._addLine(__text)
if not __switchoff:
self._switchoff = False
+ #
def _finalize(self, *__args):
self.__loadVariablesByScript()
if self.__DebugCommandNotSet:
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)
"""
Etablissement des commandes d'un cas YACS (Cas->SCD->YACS)
"""
+ __slots__ = ("__internalSCD", "_append")
+ #
def __init__(self, __name="", __objname="case", __content=None, __object=None):
"Initialisation et enregistrement de l'entete"
GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
self.__internalSCD = _SCDViewer(__name, __objname, __content, __object)
self._append = self.__internalSCD._append
+ #
def dump(self, __filename=None, __upa=None):
"Restitution normalisée des commandes"
# -----
"""
Partie commune de restitution simple
"""
+ __slots__ = ("_r")
+ #
def __init__(self, __name="", __objname="case", __content=None, __object=None):
"Initialisation et enregistrement de l'entete"
GenericCaseViewer.__init__(self, __name, __objname, __content, __object)
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 += " with values:" + __ktext
__text = __text.rstrip(", ")
self._r.append(__text, "uli")
+ #
def _finalize(self, __upa=None):
"Enregistrement du final"
raise NotImplementedError()
"""
Restitution simple en RST
"""
+ __slots__ = ()
+ #
def _finalize(self, __upa=None):
self._lineSerie.append(Reporting.ReportViewInRst(self._r).__str__())
"""
Restitution simple en HTML
"""
+ __slots__ = ()
+ #
def _finalize(self, __upa=None):
self._lineSerie.append(Reporting.ReportViewInHtml(self._r).__str__())
"""
Restitution simple en TXT
"""
+ __slots__ = ()
+ #
def _finalize(self, __upa=None):
self._lineSerie.append(Reporting.ReportViewInPlainTxt(self._r).__str__())
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:
self.__filenspace = ""
with open(__filename,'r') as fid:
self.__filestring = fid.read()
+ #
def getvalue(self, __varname=None, __synonym=None ):
"Renvoie la variable demandee par son nom ou son synonyme"
if __varname is None:
return getattr(self.__filenspace, __synonym)
else:
return getattr(self.__filenspace, __varname)
+ #
def getstring(self):
"Renvoie le script complet"
return self.__filestring
"""
Détection des caractéristiques de fichiers ou objets en entrée
"""
- __slots__ = (
- "__url", "__usr", "__root", "__end")
+ __slots__ = ("__url", "__usr", "__root", "__end")
+ #
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
return True
else:
return False
+ #
def is_not_local_file(self):
return not self.is_local_file()
+ #
def raise_error_if_not_local_file(self):
if self.is_not_local_file():
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))
return True
else:
return False
+ #
def is_not_local_dir(self):
return not self.is_local_dir()
+ #
def raise_error_if_not_local_dir(self):
if self.is_not_local_dir():
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))
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()
# ----------------------
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
"_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
#
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
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:
__useindex = None
#
return (__usecols, __useindex)
-
+ #
def getsupported(self):
self.__supportedformats = {}
self.__supportedformats["text/plain"] = 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 demandées par la liste de leurs noms"
# Uniquement si mise à jour
__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:
else:
with open(self._filename,'r') as fid:
return fid.read()
-
+ #
def getformat(self):
return self._format
Seule la méthode "getvalue" est changée.
"""
+ __slots__ = ()
+ #
def __enter__(self):
return self
+ #
def __exit__(self, exc_type, exc_val, exc_tb):
return False
#
"""
Lancement autonome de l'interface EFICAS/ADAO
"""
+ __slots__ = ("__msg", "__path_settings_ok")
+ #
def __init__(self, __addpath = None):
# Chemin pour l'installation (ordre important)
self.__msg = ""
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...")
