Code for Visualizing a gdu json via Treemap in Python Dash / Plotly

[0nelight]

I vibe coded something so I can visualize this like in WinDirStat or similar Software:

import json
import plotly.graph_objects as go
from pathlib import Path
import sys
import dash
from dash import dcc, html, Input, Output, State
import dash_bootstrap_components as dbc

# tested with header:
# [1,2,{"progname":"gdu","progver":"v5.32.0"}

filename = "test.json"

def parse_structure(data, parent_path="", parent_name="", max_depth=None, current_depth=0):
    """
    Rekursive Funktion zum Parsen der verschachtelten Struktur.
    Gibt eine Liste von Dictionaries zurück mit: name, parent, size, full_path
    """
    items = []

    if not isinstance(data, list) or len(data) == 0:
        return items

    # Prüfe Tiefenlimit
    if max_depth is not None and current_depth > max_depth:
        return items

    # Erstes Element ist das Ordner-Dict mit name und mtime
    current_dir = data[0] if isinstance(data[0], dict) else None
    if not current_dir or 'name' not in current_dir:
        return items

    current_name = Path(current_dir['name']).name
    current_full_path = f"{parent_path}/{current_name}" if parent_path else current_name

    # Füge den aktuellen Ordner ZUERST hinzu (vor seinen Kindern)
    items.append({
        'name': current_name,
        'parent': parent_path,
        'size': 0,
        'full_path': current_full_path,
        'type': 'folder',
        'depth': current_depth
    })

    # Verarbeite alle weiteren Elemente
    for item in data[1:]:
        if isinstance(item, dict):
            # Es ist eine Datei
            if 'asize' in item:
                file_name = item['name']
                file_size = item['asize']

                items.append({
                    'name': file_name,
                    'parent': current_full_path,
                    'size': file_size,
                    'full_path': f"{current_full_path}/{file_name}",
                    'type': 'file',
                    'depth': current_depth + 1
                })
            # Es ist ein leerer Ordner
            else:
                subdir_name = item['name']
                subdir_full_path = f"{current_full_path}/{subdir_name}"
                items.append({
                    'name': subdir_name,
                    'parent': current_full_path,
                    'size': 0,
                    'full_path': subdir_full_path,
                    'type': 'folder',
                    'depth': current_depth + 1
                })

        elif isinstance(item, list):
            # Rekursiver Aufruf für Unterordner
            sub_items = parse_structure(item, current_full_path, current_name, max_depth, current_depth + 1)
            items.extend(sub_items)

    return items


def calculate_folder_sizes(items):
    """
    Berechnet die Gesamtgröße jedes Ordners basierend auf seinen Dateien und Unterordnern.
    """
    # Sortiere nach Tiefe (tiefste zuerst) für Bottom-Up-Berechnung
    sorted_items = sorted(items, key=lambda x: x['full_path'].count('/'), reverse=True)

    for item in sorted_items:
        if item['type'] == 'folder':
            # Berechne Größe aus direkten Kindern
            children_size = sum(
                child['size'] for child in items
                if child['parent'] == item['full_path']
            )
            item['size'] = children_size if children_size > 0 else 1

    return items


def filter_by_size(items, min_size_mb):
    """Filtert Items nach Mindestgröße"""
    if min_size_mb <= 0:
        return items

    min_bytes = min_size_mb * 1024 * 1024
    filtered = []

    # Behalte alle Ordner und Dateien über dem Limit
    for item in items:
        if item['size'] >= min_bytes or item['type'] == 'folder':
            filtered.append(item)

    return filtered


def format_size(size):
    """Konvertiert Bytes in lesbare Größe"""
    for unit in ['B', 'KB', 'MB', 'GB']:
        if size < 1024.0:
            return f"{size:.2f} {unit}"
        size /= 1024.0
    return f"{size:.2f} TB"


