salome.kernel 9.14.0__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

salome/kernel/salome/kernel/threadhelper.py

@@ -0,0 +1,385 @@
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+__author__="gboulant"
+__date__ ="$1 avr. 2010 18:12:38$"
+
+import time
+import threading
+
+# ===========================================================================
+class Runner(threading.Thread):
+    """
+    This class provides a tool to run and drive a function in a dedicated thread.
+    """
+    def __init__(self, functionToRun=None,*argv):
+        threading.Thread.__init__( self )
+        self._stopevent = threading.Event()
+        self.setFunction(functionToRun)
+        self.setArguments(*argv)
+        self._exception = None
+        self._return    = None
+        self._observer  = None
+        self._callbackFunction = None
+        # We create an id from the name and the time date in milliseconds
+        self._id = functionToRun.__name__ +"/"+ str(time.time())
+
+    def setFunction(self,functionToRun):
+        """
+        Positionne la fonction � ex�cuter. La fonction peut �tre la
+        m�thode d'un objet pass�e sous la forme 'monobjet.mamethode'.
+        """
+        self.clear()
+        self._function = functionToRun
+
+    def setArguments(self,*argv):
+        """
+        Positionne les arguments � passer � la fonction
+        """
+        self.clear()
+        self._argv = argv
+
+    def getReturn(self):
+        """
+        Retourne le resultat de la fonction. En cas d'erreur, on
+        r�cup�rera l'exception lev�e au moyen de la m�thode
+        getException().
+        """
+        return self._return
+
+    def setCallbackFunction(self, callbackFunction):
+        self._callbackFunction = callbackFunction
+
+    def setObserver(self, observerToNotify):
+        """
+        Permet de sp�cifier un observateur � notifier en fin
+        d'ex�cution. L'observateur est suppos� �tre un objet qui
+        impl�mente une m�thode processNotification()
+        """
+        try:
+            observerToNotify.processNotification
+        except AttributeError:
+            raise DevelException("The observer should implement the method processNotification()")
+
+        self._observer = observerToNotify
+
+    def run(self):
+        """
+        Ex�cution de la fonction. Impl�mentation de la m�thode run
+        d�clench�e par l'appel � Thread.start().
+        """
+        print("##################### threadhelper.run")
+        if self._function is None: return
+        try:
+            self._return = self._function(*self._argv)
+        except Exception as e:
+            print(e)
+            self._exception = e
+        self._stopevent.set()
+        self.notifyObserver()
+        self.callback()
+        # _GBO_ Maybe it's no use to have both observers and a callback function.
+        # One of the two mechanism should be sufficient
+
+    def notifyObserver(self):
+        if self._observer is None:
+            # Aucune notification pr�vue
+            return
+        try:
+            self._observer.processNotification()
+        except AttributeError as att:
+            if str(att) == "processNotification":
+                print("L'observateur n'impl�mente pas la m�thode processNotification()")
+            else:
+                print("La fonction processNotification() a lev� une exception:")
+                print(att)
+        except Exception as e:
+            print("La fonction processNotification() a lev� une exception:")
+            print(e)
+
+    def callback(self):
+        if self._callbackFunction is None: return
+        self._callbackFunction()
+
+    def isEnded(self):
+        """
+        Retourne true si la fonction s'est termin�e naturellement
+        (correctement ou en erreur). Utile pour les client qui
+        pratique le pooling (interrogation r�p�t�e � intervalle
+        r�gulier.
+        """
+        return self._stopevent.isSet()
+        # _GBO_ On n'utilise pas isAlive() pour pouvoir ma�triser
+        # l'indicateur de stop (exemple de la fonction kill)
+        # return not self.isAlive()
+
+    def getException(self):
+        return self._exception
+
+    def getId(self):
+        return self._id
+
+    def wait(self,timeout=None):
+        """
+        Met fin au thread apr�s timeout seconde s'il est encore en
+        ex�cution.
+        Si le compte-�-rebours est atteind sans que la fonction
+        functionToRun soit termin�e, alors le runner est laiss� dans
+        l'�tat 'not Ended', c'est-�-dire que isEnded retourne
+        false. On peut ainsi distinguer l'arr�t normal de l'arr�t �
+        l'issue du timeout.
+        """
+        threading.Thread.join(self, timeout)
+
+
+    def kill(self,message="Arr�t demand�"):
+        """
+        Cette m�thode doit �tre appeler pour interrombre le
+        thread. Cet appel d�clare le thread comme en erreur (exception
+        mise � disposition par la m�thode getException().
+        """
+        # On cr�e un exception indiquant la demande d'interruption
+        self._exception = Exception(message)
+        self._stopevent.set()
+        # _GBO_ ATTENTION
+        # Un thread python ne peut pas en r�alit� �tre int�rrompu.
+        # La fonction reste donc en ex�cution m�me si on a rejoint le
+        # thread appelant.
+
+    def clear(self):
+        self._stopevent.clear()
+        self._exception = None
+        self._return    = None
+
+# ===========================================================================
+CONTINUE=1
+STOP=0
+
+class PeriodicTimer( threading.Thread ):
+    """
+    Cette classe permet d'amorcer un compte-�-rebours p�riodique pour
+    op�rer un m�canisme de pooling. On d�finit la fonction appell�e
+    p�riodiquement et la fonction terminale.
+    """
+    def __init__( self,  loopdelay, initdelay=0,
+                  periodic_action=None,
+                  ended_action=None,
+                  *ended_argv ):
+
+        if periodic_action is None:
+            self._periodic_action = self.defaultPeriodicAction
+        else:
+            self._periodic_action = periodic_action
+        self._ended_action = ended_action
+        self._loopdelay = loopdelay
+        self._initdelay = initdelay
+        self._running = CONTINUE
+        self._ended_argv    = ended_argv
+        threading.Thread.__init__( self )
+
+    def defaultPeriodicAction():
+        """
+        Les fonctions 'periodicAction' retournent CONTINU ou STOP
+        apr�s avoir ex�cut� l'action de fin de boucle. Si STOP est
+        retourn�, le cycle est interrompu. 
+        """
+        return CONTINU
+
+    def run( self ):
+        if self._initdelay:
+            time.sleep( self._initdelay )
+        self._runtime = time.time()
+        while self._running == CONTINUE:
+            start = time.time()
+            self._running  = self._periodic_action()
+            self._runtime += self._loopdelay
+            time.sleep( max( 0, self._runtime - start ) )
+        if self._ended_action is not None:
+            self._ended_action( *self._ended_argv )
+
+    def stop( self ):
+        self._running = STOP
+
+
+
+#
+# ======================================================
+# Fonctions de test unitaire
+# ======================================================
+#
+
+# ======================================================
+import os
+testfilename="/tmp/threadhelperTestFile"
+def testIfContinue():
+    print("On examine la pr�sence du fichier ", testfilename)
+    if os.path.exists(testfilename):
+        return STOP
+    else:
+        return CONTINUE
+
+def endedAction():
+    print("FINI")
+
+def TEST_PeriodicTimer():
+    periodicTimer=PeriodicTimer(1,0,testIfContinue, endedAction)
+    periodicTimer.start()
+
+
+# ======================================================
+def function_ok(nbsteps=5):
+    """
+    Fonction qui se termine correctement
+    """
+    print("D�but")
+    cnt=0
+    while ( cnt < nbsteps ):
+        print("Etape ", cnt)
+        time.sleep(0.6)
+        cnt+=1
+
+    print("Fin")
+
+def function_with_exception():
+    """
+    Fonction qui aboutie � une lev�e d'exception
+    """
+    print("D�but")
+    cnt=0
+    while ( cnt < 5 ):
+        print("Etape ", cnt)
+        time.sleep(1)
+        cnt+=1
+    
+    raise Exception("erreur d'ex�cution de la fonction")
+    print("Fin")
+
+def infinite_function():
+    """
+    fonction de dur�e infinie (tant qu'il y a du courant �l�ctrique) pour
+    le test du timeout.
+    """
+    print("D�but")
+    cnt=0
+    while ( 1 ):
+        print("Etape ", cnt)
+        time.sleep(1)
+        cnt+=1
+    
+    raise Exception("erreur")
+    print("Fin")
+
+
+def runWithRunner(functionToRun):
+    """
+    Ex�cute la fonction avec le runner. On illustre ici la modalit�
+    d'utilisation du Runner.
+    """
+    print("###########")
+    runner = Runner(functionToRun)
+    runner.start()
+
+    while ( not runner.isEnded() ):
+        print("La fonction est en cours")
+        time.sleep(0.2)
+    e = runner.getException()
+    if e is not None:
+        print("La fonction s'est termin�e en erreur")
+        print(e)
+        # On peut en fait la relancer
+        # raise e
+    else:
+        print("La fonction s'est termin�e correctement")
+
+
+def runWithTimeout(functionToRun, timeout=10):
+    """
+    Ex�cute la fonction avec le runner. On illustre ici la modalit�
+    d'utilisation du Runner.
+    """
+    print("runWithTimeout : DEBUT")
+    runner = Runner(functionToRun)
+    runner.start()
+
+    # On se fixe un temps au del� duquel on consid�re que la fonction
+    # est en erreur => on tue le thread (timeout)
+    runner.wait(timeout)
+    print("Apr�s runner.timeout(timeout)")
+    if not runner.isEnded():    
+        runner.kill()
+    e = runner.getException()
+    if e is not None:
+        print("La fonction s'est termin�e en erreur")
+        print(e)
+        # On peut en fait la relancer
+        # raise e
+    else:
+        print("La fonction s'est termin�e correctement")
+
+    print("runWithTimeout : FIN")
+    import sys
+    sys.exit(0)
+    
+
+def TEST_Timeout():
+    #runWithTimeout(function_ok)
+    #runWithTimeout(function_ok,2)
+    runWithTimeout(function_with_exception)
+
+    
+def TEST_Runner():
+    runWithRunner(function_ok)
+    runWithRunner(function_with_exception)
+    #runWithRunner(infinite_function)
+
+
+def myCallbackFunction():
+    print("myCallbackFunction: the job is ended")
+    
+
+def TEST_runWithCallback():
+    runner = Runner(function_ok,8)
+    runner.setCallbackFunction(myCallbackFunction)
+    runner.start()
+
+    if runner.getException() is not None:
+        return False
+
+    runnerId = runner.getId()
+    print("A runner has been started with id="+str(runnerId))
+    cpt = 0
+    while ( not runner.isEnded() ):
+        print("Waiting notification from process "+str(runner.getId())+", step n°"+str(cpt))
+        time.sleep(0.2)
+        cpt+=1
+
+    return True
+
+if __name__ == "__main__":
+    from . import unittester
+    #TEST_PeriodicTimer()
+    #TEST_Runner()
+    #TEST_Timeout()
+    unittester.run("threadhelper","TEST_runWithCallback")
+
+    

