Narysuj wykres połączeń

Utrzymuję starą bazę kodu napisaną w języku python. W szczególności istnieje złożony fragment kodu, który z modułu wywołuje inne funkcje z innych modułów, które wywołują inne funkcje i tak dalej. To nie jest OOP, tylko funkcje i moduły.
Próbowałem śledzić, gdzie zaczyna się i kończy przepływ za każdym razem, gdy wywołuję główną funkcję, ale czuję, że muszę to narysować, ponieważ gubię się w wywołaniach podrzędnych.

To, co mnie martwi, to to, że każda funkcja wywołuje wiele funkcji zewnętrznych w swoim ciele, aby zakończyć zadanie i zwrócić wartość wywołującemu.

Jak mogę to narysować? Czyli jaki rodzaj wykresu / grafiki byłby odpowiedni do udokumentowania tego rodzaju zachowania / kodu?

Nie sądzę więc, aby rysowanie diagramu UML, ani schematu blokowego było przydatne. Może wykres połączeń?

Myślę, że tutaj szukasz diagramu sekwencji . Umożliwiają one wizualizację kolejności, w której różne moduły wywołują się nawzajem za pomocą strzałek.

Konstruowanie jednego jest proste:

1. Narysuj klasę początkową z kropkowaną linią poniżej.
2. Narysuj następną klasę / metodę w ścieżce wywołania, pod nią kropkowaną linię
3. Połącz linie ze strzałką ustawioną pionowo poniżej ostatniej narysowanej strzałki
4. Powtórz kroki 2-3 dla wszystkich połączeń w swoim śladzie

Przykład

Załóżmy, że mamy następujący kod, dla którego chcemy utworzyć diagram sekwencji:

def long_division(quotient, divisor):
    solution = ""
    remainder = quotient
    working = ""
    while len(remainder) > 0:
        working += remainder[0]
        remainder = remainder[1:]
        multiplier = find_largest_fit(working, divisor)
        solution += multiplier
        working = calculate_remainder(working, multiplier, divisor)
    print solution


def calculate_remainder(working, multiplier, divisor):
    cur_len = len(working)
    int_rem = int(working) - (int(multiplier) * int (divisor))
    return "%*d" % (cur_len, int_rem)


def find_largest_fit(quotient, divisor):
    if int(divisor) == 0:
        return "0"
    i = 0
    while i <= 10:
        if (int(divisor) * i) > int(quotient):
            return str(i - 1)
        else:
            i += 1


if __name__ == "__main__":
    long_division("645", "5")

Najpierw narysujemy punkt wejścia ( main) łączący się z metodą long_division. Zauważ, że tworzy to pole w long_division, oznaczające zakres wywołania metody. W tym prostym przykładzie ramka będzie miała całą wysokość naszego schematu sekwencji, ponieważ jest to jedyna rzecz, którą można uruchomić.

Teraz dzwonimy, find_largest_fitaby znaleźć największą wielokrotność, która mieści się w naszym numerze roboczym i zwraca go nam. Rysujemy linię od long_divisiondo find_largest_fitz innym polem, aby zaznaczyć zakres wywołania funkcji. Zwróć uwagę, jak pole kończy się po zwróceniu mnożnika; to koniec zakresu funkcji!

Powtórz kilka razy dla większej liczby, a twój wykres powinien wyglądać mniej więcej tak:

Notatki

Możesz wybrać, czy chcesz oznaczać połączenia przekazanymi nazwami zmiennych, czy ich wartości, jeśli chcesz udokumentować tylko jeden konkretny przypadek. Możesz także wyświetlić rekurencję z funkcją wywołującą samą siebie.

Ponadto możesz tutaj wyświetlać użytkowników, monitować ich i dość łatwo wprowadzać dane do systemu. To dość elastyczny system, który wydaje mi się przydatny!

Myślę, że wykres połączeń byłby najbardziej odpowiednią wizualizacją. Jeśli zdecydujesz się nie robić tego ręcznie, istnieje ładne małe narzędzie o nazwie, pyanktóre wykonuje analizę statyczną pliku Pythona i może wygenerować wizualizowany wykres wywołania za pomocą pliku kropki graphviz (który może być renderowany na obraz). Było kilka rozwidleń, ale najbardziej w pełni funkcjonalny wydaje się być https://github.com/davidfraser/pyan .

Musisz tylko określić wszystkie pliki, które chcesz przetworzyć po uruchomieniu polecenia:

python ~/bin/pyan.py --dot a.py b.py c.py -n > pyan.dot; dot -Tpng -opyan.png pyan.dot

lub

python ~/bin/pyan.py --dot $(find . -name '*.py') -n > pyan.dot; dot -Tpng -opyan.png pyan.dot

Możesz uczynić wykres czystszym za pomocą „-n”, który usuwa linie pokazujące, gdzie zdefiniowano funkcję.