def effective_max_meta_size(self, meta_size):
if hasattr(self.max_meta_size, '__call__'):
max_meta_size = self.max_meta_size(meta_size)
elif isinstance(self.max_meta_size, int): # TOOD: py3 compat
max_meta_size = self.max_meta_size
log.debug('max meta size is deemed to be: %d' % max_meta_size)
return max_meta_size
def _handle_max_apps(offsets, nchunks, max_app_chunks):
""" Process and handle the 'max_app_chunks' argument
Parameters
----------
offsets: bool
if the offsets to the chunks are present
nchunks : int
the number of chunks
max_app_chunks : callable or int
the total number of possible append chunks
Returns
-------
max_app_chunks : int
the int value
Raises
------
TypeError
if 'max_app_chunks' is neither a callable or an int
ValueError
if 'max_app_chunks' is a callable and returned either a non-int or a
negative int.
Notes
-----
The 'max_app_chunks' parameter can either be a function of 'nchunks'
(callable that takes a single int as argument and returns a single int) or
an int. The sum of the resulting value and 'nchunks' can not be larger
than MAX_CHUNKS. The value of 'max_app_chunks' must be '0' if there is not
offsets section or if nchunks is unknown (has the value '-1').
The function performs some silent optimisations. First, if there are no
offsets or 'nchunks' is unknown any value for 'max_app_chunks' will be
silently ignored. Secondly, if the resulting value of max_app_chunks would
be too large, i.e. the sum of 'nchunks' and 'max_app_chunks' is larger than
'MAX_CHUNKS', then 'max_app_chunks' is automatically set to the maximum
permissible value.
"""
# first check that the args are actually valid
check_range('nchunks', nchunks, -1, MAX_CHUNKS)
# then check that we actually need to evaluate it
if offsets and nchunks != -1:
if hasattr(max_app_chunks, '__call__'):
# it's a callable all right
log.debug("max_app_chunks is a callable")
max_app_chunks = max_app_chunks(nchunks)
if not isinstance(max_app_chunks, (int, long)):
raise ValueError(
"max_app_chunks callable returned a non integer "
"of type '%s'" % type(max_app_chunks))
# check that the result is still positive, might be quite large
if max_app_chunks < 0:
raise ValueError(
'max_app_chunks callable returned a negative integer')
elif isinstance(max_app_chunks, (int, long)):
# it's a plain int, check its range
log.debug("max_app_chunks is an int")
check_range('max_app_chunks', max_app_chunks, 0, MAX_CHUNKS)
else:
raise TypeError('max_app_chunks was neither a callable or an int')
# we managed to get a reasonable value, make sure it's not too large
if nchunks + max_app_chunks > MAX_CHUNKS:
max_app_chunks = MAX_CHUNKS - nchunks
log.debug(
"max_app_chunks was too large, setting to max value: %d"
% max_app_chunks)
else:
if max_app_chunks is not None:
log.debug('max_app_chunks will be silently ignored')
max_app_chunks = 0
log.debug("max_app_chunks was set to: %d" % max_app_chunks)
return max_app_chunks
