salome.kernel 9.14.0__cp37-cp37m-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

salome/kernel/salome/kernel/diclookup.py

@@ -0,0 +1,137 @@
+# -*- 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
+#
+
+## \defgroup diclookup diclookup
+#  \{ 
+#  \details Smart dictionary with key/value lookup
+#  \}
+
+__author__="gboulant"
+__date__ ="$21 mai 2010 18:00:23$"
+
+
+# search a dictionary for key or value
+# using named functions or a class
+# tested with Python25   by Ene Uran    01/19/2008
+
+## return the key of dictionary dic given the value
+#  \ingroup diclookup
+def find_key(dic, val):
+    """return the key of dictionary dic given the value"""
+    return [k for k, v in dic.items() if v == val][0]
+
+## return the value of dictionary dic given the key
+#  \ingroup diclookup
+def find_value(dic, key):
+    """return the value of dictionary dic given the key"""
+    return dic[key]
+
+## a dictionary which can lookup value by key, or keys by value
+#  \ingroup diclookup
+class Lookup(dict):
+    """
+    a dictionary which can lookup value by key, or keys by value
+    """
+    ## items can be a list of pair_lists or a dictionary
+    def __init__(self, items=None):
+        """items can be a list of pair_lists or a dictionary"""
+        if items is None:
+            items = []
+        dict.__init__(self, items)
+
+    ## find the key(s) as a list given a value
+    def get_keys(self, value):
+        """find the key(s) as a list given a value"""
+        return [item[0] for item in list(self.items()) if item[1] == value]
+
+    ## find the key associated to the given a value. If several keys exist,
+    #  only the first is given. To get the whole list, use get_keys instead.
+    def get_key(self, value):
+        """
+        find the key associated to the given a value. If several keys exist,
+        only the first is given. To get the whole list, use get_keys instead.
+        """
+        list = self.get_keys(value)
+        if len(list) == 0:
+            return None
+        return list[0]
+
+    ## find the value given a key
+    def get_value(self, key):
+        """find the value given a key"""
+        return self[key]
+
+#
+# ==============================================================================
+# Use cases and unit tests
+# ==============================================================================
+#
+def TEST_getTestDictionnary():
+    # dictionary of chemical symbols
+    symbol_dic = {
+    'C': 'carbon',
+    'H': 'hydrogen',
+    'N': 'nitrogen',
+    'Li': 'lithium',
+    'Be': 'beryllium',
+    'B': 'boron'
+    }
+    return symbol_dic
+
+def TEST_find_value():
+    symbol_dic = TEST_getTestDictionnary()
+    print(find_key(symbol_dic, 'boron'))  # B
+    print(find_value(symbol_dic, 'B'))    # boron
+    print(find_value(symbol_dic, 'H'))    # hydrogen
+    if find_key(symbol_dic, 'nitrogen') != 'N':
+        return False
+    return True
+
+def TEST_lookup():
+    symbol_dic = TEST_getTestDictionnary()
+
+    name = 'lithium'
+    symbol = 'Li'
+    # use a dictionary as initialization argument
+    look = Lookup(symbol_dic)
+    print(look.get_key(name))      # [Li']
+    if look.get_key(name) != symbol:
+        print("get "+str(look.get_key(name))+" while "+str(symbol)+" was expected")
+        return False
+    print(look.get_value(symbol))  # lithium
+
+    # use a list of pairs instead of a dictionary as initialization argument
+    # (will be converted to a dictionary by the class internally)
+    age_list = [['Fred', 23], ['Larry', 28], ['Ene', 23]]
+    look2 = Lookup(age_list)
+    print(look2.get_keys(23))        # ['Ene', 'Fred']
+    if look2.get_keys(23)[0] != 'Ene' or look2.get_keys(23)[1] != 'Fred':
+        print("get "+str(look2.get_keys(23))+" while ['Ene', 'Fred'] was expected")
+        return False
+    print(look2.get_value('Fred'))  # 23
+    return True
+
+if __name__ == '__main__':
+    from . import unittester
+    unittester.run("diclookup", "TEST_find_value")
+    unittester.run("diclookup", "TEST_lookup")

salome/kernel/salome/kernel/enumerate.py

