Remove references to dpath.util in tests

Author: moomoohk

dpath/__init__.py

@@ -186,7 +186,7 @@ def f(_, pair, results):
 
         raise KeyError(glob)
     elif len(results) > 1:
-        raise ValueError(f"dpath.util.get() globs must match only one leaf: {glob}")
+        raise ValueError(f"dpath.get() globs must match only one leaf: {glob}")
 
     return results[0]
 

dpath/util.py

@@ -1,9 +1,8 @@
 import warnings
-from typing import Any, Dict
 
 import dpath
 from dpath import _DEFAULT_SENTINEL
-from dpath.types import Filter, Creator, MergeType
+from dpath.types import MergeType
 
 
 def deprecated(func):
@@ -18,35 +17,35 @@ def wrapper(*args, **kwargs):
 
 
 @deprecated
-def new(obj: Dict, path: str, value, separator="/", creator: Creator = None) -> Dict:
+def new(obj, path, value, separator="/", creator=None):
     return dpath.new(obj, path, value, separator, creator)
 
 
 @deprecated
-def delete(obj: Dict, glob: str, separator="/", afilter: Filter = None) -> int:
+def delete(obj, glob, separator="/", afilter=None):
     return dpath.delete(obj, glob, separator, afilter)
 
 
 @deprecated
-def set(obj: Dict, glob: str, value, separator="/", afilter: Filter = None) -> int:
+def set(obj, glob, value, separator="/", afilter=None):
     return dpath.set(obj, glob, value, separator, afilter)
 
 
 @deprecated
-def get(obj: Dict, glob: str, separator="/", default: Any = _DEFAULT_SENTINEL) -> Dict:
+def get(obj, glob, separator="/", default=_DEFAULT_SENTINEL):
     return dpath.get(obj, glob, separator, default)
 
 
 @deprecated
-def values(obj: Dict, glob: str, separator="/", afilter: Filter = None, dirs=True):
+def values(obj, glob, separator="/", afilter=None, dirs=True):
     return dpath.values(obj, glob, separator, afilter, dirs)
 
 
 @deprecated
-def search(obj: Dict, glob: str, yielded=False, separator="/", afilter: Filter = None, dirs=True):
+def search(obj, glob, yielded=False, separator="/", afilter = None, dirs=True):
     return dpath.search(obj, glob, yielded, separator, afilter, dirs)
 
 
 @deprecated
-def merge(dst: Dict, src: Dict, separator="/", afilter: Filter = None, flags=MergeType.ADDITIVE):
+def merge(dst, src, separator="/", afilter=None, flags=MergeType.ADDITIVE):
     return dpath.merge(dst, src, separator, afilter, flags),

tests/test_broken_afilter.py

@@ -1,4 +1,4 @@
-import dpath.util
+import dpath
 import sys
 
 
@@ -25,15 +25,15 @@ def afilter(x):
         'a/b/c/f',
     ]
 
-    for (path, value) in dpath.util.search(dict, '/**', yielded=True, afilter=afilter):
+    for (path, value) in dpath.search(dict, '/**', yielded=True, afilter=afilter):
         assert path in paths
-    assert "view_failure" not in dpath.util.search(dict, '/**', afilter=afilter)['a']
-    assert "d" not in dpath.util.search(dict, '/**', afilter=afilter)['a']['b']['c']
+    assert "view_failure" not in dpath.search(dict, '/**', afilter=afilter)['a']
+    assert "d" not in dpath.search(dict, '/**', afilter=afilter)['a']['b']['c']
 
-    for (path, value) in dpath.util.search(dict, ['**'], yielded=True, afilter=afilter):
+    for (path, value) in dpath.search(dict, ['**'], yielded=True, afilter=afilter):
         assert path in paths
-    assert "view_failure" not in dpath.util.search(dict, ['**'], afilter=afilter)['a']
-    assert "d" not in dpath.util.search(dict, ['**'], afilter=afilter)['a']['b']['c']
+    assert "view_failure" not in dpath.search(dict, ['**'], afilter=afilter)['a']
+    assert "d" not in dpath.search(dict, ['**'], afilter=afilter)['a']['b']['c']
 
     def filter(x):
         sys.stderr.write(str(x))
@@ -52,7 +52,7 @@ def filter(x):
         ],
     }
 
