salome.kernel 9.14.0__cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

salome/kernel/salome/kernel/__init__.py

@@ -0,0 +1,111 @@
+# -*- coding: iso-8859-1 -*-
+# 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
+#
+
+## \defgroup salome_kernel_utils salome.kernel
+#  \{ 
+#  \details Package containing the KERNEL python utilities
+#  \defgroup deprecation
+#  \defgroup termcolor
+#  \defgroup logger
+#  \defgroup enumerate
+#  \defgroup uiexception
+#  \defgroup datamodeler
+#  \defgroup diclookup
+#  \defgroup service
+#  \defgroup studyedit
+#  \defgroup unittester
+#  \defgroup pyunittester
+#  \}
+
+from salome.kernel import version_and_config
+
+__all__ = [ "deprecation", "logger", "termcolor", "logconfig" ]
+__version__ = version_and_config.version
+__config_datetime__ = version_and_config.config_datetime
+
+del version_and_config
+
+# WARN: This file SHOULD NOT import salome stuff so that modules of the
+# package could be used outside of a SALOME session context when
+# possible. For example logger.py, datamodeler.py, enumerate.py,
+# diclookup.py, ... does not need a SALOME running application.
+
+#
+# ==============================================================================
+# Generic serialization functions for the module datamodeler
+# ==============================================================================
+#
+import pickle
+
+def serialize(dataToSerialize):
+    """
+    Creates a string description of the specified data.
+    .. attribute:: dataToSerialize
+    a data object to serialize
+    """
+    serialstring = pickle.dumps(dataToSerialize)
+    return serialstring
+
+def unserialize(stringToUnserialize):
+    """
+    Creates a data object from its string description. The string description
+    is supposed to be obtained by a call to serialize.
+    .. attribute:: stringToUnserialize
+    a string description of the object
+    """
+    data = pickle.loads(stringToUnserialize)
+    return data
+
+class Callable:
+    """
+    This class is used to create class-method (see MetaData)
+    """
+    def __init__(self, anycallable):
+        self.__call__ = anycallable
+#
+# ==============================================================================
+# Basic use cases and unit tests
+# ==============================================================================
+#
+
+def TEST_serialization():
+    from .testdata import TestData
+    ref_name = "my study case"
+    studyData = TestData()
+    studyData.setName(ref_name)
+
+    print("serialize data ...")
+    serialString = serialize(studyData)
+    print("unserialize data ...")
+    unserialData = unserialize(serialString)
+
+    res_name = unserialData.getName()
+    print(res_name)
+    if ( ref_name != res_name ):
+        return False
+
+    unserialData.log()
+    unserialData.setName("an other name")
+
+    return True
+
+if __name__ == "__main__":
+    from . import unittester
+    unittester.run("salome/kernel/__init__","TEST_serialization")

salome/kernel/salome/kernel/datamodeler.py