@@ -0,0 +1,232 @@
+# -*- 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 enumerate enumerate
+#  \{
+#  \details Emulates a C-like enum for python
+#  \}
+
+__author__ = "gboulant"
+__date__ = "$1 avr. 2010 09:08:02$"
+
+## This class emulates a C-like enum for python. It is initialized with a list
+#  of strings to be used as the enum symbolic keys. The enum values are automatically
+#  generated as sequencing integer starting at the specified offset value.
+#  \ingroup enumerate
+class Enumerate:
+    """
+    This class emulates a C-like enum for python. It is initialized with a list
+    of strings to be used as the enum symbolic keys. The enum values are automatically
+    generated as sequencing integer starting at the specified offset value.
+    """
+
+    ## Canonical constructor.
+    #  \param keys a list of string to be used as the enum symbolic keys. The enum values
+    #  are automatically generated as a sequence of integers starting at the specified
+    #  offset value.
+    def __init__(self, keys, offset=0):
+        """
+        Canonical constructor
+        @keys a list of string to be used as the enum symbolic keys. The enum values
+        are automatically generated as a sequence of integers starting at the specified
+        offset value.
+        """
+        self._dict_keynumbers = {}
+        for number, key in enumerate(keys):
+            value = offset + number
+            setattr(self, key, value)
+            self._dict_keynumbers[key] = value
+        self._dict_numberkeys = {v: k for k, v in self._dict_keynumbers.items()}
+
+    ## Return true if this enumerate contains the specified key string
+    #  \param key a key string to test
+    def contains(self, key):
+        """
+        Return true if this enumerate contains the specified key string
+        @key a key string to test
+        """
+        return key in self._dict_keynumbers
+
+    ## Returns true if the specified integer value is defined as an identifier
+    #  in this enumerate.
+    #  \param value a value to test
+    def isValid(self, value):
+        """
+        Returns true if the specified integer value is defined as an identifier
+        in this enumerate.
+        @value a value to test
+        """
+        return value in self._dict_numberkeys
+
+    ## Returns the list of keys in this enumerate.
+    def listkeys(self):
+        """
+        Returns the list of keys in this enumerate.
+        """
+        return sorted(self._dict_keynumbers)
+
+    ## Returns the list of values specified to initiate this enumerate.
+    def listvalues(self):
+        """
+        Returns the list of values specified to initiate this enumerate.
+        """
+        return sorted(self._dict_numberkeys)
+
+    ## Returns the symbolic key string associated to the specified identifier value.
+    #  \param value an integer value whose associated key string is requested.
+    def keyOf(self, value):
+        """
+        Returns the symbolic key string associated to the specified identifier
+        value.
+        @param value : an integer value whose associated key string is requested.
+        """
+        if not self.isValid(value):
+            return None
+        # _MEM_ We assume here that the keys and associated values are in the
+        # same order in their list.
+        return self._dict_numberkeys[value]
+
+        # If not, weshould use a longer implementation such that:
+        #for key in self._dict_keynumbers.keys():
+        #    if self._dict_keynumbers[key] == value:
+        #        return key
+
+#
+# ==============================================================================
+# Basic use cases and unit test functions
+# ==============================================================================
+#
+
+def TEST_simple():
+    TYPES_LIST = Enumerate([
+        'SEP',
+        'OTHER'
+    ])
+    print(TYPES_LIST.listvalues())
+    return True
+
+def TEST_createFromList():
+    codes = Enumerate([
+        'KERNEL', # This should take the value 0
+        'GUI', # This should take the value 1
+        'GEOM', # ...
+        'MED',
+        'SMESH'])
+
+    print(codes.KERNEL)
+    print(codes.GEOM)
+    if (codes.KERNEL == 0 and codes.GEOM == 2):
+        return True
+    else:
+        return False
+
+def TEST_createFromString():
+    aList = "KERNEL GUI GEOM MED"
+
+    codes = Enumerate(aList.split())
+
+    print(codes.KERNEL)
+    print(codes.GEOM)
+    if (codes.KERNEL == 0 and codes.GEOM == 2):
+        return True
+    else:
+        return False
+
+def TEST_contains():
+    codes = Enumerate([
+        'KERNEL', # This should take the value 0
+        'GUI', # This should take the value 1
+        'GEOM', # ...
+        'MED',
+        'SMESH'])
+
+    print("VISU in enumerate?", codes.contains("VISU"))
+    if (not codes.contains("VISU")):
+        return True
+    else:
+        return False
+
+def TEST_isValid():
+    codes = Enumerate([
+        'KERNEL', # This should take the value 0
+        'GUI', # This should take the value 1
+        'GEOM', # ...
+        'MED',
+        'SMESH'])
+
+    if (not codes.isValid(23)):
+        return True
+    else:
+        return False
+
+def TEST_offset():
+    codes = Enumerate([
+        'KERNEL', # This should take the value 0
+        'GUI', # This should take the value 1
+        'GEOM', # ...
+        'MED',
+        'SMESH'], offset=20)
+
+    print(codes.KERNEL)
+    print(codes.GEOM)
+    if (codes.KERNEL == 20 and codes.GEOM == 22):
+        return True
+    else:
+        return False
+
+def TEST_listvalues():
+    codes = Enumerate([
+        'KERNEL', # This should take the value 0
+        'GUI', # This should take the value 1
+        'GEOM', # ...
+        'MED',
+        'SMESH'], offset=20)
+
+    print(codes.listvalues())
+    if codes.listvalues() != [20, 21, 22, 23, 24]:
+        return False
+    return True
+
+def TEST_keyOf():
+    codes = Enumerate([
+        'KERNEL', # This should take the value 0
+        'GUI', # This should take the value 1
+        'GEOM', # ...
+        'MED',
+        'SMESH'])
+
+    if ( codes.keyOf(codes.KERNEL) != 'KERNEL' or
+         codes.keyOf(codes.GUI) != 'GUI' or
+         codes.keyOf(codes.GEOM) != 'GEOM' or
+         codes.keyOf(codes.MED) != 'MED' or
+         codes.keyOf(codes.SMESH) != 'SMESH'):
+            return False
+    return True
+
+if __name__ == "__main__":
+    from . import unittester
+    unittester.run("enumerate", "TEST_simple")
+    unittester.run("enumerate", "TEST_createFromList")
+    unittester.run("enumerate", "TEST_createFromString")
+    unittester.run("enumerate", "TEST_contains")
+    unittester.run("enumerate", "TEST_isValid")
+    unittester.run("enumerate", "TEST_offset")
+    unittester.run("enumerate", "TEST_listvalues")
+    unittester.run("enumerate", "TEST_keyOf")