salome/kernel/salome/kernel/uiexception.py

@@ -0,0 +1,121 @@
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2010-2024  CEA, EDF, OPEN CASCADE
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+## \defgroup uiexception uiexception
+#  \{ 
+#  \details Exception for user error management
+#  \}
+
+__author__="gboulant"
+__date__ ="$31 mars 2010 11:59:33$"
+
+from .enumerate import Enumerate
+
+## This exception should be used for functionnal error management, at least in the GUI
+#  part of the application, for example to set user oriented messages at point
+#  of exception raise.
+#  \warning The exception should NOT be used to hide defaults in the algorithm, but
+#  only predicted error in the specified use case.
+#  \ingroup uiexception
+class UiException(Exception):
+
+    TYPES = Enumerate([
+        'USER',  # This type should be displayed to end user using a dialog box
+        'ADMIN', # This type should be displayed to admin user in console log
+        'DEVEL'  # This type should be displayed to developer only
+    ])
+
+    _UImessage = "An error occurs"
+    _type = TYPES.USER
+
+    """
+    This exception should be used for functionnal error management, at least in the GUI
+    part of the application, for example to set user oriented messages at point
+    of exception raise.
+    WARN: The exception should NOT be used to hide defaults in the algorithm, but
+    only predicted error in the specified use case.
+    """
+    
+    ## Canonical constructor
+    def __init__(self, message, type=TYPES.USER):
+        """Canonical constructor"""
+        Exception.__init__(self,message)
+        self.setUIMessage(message)
+        self.setType(type)
+
+    def setUIMessage(self, UImessage):
+        self._UImessage = UImessage
+
+    def getUIMessage(self):
+        return self._UImessage
+
+    ## Specify the type of this exception. To be chosen in the TYPES list.
+    def setType(self, type):
+        """Specify the type of this exception. To be chosen in the TYPES list."""
+        if not self.TYPES.isValid(type):
+            raise UiException("The exception type "+str(type)+" can't be used",self.TYPES.DEVEL)
+        self._type = type
+
+    def getType(self):
+        return self._type
+
+    def __str__(self):
+        return self.getUIMessage()
+
+
+def UserException(msg):
+    return UiException(msg,UiException.TYPES.USER)
+
+def AdminException(msg):
+    return UiException(msg,UiException.TYPES.ADMIN)
+
+def DevelException(msg):
+    return UiException(msg,UiException.TYPES.DEVEL)
+
+#
+# ==============================================================================
+# Basic use cases and unit test functions
+# ==============================================================================
+#
+def somethingGoesWrong():
+    raise UiException("Something goes wrong")
+
+def TEST_uimessage():
+    try:
+        somethingGoesWrong()
+        return False
+    except UiException as err:
+        print('ERROR: %s' % str(err))
+        if ( str(err) == "Something goes wrong" ):
+            return True
+        else:
+            return False
+
+def TEST_specificException():
+    print(DevelException("err"))
+    print(AdminException("err"))
+    print(UserException("err"))
+    return True
+
+if __name__ == "__main__":
+    from . import unittester
+    unittester.run("uiexception","TEST_uimessage")
+    unittester.run("uiexception","TEST_specificException")
+    

