Default rule: in performance-sensitive code, prevent hidden blowups and avoid expensive work being executed repeatedly in hot paths or on import.

Apply this checklist: 1) Replace inefficient primitives inside loops

• Watch for patterns like pop(0) or sort() on each iteration.
• Use collections.deque or heapq where applicable.

2) Don’t do global scans per iteration in graph/ordering logic

• If you’re performing a topological sort / dependency resolution, build a reverse-dependency adjacency list so each “removed node” updates only its affected neighbors.

3) Cache expensive introspection/metadata

• If you use reflection (e.g., inspect.signature) or other typing-introspection, compute it once when wiring middleware/handlers, store it, and reuse it during request processing.

4) Prefer lazy, memoized loading over eager initialization

• Avoid doing heavy imports/provider setup in __init__ paths; delay until actually needed and memoize results.

5) Choose fast strategies by default (when the API is designed for it)

• For token counting/estimation, prefer approximate fast paths unless exact/model-accurate counts are required.

Example (dependency resolution):

from collections import deque

# Build reverse deps once: dep -> set(dependents)
reverse_deps = {}
for cls, deps in dep_graph.items():
    for dep in deps:
        reverse_deps.setdefault(dep, set()).add(cls)

queue = deque(sorted([c for c in instance_by_class if in_degree[c] == 0], key=lambda x: x.__name__))
while queue:
    current = queue.popleft()
    for dependent in reverse_deps.get(current, ()):  # only affected neighbors
        in_degree[dependent] -= 1
        if in_degree[dependent] == 0:
            queue.append(dependent)