def test_invalid_delete_op_target():
target = {'afunc': lambda x: 'hi %s' % x}
spec = T['afunc'](x=1)
with pytest.raises(ValueError):
delete(target, spec, None)
return
def _resolve_optional(rules: Dict, conf: Dict) -> Dict:
"""Go through the rules and drop optional keys that are absent in conf"""
all_nodes = _nodes(conf) # this is some superset of valid keys
for node in _optional_nodes(rules):
if node not in all_nodes:
# delete unused optional rules
delete(rules, ".".join(map(str, node)))
return rules
def test_sequence_delete():
target = {'alist': [0, 1, 2]}
delete(target, 'alist.1')
assert target['alist'] == [0, 2]
with pytest.raises(PathDeleteError, match='could not delete') as exc_info:
delete(target, 'alist.2')
exc_repr = repr(exc_info.value)
assert exc_repr.startswith('PathDeleteError(')
assert exc_repr.endswith("'2')")
return
def unset(self, target):
target = self._sanitize_target(target)
glom.delete(self.config_data, target, ignore_missing=True)
with open(self.config_path, "w") as f:
yaml.dump(
self.config_data,
stream=f,
Dumper=IndentListDumper,
default_flow_style=False,
sort_keys=False,
)
def reset(meta, spec=None) -> dict:
"""
Set metadata in a dataframe columns
:param meta: Meta data to be modified
:param spec: path to the key to be modified
:param value: dict value
:param missing:
:return:
"""
if spec is not None:
data = copy.deepcopy(meta)
delete(data, spec, ignore_missing=True)
else:
data = meta
return data
def test_delete():
class Foo(object):
def __init__(self, d=None):
for k, v in d.items():
setattr(self, k, v)
assert glom({'a': 1}, Delete(T['a'])) == {}
assert glom({'a': {'a': 1}}, Delete(T['a']['a'])) == {'a': {}}
assert glom({'a': {'a': 1}}, Delete('a.a')) == {'a': {}}
assert not hasattr(glom(Foo({'a': 1}), Delete(T.a)), 'a')
assert glom({'a': 1}, Delete('a')) == {}
assert not hasattr(glom(Foo({'a': 1}), Delete('a')), 'a')
assert not hasattr(glom({'a': Foo({'a': 1})}, Delete('a.a'))['a'], 'a')
def r():
r = {}
r['r'] = r
return r
assert glom(r(), Delete('r.r.r.r.r.r.r.r.r')) == {}
assert glom(r(), Delete(T['r']['r']['r']['r'])) == {}
assert glom(r(), Delete(Path('r', 'r', T['r']))) == {}
assert delete(r(), Path('r', 'r', T['r'])) == {}
with pytest.raises(TypeError, match='path argument must be'):
Delete(1, 'a')
with pytest.raises(ValueError,
match='path must have at least one element'):
Delete(T, 1)
assert repr(Delete(T.a)) == 'Delete(T.a)'
def test_bad_delete_target():
class BadTarget(object):
def __delattr__(self, name):
raise Exception("and you trusted me?")
spec = Delete('a')
ok_target = lambda: None
ok_target.a = 1
glom(ok_target, spec)
assert not hasattr(ok_target, 'a')
with pytest.raises(PathDeleteError, match='could not delete'):
glom(BadTarget(), spec)
with pytest.raises(PathDeleteError, match='could not delete'):
delete({}, 'a')
return
def test_delete():
class Foo(object):
def __init__(self, d=None):
for k, v in d.items():
setattr(self, k, v)
assert glom({'a': 1}, Delete(T['a'])) == {}
assert glom({'a': {'a': 1}}, Delete(T['a']['a'])) == {'a': {}}
assert glom({'a': {'a': 1}}, Delete('a.a')) == {'a': {}}
assert not hasattr(glom(Foo({'a': 1}), Delete(T.a)), 'a')
assert glom({'a': 1}, Delete('a')) == {}
assert not hasattr(glom(Foo({'a': 1}), Delete('a')), 'a')
assert not hasattr(glom({'a': Foo({'a': 1})}, Delete('a.a'))['a'], 'a')
def r():
r = {}
r['r'] = r
return r
assert glom(r(), Delete('r.r.r.r.r.r.r.r.r')) == {}
assert glom(r(), Delete(T['r']['r']['r']['r'])) == {}
assert glom(r(), Delete(Path('r', 'r', T['r']))) == {}
assert delete(r(), Path('r', 'r', T['r'])) == {}
with pytest.raises(TypeError, match='path argument must be'):
Delete(1, 'a')
with pytest.raises(ValueError,
match='path must have at least one element'):
Delete(T, 1)
assert repr(Delete(T.a)) == 'Delete(T.a)'
# test delete from scope
assert glom(1, (S(x=T), S['x'])) == 1
with pytest.raises(PathAccessError):
glom(1, (S(x=T), Delete(S['x']), S['x']))
# test raising on missing parent
with pytest.raises(PathAccessError):
glom({}, Delete(T['a']['b']))
# test raising on missing index
with pytest.raises(PathDeleteError):
glom([], Delete(T[0]))
target = []
assert glom(target, Delete(T[0], ignore_missing=True)) is target
# test raising on missing attr
with pytest.raises(PathDeleteError):
glom(object(), Delete(T.does_not_exist))
target = object()
assert glom(target, Delete(T.does_not_exist,
ignore_missing=True)) is target
def delete_user_pref(self, k):
new_data = glom.delete(self.data, k, ignore_missing=True)
write_user_prefs(self.username, new_data)
def test_delete_ignore_missing():
assert delete({}, 'a', ignore_missing=True) == {}
assert delete({}, 'a.b', ignore_missing=True) == {}
