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_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 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))
