Unexpected ordering of nodes in partite graph

[StefanUlbrich]

Description of bug / unexpected behavior

I want to create a multi-partite graph not fully connected between the layers. It is created by subtracting a probability mass function from layer to layer and therefore, the nodes carry the type tuple[int,int] (layer number, display value). I expect the nodes in the layers / partitions to be either ascending or descending but this is not the case:

Expected behavior

I expect to be able to take influence on how the nodes are rendered by specifying the order in the partitions argument to Graph(). This is not the case.

How to reproduce the issue

Code for reproducing the problem

        loss = [list(range(4)), list(range(5)), list(range(5))]

        layers: list[list[tuple[int, int]]] = [[(0, start)]]

        values = {start}
        edges: list[tuple[tuple[int, int], tuple[int, int]]] = []
        for i, layer_loss in enumerate(loss):
            new_layer = []
            new_values = set()
            edges_layer = []
            for d in layer_loss:
                for v in values:
                    n = int(max(0, v - d))
                    if n not in new_values:
                        new_layer.append((i + 1, n))
                        new_values.add(n)
                    edges_layer.append(((i, v), (i + 1, n)))
            edges += edges_layer
            values = new_values
            layers += [new_layer]

            graph = Graph(
               vertices,
               edges,
               layout="partite",
               partitions=partitions,
            )

Additional comments

I found a solution that works around this behavior:
After digging into networkx, I found out that in networkx.utils.misc.groups the ordering is lost. To avoid calling this tool, one can pass a dictionary that maps the layer number to a sorted list of its nodes:

for i, p in enumerate(partitions):
     subset_key[i] = p

 graph = Graph(
            vertices,
            edges,
            # labels=True,
            labels=labels,
            layout="partite",
            layout_config={"subset_key": subset_key}, # <----- This line suppress a shuffling of nodes
            partitions=partitions,
)

I have the feeling, that this is closer to the expected behavior and should be considered to be added to Graph._partite_layout.