@@ -0,0 +1,363 @@
+# -*- 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 datamodeler datamodeler
+#  \{ 
+#  \details Helper for modeling user data
+#  \}
+
+__author__="gboulant"
+__date__ ="$15 avr. 2010 19:44:17$"
+
+from .uiexception import DevelException
+
+# Most usable class types
+TypeString= "".__class__
+__ref_integer = 0
+TypeInteger = __ref_integer.__class__
+__ref_double = 0.0
+TypeDouble = __ref_double.__class__
+__ref_list = []
+TypeList = __ref_list.__class__
+__ref_dict = {}
+TypeDictionnary = __ref_dict.__class__
+
+# There is no control to do for these attributes. They are attributes for the
+# class management and not data of the model.
+UNCHECKED_ATTRIBUTES = [
+    "_typemap",
+    "_rangemap",
+    "_defaultmap",
+    "_voidmap",
+]
+
+## This class is a placeholder for modeling data. An object based on this class
+#  (particular instance or specialized derived class) can defined attributes with
+#  the following properties:
+#  - a type : the class or the type of the attribute. Setting an attribute to
+#    a value whose type is not the specified type raises an exception.
+#  - a range : a list of the possible values for the attribute. Setting an
+#    attribute to a value not in the range raises an exception
+#  - a default: the default value of an attribute when an instance is created
+#  - a void flag: the attribute can be authorized to be None or not using this
+#    flag. Setting an attribute to a None value while the flag is not set to
+#    True raises an exception. By default, a None value is not allowed.
+#
+#  These properties are dictionnaries mapping the attribute name to its
+#  associated value for the property.
+#  \n A typical usage is to derived this class in a specialized form where the
+#  attributes names and there properties are defined in the constructor. See
+#  use cases at the end of this file.
+#  \ingroup datamodeler
+class DataModeler:
+    """
+    This class is a placeholder for modeling data. An object based on this class
+    (particular instance or specialized derived class) can defined attributes with
+    the following properties:
+
+    - a type : the class or the type of the attribute. Setting an attribute to
+      a value whose type is not the specified type raises an exception.
+    - a range : a list of the possible values for the attribute. Setting an
+      attribute to a value not in the range raises an exception
+    - a default: the default value of an attribute when an instance is created
+    - a void flag: the attribute can be authorized to be None or not using this
+      flag. Setting an attribute to a None value while the flag is not set to
+      True raises an exception. By default, a None value is not allowed.
+
+    These properties are dictionnaries mapping the attribute name to its
+    associated value for the property.
+
+    A typical usage is to derived this class in a specialized form where the
+    attributes names and there properties are defined in the constructor. See
+    use cases at the end of this file.
+
+    """
+    def __init__(self, typemap=None, rangemap=None, defaultmap=None, voidmap=None):
+        self._typemap = {}
+        self._rangemap   = {} # possible values
+        self._defaultmap = {} # defaults values
+        self._voidmap    = {}    # None values are allowed
+        
+        if typemap is not None:
+            self._typemap.update(typemap)
+        if rangemap is not None:
+            self._rangemap.update(rangemap)
+        if voidmap is not None:
+            self._voidmap.update(voidmap)
+
+        # Default initialization (if any)
+        if defaultmap is not None:
+            self._defaultmap.update(defaultmap)
+            for name in self._defaultmap:
+                self.__setattr__(name,self._defaultmap[name])
+
+    ## %A None argument means that no entry is created in the associated maps.
+    def addAttribute(self, name, a_type=None, a_range=None, default=None, void=None):
+        """
+        A None argument means that no entry is created in the associated maps.
+        """
+        self._typemap[name] = a_type
+
+        if a_range is not None:
+            self._rangemap[name] = a_range
+
+        if void is not None:
+            self._voidmap[name] = void
+
+        if (not void) and (default is None):
+            return
+        
+        self.__setattr__(name,default)
+
+    def __setattr__(self, name, val):
+        if name in UNCHECKED_ATTRIBUTES:
+            object.__setattr__(self, name, val)
+            return
+
+        #__GBO_DEBUG_
+        if name == "_typemap":
+            print("WARNING WARNING WARNING : changing value of _typemap by ",val)
+
+        if name not in self._typemap:
+            raise DevelException("The class "+str(self.__class__)+" has no attribute "+str(name))
+
+        if val is None:
+            if not self.__isVoidAllowed(name):
+                raise DevelException("The attribute "+str(name)+" can't be None")
+            else:
+                # We can stop here and set the value to None
+                self.__dict__[name] = None
+                return
+
+        if self.__isNotValidType(name,val):
+            raise DevelException("The attribute "+str(name)+" must be an instance of "+str(self._typemap[name]))
+
+        if self.__isNotValidRange(name,val):
+            raise DevelException("The attribute "+str(name)+" must be a value in :"+str(self._rangemap[name]))
+
+        self.__dict__[name] = val
+    
+    def __getattribute__(self, name):
+        if name in UNCHECKED_ATTRIBUTES:
+            return object.__getattribute__(self, name)
+
+        if name in DataModeler.__dict__:
+            return object.__getattribute__(self, name)
+
+        if name not in self._typemap:
+            raise DevelException("The class  has no attribute "+str(name))
+        # The attribute coulb be requested while it has not been created yet (for
+        # example if we did't call the setter before).
+        if name not in self.__dict__.keys():
+            return None
+
+        return object.__getattribute__(self, name)
+
+    def __isNotValidType(self, name, val):
+        isNotValid = (
+            ( self._typemap[name] is not None) and
+            ( not isinstance(val,self._typemap[name]) ) )
+
+        return isNotValid
+
+    def __isNotValidRange(self, name, val):
+        isNotValid = (
+            ( self._rangemap is not None) and
+            ( name in self._rangemap ) and
+            ( self._rangemap[name] is not None ) and
+            ( val not in self._rangemap[name] ) )
+
+        return isNotValid
+
+    def __isVoidAllowed(self,name):
+        isVoidAllowed = (
+            ( self._voidmap is not None) and
+            ( name in self._voidmap ) and
+            ( self._voidmap[name] is True ) )
+            
+        return isVoidAllowed
+
+    def log(self):
+        print("DATAMODELER ["+str(self.__class__)+"]: self._typemap.keys() = "+str(list(self._typemap.keys())))
+
+
+
+
+#
+# ==============================================================================
+# Basic use cases and unit tests
+# ==============================================================================
+#
+def TEST_usecase():
+    typemap={}
+    typemap["stringdata"] = TypeString
+    typemap["integerdata"] = TypeInteger
+    typemap["anydata"] = None # can be anything
+
+    data = DataModeler(typemap)
+
+    sdata = "toto"
+    idata = 3
+    data.stringdata = sdata
+    data.integerdata = idata
+
+    data.anydata = 5.3
+    data.anydata = "any value"
+    data.anydata = True
+
+    print(data.integerdata)
+    return True
+
+def TEST_addAttribute():
+    typemap={}
+    typemap["stringdata"] = TypeString
+    typemap["integerdata"] = TypeInteger
+    data = DataModeler(typemap)
+    data.stringdata = "a string value"
+
+    ref_value = 1.3
+    data.addAttribute(
+        name    = "myAttr",
+        a_type    = TypeDouble,
+        a_range   = None,
+        default = ref_value,
+        void    = False)
+
+    try:
+        if data.myAttr != ref_value:
+            return False
+        data.myAttr = 5.3
+        #data.myAttr = 5
+    except Exception as e:
+        print(e)
+        return False
+
+    try:
+        data.myAttr = "bad type value"
+        return False
+    except Exception as e:
+        print(e)
+        return True
+
+def TEST_badAttributeName():
+    map={}
+    map["stringdata"] = TypeString
+    map["integerdata"] = TypeInteger
+
+    data = DataModeler(map)
+
+    # this should raise an exception
+    try:
+        data.myatt = 3
+        return False
+    except Exception as e:
+        print("OK : "+str(e))
+        return True
+
+def TEST_badAttributeType():
+    map={}
+    map["stringdata"] = TypeString
+    map["integerdata"] = TypeInteger
+
+    data = DataModeler(map)
+    # this should raise an exception
+    try:
+        data.stringdata = 2
+        return False
+    except Exception as e:
+        print("OK : "+str(e))
+        return True
+
+def TEST_badAttributeRange():
+    map={}
+    map["stringdata"] = TypeString
+    map["integerdata"] = TypeInteger
+
+    range={}
+    ref_integervalue = 3
+    range["integerdata"] = [1,ref_integervalue,7]
+
+    data = DataModeler(map,range)
+    # this should not raise an exception
+    try:
+        data.integerdata = ref_integervalue
+        data.stringdata = "anything (no restriction has been defined)"
+    except Exception as e:
+        print(e)
+        return False
+
+    # this should raise an exception
+    try:
+        data.integerdata = 9999 # a value not in the range
+        return False
+    except Exception as e:
+        print(e)
+        return True
+
+def TEST_voidAttributeAllowed():
+    map={}
+    map["stringdata"] = TypeString
+    map["integerdata"] = TypeInteger
+
+    voidmap={}
+    voidmap["stringdata"] = True
+
+    data = DataModeler(typemap=map,voidmap=voidmap)
+    try:
+        # this should not raise an exception
+        data.stringdata = None
+        print(data.stringdata)
+    except Exception as e:
+        print(e)
+        return False
+    
+    try:
+        # this should raise an exception
+        data.integerdata = None
+        return False
+    except Exception as e:
+        print(e)
+        return True
+
+def TEST_defaultValues():
+    typemap={}
+    typemap["stringdata"] = TypeString
+    typemap["integerdata"] = TypeInteger
+
+    ref_value = "my initial value"
+    defaultmap={}
+    defaultmap["stringdata"] = ref_value
+
+    data = DataModeler(typemap=typemap,defaultmap=defaultmap)
+    print(data.stringdata)
+    if data.stringdata != ref_value:
+        return False
+    else:
+        return True
+
+if __name__ == "__main__":
+    from .unittester import run
+    run("salome/kernel/datamodeler","TEST_usecase")
+    run("salome/kernel/datamodeler","TEST_addAttribute")
+    run("salome/kernel/datamodeler","TEST_badAttributeName")
+    run("salome/kernel/datamodeler","TEST_badAttributeType")
+    run("salome/kernel/datamodeler","TEST_badAttributeRange")
+    run("salome/kernel/datamodeler","TEST_voidAttributeAllowed")
+    run("salome/kernel/datamodeler","TEST_defaultValues")

