Why not support an API that can break up circular reference of a Machine object ?

[dokiyi]

An example start from here :

from transitions import Machine
customMachine = Machine()

There are serial circular reference in the new object customMachine, for example customMachine.models is referenced by customMachine while customMachine is also referenced by customMachine.models‘scustomMachine.models[0]. Some functions.partial object in customMachine is similar too.

The object customMachine will not be recycle as soon as all its references, which is held by application, are released. Side effect can be control with cpython's gc work properly, but extreme case might exist though...

Why not support an API that can break up those circular reference of a Machine object? Or if I'm rude, from the view of developer, Is there appropriate way to help application to break up circular reference in some case correctly?

[aleneum]

Hi @dokiyi,

I know that you posted that quite some time ago but I am curious if these circular references caused issues for you. Maybe you can remember :).

I had the impression that Python's garbage collector is smart enough to remove objects even if they reference themselves.
I ran a simplistic memory check and could not see a memory leak.

Code

import tracemalloc
tracemalloc.start()
from transitions import Machine

memory = []

MACHINES_PER_ITERATION = 10000

for j in range(20):
    memory.append(tracemalloc.get_traced_memory())
    for i in range(MACHINES_PER_ITERATION):
        machine = Machine(states=["A", "B", "C"], transitions=[["go", "A", "B"], ["back", "*", "A"]], initial="A")
        machine.add_state("D")
        machine.add_transition("go_to_C", "B", "C")
        machine.add_transition("go_to_D", "C", "D")
        machine.add_transition("go_to_A", "*", "A")
    print(".", end="", flush=True)

memory.append(tracemalloc.get_traced_memory())
print("\nMemory usage:")
for i, mem in enumerate(memory):
    print(f"Iteration {i} ({i * MACHINES_PER_ITERATION} machines created): {mem[0] / 1024:.2f} KB, {mem[1] / 1024:.2f} KB")

Result

Memory usage:
Iteration 0 (0 machines created): 2579.53 KB, 2613.06 KB
Iteration 1 (10000 machines created): 3047.98 KB, 3480.60 KB
Iteration 2 (20000 machines created): 3030.63 KB, 3480.60 KB
Iteration 3 (30000 machines created): 2818.42 KB, 3480.60 KB
Iteration 4 (40000 machines created): 3213.44 KB, 3480.60 KB
Iteration 5 (50000 machines created): 3137.16 KB, 3480.60 KB
Iteration 6 (60000 machines created): 2984.18 KB, 3480.60 KB
Iteration 7 (70000 machines created): 2746.63 KB, 3480.60 KB
Iteration 8 (80000 machines created): 3166.79 KB, 3480.60 KB
Iteration 9 (90000 machines created): 3149.43 KB, 3480.60 KB
Iteration 10 (100000 machines created): 2937.32 KB, 3480.60 KB
Iteration 11 (110000 machines created): 3072.82 KB, 3480.60 KB
Iteration 12 (120000 machines created): 2860.22 KB, 3480.60 KB
Iteration 13 (130000 machines created): 3102.71 KB, 3480.60 KB
Iteration 14 (140000 machines created): 2864.70 KB, 3480.60 KB
Iteration 15 (150000 machines created): 3026.26 KB, 3480.60 KB
Iteration 16 (160000 machines created): 2714.56 KB, 3480.60 KB
Iteration 17 (170000 machines created): 3056.31 KB, 3480.60 KB
Iteration 18 (180000 machines created): 3191.94 KB, 3480.60 KB
Iteration 19 (190000 machines created): 2979.61 KB, 3480.60 KB
Iteration 20 (200000 machines created): 2961.97 KB, 3480.60 KB

But maybe memory leaks are not what caused issues for you. So, if you can remember, let me know.