def test_flatten_a(self): '''Structure: [].''' structure_a = [1, 2, 3] structure_a_flat = { None: structure_a, 'some.path': [{'some.path': [1, 2, 3]}] } (nested, flat) = (structure_a, structure_a_flat) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None]) ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), nested ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path']) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=2 )), sorted(flat['some.path']) )
def test_flatten_s(self): '''Structure: 1.''' structure_s = 1 structure_s_flat = { None: structure_s, 'some.path': [{'some.path': 1}] } (nested, flat) = (structure_s, structure_s_flat) self.assertEqual( flatten.flatten(nested), flat[None] ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), nested ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path']) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=2 )), sorted(flat['some.path']) )
def prune_branches( self, source, balanced=False, require_serializable=False ): '''Prune source and return the branches matching the prune specs. Arguments: balanced (bool): If True, the superset of all keys that occur in any branch will be included in all branches returned. If a branch was missing one of these keys it will be added with a placeholder value of None. Thus all the dicts in the list returned will have an identical set of keys. require_serializable (bool): This will be passed through to flatten. If True, flatten raises an exception if an unserializable value is encountered. Returns: (list of dicts): A flattened list of dicts with keys derived from prune_spec paths for the pruner and values the corresponding leaf values for those paths. ''' pruned = self.get_subtree( source ) trace("PRUNED: %s" % pruned) flatten_leaves_path_prefix = [ dotpath(ps['path'], no_lists=True) for ps in self.prune_specs if 'flatten_leaves' in ps and ps['flatten_leaves'] ] pruned = flatten.flatten( pruned, flatten_leaves=flatten_leaves_path_prefix, require_serializable=require_serializable ) if balanced: all_keys = { dotpath(ps['path'], no_lists=True): None for ps in self.prune_specs } if pruned is None or pruned == []: pruned = [{}] pruned = [dict(all_keys, **p) for p in pruned] return pruned
def test_flatten_d_saa(self): '''Structure: {1, [], []}.''' structure_d_saa = { 's': 'S', 'a': [1, 3, 3], 'b': [4, 5, 6] } structure_d_saa_flat = { None: [ structure_d_saa, [structure_d_saa], ], 'some.path': [ structure_d_saa, [{ 'some.path.s': 'S', 'some.path.a': [1, 3, 3], 'some.path.b': [4, 5, 6] }] ], } (nested, flat) = (structure_d_saa, structure_d_saa_flat) self.assertEqual( sorted(flatten.flatten(nested, to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None][1]) ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), sorted(flat['some.path'][0]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten(nested, path_prefix='some.path')), sorted(flat['some.path'][1]) )
def test_flatten_d(self): '''Structure: {}.''' structure_d = {'a': 1, 'b': 2} structure_d_flat = { None: [structure_d], 'some.path': [ {'some.path.a': 1, 'some.path.b': 2} ] } (nested, flat) = (structure_d, structure_d_flat) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None]) ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), nested ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path']) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=2 )), sorted(flat['some.path']) )
def test_flatten_a_d(self): '''Structure: [{}].''' structure_a_d = [ {'a': 1, 'b': 2}, {'a': 3, 'b': 4} ] structure_a_d_flat = { None: [ structure_a_d, structure_a_d, ], 'some.path': [ structure_a_d, [ {'some.path.a': 1, 'some.path.b': 2}, {'some.path.a': 3, 'some.path.b': 4}, ], ], } (nested, flat) = (structure_a_d, structure_a_d_flat) self.assertEqual( sorted(flatten.flatten(nested, to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None][1]) ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), sorted(flat['some.path'][0]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten(nested, path_prefix='some.path')), sorted(flat['some.path'][1]) )
def test_flatten_a_ad(self): '''Structure: [[], {}].''' structure_a_ad = [ {'a': 1, 'b': 2}, ['k', 'l'] ] structure_a_ad_flat = { None: [ structure_a_ad, [{'a': 1, 'b': 2}, 'k', 'l'] ], 'some.path': [ structure_a_ad, [] ], } (nested, flat) = (structure_a_ad, structure_a_ad_flat) with self.assertRaises(TypeError): self.assertEqual( sorted(flatten.flatten(nested, to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=0 )), sorted(flat['some.path'][0]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten(nested, path_prefix='some.path')), sorted(flat['some.path'][1]) )
def test_flatten_a_aa(self): '''Structure: [[], []].''' structure_a_aa = [['a', 'b'], [3, 4]] structure_a_aa_flat = { None: [ structure_a_aa, ['a', 'b', 3, 4], ], 'some.path': [ structure_a_aa, [{'some.path': ['a', 'b', 3, 4]}] ], } (nested, flat) = (structure_a_aa, structure_a_aa_flat) self.assertEqual( sorted(flatten.flatten(nested, to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=0 )), sorted(flat['some.path'][0]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten(nested, path_prefix='some.path')), sorted(flat['some.path'][1]) )
def extract_from(self, informers, flat=True): '''Extract the fields specified by prune_specs. Arguments: informers (list of AWSInformer): ``AWSInformer`` instances from which to extract report data. Any informer whose ``entity_type`` attribute doesn't match the report definition's ``entity_type`` attribute will be skipped. flat (bool): If ``True``, return a *flat* result; if ``False``, return a nested result. See the documentation for ``utensils.prune`` and ``utensils.flatten`` for more information. ''' pruner = prune.Pruner(*self.prune_specs) extractable_informers = [ i for i in informers if i.entity_type == self.entity_type ] if flat: records = flatten.flatten([ pruner.prune_branches(informer.to_dict(), balanced=True) for informer in extractable_informers ]) else: records = [ pruner.prune_tree(informer.to_dict()) for informer in extractable_informers ] return records
def test_flatten_deep1(self): '''Structure: {{[{}, {}}],[{, {}}]}}.''' structure_deep1 = { 'a': [ {'x': 1, 'y': 2}, {'x': 11, 'y': 12} ], 'b': [ {'x': 3, 'y': 4}, {'x': 13, 'y': 14} ] } structure_deep1_flat = { None: [ structure_deep1, [structure_deep1], [ { 'a.x': 1, 'a.y': 2, 'b.x': 3, 'b.y': 4 }, { 'a.x': 1, 'a.y': 2, 'b.x': 13, 'b.y': 14 }, { 'a.x': 11, 'a.y': 12, 'b.x': 3, 'b.y': 4 }, { 'a.x': 11, 'a.y': 12, 'b.x': 13, 'b.y': 14 } ], ], 'some.path': [ structure_deep1, [{ 'some.path.a': [ {'x': 1, 'y': 2}, {'x': 11, 'y': 12} ], 'some.path.b': [ {'x': 3, 'y': 4}, {'x': 13, 'y': 14} ] }], [ { 'some.path.a.x': 1, 'some.path.a.y': 2, 'some.path.b.x': 3, 'some.path.b.y': 4 }, { 'some.path.a.x': 1, 'some.path.a.y': 2, 'some.path.b.x': 13, 'some.path.b.y': 14 }, { 'some.path.a.x': 11, 'some.path.a.y': 12, 'some.path.b.x': 3, 'some.path.b.y': 4 }, { 'some.path.a.x': 11, 'some.path.a.y': 12, 'some.path.b.x': 13, 'some.path.b.y': 14 } ], ], } (nested, flat) = (structure_deep1, structure_deep1_flat) self.assertEqual( sorted(flatten.flatten(nested, to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=2)), sorted(flat[None][2]) ) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None][2]) ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), sorted(flat['some.path'][0]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=2 )), sorted(flat['some.path'][2]) ) self.assertEqual( sorted(flatten.flatten(nested, path_prefix='some.path')), sorted(flat['some.path'][2]) )
def test_flatten_d_saadd(self): '''Structure: {1, [], [], {}, {}}.''' structure_d_saadd = { 's': 'S', 'u': {'a': 1, 'b': 2}, 'v': {'c': 3, 'd': 4}, 'x': ['k', 'l', 'm'], 'y': ['n', 'o'] } structure_d_saadd_flat = { None: [ structure_d_saadd, [structure_d_saadd], [{ 's': 'S', 'u.a': 1, 'u.b': 2, 'v.d': 4, 'v.c': 3, 'y': ['n', 'o'], 'x': ['k', 'l', 'm'] }] ], 'some.path': [ structure_d_saadd, [{ 'some.path.s': 'S', 'some.path.u': {'a': 1, 'b': 2}, 'some.path.v': {'c': 3, 'd': 4}, 'some.path.x': ['k', 'l', 'm'], 'some.path.y': ['n', 'o'] }], [{ 'some.path.s': 'S', 'some.path.u.a': 1, 'some.path.u.b': 2, 'some.path.v.d': 4, 'some.path.v.c': 3, 'some.path.y': ['n', 'o'], 'some.path.x': ['k', 'l', 'm'] }] ], } (nested, flat) = (structure_d_saadd, structure_d_saadd_flat) self.assertEqual( sorted(flatten.flatten(nested, to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=2)), sorted(flat[None][2]) ) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None][2]) ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), sorted(flat['some.path'][0]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=2 )), sorted(flat['some.path'][2]) ) self.assertEqual( sorted(flatten.flatten(nested, path_prefix='some.path')), sorted(flat['some.path'][2]) )
def test_flatten_d_ad(self): '''Structure: {[], {}}.''' structure_d_ad = { 'u': {'a': 1, 'b': 2}, 'y': ['n', 'o'] } structure_d_ad_flat = { None: [ structure_d_ad, [structure_d_ad], [{'u.a': 1, 'u.b': 2, 'y': ['n', 'o']}], ], 'some.path': [ structure_d_ad, [{ 'some.path.u': {'a': 1, 'b': 2}, 'some.path.y': ['n', 'o']}], [{ 'some.path.u.a': 1, 'some.path.u.b': 2, 'some.path.y': ['n', 'o'] }], ], } (nested, flat) = (structure_d_ad, structure_d_ad_flat) self.assertEqual( sorted(flatten.flatten(nested, to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=2)), sorted(flat[None][2]) ) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None][2]) ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), sorted(flat['some.path'][0]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=2 )), sorted(flat['some.path'][2]) ) self.assertEqual( sorted(flatten.flatten(nested, path_prefix='some.path')), sorted(flat['some.path'][2]) )
def test_flatten_d_aa(self): '''Structure: {[], []}.''' structure_d_aa = { 'a': [1, 3, 3], 'b': [4, 5, 6] } structure_d_aa_flat = { None: [ structure_d_aa, [{'a': [1, 3, 3], 'b': [4, 5, 6]}] ], 'some.path': [ structure_d_aa, [{'some.path.a': [1, 3, 3], 'some.path.b': [4, 5, 6]}], ], 'flat_leaves': [ structure_d_aa, [ {'a': 1, 'b': 4}, {'a': 1, 'b': 5}, {'a': 1, 'b': 6}, {'a': 3, 'b': 4}, {'a': 3, 'b': 5}, {'a': 3, 'b': 6}, {'a': 3, 'b': 4}, {'a': 3, 'b': 5}, {'a': 3, 'b': 6} ], ], } (nested, flat) = (structure_d_aa, structure_d_aa_flat) self.assertEqual( sorted(flatten.flatten(nested, to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=2)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None][1]) ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), sorted(flat['some.path'][0]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=2 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten(nested, path_prefix='some.path')), sorted(flat['some.path'][1]) ) # self.assertEqual( # sorted(flatten.flatten(nested, flatten_leaves=True, to_depth=0)), # sorted(flat['flat_leaves'][0]) # ) self.assertEqual( sorted(flatten.flatten(nested, flatten_leaves=True)), sorted(flat['flat_leaves'][1]) )
def test_flatten_d_saadd_with_separator(self): '''Structure: {1, [], [], {}, {}}.''' structure_d_saadd = { 's': 'S', 'u': {'a': 1, 'b': 2}, 'v': {'c': 3, 'd': 4}, 'x': ['k', 'l', 'm'], 'y': ['n', 'o'] } structure_d_saadd_flat = { None: [ structure_d_saadd, [structure_d_saadd], [{ 's': 'S', 'u:a': 1, 'u:b': 2, 'v:d': 4, 'v:c': 3, 'y': ['n', 'o'], 'x': ['k', 'l', 'm'] }] ], 'some:path': [ structure_d_saadd, [{ 'some:path:s': 'S', 'some:path:u': {'a': 1, 'b': 2}, 'some:path:v': {'c': 3, 'd': 4}, 'some:path:x': ['k', 'l', 'm'], 'some:path:y': ['n', 'o'] }], # [{ # 'some:path:s': 'S', # 'some:path:u:a': 1, 'some:path:u:b': 2, # 'some:path:v:d': 4, 'some:path:v:c': 3, # 'some:path.y': ['n', 'o'], # 'some:path.x': ['k', 'l', 'm'] # }] [{ 'some:path:v:d': 4, 'some:path:u:b': 2, 'some:path:u:a': 1, 'some:path:x': ['k', 'l', 'm'], 'some:path:y': ['n', 'o'], 'some:path:s': 'S', 'some:path:v:c': 3, }] ], } (nested, flat) = (structure_d_saadd, structure_d_saadd_flat) self.assertEqual( sorted(flatten.flatten(nested, separator=':', to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, separator=':', to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested, separator=':', to_depth=2)), sorted(flat[None][2]) ) self.assertEqual( sorted(flatten.flatten(nested, separator=':')), sorted(flat[None][2]) ) self.assertEqual( flatten.flatten( nested, separator=':', path_prefix='some:path', to_depth=0 ), sorted(flat['some:path'][0]) ) self.assertEqual( sorted(flatten.flatten( nested, separator=':', path_prefix='some:path', to_depth=1 )), sorted(flat['some:path'][1]) ) self.assertEqual( sorted(flatten.flatten( nested, separator=':', path_prefix='some:path', to_depth=2 )), sorted(flat['some:path'][2]) ) self.assertEqual( sorted(flatten.flatten( nested, separator=':', path_prefix='some:path' )), sorted(flat['some:path'][2]) )
import unittest import json # import random from boogio import aws_informer from boogio import site_boogio from boogio.utensils import flatten # Sharing this will mean reducing fetch time when the same resources are needed # in multiple test cases. GLOBAL_MEDIATOR = aws_informer.AWSMediator( region_name=site_boogio.test_region_name, profile_name=site_boogio.test_profile_name) FLATTEN_COLLAPSES = (flatten.flatten({'a': {'b': {}}, 'c': 1}) == []) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - class TestAWSInformerJSONDumps(unittest.TestCase): '''Basic test cases for AWSInformer and subclasses JSON output.''' # Some of the test case function names get pretty long. # pylint: disable=invalid-name # TODO: Add skiptest based on os.environ['TEST_DURATION_LIMIT'] # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @classmethod def setUpClass(cls): '''Test class level common fixture.'''
def test_flatten_deep2(self): '''Structure: {[{}, {}], [{}, {}], 1, 1}.''' structure_deep2 = { 'a': [ {'x': 1, 'y': 2}, {'x': 11, 'y': 12} ], 'b': [ {'x': 3, 'y': 4}, {'x': 13, 'y': 14} ], 'c': 42, 'd': 66 } structure_deep2_flat = { None: [ structure_deep2, [structure_deep2], [ { 'a.x': 1, 'a.y': 2, 'b.x': 3, 'b.y': 4, 'c': 42, 'd': 66 }, { 'a.x': 1, 'a.y': 2, 'b.x': 13, 'b.y': 14, 'c': 42, 'd': 66 }, { 'a.x': 11, 'a.y': 12, 'b.x': 3, 'b.y': 4, 'c': 42, 'd': 66 }, { 'a.x': 11, 'a.y': 12, 'b.x': 13, 'b.y': 14, 'c': 42, 'd': 66 } ] ], 'some.path': [ structure_deep2, [{ 'some.path.a': [ {'x': 1, 'y': 2}, {'x': 11, 'y': 12} ], 'some.path.b': [ {'x': 3, 'y': 4}, {'x': 13, 'y': 14} ], 'some.path.c': 42, 'some.path.d': 66 }], [ { 'some.path.a.x': 1, 'some.path.a.y': 2, 'some.path.b.x': 3, 'some.path.b.y': 4, 'some.path.c': 42, 'some.path.d': 66 }, { 'some.path.a.x': 1, 'some.path.a.y': 2, 'some.path.b.x': 13, 'some.path.b.y': 14, 'some.path.c': 42, 'some.path.d': 66 }, { 'some.path.a.x': 11, 'some.path.a.y': 12, 'some.path.b.x': 3, 'some.path.b.y': 4, 'some.path.c': 42, 'some.path.d': 66 }, { 'some.path.a.x': 11, 'some.path.a.y': 12, 'some.path.b.x': 13, 'some.path.b.y': 14, 'some.path.c': 42, 'some.path.d': 66 } ], ], } (nested, flat) = (structure_deep2, structure_deep2_flat) self.assertEqual( sorted(flatten.flatten(nested, to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=2)), sorted(flat[None][2]) ) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None][2]) ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), sorted(flat['some.path'][0]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=2 )), sorted(flat['some.path'][2]) ) self.assertEqual( sorted(flatten.flatten(nested, path_prefix='some.path')), sorted(flat['some.path'][2]) )
def test_flatten_d_dd(self): '''Structure: {{}, {}}.''' structure_d_dd = { 'u': {'a': 1, 'b': 2}, 'v': {'a': 3, 'b': 4} } structure_d_dd_flat = { None: [ structure_d_dd, [{'u': {'a': 1, 'b': 2}, 'v': {'a': 3, 'b': 4}}], [{'u.a': 1, 'u.b': 2, 'v.a': 3, 'v.b': 4}] ], 'some.path': [ structure_d_dd, [{ 'some.path.u': {'a': 1, 'b': 2}, 'some.path.v': {'a': 3, 'b': 4} }], [{ 'some.path.u.a': 1, 'some.path.u.b': 2, 'some.path.v.a': 3, 'some.path.v.b': 4 }] ] } (nested, flat) = (structure_d_dd, structure_d_dd_flat) self.assertEqual( sorted(flatten.flatten(nested, to_depth=0)), sorted(flat[None][0]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=1)), sorted(flat[None][1]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=2)), sorted(flat[None][2]) ) self.assertEqual( sorted(flatten.flatten(nested, to_depth=3)), sorted(flat[None][2]) ) self.assertEqual( sorted(flatten.flatten(nested)), sorted(flat[None][2]) ) self.assertEqual( flatten.flatten(nested, path_prefix='some.path', to_depth=0), flat['some.path'][0] ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=1 )), sorted(flat['some.path'][1]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=2 )), sorted(flat['some.path'][2]) ) self.assertEqual( sorted(flatten.flatten( nested, path_prefix='some.path', to_depth=3 )), sorted(flat['some.path'][2]) ) self.assertEqual( sorted(flatten.flatten(nested, path_prefix='some.path')), sorted(flat['some.path'][2]) )