The solution to this kind of issue is something like parameters (See for example https://www.gnu.org/software/guile/manual/html_node/Paramete...). They are also thread safe. One can easily set them in tests without having to mock things. I am not sure it is possible to even have something like this in Python. Have not seen it anywhere in Python.

> Passing arguments to functions is thread-safe, but that soon becomes tedious when there’s more than a few or when they need to pass down through several layers of calls before reaching the point they should affect. Introducing a new setting to existing code is often easier with a parameter object than adding arguments.

But also, if you really wanted to, you could set the argsparse object to a global variable and then import it everywhere else. So that is not a limitation.

My issue with argparse isn't that it's not global, it's that you have to create sub-parsers for multiple commands, and then add arguments to those subparsers. Those parsers are all typically defined in a central location, but copying arguments between those parsers as I define new commands can get them jumbled up because the sub-parser comes along with the argument:

    sub1 = [create subparser]
    sub1.add_argument('-x')
    sub2 = [create subparser]

If I copy "sub1.add_argument" and put it under "sub2", and forget to change "sub1" to "sub2", it is a hard to track down bug. I've had this happen a lot as the parser gets more complex.

Typer completely eliminates this potential bug, because the arguments are defined as type annotations in the sub-command function itself.

Gee if only there was a way to reuse logic within a program.

> arguments are defined as type annotations in the sub-command function itself

So you duplicate logic in your type definitions instead of as instructions. Whatever makes you happy i guess.