Use idiomatic Python

Favor clear, idiomatic Python constructs over manual or convoluted implementations, and avoid unnecessary duplication or redundant work. Specifically:

• Use list/dict comprehensions instead of map()/filter() with lambdas: [(category, x) for x in flash_values] rather than map(lambda x: (category, x), flash_values).
• Prefer built-in functions and operators over hand-rolled equivalents, e.g. return all(ord(c) < 128 for c in s) instead of wrapping it in an if/return, operator.attrgetter('endpoint') instead of lambda r: r.endpoint, and callable(obj) instead of hasattr(obj, '__call__').
• Use ternary expressions for simple conditional assignment instead of the x and y or z idiom or multi-line if/else when a one-liner is clearer: return '/' + basename if basename else ''.
• Use == for value comparisons (never is) when comparing numbers, strings, or other value types, since is checks identity and can fail unpredictably (e.g. len(v) is 1 should be len(v) == 1).
• Prefer standard library flags/APIs over manual string/regex tricks when they exist, e.g. re.search(pattern, s, flags=re.IGNORECASE) instead of embedding (?i) inline, or a simple [h.strip() for h in header.split(',')] instead of compiling a regex for trivial splitting.
• Call dunder methods via their built-in wrapper (repr(obj)) rather than invoking them directly (obj.__repr__()), and avoid unnecessary character escaping in string literals when an alternate quote style avoids it.
• Avoid introducing a class solely to group functions that don’t share state; prefer plain module-level functions.
• Don’t duplicate blocks of logic for minor variations (e.g., table formatting with/without a column); refactor to a single parameterized implementation that handles the variable cases.
• Reuse variables and context already available in scope instead of recomputing, reassigning, or re-importing them (e.g., call top.something directly after already assigning top, or reuse ctx.app/request already in scope instead of re-importing current_app).

Applying these practices keeps the codebase consistent, easier to read, and avoids subtle bugs introduced by non-idiomatic or duplicated code.