def _to_dict( self, comm: Comm = None, *, exclude: Container[str] = None ) -> dict[str, str]: """ A very verbose dictionary representation for debugging purposes. Not type stable and not inteded for roundtrips. Parameters ---------- comm: exclude: A list of attributes which must not be present in the output. See also -------- Server.identity Client.dump_cluster_state """ info = self.identity() extra = { "address": self.address, "status": self.status.name, "thread_id": self.thread_id, } info.update(extra) return recursive_to_dict(info, exclude=exclude)
def _to_dict_no_nest(self, *, exclude: Container[str] = ()) -> dict: """Dictionary representation for debugging purposes. Not type stable and not intended for roundtrips. See also -------- Client.dump_cluster_state distributed.utils.recursive_to_dict """ return recursive_to_dict(self, exclude=exclude, members=True)
def test_recursive_to_dict_no_nest(): class Person: def __init__(self, name): self.name = name self.children = [] self.pets = [] ... def _to_dict_no_nest(self, exclude=()): return recursive_to_dict(self.__dict__, exclude=exclude) def __repr__(self): return self.name class Pet: def __init__(self, name): self.name = name self.owners = [] ... def _to_dict_no_nest(self, exclude=()): return recursive_to_dict(self.__dict__, exclude=exclude) def __repr__(self): return self.name alice = Person("Alice") bob = Person("Bob") charlie = Pet("Charlie") alice.children.append(bob) alice.pets.append(charlie) bob.pets.append(charlie) charlie.owners[:] = [alice, bob] info = {"people": [alice, bob], "pets": [charlie]} expect = { "people": [ { "name": "Alice", "children": ["Bob"], "pets": ["Charlie"] }, { "name": "Bob", "children": [], "pets": ["Charlie"] }, ], "pets": [ { "name": "Charlie", "owners": ["Alice", "Bob"] }, ], } assert recursive_to_dict(info) == expect
def _to_dict(self, *, exclude: Container[str] = ()) -> dict: """Dictionary representation for debugging purposes. Not type stable and not intended for roundtrips. See also -------- Server.identity Client.dump_cluster_state distributed.utils.recursive_to_dict """ info = self.identity() extra = { "address": self.address, "status": self.status.name, "thread_id": self.thread_id, } info.update(extra) info = {k: v for k, v in info.items() if k not in exclude} return recursive_to_dict(info, exclude=exclude)
def _to_dict_no_nest(self, *, exclude: Container[str] = ()) -> dict: """Dictionary representation for debugging purposes. Not type stable and not intended for roundtrips. See also -------- Client.dump_cluster_state distributed.utils.recursive_to_dict Notes ----- This class uses ``_to_dict_no_nest`` instead of ``_to_dict``. When a task references another task, just print the task repr. All tasks should neatly appear under Worker.tasks. This also prevents a RecursionError during particularly heavy loads, which have been observed to happen whenever there's an acyclic dependency chain of ~200+ tasks. """ out = recursive_to_dict(self, exclude=exclude, members=True) # Remove all Nones and empty containers return {k: v for k, v in out.items() if v}
def test_TaskState__to_dict(): """Tasks that are listed as dependencies or dependents of other tasks are dumped as a short repr and always appear in full directly under Worker.tasks. Uninteresting fields are omitted. """ x = TaskState("x", state="memory", done=True) y = TaskState("y", priority=(0, ), dependencies={x}) x.dependents.add(y) actual = recursive_to_dict([x, y]) assert actual == [ { "key": "x", "state": "memory", "done": True, "dependents": ["<TaskState 'y' released>"], }, { "key": "y", "state": "released", "dependencies": ["<TaskState 'x' memory>"], "priority": [0], }, ]
def _to_dict_no_nest(self, exclude=()): return recursive_to_dict(self.__dict__, exclude=exclude)
def _to_dict(self, *, exclude): # Output: {"x": 1, "z": 4} return recursive_to_dict(self, exclude=exclude, members=True)
def _to_dict(self, *, exclude): assert exclude == ["foo"] return ["C:", recursive_to_dict(self.x, exclude=exclude)]
def test_recursive_to_dict(): class C: def __init__(self, x): self.x = x def __repr__(self): return "<C>" def _to_dict(self, *, exclude): assert exclude == ["foo"] return ["C:", recursive_to_dict(self.x, exclude=exclude)] class D: def __repr__(self): return "<D>" class E: def __init__(self): self.x = 1 # Public attribute; dump self._y = 2 # Private attribute; don't dump self.foo = 3 # In exclude; don't dump @property def z(self): # Public property; dump return 4 def f(self): # Callable; don't dump return 5 def _to_dict(self, *, exclude): # Output: {"x": 1, "z": 4} return recursive_to_dict(self, exclude=exclude, members=True) inp = [ 1, 1.1, True, False, None, "foo", b"bar", C, C(1), D(), (1, 2), [3, 4], {5, 6}, frozenset([7, 8]), deque([9, 10]), { 3: 4, 1: 2 }.keys(), { 3: 4, 1: 2 }.values(), E(), ] expect = [ 1, 1.1, True, False, None, "foo", "b'bar'", "<class 'test_utils.test_recursive_to_dict.<locals>.C'>", ["C:", 1], "<D>", [1, 2], [3, 4], list({5, 6}), list(frozenset([7, 8])), [9, 10], [3, 1], [4, 2], { "x": 1, "z": 4 }, ] assert recursive_to_dict(inp, exclude=["foo"]) == expect # Test recursion a = [] c = C(a) a += [c, c] # The blocklist of already-seen objects is reentrant: a is converted to string when # found inside itself; c must *not* be converted to string the second time it's # found, because it's outside of itself. assert recursive_to_dict(a, exclude=["foo"]) == [ ["C:", "[<C>, <C>]"], ["C:", "[<C>, <C>]"], ]
def test_recursive_to_dict(): class C: def __init__(self, x): self.x = x def __repr__(self): return "<C>" def _to_dict(self, *, exclude): assert exclude == ["foo"] return ["C:", recursive_to_dict(self.x, exclude=exclude)] class D: def __repr__(self): return "<D>" inp = [ 1, 1.1, True, False, None, "foo", b"bar", C, C(1), D(), (1, 2), [3, 4], {5, 6}, frozenset([7, 8]), deque([9, 10]), ] expect = [ 1, 1.1, True, False, None, "foo", "b'bar'", "<class 'test_utils.test_recursive_to_dict.<locals>.C'>", ["C:", 1], "<D>", [1, 2], [3, 4], list({5, 6}), list(frozenset([7, 8])), [9, 10], ] assert recursive_to_dict(inp, exclude=["foo"]) == expect # Test recursion a = [] c = C(a) a += [c, c] # The blocklist of already-seen objects is reentrant: a is converted to string when # found inside itself; c must *not* be converted to string the second time it's # found, because it's outside of itself. assert recursive_to_dict(a, exclude=["foo"]) == [ ["C:", "[<C>, <C>]"], ["C:", "[<C>, <C>]"], ]