salome/kernel/salome/kernel/logconfig.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2007-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
+#
+"""
+This module defines a variable to indicate which traces should be logged.
+"""
+
+import logging
+
+loggingLevel = logging.WARNING

salome/kernel/salome/kernel/logger.py

@@ -0,0 +1,290 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2007-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
+#
+
+#=============================================================================
+#  Author    : Guillaume Boulant (CSSI)
+#  Rewritten by Renaud Barate (EDF R&D)
+#=============================================================================
+
+## \defgroup logger logger
+#  \{ 
+#  \details
+#  This module defines a class which provides logging facility in Salome.
+#  \}
+
+"""
+This module defines a class which provides logging facility in Salome:
+"""
+
+import sys, os
+import logging
+
+from salome.kernel.salome.kernel.deprecation import deprecated
+from salome.kernel.salome.kernel import termcolor
+import salome.kernel.salome.kernel.logconfig
+
+## This class formats and displays log messages in Salome environment. It
+#  inherits \b logging.Logger class defined in \b logging module from Python 
+#  library, so all methods from \b logging.Logger can be used here. 
+#  The format of the traces is:
+#  LEVEL[keyword] : Message  
+#  
+#  ,where \em LEVEL is the level of the message (\em DEBUG, \em INFO, etc.),
+#  \em keyword is the name of the logger, and \em Message is the message to log.
+#    
+#  When creating a new Logger object, the parameter \em keyword defines the
+#  name of the logger, \em level defines the logging level (default is
+#  \b logging.DEBUG if KERNEL module is configured with --enable-debug option 
+#  or \b logging.WARNING otherwise), and \em color defines the color
+#  of the log messages for this logger (log messages will appear in color
+#  only when displayed on color - capable ASCII terminals). See module
+#  \ref termcolor "salome.kernel.termcolor" for the color constants.
+#    
+#  By default, log messages will be displayed only on standard output. They
+#  can also be recorded in a file (see method setLogFile()). For now,
+#  the CORBA-based logging facility can not be used through this class.
+#
+#  A source filename \em sourceFileName can be defined. If this argument is
+#  specified, then the \em keyword is modified to the basename of the 
+#  \em sourceFileName
+#    
+#  Basic usage::
+#  \code    
+#  from salome.kernel.logger import Logger
+#  log = Logger("Test")
+#  log.debug("Debug message")
+#  log.info("Information message")
+#  log.warning("Warning message")
+#  log.error("Error message")
+#  log.critical("Fatal error message")
+#  \endcode
+#  \ingroup logger
+class Logger(logging.Logger):
+    """
+    This class formats and displays log messages in Salome environment. It
+    inherits :class:`Logger<logging.Logger>` class defined in :mod:`logging`
+    module from Python library, so all methods from :class:`logging.Logger`
+    can be used here. The format of the traces is:
+    
+    LEVEL    [keyword] : Message
+    
+    where `LEVEL` is the level of the message (`DEBUG`, `INFO`, etc.),
+    `keyword` is the name of the logger, and `Message` is the message to log.
+    
+    When creating a new Logger object, the parameter `keyword` defines the
+    name of the logger, `level` defines the logging level (default is
+    :const:`logging.DEBUG` if KERNEL module is configured with --enable-debug
+    option or :const:`logging.WARNING` otherwise), and `color` defines the color
+    of the log messages for this logger (log messages will appear in color
+    only when displayed on color-capable ASCII terminals). See module
+    :mod:`salome.kernel.termcolor` for the color constants.
+    
+    By default, log messages will be displayed only on standard output. They
+    can also be recorded in a file (see method :meth:`setLogFile`). For now,
+    the CORBA-based logging facility can not be used through this class.
+
+    A source filename `sourceFileName` can be defined. If this argument is
+    specified, then the `keyword` is modified to the basename of the `sourceFileName`
+    
+    Basic usage::
+    
+        from salome.kernel.salome.kernel.logger import Logger
+        log = Logger("Test")
+        log.debug("Debug message")
+        log.info("Information message")
+        log.warning("Warning message")
+        log.error("Error message")
+        log.critical("Fatal error message")
+
+    """
+
+    def __init__(self, keyword = "KEY", level = salome.kernel.salome.kernel.logconfig.loggingLevel,
+                 color = None, sourceFileName=None):
+
+        if sourceFileName is not None:
+            keyword = os.path.basename(sourceFileName).split('.')[0]
+        logging.Logger.__init__(self, keyword, level)
+        self._baseFormatString = "%(levelname)-8s [%(name)s] : %(message)s"
+        self._baseFormatter = logging.Formatter(self._baseFormatString)
+        if hasattr(sys.stdout, "flush"):
+            self._stdoutStream = sys.stdout
+        else:
+            self._stdoutStream = _UnFlushableLogStream(sys.stdout)
+        self._stdoutHandler = logging.StreamHandler(self._stdoutStream)
+        self._stdoutHandler.setLevel(logging.DEBUG)
+        self.setColor(color)
+        self.addHandler(self._stdoutHandler)
+        self._fileHandler = None
+
+    ## Log all messages, including DEBUG level messages (equivalent to
+    #  setLevel(logging.DEBUG)).
+    def showDebug(self):
+        """
+        Log all messages, including DEBUG level messages (equivalent to
+        ``setLevel(logging.DEBUG)``).
+        """
+        self.setLevel(logging.DEBUG)
+
+    ## Define a log file to record the log messages (in addition to the
+    #  standard output).
+    def setLogFile(self, logFilename):
+        """
+        Define a log file to record the log messages (in addition to the
+        standard output).
+        """
+        self.closeLogFile()
+        self._fileHandler = logging.FileHandler(logFilename, 'w')
+        self._fileHandler.setLevel(logging.DEBUG)
+        self._fileHandler.setFormatter(self._baseFormatter)
+        self.addHandler(self._fileHandler)
+
+    ## Set the color of log messages on color-capable terminals. If \em color
+    #  is \b None, the default color will be used.
+    def setColor(self, color):
+        """
+        Set the color of log messages on color-capable terminals. If `color`
+        is :const:`None`, the default color will be used.
+        """
+        if color is None or not termcolor.canDisplayColor(self._stdoutStream):
+            stdoutFormatter = self._baseFormatter
+        else:
+            format = ("%s%s%s" %
+                      (termcolor.getControlSequence(color),
+                       self._baseFormatString,
+                       termcolor.getControlSequence(termcolor.DEFAULT)))
+            stdoutFormatter = logging.Formatter(format)
+        self._stdoutHandler.setFormatter(stdoutFormatter)
+
+    ## Close the log file.
+    def closeLogFile(self):
+        """Close the log file."""
+        if self._fileHandler is not None:
+            self.removeHandler(self._fileHandler)
+            self._fileHandler.close()
+            self._fileHandler = None
+
+    ## Hide DEBUG level messages (equivalent to setLevel(logging.INFO)).
+    def hideDebug(self):
+        """
+        Hide DEBUG level messages (equivalent to ``setLevel(logging.INFO)``).
+        """
+        self.setLevel(logging.INFO)
+
+    @deprecated("Deprecated since version 5.1.5. Please replace with "
+                "Logger.critical(message)")
+    
+    ## Log a message with CRITICAL level. This method only exists for
+    #  backward compatibility and is equivalent to \b critical(message).
+    def fatal(self, message):
+        """
+        Log a message with CRITICAL level. This method only exists for
+        backward compatibility and is equivalent to ``critical(message)``.
+        """
+        self.critical(message)
+
+## This utility class allows to log messages to a stream with no \b flush
+#  method. This is useful to send log messages to \b PyOut objects.
+#  \ingroup logger
+class _UnFlushableLogStream:
+    """
+    This utility class allows to log messages to a stream with no `flush`
+    method. This is useful to send log messages to `PyOut` objects.
+    """
+
+    def __init__(self, stream):
+        self._stream = stream
+
+    def write(self, msg):
+        self._stream.write(msg)
+
+    def flush(self):
+        pass
+
+## This class extends Logger class and adds exception information
+#  when DEBUG messages are recorded. It exists mainly for backward
+#  compatibility, as the same thing can be done by calling
+#  <em> Logger.debug(message, exc_info = True) </em>.
+#  \ingroup logger
+class ExtLogger(Logger):
+    """
+    This class extends :class:`Logger` class and adds exception information
+    when DEBUG messages are recorded. It exists mainly for backward
+    compatibility, as the same thing can be done by calling
+    ``Logger.debug(message, exc_info = True)``.
+    """
+    
+    @deprecated("Class ExtLogger is deprecated since version 5.1.5. See "
+                "documentation for replacement.")
+    def __init__(self, keyword = "KEY",
+                 level = salome.kernel.salome.kernel.logconfig.loggingLevel,
+                 color = None, sourceFileName=None):
+        Logger.__init__(self, keyword, level, color, sourceFileName)
+
+    ## Log a DEBUG message with exception information (equivalent to
+    #  <em> Logger.debug(message, exc_info = True) </em>).
+    def debug( self, message ):
+        """
+        Log a DEBUG message with exception information (equivalent to
+        ``Logger.debug(message, exc_info = True)``).
+        """
+        Logger.debug(self, message, exc_info = True)
+
+## Test function for logger module
+#  \ingroup logger
+def TEST_Logger():
+    """Test function for logger module"""
+    log = Logger("TST")
+
+    # Base methods
+    log.info("Information message")
+    log.debug("Debug message")
+    log.fatal("Fatal error message")
+
+    # Message building
+    data = 12
+    log.info("This message displays data = " + str(data))
+
+    data = {}
+    data["KERNEL"] = "V1"
+    data["GEOM"] = "V2"
+    log.info("This message displays data = " + str(data))
+
+    # Test with a non-string parameter
+    log.info(data)
+
+    # Test with a default instance
+    log = Logger()
+    log.info("Default logger")
+
+    # Test showDebug method
+    log.setLogFile("test.log")
+    log.debug("Debug trace")
+    log.hideDebug()
+    log.debug("This trace should NOT be displayed")
+    log.showDebug()
+    log.debug("This trace should be displayed")
+    log.closeLogFile()
+    log.info("After closing the log file")
+
+
+# Main function only used to test the module
+if __name__ == "__main__":
+    TEST_Logger()