-    results = [[x[0], x[1]] for x in dpath.util.search(a, 'actions/*', yielded=True)]
-    results = [[x[0], x[1]] for x in dpath.util.search(a, 'actions/*', afilter=filter, yielded=True)]
+    results = [[x[0], x[1]] for x in dpath.search(a, 'actions/*', yielded=True)]
+    results = [[x[0], x[1]] for x in dpath.search(a, 'actions/*', afilter=filter, yielded=True)]
     assert len(results) == 1
     assert results[0][1]['type'] == 'correct'

tests/test_util_delete.py tests/test_delete.pytests/test_util_delete.py renamed to tests/test_delete.py

@@ -1,6 +1,6 @@
 from nose2.tools.such import helper
 
-import dpath.util
+import dpath
 import dpath.exceptions
 
 
@@ -11,7 +11,7 @@ def test_delete_separator():
         },
     }
 
-    dpath.util.delete(dict, ';a;b', separator=";")
+    dpath.delete(dict, ';a;b', separator=";")
     assert 'b' not in dict['a']
 
 
@@ -22,7 +22,7 @@ def test_delete_existing():
         },
     }
 
-    dpath.util.delete(dict, '/a/b')
+    dpath.delete(dict, '/a/b')
     assert 'b' not in dict['a']
 
 
@@ -33,7 +33,7 @@ def test_delete_missing():
     }
 
     with helper.assertRaises(dpath.exceptions.PathNotFound):
-        dpath.util.delete(dict, '/a/b')
+        dpath.delete(dict, '/a/b')
 
 
 def test_delete_filter():
@@ -50,7 +50,7 @@ def afilter(x):
         },
     }
 
-    dpath.util.delete(dict, '/a/*', afilter=afilter)
+    dpath.delete(dict, '/a/*', afilter=afilter)
     assert dict['a']['b'] == 0
     assert dict['a']['c'] == 1
     assert 'd' not in dict['a']

tests/test_util_get_values.py tests/test_get_values.pytests/test_util_get_values.py renamed to tests/test_get_values.py

@@ -5,16 +5,16 @@
 import mock
 from nose2.tools.such import helper
 
-import dpath.util
+import dpath
 
 
 def test_util_get_root():
     x = {'p': {'a': {'t': {'h': 'value'}}}}
 
-    ret = dpath.util.get(x, '/p/a/t/h')
+    ret = dpath.get(x, '/p/a/t/h')
     assert ret == 'value'
 
-    ret = dpath.util.get(x, '/')
+    ret = dpath.get(x, '/')
     assert ret == x
 
 
@@ -31,11 +31,11 @@ def test_get_explicit_single():
         },
     }
 
-    assert dpath.util.get(ehash, '/a/b/c/f') == 2
-    assert dpath.util.get(ehash, ['a', 'b', 'c', 'f']) == 2
-    assert dpath.util.get(ehash, ['a', 'b', 'c', 'f'], default=5) == 2
-    assert dpath.util.get(ehash, ['does', 'not', 'exist'], default=None) is None
-    assert dpath.util.get(ehash, ['doesnt', 'exist'], default=5) == 5
+    assert dpath.get(ehash, '/a/b/c/f') == 2
+    assert dpath.get(ehash, ['a', 'b', 'c', 'f']) == 2
+    assert dpath.get(ehash, ['a', 'b', 'c', 'f'], default=5) == 2
+    assert dpath.get(ehash, ['does', 'not', 'exist'], default=None) is None
+    assert dpath.get(ehash, ['doesnt', 'exist'], default=5) == 5
 
 
 def test_get_glob_single():
@@ -51,10 +51,10 @@ def test_get_glob_single():
         },
     }
 
-    assert dpath.util.get(ehash, '/a/b/*/f') == 2
-    assert dpath.util.get(ehash, ['a', 'b', '*', 'f']) == 2
-    assert dpath.util.get(ehash, ['a', 'b', '*', 'f'], default=5) == 2
-    assert dpath.util.get(ehash, ['doesnt', '*', 'exist'], default=6) == 6
+    assert dpath.get(ehash, '/a/b/*/f') == 2
+    assert dpath.get(ehash, ['a', 'b', '*', 'f']) == 2
+    assert dpath.get(ehash, ['a', 'b', '*', 'f'], default=5) == 2
+    assert dpath.get(ehash, ['doesnt', '*', 'exist'], default=6) == 6
 
 
 def test_get_glob_multiple():
@@ -71,16 +71,16 @@ def test_get_glob_multiple():
         },
     }
 
