def weakmemoize(f):
"""Memoize ``f`` with a ``WeakKeyDictionary`` to allow the arguments
to be garbage collected.
Parameters
----------
f : callable
The function to memoize.
Returns
-------
g : callable
``f`` with weak memoiza
"""
return memoize(f, cache=WeakKeyDictionary())
def weakmemoize(f):
"""Memoize ``f`` with a ``WeakKeyDictionary`` to allow the arguments
to be garbage collected.
Parameters
----------
f : callable
The function to memoize.
Returns
-------
g : callable
``f`` with weak memoiza
"""
return memoize(f, cache=WeakKeyDictionary())
def __init_halfsummed_pn():
n = symbols('n', integer=True, positive=True)
expr = (legendre(n-1, 0)-legendre(n+1, 0))/(2*n+1)
f = memoize(lambdify(n, expr, ('math', 'mpmath', 'numpy')))
@vectorize
def summed(n, region='top'):
if n < 0:
raise ValueError("Par 'n' is invalid!")
elif n == 0:
return 1.0
elif n % 2 == 0:
return 0.0
if region == 'top':
return f(n)
elif region == 'btm':
return -f(n)
else:
raise ValueError("Par 'region' have to be 'top' or 'btm'!")
return summed
return self[key + '.each_event']
k, w = key[:i], key[i + 1:]
if w == 'each_file':
return (f[self.map(k)].value for f in self.files)
elif w == 'each_event':
return concat(f[self.map(k)] for f in self.files)
else:
raise ValueError("Key '{}' is invalid!".format(key))
try:
from dbpy import (read_hightagnumber as __read_hightagnumber,
read_taglist_byrun as __read_taglist_byrun,
read_syncdatalist_float)
from stpy import StorageReader, StorageBuffer
read_hightagnumber = curry(memoize(__read_hightagnumber))
read_taglist_byrun = curry(memoize(__read_taglist_byrun))
class _ReadonlyBuffer:
def __init__(self, buffer):
self.__buffer = buffer
@property
def data(self):
return self.__buffer.read_det_data(0)
@property
def info(self):
return self.__buffer.read_det_info(0)
class StorageWrapper:
def hightag(*args, **kwargs):
global hightag
from dbpy import read_hightagnumber
hightag = memoize(read_hightagnumber)
return hightag(*args, **kwargs)
def taglist(*args, **kwargs):
global taglist
from dbpy import read_taglist_byrun
taglist = memoize(read_taglist_byrun)
return taglist(*args, **kwargs)
def make_odd(number):
if number % 2 == 0:
return number - 1
else:
return number
def make_hashable(obj):
if isinstance(obj, np.ndarray):
return hash(obj.tobytes())
else:
return toolz.sandbox.EqualityHashKey(None, obj)
def hash_key(args, kwargs):
# return (args, hash(frozenset(kwargs.items())))
# return (map(make_hashable, args), frozenset(kwargs.items()))
args = tuple(map(make_hashable, args))
kwargs = frozenset(
map(compose(tuple, partial(map, make_hashable)), kwargs.items()))
# print('args', args)
# print('kwargs', kwargs)
return (args, kwargs)
# return (tuple(map(make_hashable, args)), frozenset(map(map(make_hashable), kwargs.items())))
# return (map(make_hashable, args), frozenset(itemmap(map(make_hashable), kwargs)))
# memoize = lambda func: cachetools.cached({}, key=hashkey)(func)
memoize = lambda func: cytoolz.memoize(key=hash_key)(func)