######################################################################################## # # # Author: Bertrand Neron, # # Organization:'Biological Software and Databases' Group, Institut Pasteur, Paris. # # Distributed under GPLv2 Licence. Please refer to the COPYING.LIB document. # # # ######################################################################################## """ Content the basics Mobyle Parameter types """ import os import re from types import BooleanType , StringTypes from logging import getLogger c_log = getLogger(__name__) b_log = getLogger('Mobyle.builder') import shutil from Mobyle.Utils import safeFileName from Mobyle.Classes.DataType import DataType from Mobyle.Service import MobyleType from Mobyle.MobyleError import MobyleError , UserValueError , UnDefAttrError , UnSupportedFormatError from Mobyle.ConfigManager import Config _cfg = Config() def safeMask( mask ): import string for car in mask : if car not in string.printable : mask = mask.replace( car , '_') #don't use re.UNICODE because safeFileName don't permit to use unicode char. #we must work whit the same char set mask = re.sub( "(;|`|$\(\s)+" , '_' , mask ) mask = re.sub( "^.*[\\\]", "" , mask ) mask = re.sub( "^/", "" , mask ) mask = re.sub( "\.(\.)+", "" , mask ) return mask class DataTypeTemplate( DataType ): def convert( self , value , AcceptedMobyleType , detectedMobyleType = None , paramFile= False ): """ cast the value to the right typeand compute the dataFormat conversion if needed (based on the detectedMobyleType and the AcceptedMobyleType) @param value: the value provided by the User for this parameter @type value: String @param acceptedMobyleType: the MobyleType with the Dataformat accepted by this service parameter @type acceptedMobyleType: L{MobyleType} instance @param detectedMobyleType: the MobyleType discribing the real dataformat of this data @type detectedMobyleType: L{MobyleType} instance @return: the casted value and the mobyleType describing this data (with the effective DataFormat) for datatype which have not dataFormat (boolean , integer, ... ) the MobyleType returned is the same as the AcceptedMobyleType. @rtype: ( value any type , MobyleType instance ) @raise UseValueError: if the cast failed """ realMobyleType = MobyleType( self ) return ( "DataTypeTemplate convert: " + str( value ) , realMobyleType ) def detect( self , value ): mt = MobyleType( self ) return mt def validate( self, param ): """ do type controls. if the value in the param pass the controls return True, False otherwise. @rtype: boolean """ return "DataTypeTemplate validate" class BooleanDataType( DataType ): """ """ def convert( self , value , acceptedMobyleType , detectedMobyleType = None , paramFile= False ): """ cast the value to a Boolean. The values: "off", "false", "0" or '' (case insensitive) are false, all others values are True. @param value: the value provided by the User for this parameter @type value: String @param acceptedMobyleType: the MobyleType accepted by this service parameter @type acceptedMobyleType: L{MobyleType} instance @param detectedMobyleType: the MobyleType discribing this data @type detectedMobyleType: L{MobyleType} instance @return: the value converted to Boolean, and a MobyleType discribing this value @rtype: tuple ( boolean , MobyleType instance ) """ if value is None: # in html form boolean appear as checkbox # if the checkbox is not selected # the parameter is not send in the request return ( False , acceptedMobyleType ) if isinstance( value , BooleanType ): return ( value , acceptedMobyleType ) elif isinstance( value , StringTypes ): value = value.lower() if value in [ "off", "false", "0", "", "''", '""' ]: return ( False , acceptedMobyleType ) elif value in [ "on", "true", "1" ]: return ( True , acceptedMobyleType ) else: msg = "Invalid value: " + str( value ) + " is not a boolean." raise UserValueError( msg = msg ) def detect( self , value ): mt = MobyleType( self ) return mt def validate( self, param ): """ do type controls. if the value is True or False or None return True, otherwise return False.. """ value = param.getValue() if value == True or value == False: return True else: return False class IntegerDataType( DataType ): def convert( self , value , acceptedMobyleType , detectedMobyleType = None , paramFile= False ): """ Try to cast the value to Integer. the allowed values are digits and strings. @param value: the value provided by the User for this parameter @type value: string @param acceptedMobyleType: the MobyleType accepted by this service parameter @type acceptedMobyleType: L{MobyleType} instance @param detectedMobyleType: the MobyleType discribing this data @type detectedMobyleType: L{MobyleType} instance @return: the value converted to Integer and the mobyleType discribing this value. @rtype: ( int , MobyleType instance ) @raise UserValueError: if the cast fails. Unlike python, this method convert "8.0" to 8 and raise a UserValueError if you try to convert 8.2 . """ if value is None: return ( None , acceptedMobyleType ) #type controls # int("8.0") failed and a ValueError is raised # int(8.1) return 8 try: f= float( value ) i = int( f ) if ( (f - i) == 0): return ( i , acceptedMobyleType ) else: msg = "\"%s\" : this parameter must be an integer" %value raise UserValueError( msg = msg) except OverflowError: raise UserValueError( msg = "this value is too big" ) except ( ValueError , TypeError ): msg = "\"%s\" : this parameter must be an integer" %value raise UserValueError( msg = msg) def detect( self , value ): mt = MobyleType( self ) return mt def validate( self, param ): """ @return True if the value is an integer, False othewise. """ value = param.getValue() if value is None: return True try: int( value ) except ( TypeError , ValueError ): return False class FloatDataType( DataType ): def convert( self , value , acceptedMobyleType , detectedMobyleType = None , paramFile= False ): """ Try to cast the value to Float. @param value: the value provided by the User for this parameter @type value: @param acceptedMobyleType: the MobyleType accepted by this service parameter @type acceptedMobyleType: L{MobyleType} instance @param detectedMobyleType: the MobyleType discribing this data @type detectedMobyleType: L{MobyleType} instance @return: the value converted to Float @rtype: float """ if value is None: return ( None , acceptedMobyleType ) try: return ( float( value ) , acceptedMobyleType ) except ( ValueError, TypeError ): msg = str( value ) + " this parameter must be a Float" raise UserValueError( msg = msg ) def detect( self , value ): mt = MobyleType( self ) return mt def validate( self, param ): """ @return: True if the value is a float, False othewise. @rtype: boolean """ value = param.getValue() if value is None: return True try: float( value ) except ( ValueError , TypeError ): return False class StringDataType( DataType ): def convert( self , value , acceptedMobyleType , detectedMobyleType = None , paramFile= False ): """ Try to cast the value to String. @param value: the value provided by the User for this parameter @type value: @return: the value converted to String. @rtype: String @param acceptedMobyleType: the MobyleType accepted by this service parameter @type acceptedMobyleType: L{MobyleType} instance @param detectedMobyleType: the MobyleType discribing this data @type detectedMobyleType: L{MobyleType} instance @raise UserValueError: if the cast fails. """ if value is None: return ( None , acceptedMobyleType ) #type controls try: value = str( value ).encode('ascii') except ValueError : raise UserValueError( msg = "should be an (ascii) string" ) #strings with space are allowed, but if the string will appear #as shell instruction it must be quoted if value.find(' ') != -1 and not paramFile: value = "'%s'" % value return ( value , acceptedMobyleType ) def detect( self , value ): mt = MobyleType( self ) return mt def validate( self, param ): """ @return: True if the value is a string and doesnot contain dangerous characters. ( allowed characters: the words , space, ' , - , + , and dot if is not followed by another dot and eventually surrounded by commas) @rtype: boolean @raise UserValueError: if the value does not statisfy security regexp. """ value = param.getValue() if value is None: return True #allowed characters: #the words , space, ' , - , + , and dot if is not followed by another dot #and eventually surrounded by commas reg = "(\w|\ |-|\+|,|@|\.(?!\.))+" if re.search( "^(%s|'%s')$" % (reg, reg) , value ) : return True else: msg = "this value: \"" + str( value ) + "\" , is not allowed" raise UserValueError( parameter = param , msg = msg ) class ChoiceDataType( StringDataType ): #the values of ChoiceDataType are literals thus they are String def convert( self , value , acceptedMobyleType , detectedMobyleType = None , paramFile= False ): """ The values of ChoiceDataType are literals thus this method try to cast the value to string. @param value: the value provided by the User for this parameter @type value: @param acceptedMobyleType: the MobyleType accepted by this service parameter @type acceptedMobyleType: L{MobyleType} instance @param detectedMobyleType: the MobyleType discribing this data @type detectedMobyleType: L{MobyleType} instance @return: the value converted in String @rtype: string """ if value is None: return ( None , acceptedMobyleType ) try: value = str( value ) if hasattr( acceptedMobyleType , '_undefValue' ) and value == acceptedMobyleType._undefValue : return ( None , acceptedMobyleType ) else: return ( value, acceptedMobyleType ) except ValueError: msg = " this parameter is a Choice its value should be a String" raise UserValueError( msg = msg ) def detect( self , value ): mt = MobyleType( self ) return mt def validate( self, param ): """ @return: True if the value is valid. that's mean the value should be a string among the list defined in the xml. otherwise a MobyleError is raised. @rtype: boolean @param value: a value from a Choice parameter @type value: Choice value @raise UserValueError: if the value is not a string or is not among the list defined in the xml vlist. """ paramName = param.getName() value = param.getValue() if param.hasVlist() : authorizedValues = param.getVlistValues() elif param.hasFlist() : authorizedValues = param.getFlistValues() else: msg = "%s a Choice must have a flist or vlist" %( paramName ) c_log.error( msg ) raise MobyleError , msg if value is None or value in authorizedValues: return True else: logMsg = "Unauthorized value for the parameter : %s : authorized values = %s : provided value = %s" %( paramName , authorizedValues , value ) c_log.error( logMsg ) msg = "Unauthorized value for the parameter : %s" %( paramName ) raise UserValueError( parameter = param , msg = msg ) class MultipleChoiceDataType( StringDataType ): def convert( self , value , acceptedMobyleType , detectedMobyleType = None , paramFile= False, separator = None): """ The MutipleChoiceDataType value are literals thus this method try to cast the value to a list of string. @param value: the values provided by the User for this parameter @type value: list @param acceptedMobyleType: the MobyleType accepted by this service parameter @type acceptedMobyleType: L{MobyleType} instance @param detectedMobyleType: the MobyleType describing this data @type detectedMobyleType: L{MobyleType} instance @return: a string based on each selected value and joined by the separator. @rtype: String . @raise UserValueError: if the value can't be converted to a string. """ if value is None: return ( None , acceptedMobyleType ) sep = separator if separator is not None else '' if hasattr( acceptedMobyleType , '_undefValue' ) and value == acceptedMobyleType._undefValue : return ( None , acceptedMobyleType ) else: try: values = [ str( elem ) for elem in value ] except ValueError: msg = "this parameter is a MultipleChoice its all values must be Strings" %value raise UserValueError( msg = msg ) return ( sep.join(values) , acceptedMobyleType ) def detect( self , value ): mt = MobyleType( self ) return mt def validate( self, param ): #values are stored as string in evaluator #the string is computed by service.setValue() #the string is return by getValue and used as is in ComandBuilder userValues = param.getValue() #it's a string if userValues is None: return True sep = param.getSeparator() #we must retransform the string in a list to check if each #element is in the list of authorized values if sep == '': userValues = [ i for i in userValues ] else: userValues = userValues.split( sep ) authorizedValues = param.getVlistValues() undef_value = param.getListUndefValue() for value in userValues: if value not in authorizedValues and value != param.getListUndefValue(): msg = "the value %s is not allowed (allowed values: %s)" % ( str( value ) , str( param.getVlistValues() ) ) raise UserValueError( parameter = param , msg = msg ) return True class AbstractFileDataType(DataType): """ AbstractFileDataType is an abstract class that centralizes the code which is common to text files (AbstractTextDataType) and binary files (BinaryDataType) """ def isFile( self ): return True @classmethod def supportedFormat( cls ): """ @return: the list supported by the format detector @rtype: list of string """ uniq_formats = [] for converter in _cfg.dataconverter( cls.__name__[:-8] ): for f in converter.detectedFormat(): if f not in uniq_formats: uniq_formats.append( f ) return uniq_formats @classmethod def supportedConversion( cls ): """ @return: the list of dataFormat conversion available. @rtype: list of tuple [ (string input format, string output formt) , ... ] """ uniq_conversion = [] for converter in _cfg.dataconverter( cls.__name__[:-8] ): for f in converter.convertedFormat(): if f not in uniq_conversion: uniq_conversion.append( f ) return uniq_conversion def detect( self , value ): """ detects the format of the sequence(s) contained in fileName @param value: the src object and the filename in the src of the data to detect @type value: tuple ( session/Job/MobyleJob instance , string filename ) @return: a tuple of the detection run information: - the detected format, - the detected items number, - program name used for the detection. """ if value is None: return None if len( value ) == 2 : src , srcFileName = value else: raise MobyleError ,"value must be a tuple of 2 elements: ( Job/MobyleJob/JobState or Session instance , Job/MobyleJob/JobState or Session instance , srcFileName )" if src and not srcFileName : raise MobyleError , "if src is specified, srcFileName must be also specified" absFileName = os.path.join( src.getDir() , srcFileName ) all_converters = _cfg.dataconverter( self.__class__.__name__[:-8] ) for converter in all_converters: detected_format , seq_nb = converter.detect( absFileName ) prg = converter.program_name if detected_format: detected_mt = MobyleType( self , dataFormat = detected_format , format_program = prg , item_nb = seq_nb) return detected_mt return MobyleType( self ) #no dataFormat have been detected def convert( self , value ,acceptedMobyleType , detectedMobyleType = None, paramFile= False): """ convert the sequence contain in the file fileName in the rigth format throws an UnsupportedFormatError if the output format is not supported or a MobyleError if something goes wrong during the conversion. @param value: is a tuple ( src , srcFileName) - srcfilename is the name of the file to convert in the src - src must be a L{Job} instance the conversion are perform only by jobs (not session) . @type value: ( L{Job} instance dest, L{Job} instance, src) @return: the fileName ( basename ) of the sequence file and the effective MobyleType associated to this value @rtype: ( string fileName , MobyleType instance ) @raise UnSupportedFormatError: if the data cannot be converted in any suitable format """ if value is None: return None if len( value ) == 2 : src , srcFileName = value else: raise MobyleError ,"value must be a tuple of 2 elements: ( Job/MobyleJob/JobState or Session instance , Job/MobyleJob/JobState or Session instance , srcFileName )" if src and not srcFileName : raise MobyleError , "if src is specified, srcFileName must be also specified" absFileName = os.path.join( src.getDir() , srcFileName ) all_converters = _cfg.dataconverter( self.__class__.__name__[:-8] ) in_format = detectedMobyleType.getDataFormat() if not all_converters: fileName = safeFileName( absFileName ) if detectedMobyleType : mt = detectedMobyleType else: mt = MobyleType( self ) #filename is a basename return ( fileName , mt ) else: def unknow_converter( in_format , converters ): result = None for converter in converters: try: result = fixed_converter( in_format , converter ) except UnSupportedFormatError: continue if result is not None: break #if I cannot find any suitable converter result is None return result def fixed_converter( in_format , converter ): allowed_conversions = converter.convertedFormat() for out_format , force in acceptedMobyleType.getAcceptedFormats(): if ( in_format , out_format ) in allowed_conversions: try: outFileName = converter.convert( absFileName , out_format , inputFormat = in_format ) outFileName = os.path.basename( outFileName ) except UnSupportedFormatError, err: raise UnSupportedFormatError( msg = "a problem occurred during the data conversion : "+str( err ) ) converted_mt = MobyleType( self , dataFormat = out_format , format_program = converter.program_name ) return ( outFileName , converted_mt ) #it's not a suitable converter return None if detectedMobyleType.format_program is None: result = unknow_converter( in_format , all_converters ) else: for converter in all_converters: if converter.program_name == detectedMobyleType.format_program : detector_used = converter break if detector_used is None: raise MobyleError( "unable to find %s converter" % detectedMobyleType.format_program ) result = fixed_converter( in_format , detector_used ) if result is None:# the detector_used is not suitable for the conversion result= unknow_converter( in_format , [ c for c in all_converters if c != detector_used ] ) if result is None: raise UnSupportedFormatError( "unable to convert %s in %s sequence format" %( in_format , [ f[0] for f in acceptedMobyleType.getAcceptedFormats() ] ) ) else: return result #( outFileName , converted_mt ) def validate( self , param ): """ """ value = param.getValue() if param.isout(): if value is not None : #un parametre isout ne doit pas etre modifier par l'utilisateur return False else: ##################################################### # # # check if the Parameter have a secure filenames # # # ##################################################### try: debug = param.getDebug() if debug > 1: b_log.debug( "check if the Parameter have a secure filename" ) #getFilenames return a list of strings representing a unix file mask which is the result of a code evaluation #getFilenames return None if there is no mask for a parameter. filenames = param.getFilenames( ) for filename in filenames : if filename is None: continue mask = safeMask( filename ) if debug > 1: b_log.debug( "filename= %s safeMask = %s"%(filename, mask)) if not mask or mask != filename : msg = "The Parameter:%s, have an unsecure filenames value: %s " %( param.getName() , filename ) c_log.error("Mobyle Internal Server Error") if debug == 0: c_log.critical( "%s : %s : %s" %( self._service.getName(), self._job.getKey() , msg ) ) raise MobyleError , "Mobyle Internal Server Error" else: if debug > 1: b_log.debug( "filename = %s ...........OK" % filename ) except UnDefAttrError : b_log.debug("no filenames") else: if value is None: #un infile Text ne peut pas avoir de vdef mais peut il etre a None? #=> oui s'il n'est pas obligatoire return True else: return os.path.exists( param.getValue() ) class AbstractTextDataType( AbstractFileDataType ): def head( self , data ): return data[ 0 : 50 ] def cleanData( self , data ): """ convert the data in right encoding and replace windows end of line by unix one. """ # trying to guess the encoding, before converting the data to ascii try: # trying ascii data = unicode(data.decode('ascii','strict')) except: try: # utf8 codec with BOM support data = unicode(data,'utf_8_sig') except: try: # utf16 (default Windows Unicode encoding) data = unicode(data,'utf_16') except: # latin1 data = unicode(data,'latin1') # converting the unicode data to ascii data = data.encode('ascii','replace') return re.sub( "\r\n|\r|\n" , '\n' , data ) def toFile( self , data , dest , destFileName , src , srcFileName ): """ Write file (of user data) in dest directory . @param fileName: @type fileName: string @param data: the content of the file @type data: string @param dest: the object in which the data will be copied @type dest: Job, Session object @param src: the object where the data can be found @type src: Job, Session object @param srcFileName: the file namae of the data in the src ( basename ) @type srcFileName: string @return: the name of the created file (the basename) @rtype: string @raise: L{UserValueError} when filename is not allowed (for security reason) @raise: L{MobyleError} if an error occured during the file creation """ try: destSafeFileName = safeFileName( destFileName ) except UserValueError, err: raise UserValueError( msg = "this value : %s is not allowed for a file name, please change it" % destFileName ) abs_DestFileName= os.path.join( dest.getDir() , destSafeFileName ) # if the user upload 2 files with the same basename safeFileName # return the same safeFileName # add an extension to avoid _toFile erase the existing file. ext = 1 completeName = abs_DestFileName.split( '.' ) base = completeName[0] suffixe = '.'.join( completeName[1:] ) while os.path.exists( abs_DestFileName ): abs_DestFileName = base + '.' + str( ext ) + '.' + suffixe ext = ext + 1 if src: if src.isLocal(): try: srcSafeFileName = safeFileName( srcFileName ) except UserValueError, err: raise UserValueError( msg = "this value : %s is not allowed for a file name, please change it" % srcFileName ) #the realpath is because if the abs_SrcFileName is a soft link ( some results are ) the # hardlink point to softlink and it causse ane error : no such file abs_SrcFileName = os.path.realpath( os.path.join( src.getDir() , srcSafeFileName ) ) try: os.link( abs_SrcFileName , abs_DestFileName ) except OSError : #if the src and dest are not on the same device #an OSError: [Errno 18] Invalid cross-device link , is raised try: shutil.copy( abs_SrcFileName , abs_DestFileName ) except IOError ,err: # I don't know - neither the service ( if it exists ) # - nor the job or session ID # I keep the Job or the Session to log this error msg = "can't copy data from %s to %s : %s" %( abs_SrcFileName , abs_DestFileName , err ) c_log.error( msg ) raise MobyleError , "can't copy data : "+ str(err) else: #src is a job , jobState , MobyleJob instance ( Session is always Local ) data = src.getOutputFile( srcFileName ) try: f = open( abs_DestFileName , 'w' ) f.write( data ) f.close() except IOError ,err: msg = "unable to write data from %s to %s: %s"%(src , dest , err ) c_log.error( msg ) raise MobyleError , msg else: try: clean_content = self.cleanData(data) except Exception, err: msg = "error when cleaning file : " + abs_DestFileName + str( err ) c_log.critical(msg, exc_info=True) raise MobyleError, msg try: fh = open(abs_DestFileName, "w") fh.write(clean_content) fh.close() except IOError, err: msg = "error when creating file : " + abs_DestFileName + str(err) raise MobyleError, msg size = os.path.getsize(abs_DestFileName) return os.path.basename(abs_DestFileName), size class TextDataType( AbstractTextDataType ): # this trick is to avoid that SequenceDataType is a subclass of TextDataType pass class ReportDataType( AbstractTextDataType ): pass class BinaryDataType( AbstractFileDataType ): def head( self , data ): return 'Binary data' def cleanData( self, data ): """ prepare data prior to write it on a disk @param data: @type data:a buffer """ return data def toFile( self , data , dest , destFileName , src , srcFileName ): """ Write file (of user data) in the working directory . @param fileName: @type fileName: string @param content: the content of the file @type content: string @return: the name ( absolute path ) of the created file ( could be different from the arg fileName ) @rtype: string @call: L{MobyleJob._fillEvaluator} """ try: destSafeFileName = safeFileName( destFileName ) except UserValueError, err: raise UserValueError( msg = "this value : %s is not allowed for a file name, please change it" % destFileName ) abs_DestFileName = os.path.join( dest.getDir() , destSafeFileName ) # if the user upload 2 files with the same basename safeFileName # return the same safeFileName # add an extension to avoid _toFile to erase the existing file. ext = 1 completeName = abs_DestFileName.split( '.' ) base = completeName[0] suffixe = '.'.join( completeName[1:] ) while os.path.exists( abs_DestFileName ): abs_DestFileName = base + '.' + str( ext ) + '.' + suffixe ext = ext + 1 if src: if src.isLocal(): try: srcSafeFileName = safeFileName( srcFileName ) except UserValueError, err: raise UserValueError( msg = "this value : %s is not allowed for a file name, please change it" % srcFileName ) #the realpath is because if the abs_SrcFileName is a soft link ( some results are ) the #hardlink point to softlink and it cause an error : no such file abs_SrcFileName = os.path.realpath( os.path.join( src.getDir() , srcSafeFileName ) ) try: os.link( abs_SrcFileName , abs_DestFileName ) except OSError : #if the src and dest are not on the same device #an OSError: [Errno 18] Invalid cross-device link , is raised try: shutil.copy( abs_SrcFileName , abs_DestFileName ) except IOError ,err: # je ne connais - ni le service (s'il existe) # - ni le l' ID du job ou de la session # donc je laisse le soin au Job ou la session a logger l'erreur msg = "can't copy data from %s to %s : %s" %( abs_SrcFileName , abs_DestFileName , err ) raise MobyleError , "can't copy data : "+ str(err) else: #src is a job , jobState , MobyleJOb instance ( session is Local ) data = src.getOutputFile( srcFileName ) try: f = open( abs_DestFileName , 'wb' ) f.write( data ) f.close() except IOError ,err: pass else: try: fh = open( abs_DestFileName , "wb" ) fh.write( data ) fh.close() except IOError , err: # je ne connais - ni le service (s'il existe) # - ni le l' ID du job ou de la session # donc je laisse le soin au Job ou la session a logger l'erreur msg = "error when creating file %s: %s" %( os.path.basename( abs_DestFileName ) , err ) raise MobyleError , msg size = os.path.getsize( abs_DestFileName ) return os.path.basename( abs_DestFileName ) , size class FilenameDataType( DataType ): def convert( self , value , acceptedMobyleType , detectedMobyleType = None , paramFile= False ): """ @param acceptedMobyleType: the MobyleType accepted by this service parameter @type acceptedMobyleType: L{MobyleType} instance @param detectedMobyleType: the MobyleType describing this data @type detectedMobyleType: L{MobyleType} instance """ if value is None: return ( None , acceptedMobyleType ) #raise UserValueError( parameter = param , msg= " this parameter must be a String" ) #fileName = safeFileName( value ) return ( value , acceptedMobyleType ) def detect( self , value ): mt = MobyleType( self ) return mt def validate( self, param ): value = param.getValue() if value is None : return True safefileName = safeFileName( value ) if safefileName != value: msg = "invalid value: %s : the followings characters \:/ ;` {} are not allowed" %( value ) raise UserValueError( parameter = param , msg = msg ) else: return True