def takes_invocation_proxy(*args, **kwargs): # append the default parameters if method_defaults is not None and len(method_defaults) > 0 \ and len(method_args) - len(method_defaults) <= len(args) < len(method_args): args += method_defaults[len(args) - len(method_args):] # check the types of the actual call parameters for i, (arg, checker) in enumerate(zip(args, checkers)): if not checker.check(arg): #raise InputParameterError("%s() got invalid parameter " #"%d of type %s" % #(method.__name__, i + 1, #type_name(arg))) mainMessage = "%s() got invalid parameter %d of type %s" %\ (method.__name__, i + 1, type_name(arg)) logMessageOnce(mainMessage, level=5, logger=SIGNATURE_DEVIANCE_LOGGER) for kwname, checker in kwcheckers.iteritems(): if not checker.check(kwargs.get(kwname, None)): #raise InputParameterError("%s() got invalid parameter " #"%s of type %s" % #(method.__name__, kwname, #type_name(kwargs.get(kwname, None)))) logMessageOnce("%s() got invalid parameter " "%s of type %s" % (method.__name__, kwname, type_name(kwargs.get(kwname, None))), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) return method(*args, **kwargs)
def close(self): for key in self._memoDicts.keys(): try: self._memoDicts[key].close() except Exception, e: logMessageOnce('No memoization due to IOError (probably because some other process are writing same data): ' + str(e)) del self._memoDicts[key]
def _loadMemoized(self): self.resultLoadedFromDisk = False try: ResultsMemoizer.loadResult(self) except IOError, e: logMessageOnce( 'No memoization due to IOError (probably because some other process are writing same data): ' + str(e))
def close(self): for path in self._memoDicts.keys(): try: self.syncDict(path) self._memoDicts[path].close() except Exception as e: logMessageOnce('No memoization due to error: ' + str(e)) del self._memoDicts[path]
def __getitem__(self, memoPath): if not memoPath in self._memoDicts: memoFn = self._createPickleFn(memoPath) ensurePathExists( memoFn ) try: self._memoDicts[memoPath] = SafeDiskMirroredDict(memoFn) except Exception, e: logMessageOnce("Exception when accessing memo file '%s': %s" % (memoFn, str(e))) raise
def __getitem__(self, memoPath): if not memoPath in self._memoDicts: memoFn = self._createPickleFn(memoPath) ensurePathExists(memoFn) try: self._memoDicts[memoPath] = SafeDiskMirroredDict(memoFn) except Exception, e: logMessageOnce("Exception when accessing memo file '%s': %s" % (memoFn, str(e))) raise
def close(self): for key in self._memoDicts.keys(): try: self._memoDicts[key].close() except Exception, e: logMessageOnce( 'No memoization due to IOError (probably because some other process are writing same data): ' + str(e)) del self._memoDicts[key]
def returns_invocation_proxy(*args, **kwargs): result = method(*args, **kwargs) if not checker.check(result): #raise ReturnValueError("%s() has returned an invalid " # "value of type %s" % # (method.__name__, type_name(result))) logMessageOnce("%s() has returned an invalid " "value of type %s" % (method.__name__, type_name(result)), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) return result
def __getitem__(self, memoPath): if memoPath not in self._memoDicts: memoFn = self._createFilePath(memoPath) try: safePickleFile = SafePickleFile(memoFn) if safePickleFile.object is None: safePickleFile.object = {} safePickleFile.sync(conflictResolution='remote') self._memoDicts[memoPath] = safePickleFile except Exception as e: logMessageOnce("Exception when accessing memo file '%s': %s" % (memoFn, str(e))) raise # self._memoDicts[memoPath].sync(conflictResolution='remote', readOnly=True) return self._memoDicts[memoPath]
def returns(sometype): "Return type checking decorator" # convert decorator argument into a checker checker = Checker.create(sometype) if checker is None: if RAISE_DEVIANCES: raise ShouldNotOccurError( "@returns decorator got parameter of unsupported " "type %s" % type_name(sometype)) else: logMessageOnce("@returns decorator got parameter of unsupported " "type %s" % type_name(sometype), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) if NO_CHECK: # no type checking is performed, return decorated method itself def returns_proxy(method): return method else: def returns_proxy(method): def returns_invocation_proxy(*args, **kwargs): result = method(*args, **kwargs) if not checker.check(result): if RAISE_DEVIANCES: raise ReturnValueError( "%s() has returned an invalid " "value of type %s" % (method.__name__, type_name(result))) else: logMessageOnce("%s() has returned an invalid " "value of type %s" % (method.__name__, type_name(result)), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) return result returns_invocation_proxy.__name__ = method.__name__ return returns_invocation_proxy return returns_proxy
def takes_invocation_proxy(*args, **kwargs): # append the default parameters if method_defaults is not None and len(method_defaults) > 0 \ and len(method_args) - len(method_defaults) <= len(args) < len(method_args): args += method_defaults[len(args) - len(method_args):] # check the types of the actual call parameters for i, (arg, checker) in enumerate(zip(args, checkers)): if not checker.check(arg): if RAISE_DEVIANCES: raise InputParameterError( "%s() got invalid parameter " "%d of type %s" % (method.__name__, i + 1, type_name(arg))) else: mainMessage = "%s() got invalid parameter %d of type %s" %\ (method.__name__, i + 1, type_name(arg)) logMessageOnce(mainMessage, level=5, logger=SIGNATURE_DEVIANCE_LOGGER) for kwname, checker in kwcheckers.iteritems(): if not checker.check(kwargs.get(kwname, None)): if RAISE_DEVIANCES: raise InputParameterError( "%s() got invalid parameter " "%s of type %s" % (method.__name__, kwname, type_name(kwargs.get(kwname, None)))) else: logMessageOnce( "%s() got invalid parameter " "%s of type %s" % (method.__name__, kwname, type_name(kwargs.get(kwname, None))), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) return method(*args, **kwargs)
def returns(sometype): "Return type checking decorator" # convert decorator argument into a checker checker = Checker.create(sometype) if checker is None: #raise TypeError("@returns decorator got parameter of unsupported " # "type %s" % type_name(sometype)) logMessageOnce("@returns decorator got parameter of unsupported " "type %s" % type_name(sometype), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) if NO_CHECK: # no type checking is performed, return decorated method itself def returns_proxy(method): return method else: def returns_proxy(method): def returns_invocation_proxy(*args, **kwargs): result = method(*args, **kwargs) if not checker.check(result): #raise ReturnValueError("%s() has returned an invalid " # "value of type %s" % # (method.__name__, type_name(result))) logMessageOnce("%s() has returned an invalid " "value of type %s" % (method.__name__, type_name(result)), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) return result returns_invocation_proxy.__name__ = method.__name__ return returns_invocation_proxy return returns_proxy
def takes(*args, **kwargs): "Method signature checking decorator" # convert decorator arguments into a list of checkers checkers = [] for i, arg in enumerate(args): checker = Checker.create(arg) if checker is None: #raise TypeError("@takes decorator got parameter %d of unsupported " #"type %s" % (i + 1, type_name(arg))) logMessageOnce("@takes decorator got parameter %d of unsupported " + "type %s" % (i + 1, type_name(arg)), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) checkers.append(checker) kwcheckers = {} for kwname, kwarg in kwargs.iteritems(): checker = Checker.create(kwarg) if checker is None: #raise TypeError("@takes decorator got parameter %s of unsupported " #"type %s" % (kwname, type_name(kwarg))) logMessageOnce("@takes decorator got parameter %s of unsupported " + "type %s" % (kwname, type_name(kwarg)), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) kwcheckers[kwname] = checker if NO_CHECK: # no type checking is performed, return decorated method itself def takes_proxy(method): return method else: def takes_proxy(method): method_args, method_defaults = getargspec(method)[0::3] def takes_invocation_proxy(*args, **kwargs): # append the default parameters if method_defaults is not None and len(method_defaults) > 0 \ and len(method_args) - len(method_defaults) <= len(args) < len(method_args): args += method_defaults[len(args) - len(method_args):] # check the types of the actual call parameters for i, (arg, checker) in enumerate(zip(args, checkers)): if not checker.check(arg): #raise InputParameterError("%s() got invalid parameter " #"%d of type %s" % #(method.__name__, i + 1, #type_name(arg))) mainMessage = "%s() got invalid parameter %d of type %s" %\ (method.__name__, i + 1, type_name(arg)) logMessageOnce(mainMessage, level=5, logger=SIGNATURE_DEVIANCE_LOGGER) for kwname, checker in kwcheckers.iteritems(): if not checker.check(kwargs.get(kwname, None)): #raise InputParameterError("%s() got invalid parameter " #"%s of type %s" % #(method.__name__, kwname, #type_name(kwargs.get(kwname, None)))) logMessageOnce("%s() got invalid parameter " "%s of type %s" % (method.__name__, kwname, type_name(kwargs.get(kwname, None))), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) return method(*args, **kwargs) takes_invocation_proxy.__name__ = method.__name__ return takes_invocation_proxy return takes_proxy
def takes(*args, **kwargs): "Method signature checking decorator" # convert decorator arguments into a list of checkers checkers = [] for i, arg in enumerate(args): checker = Checker.create(arg) if checker is None: if IS_EXPERIMENTAL_INSTALLATION: raise TypeError( "@takes decorator got parameter %d of unsupported " "type %s" % (i + 1, type_name(arg))) else: logMessageOnce( "@takes decorator got parameter %d of unsupported " + "type %s" % (i + 1, type_name(arg)), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) checkers.append(checker) kwcheckers = {} for kwname, kwarg in kwargs.iteritems(): checker = Checker.create(kwarg) if checker is None: if IS_EXPERIMENTAL_INSTALLATION: raise TypeError( "@takes decorator got parameter %s of unsupported " "type %s" % (kwname, type_name(kwarg))) else: logMessageOnce( "@takes decorator got parameter %s of unsupported " + "type %s" % (kwname, type_name(kwarg)), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) kwcheckers[kwname] = checker if NO_CHECK: # no type checking is performed, return decorated method itself def takes_proxy(method): return method else: def takes_proxy(method): method_args, method_defaults = getargspec(method)[0::3] def takes_invocation_proxy(*args, **kwargs): # append the default parameters if method_defaults is not None and len(method_defaults) > 0 \ and len(method_args) - len(method_defaults) <= len(args) < len(method_args): args += method_defaults[len(args) - len(method_args):] # check the types of the actual call parameters for i, (arg, checker) in enumerate(zip(args, checkers)): if not checker.check(arg): #raise InputParameterError("%s() got invalid parameter " #"%d of type %s" % #(method.__name__, i + 1, #type_name(arg))) mainMessage = "%s() got invalid parameter %d of type %s" %\ (method.__name__, i + 1, type_name(arg)) logMessageOnce(mainMessage, level=5, logger=SIGNATURE_DEVIANCE_LOGGER) for kwname, checker in kwcheckers.iteritems(): if not checker.check(kwargs.get(kwname, None)): #raise InputParameterError("%s() got invalid parameter " #"%s of type %s" % #(method.__name__, kwname, #type_name(kwargs.get(kwname, None)))) logMessageOnce("%s() got invalid parameter " "%s of type %s" % (method.__name__, kwname, type_name(kwargs.get(kwname, None))), level=5, logger=SIGNATURE_DEVIANCE_LOGGER) return method(*args, **kwargs) takes_invocation_proxy.__name__ = method.__name__ return takes_invocation_proxy return takes_proxy
class Statistic(object): VERSION = '1.0' IS_MEMOIZABLE = True def _trace(self, methodName): if DebugConfig.TRACE_STAT[methodName]: if not hasattr(Statistic, 'objAddresses'): Statistic.objAddresses = {} if not hasattr(self, '_traceId'): if not self.__class__.__name__ in Statistic.objAddresses: Statistic.objAddresses[self.__class__.__name__] = 0 self._traceId = str( Statistic.objAddresses[self.__class__.__name__]) Statistic.objAddresses[self.__class__.__name__] += 1 message = self.__class__.__name__ + '(' + self._traceId + ').' + methodName \ + ( (' (' + str(self._region) +')') if DebugConfig.TRACE_PRINT_REGIONS else '') \ + ( ( ' (' + str(self._track.trackName) \ + (',' + str(self._track2.trackName) if hasattr(self,'_track2') else '') \ + ')' ) if DebugConfig.TRACE_PRINT_TRACK_NAMES else '') logMessage(message) print message, '<br>' def __init__(self, region, track, track2=None, *args, **kwArgs): from config.Config import IS_EXPERIMENTAL_INSTALLATION if 'isExperimental' in kwArgs: x = kwArgs['isExperimental'].lower() if not x in ['false', 'true']: logMessage('isExperimental has value other than false/true', level=logging.WARN) raise ShouldNotOccurError( 'isExperimental has value other than false/true.') if x == 'true': assert IS_EXPERIMENTAL_INSTALLATION, IS_EXPERIMENTAL_INSTALLATION #else: # assert IS_EXPERIMENTAL_INSTALLATION if 'assumptions' in kwArgs: self._checkAssumptions(kwArgs['assumptions']) self._region = region self._track = track if track2 not in [None, []]: self._track2 = track2 self._kwArgs = kwArgs self._init(**kwArgs) self._trace('__init__') #self._loadMemoized() #removed _result and _children entirely, to mark difference between not created and None/empty. #self._result = None #self._children = None def _init(self, **kwArgs): pass def _checkAssumptions(self, assumptions): pass def getDescription(self): import gold.description.StatDescriptionList as StatDescrModule statClassName = getClassName(self).replace('Unsplittable', '') #statClassName = cls.__name__ if statClassName == 'RandomizationManagerStat': assert hasattr(self, 'getRawStatisticMainClassName') statClassName += '_' + self.getRawStatisticMainClassName() if not statClassName in vars(StatDescrModule): return 'No description available.' assert type(vars(StatDescrModule)[statClassName]) is str return vars(StatDescrModule)[statClassName] @exceptionLogging(level=logging.WARNING) def _loadMemoized(self): self.resultLoadedFromDisk = False try: ResultsMemoizer.loadResult(self) except IOError, e: logMessageOnce( 'No memoization due to IOError (probably because some other process are writing same data): ' + str(e)) #raise #NB! Remove, only for debugging.. #logging.getLogger(HB_LOGGER).debug('No memoization due to IOError (probably because some other process are writing same data): ' + str(e)) except AssertionError, e: logMessageOnce( 'No memoization due to assertionError (probably missing formatConverter): ' + str(e))
def _loadMemoized(self): self.resultLoadedFromDisk = False try: ResultsMemoizer.loadResult(self) except IOError, e: logMessageOnce('No memoization due to IOError (probably because some other process are writing same data): ' + str(e))
def syncDict(self, memoPath): try: self._memoDicts[memoPath].sync(conflictResolution='local') except Exception as e: logMessageOnce('No memoization due to error: ' + str(e))