def create_treemap(items):
    """Erstellt die Treemap Figure aus Items"""
    if not items:
        return go.Figure()

    ids = []
    labels = []
    parents = []
    values = []
    colors = []
    hover_text = []

    for item in items:
        ids.append(item['full_path'])
        labels.append(item['name'])
        parents.append(item['parent'] if item['parent'] else "")
        values.append(item['size'])
        colors.append('#1f77b4' if item['type'] == 'folder' else '#ff7f0e')
        hover_text.append(
            f"{item['name']}<br>Größe: {format_size(item['size'])}<br>Typ: {item['type']}"
        )

    fig = go.Figure(go.Treemap(
        ids=ids,
        labels=labels,
        parents=parents,
        values=values,
        hovertext=hover_text,
        hovertemplate='%{hovertext}<extra></extra>',
        textposition="middle center",
        marker=dict(
            colors=colors,
            line=dict(width=2, color='white')
        ),
        branchvalues="total"
    ))

    fig.update_layout(
        margin=dict(t=50, l=0, r=0, b=0),
        height=800
    )

    return fig


# Lade JSON-Daten beim Start
script_dir = Path(__file__).parent
json_file = script_dir / filename

if not json_file.exists():
    print(f"Fehler: Die Datei '{json_file}' wurde nicht gefunden!")
    print(f"Bitte erstelle eine Datei 'folder_structure.json' im selben Verzeichnis wie dieses Script.")
    sys.exit(1)

print(f"Lade JSON-Daten aus: {json_file}")
with open(json_file, 'r', encoding='utf-8') as f:
    json_data = json.load(f)

# Initialisiere Dash App
app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])

app.layout = dbc.Container([
    dbc.Row([
        dbc.Col([
            html.H1("Ordner- und Dateigrößen Visualisierung", className="text-center mb-4")
        ])
    ]),

    dbc.Row([
        dbc.Col([
            dbc.Card([
                dbc.CardBody([
                    html.Label("Maximale Tiefe:", className="fw-bold"),
                    dcc.Slider(
                        id='depth-slider',
                        min=1,
                        max=10,
                        step=1,
                        value=4,
                        marks={i: str(i) for i in range(1, 11)},
                        tooltip={"placement": "bottom", "always_visible": True}
                    )
                ])
            ], className="mb-3")
        ], width=6),

        dbc.Col([
            dbc.Card([
                dbc.CardBody([
                    html.Label("Minimale Größe (MB):", className="fw-bold"),
                    dcc.Slider(
                        id='size-slider',
                        min=0,
                        max=10,
                        step=0.5,
                        value=2,
                        marks={i: f"{i} MB" for i in range(0, 11, 2)},
                        tooltip={"placement": "bottom", "always_visible": True}
                    )
                ])
            ], className="mb-3")
        ], width=6)
    ]),

    dbc.Row([
        dbc.Col([
            html.Div(id='stats-output', className="mb-3")
        ])
    ]),

    dbc.Row([
        dbc.Col([
            dcc.Loading(
                id="loading",
                type="default",
                children=dcc.Graph(id='treemap', style={'height': '800px'})
            )
        ])
    ])
], fluid=True, className="p-4")


@app.callback(
    [Output('treemap', 'figure'),
     Output('stats-output', 'children')],
    [Input('depth-slider', 'value'),
     Input('size-slider', 'value')]
)
def update_treemap(max_depth, min_size_mb):
    """Lädt und verarbeitet Daten dynamisch basierend auf Filtern"""

    # Parse die Struktur mit Tiefenlimit
    root_structure = json_data[3]
    items = parse_structure(root_structure, max_depth=max_depth)

    # Berechne Ordnergrößen
    items = calculate_folder_sizes(items)

    # Filtere nach Größe
    items = filter_by_size(items, min_size_mb)

    # Erstelle Treemap
    fig = create_treemap(items)

    # Statistiken
    total_items = len(items)
    total_folders = sum(1 for item in items if item['type'] == 'folder')
    total_files = sum(1 for item in items if item['type'] == 'file')
    total_size = sum(item['size'] for item in items if item['parent'] == "")

    stats = dbc.Alert([
        html.Strong("Statistiken: "),
        f"Elemente: {total_items} | ",
        f"Ordner: {total_folders} | ",
        f"Dateien: {total_files} | ",
        f"Gesamtgröße: {format_size(total_size)}"
    ], color="info")

    return fig, stats


if __name__ == '__main__':
    print("\n" + "=" * 50)
    print("Dash App wird gestartet...")
    print("Öffne http://127.0.0.1:8050 in deinem Browser")
    print("=" * 50 + "\n")
    app.run(debug=True, port=8050)

[dundee]

Cool, thank you!