def vec3(val=None):
"""a 3-vector"""
val = val if val is not None else [0, 0, 0]
ret = [float(v) for v in val]
if len(ret) != 3:
raise ValueError('value needs to be a 3-element vector')
return readonlylist(ret)
def test_readonly_objects(self, session):
cc = session.cache
testval1 = readonlylist(('A', 'B', 'C'))
cc.put('testcache', 'rolist', testval1)
cc.flush()
rol1 = cc.get('testcache', 'rolist')
rol = cc.get_explicit('testcache', 'rolist', None)
assert rol[2] is not None
print(type(rol1), type(testval1))
assert type(rol1) == type(testval1)
assert type(rol[2]) == type(testval1)
testval2 = readonlydict((('A', 'B'), ('C', 'D')))
cc.put('testcache', 'rodict', testval2)
cc.flush()
rod = cc.get_explicit('testcache', 'rodict', None)
assert rod[2] is not None
print(type(rod[2]), type(testval2))
assert type(rod[2]) == type(testval2)
testval3 = readonlylist((testval1, testval2, 'C'))
cc.put('testcache', 'rolist2', testval3)
cc.flush()
rol = cc.get_explicit('testcache', 'rolist2', None)
assert rol[2] is not None
print(type(rol[2]), type(testval3))
assert type(rol[2]) == type(testval3)
assert type(rol[2][0]) == type(testval1)
assert type(rol[2][1]) == type(testval2)
testval4 = readonlydict((('A', testval1), ('B', testval2), ('C', 'D')))
cc.put('testcache', 'rodict2', testval4)
cc.flush()
rod = cc.get_explicit('testcache', 'rodict2', None)
assert rod[2] is not None
print(type(rod[2]), type(testval4))
assert type(rod[2]) == type(testval4)
assert type(rod[2]['A']) == type(testval1)
assert type(rod[2]['B']) == type(testval2)
def _convert(node):
if isinstance(node, (Str, Bytes)):
return node.s
elif isinstance(node, Num):
return node.n
elif isinstance(node, Tuple):
return tuple(map(_convert, node.elts))
elif isinstance(node, List):
return readonlylist(map(_convert, node.elts))
elif isinstance(node, Dict):
return readonlydict((_convert(k), _convert(v)) for k, v
in zip(node.keys, node.values))
elif isinstance(node, Set):
return frozenset(map(_convert, node.elts))
elif isinstance(node, Name):
if node.id in _safe_names:
return _safe_names[node.id]
elif isinstance(node, NameConstant):
return node.value
elif isinstance(node, UnaryOp) and \
isinstance(node.op, USub) and \
isinstance(node.operand, Name) and \
node.operand.id in _safe_names:
return -_safe_names[node.operand.id]
elif isinstance(node, UnaryOp) and \
isinstance(node.op, USub) and \
isinstance(node.operand, Num):
return -node.operand.n
elif isinstance(node, BinOp) and \
isinstance(node.op, (Add, Sub)) and \
isinstance(node.right, Num) and \
isinstance(node.right.n, complex) and \
isinstance(node.left, Num) and \
isinstance(node.left.n, number_types):
left = node.left.n
right = node.right.n
if isinstance(node.op, Add):
return left + right
else:
return left - right
elif isinstance(node, Call) and node.func.id == 'cache_unpickle':
return pickle.loads(b64decode(ast_eval(node.args[0])))
raise ValueError('malformed literal string with %s' % node)
def test_readonly_objects():
d = readonlydict({'a': 1, 'b': 2})
assert raises(TypeError, d.update, {})
# pickle Protocoll 0
unpickled = pickle.loads(pickle.dumps(d))
assert isinstance(unpickled, readonlydict)
assert len(unpickled) == 2
# pickle Protocoll 2
unpickled = pickle.loads(pickle.dumps(d, 2))
assert isinstance(unpickled, readonlydict)
assert len(unpickled) == 2
l = readonlylist([1, 2, 3])
assert raises(TypeError, l.append, 4)
# pickle Protocoll 0
unpickled = pickle.loads(pickle.dumps(l))
assert isinstance(unpickled, readonlylist)
assert len(unpickled) == 3
# pickle Protocoll 2
unpickled = pickle.loads(pickle.dumps(l, 2))
assert isinstance(unpickled, readonlylist)
assert len(unpickled) == 3
def __call__(self, val=None):
if val is None:
return readonlylist([self.conv()])
if not isinstance(val, (list, tuple)) or len(val) < 1:
raise ValueError('value needs to be a nonempty list')
return readonlylist(map(self.conv, val))
def __call__(self, val=None):
val = val if val is not None else []
if not isinstance(val, (list, tuple)):
raise ValueError('value needs to be a list')
return readonlylist(map(self.conv, val))
def __call__(self, val=None):
val = val if val is not None else []
if not isinstance(val, (list, tuple)):
raise ValueError('value needs to be a list')
return readonlylist(map(self.conv, val)) # pylint: disable=map-builtin-not-iterating
def test_readonlylist_hashable():
l = readonlylist([1, 2, 3])
assert l == [1, 2, 3]
dt = {l: 'testval'}
assert dt[readonlylist([1, 2, 3])] == 'testval'
