def iteritems_wrapper(mappingorseq):
"""Wrapper for efficient iteration over mappings represented by dicts
or sequences::
>>> for k, v in iteritems_wrapper((i, i*i) for i in xrange(5)):
... assert k*k == v
>>> for k, v in iteritems_wrapper(dict((i, i*i) for i in xrange(5))):
... assert k*k == v
"""
if hasattr(mappingorseq, "items"):
return iteritems(mappingorseq)
return mappingorseq
def iteritems_wrapper(mappingorseq):
"""Wrapper for efficient iteration over mappings represented by dicts
or sequences::
>>> for k, v in iteritems_wrapper((i, i*i) for i in xrange(5)):
... assert k*k == v
>>> for k, v in iteritems_wrapper(dict((i, i*i) for i in xrange(5))):
... assert k*k == v
"""
if hasattr(mappingorseq, "items"):
return iteritems(mappingorseq)
return mappingorseq
def get_dict(self, *keys):
key_mapping = {}
have_encoded_keys = False
for key in keys:
encoded_key = self._normalize_key(key)
if not isinstance(key, str):
have_encoded_keys = True
if _test_memcached_key(key):
key_mapping[encoded_key] = key
_keys = list(key_mapping)
d = rv = self._client.get_multi(_keys)
if have_encoded_keys or self.key_prefix:
rv = {}
for key, value in iteritems(d):
rv[key_mapping[key]] = value
if len(rv) < len(keys):
for key in keys:
if key not in rv:
rv[key] = None
return rv
def _memoize_kwargs_to_args(self, f, *args, **kwargs):
#: Inspect the arguments to the function
#: This allows the memoization to be the same
#: whether the function was called with
#: 1, b=2 is equivilant to a=1, b=2, etc.
new_args = []
arg_num = 0
# If the function uses VAR_KEYWORD type of parameters,
# we need to pass these further
kw_keys_remaining = list(kwargs.keys())
arg_names = get_arg_names(f)
args_len = len(arg_names)
for i in range(args_len):
arg_default = get_arg_default(f, i)
if i == 0 and arg_names[i] in ("self", "cls"):
#: use the repr of the class instance
#: this supports instance methods for
#: the memoized functions, giving more
#: flexibility to developers
arg = repr(args[0])
arg_num += 1
elif arg_names[i] in kwargs:
arg = kwargs[arg_names[i]]
kw_keys_remaining.pop(kw_keys_remaining.index(arg_names[i]))
elif arg_num < len(args):
arg = args[arg_num]
arg_num += 1
elif arg_default:
arg = arg_default
arg_num += 1
else:
arg = None
arg_num += 1
#: Attempt to convert all arguments to a
#: hash/id or a representation?
#: Not sure if this is necessary, since
#: using objects as keys gets tricky quickly.
# if hasattr(arg, '__class__'):
# try:
# arg = hash(arg)
# except:
# arg = repr(arg)
#: Or what about a special __cacherepr__ function
#: on an object, this allows objects to act normal
#: upon inspection, yet they can define a representation
#: that can be used to make the object unique in the
#: cache key. Given that a case comes across that
#: an object "must" be used as a cache key
# if hasattr(arg, '__cacherepr__'):
# arg = arg.__cacherepr__
new_args.append(arg)
new_args.extend(args[len(arg_names):])
return (
tuple(new_args),
OrderedDict(
sorted((k, v) for k, v in iteritems(kwargs)
if k in kw_keys_remaining)),
)
def _memoize_kwargs_to_args(self, f, *args, **kwargs):
#: Inspect the arguments to the function
#: This allows the memoization to be the same
#: whether the function was called with
#: 1, b=2 is equivilant to a=1, b=2, etc.
new_args = []
arg_num = 0
# If the function uses VAR_KEYWORD type of parameters,
# we need to pass these further
kw_keys_remaining = list(kwargs.keys())
arg_names = get_arg_names(f)
args_len = len(arg_names)
for i in range(args_len):
arg_default = get_arg_default(f, i)
if i == 0 and arg_names[i] in ("self", "cls"):
#: use the repr of the class instance
#: this supports instance methods for
#: the memoized functions, giving more
#: flexibility to developers
arg = repr(args[0])
arg_num += 1
elif arg_names[i] in kwargs:
arg = kwargs[arg_names[i]]
kw_keys_remaining.pop(kw_keys_remaining.index(arg_names[i]))
elif arg_num < len(args):
arg = args[arg_num]
arg_num += 1
elif arg_default:
arg = arg_default
arg_num += 1
else:
arg = None
arg_num += 1
#: Attempt to convert all arguments to a
#: hash/id or a representation?
#: Not sure if this is necessary, since
#: using objects as keys gets tricky quickly.
# if hasattr(arg, '__class__'):
# try:
# arg = hash(arg)
# except:
# arg = repr(arg)
#: Or what about a special __cacherepr__ function
#: on an object, this allows objects to act normal
#: upon inspection, yet they can define a representation
#: that can be used to make the object unique in the
#: cache key. Given that a case comes across that
#: an object "must" be used as a cache key
# if hasattr(arg, '__cacherepr__'):
# arg = arg.__cacherepr__
new_args.append(arg)
new_args.extend(args[len(arg_names):])
return (
tuple(new_args),
OrderedDict(
sorted(
(k, v)
for k, v in iteritems(kwargs)
if k in kw_keys_remaining
)
),
)