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>]"],
]