-    helper.assertRaises(ValueError, dpath.util.get, ehash, '/a/b/*/d')
-    helper.assertRaises(ValueError, dpath.util.get, ehash, ['a', 'b', '*', 'd'])
-    helper.assertRaises(ValueError, dpath.util.get, ehash, ['a', 'b', '*', 'd'], default=3)
+    helper.assertRaises(ValueError, dpath.get, ehash, '/a/b/*/d')
+    helper.assertRaises(ValueError, dpath.get, ehash, ['a', 'b', '*', 'd'])
+    helper.assertRaises(ValueError, dpath.get, ehash, ['a', 'b', '*', 'd'], default=3)
 
 
 def test_get_absent():
     ehash = {}
 
-    helper.assertRaises(KeyError, dpath.util.get, ehash, '/a/b/c/d/f')
-    helper.assertRaises(KeyError, dpath.util.get, ehash, ['a', 'b', 'c', 'd', 'f'])
+    helper.assertRaises(KeyError, dpath.get, ehash, '/a/b/c/d/f')
+    helper.assertRaises(KeyError, dpath.get, ehash, ['a', 'b', 'c', 'd', 'f'])
 
 
 def test_values():
@@ -96,13 +96,13 @@ def test_values():
         },
     }
 
-    ret = dpath.util.values(ehash, '/a/b/c/*')
+    ret = dpath.values(ehash, '/a/b/c/*')
     assert isinstance(ret, list)
     assert 0 in ret
     assert 1 in ret
     assert 2 in ret
 
-    ret = dpath.util.values(ehash, ['a', 'b', 'c', '*'])
+    ret = dpath.values(ehash, ['a', 'b', 'c', '*'])
     assert isinstance(ret, list)
     assert 0 in ret
     assert 1 in ret
@@ -116,17 +116,17 @@ def test_values_passes_through(searchfunc):
     def y():
         return False
 
-    dpath.util.values({}, '/a/b', ':', y, False)
+    dpath.values({}, '/a/b', ':', y, False)
     searchfunc.assert_called_with({}, '/a/b', True, ':', y, False)
 
-    dpath.util.values({}, ['a', 'b'], ':', y, False)
+    dpath.values({}, ['a', 'b'], ':', y, False)
     searchfunc.assert_called_with({}, ['a', 'b'], True, ':', y, False)
 
 
 def test_none_values():
     d = {'p': {'a': {'t': {'h': None}}}}
 
-    v = dpath.util.get(d, 'p/a/t/h')
+    v = dpath.get(d, 'p/a/t/h')
     assert v is None
 
 
@@ -142,7 +142,7 @@ def test_values_list():
         ],
     }
 
-    ret = dpath.util.values(a, 'actions/*')
+    ret = dpath.values(a, 'actions/*')
     assert isinstance(ret, list)
     assert len(ret) == 2
 
@@ -174,18 +174,18 @@ def func(x):
     }
 
     # It should be possible to get the callables:
-    assert dpath.util.get(testdict, 'a') == func
-    assert dpath.util.get(testdict, 'b')(42) == 42
+    assert dpath.get(testdict, 'a') == func
+    assert dpath.get(testdict, 'b')(42) == 42
 
     # It should be possible to get other values:
-    assert dpath.util.get(testdict, 'c/0') == testdict['c'][0]
-    assert dpath.util.get(testdict, 'd')[0] == testdict['d'][0]
-    assert dpath.util.get(testdict, 'd/0') == testdict['d'][0]
-    assert dpath.util.get(testdict, 'd/1') == testdict['d'][1]
-    assert dpath.util.get(testdict, 'e') == testdict['e']
+    assert dpath.get(testdict, 'c/0') == testdict['c'][0]
+    assert dpath.get(testdict, 'd')[0] == testdict['d'][0]
+    assert dpath.get(testdict, 'd/0') == testdict['d'][0]
+    assert dpath.get(testdict, 'd/1') == testdict['d'][1]
+    assert dpath.get(testdict, 'e') == testdict['e']
 
     # Values should also still work:
-    assert dpath.util.values(testdict, 'f/config') == ['something']
+    assert dpath.values(testdict, 'f/config') == ['something']
 
     # Data classes should also be retrievable:
     try:
@@ -207,4 +207,4 @@ class Connection:
         ),
     }
 
-    assert dpath.util.search(testdict, 'g/my*')['g']['my-key'] == testdict['g']['my-key']
+    assert dpath.search(testdict, 'g/my*')['g']['my-key'] == testdict['g']['my-key']