Can Typer deal with camelCase arguments somehow?

[imLew]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the Typer documentation, with the integrated search.
• I already searched in Google "How to X in Typer" and didn't find any information.
• I already read and followed all the tutorials in the docs and didn't find an answer.
• I already checked if it is not related to Typer but to Click.

Commit to Help

• I commit to help with one of those options 👆

Example Code

import typer
from typing_extensions import Annotated

app = typer.Typer()

@app.command()
def cmd(camelCaseArgument: Annotated[ str, typer.Argument() ]):
    print(camelCaseArgument)

if __name__ == "__main__":
    app()

Description

Typer converts argument to lower case under the hood, this results in an error when using camelCase.
To reproduce:

• Create script as above.
• Run the script with any argument.

Operating System

Linux

Operating System Details

No response

Typer Version

0.16.0

Python Version

Python 3.12.9

Additional Context

This doesn't happen for typer.Option.

[svlandeg]

I think it is by convention that arguments on any command line interface are always lowercased?

Also, this doesn't work for Option either, because those get internally lowercased as well. So you wouldn't be able to do

python myapp.py --camelCaseArgument "something"

It would error out with

No such option: --camelCaseArgument
Did you mean --camelcaseargument?

[svlandeg]

The discussion about the Option case is probably a distraction, but just to clarify: that wasn't a Click example, but a Typer example with Option (as you mentioned that that does work, but it doesn't, as far as I can see).

import typer
from typing_extensions import Annotated

app = typer.Typer()

@app.command()
def cmd(camelCaseArgument: Annotated[ str, typer.Option() ]):
    print(camelCaseArgument)

if __name__ == "__main__":
    app()

and then on the console:

$ python myapp.py --camelCaseArgument "yay"

Usage: myapp.py [OPTIONS]
Try 'myapp.py --help' for help.
┌─ Error ─────────────────────────────────────────────────────────────────────┐
│ No such option: --camelCaseArgument Did you mean --camelcaseargument?       │
└─────────────────────────────────────────────────────────────────────────────┘

$ python myapp.py --camelcaseargument "yay"
yay

[svlandeg]

Anyway so to come back to the actual point of your thread

a big part of the appeal of typer is that the variable name is the same as the option name

that's definitely a valid point!

[imLew]

The discussion about the Option case is probably a distraction, but just to clarify: that wasn't a Click example, but a Typer
example with Option (as you mentioned that that does work, but it doesn't, as far as I can see).

Sorry, my mistake. I missed that when I re-read my post.
I don't remember why I wrote that, your example clearly shows it doesn't work.

[imLew]

OK, I've done a bit more testing and found a difference, which is probably what I was referring to back when I made this post:

If we change the function in the example above to

def cmd(
    camelCaseArgument: Annotated[ str, typer.Argument() ],
    camelCaseOption: Annotated[ str, typer.Option() ]
    ):

then it will always fail with TypeError: cmd() got an unexpected keyword argument 'camelcaseargument'
Whereas if we s/camelCaseArgument/camelcaseargument, it will indeed require the option to be all lower case, but given that lower case option (or a default value!) it can run successfully.

I probably had a default value in the function that prompted me to write the bit about this working with Option, but it actually doesn't work with camelCase on the command line, only in the corresponding variable name.

[imLew]

I just came across a script where I have used camelCase typer.Options.
It can be done by specifying the name of the option as documented here https://typer.tiangolo.com/tutorial/options/name/

[imLew]

After the preceding discussion I don't think my original question was clear enough in its intent.

The questions is whether there is a way to have a command line typer.Argument for which the corresponding python variable is written in camelCase.