This Python evacuation framework is structured as an automated network-analysis pipeline that begins with standardized geospatial inputs and user-defined pedestrian parameters, especially average walking speed and the maximum admissible evacuation time. Its first critical stage is the geometric and topological correction of the street network, since raw road layers often contain disconnected segments, invalid geometries, overlaps without true intersections, and MultiLineString features that prevent proper routing. To solve this, the algorithm removes empty or corrupted geometries, repairs invalid lines using geometric reconstruction procedures, explodes multipart features into individual LineStrings, and performs automatic snapping of vertices within a 2 m tolerance to restore continuity. It then applies topological subdivision by splitting segments at all detected intersections, converting the original linework into a fully connected and routable network. Once cleaned, each segment vertex becomes a graph node and each segment between adjacent nodes becomes an edge in a weighted graph. The weighting scheme is not based on distance alone, but on travel time adjusted by terrain slope. Node elevations are sampled from the Digital Terrain Model, and elevation differences between consecutive nodes are incorporated into the edge cost through an asymmetric slope-dependent function inspired by the GRASS GIS r.walk model. This means the algorithm explicitly distinguishes between uphill and downhill movement: positive slopes progressively increase travel cost, gentle descents can reduce travel time, and steep descents are penalized again because they reduce walking stability and require more cautious movement during evacuation. In practice, the framework converts horizontal movement and vertical variation into an effective walking speed for each edge, producing a more realistic time-based graph. After this graph is built, the algorithm identifies affected buildings, connects each one to its nearest accessible road node, defines an initial global meeting point outside the flooded area, and calculates the fastest route from every building to that destination using Dijkstra’s shortest-path algorithm with time-weighted edges. To handle cases in which evacuation is not feasible within the user-defined time threshold, the framework includes a dynamic redistribution mechanism based on spatial clustering. After the first routing cycle, all buildings whose travel time exceeds the admissible limit are automatically flagged as excessive cases. These buildings are then grouped with DBSCAN, which detects spatial clusters of nearby unmet demand without requiring a predefined number of groups. For each cluster, the algorithm computes a new local meeting point from the group centroid, relocates it to the nearest accessible road node outside the flood polygon, and recalculates only the routes associated with that cluster. This iterative logic decentralizes evacuation support and prevents isolated or distant buildings from remaining tied to an inefficient global destination. The final output is therefore not just a set of shortest paths, but an adaptive evacuation solution that reconstructs the road network, applies slope-sensitive travel-cost modeling, identifies infeasible routes, and generates alternative meeting-point structures until the routing pattern becomes operationally viable.