salome/kernel/salome/kernel/deprecation.py

@@ -0,0 +1,165 @@
+# -*- 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
+#
+
+## \defgroup deprecation deprecation
+#  \{ 
+#  \details
+#  This module provides several functions to indicate the deprecation of a
+#  module, a method or a function.
+#  \code
+#  from salome.kernel.deprecation import deprecated
+#  deprecated("Deprecated since version 6.3.0. Consider replacement with 
+#              newFunction()")
+#  def oldFunction():
+#  ...
+#  \endcode
+#  \}
+
+"""
+This module provides several functions to indicate the deprecation of a
+module, a method or a function.
+
+Example::
+
+    from salome.kernel.deprecation import deprecated
+
+    @deprecated("Deprecated since version 6.3.0. Consider replacement with "
+                "newFunction()")
+    def oldFunction():
+      ...
+
+"""
+
+import sys
+import warnings
+import inspect
+import os
+
+from salome.kernel.salome.kernel import termcolor
+
+msg_seedoc = "See documentation for possible replacements."
+
+def __deprecated_with_msg(func, msg):
+
+    def new_func(*args, **kwargs):
+        if len(inspect.stack()) > 1:
+            callingfunc = inspect.stack()[1][3]
+        else:
+            callingfunc = "CORBA middleware"
+        warnings.warn(
+            ("Call to deprecated function %(funcname)s of module " +
+             "%(modname)s (called from %(callingfunc)s).\n  %(msg)s") % {
+                'funcname': func.__name__,
+                'modname': func.__module__,
+                'callingfunc': callingfunc,
+                'msg': msg,
+            },
+            category = DeprecationWarning,
+            stacklevel = 2
+        )
+        return func(*args, **kwargs)
+    return new_func
+
+## This is a decorator which can be used to mark functions
+#  as deprecated. It will result in a warning being emitted
+#  when the function is used. The message in parameter will
+#  be displayed and should indicate how this function can be
+#  replaced. If the terminal can display colors, the warning
+#  messages will appear in blue.
+#  \ingroup deprecation
+def deprecated(msg = msg_seedoc):
+    """
+    This is a decorator which can be used to mark functions
+    as deprecated. It will result in a warning being emitted
+    when the function is used. The message in parameter will
+    be displayed and should indicate how this function can be
+    replaced. If the terminal can display colors, the warning
+    messages will appear in blue.
+    """
+    def make_dep(f):
+        if is_called_by_sphinx():
+            return f
+        else:
+            g = __deprecated_with_msg(f, msg)
+            g.__name__ = f.__name__
+            g.__doc__ = f.__doc__
+            g.__dict__.update(f.__dict__)
+            return g
+    return make_dep
+
+## This function can be used to mark a module as deprecated.
+#  It must be called explicitly at the beginning of the deprecated
+#  module. It will result in a warning being emitted. The message
+#  in parameter will be displayed and should indicate how this
+#  module can be replaced. If the terminal can display colors,
+#  the warning messages will appear in blue.
+#  \ingroup deprecation
+def deprecated_module(msg = msg_seedoc):
+    """
+    This function can be used to mark a module as deprecated.
+    It must be called explicitly at the beginning of the deprecated
+    module. It will result in a warning being emitted. The message
+    in parameter will be displayed and should indicate how this
+    module can be replaced. If the terminal can display colors,
+    the warning messages will appear in blue.
+    """
+    if not is_called_by_sphinx():
+        warnings.warn(
+            "Importation of deprecated module %(modname)s.\n  %(msg)s" % {
+                'modname': inspect.getmodulename(inspect.stack()[1][1]),
+                'msg': msg,
+            },
+            category = DeprecationWarning,
+            stacklevel = 5
+        )
+
+## Determine if the calling code is ultimately called by sphinx to generate
+#  documentation. The result can be used to conditionally inhibit the
+#  decorators or some Salome-related imports that fail when called outside
+#  Salome.
+#  \ingroup deprecation
+def is_called_by_sphinx():
+    """
+    Determine if the calling code is ultimately called by sphinx to generate
+    documentation. The result can be used to conditionally inhibit the
+    decorators or some Salome-related imports that fail when called outside
+    Salome.
+    """
+    calling_file = inspect.stack()[len(inspect.stack())-1][1]
+    basename = os.path.basename(calling_file)
+    return (basename == "sphinx-build")
+
+
+def __show_colored_warning(message, category, filename,
+                           lineno, file = None, line = None):
+    if file is None:
+        file = sys.stderr
+    str = warnings.formatwarning(message, category, filename, lineno, line)
+    if category == DeprecationWarning and termcolor.canDisplayColor(file):
+        file.write(termcolor.makeColoredMessage(str, termcolor.BLUE))
+    else:
+        file.write(str)
+
+# Enable warnings for deprecated functions and modules (in Python 2.7, they
+# are disabled by default)
+warnings.filterwarnings("always", "Call to *", DeprecationWarning)
+warnings.filterwarnings("always", "Importation of *", DeprecationWarning)
+warnings.showwarning = __show_colored_warning