salome/kernel/salome/kernel/unittester.py

@@ -0,0 +1,89 @@
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2010-2024  CEA, EDF, OPEN CASCADE
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+## \defgroup unittester unittester
+#  \{ 
+#  \details Run very basic unit tests
+#  \}
+
+__author__="gboulant"
+__date__ ="$1 avr. 2010 09:45:21$"
+
+import sys
+
+## This function should be used for very basic unit tests and only for a
+#  rapid development. %A better way should be the pyunit framework.
+#  The function functionName is supposed here to return a boolean value
+#  indicating if the test is OK (True) or NOT OK (False)
+#  \ingroup unittester
+def run(modulePath, functionName):
+    """
+    This function should be used for very basic unit tests and only for a
+    rapid development. A better way should be the pyunit framework.
+    The function functionName is supposed here to return a boolean value
+    indicating if the test is OK (True) or NOT OK (False)
+    """
+    moduleName = modulePath.replace('/','.')
+    import importlib
+    importlib.import_module(moduleName)
+    module=sys.modules[moduleName]
+    func = getattr(module,functionName)
+    tabsize = 70-len(moduleName)-len(functionName)
+    print("[TEST] %s.%s %s test in progress" % (moduleName, functionName,"."*tabsize))
+    ok = func()
+    if ( ok ):
+        print("[TEST] %s.%s %s OK" % (moduleName, functionName,"."*tabsize))
+    else:
+        print("[TEST] %s.%s %s NOT OK" % (moduleName, functionName,"."*tabsize))
+
+## This function is for debug only. It executes the specified function with the
+#  specified arguments in a try/except block so as to display the exception in
+#  the case where an exception is raised (useful to debug server side of a CORBA
+#  process).
+#  \ingroup unittester
+def tryfunction(function,*argv):
+    """
+    This function is for debug only. It executes the specified function with the
+    specified arguments in a try/except block so as to display the exception in
+    the case where an exception is raised (useful to debug server side of a CORBA
+    process).
+    """
+    print("[TEST] trying the function %s" % function)
+    try:
+        return function(*argv)
+    except Exception as e:
+        print(e)
+        raise e
+
+
+#
+# ==============================================================================
+# Simple use cases
+# ==============================================================================
+#
+def TEST_myTestIsOk():
+    return True
+
+def TEST_myTestIsNotOk():
+    return False
+
+if __name__ == "__main__":
+    run("salome/kernel/unittester","TEST_myTestIsOk")
+    run("salome/kernel/unittester","TEST_myTestIsNotOk")