Why do I have to specify the type of a path parameter in the path?

[simon-lund]

If I have a router handler like this, why do I have to specify the type of name twice? Why isn't it enough to only specify the type of the function parameter?

@get("/{name:str}")
async def greeter(name: str) -> str:
    return "Hello, " + name

[JacobCoffee]

My thoughts are that the function signature is for typing (mypy, pyright, etc) validation and user documentation and the route handler is for routing validation to be consumed by msgspec to validate the incoming data.

But Peter had a better answer 😅:

the path parameter doesn't have to be injected into the handler, so there may be cases where the type isn't available by inspecting the function signature - Peter
https://discord.com/channels/919193495116337154/919193495690936353/1162856495256436890

[simon-lund]

Thx for the link. Funny that someone asked the same just a month ago.

I would have expected it to work until it doesn't , i.e. if the type is not specified in the path, try to infer it from the corresponding function parameter, if it does not exist or no type is specified raise a related error.

[peterschutt]

I would have expected it to work until it doesn't , i.e. if the type is not specified in the path, try to infer it from the corresponding function parameter, if it does not exist or no type is specified raise a related error.

I'm not enthusiastic about this due to the complexity that it introduces:

• harder to teach - instead of there being 1 way to declare a path parameter it becomes a matrix of "path parameter type declared or not" x "parameter injected in handler or dependency tree or not"

• harder to implement - we not only have to inspect the handler signature, but also traverse the dependency tree to find a type

• handler/dependency parameter types can be more complex than path parameter types, so we might not even be able to infer the correct type, e.g.,:

  class MyStr(str): ...
  
  @get("/path/{thing:str}")
  def handle(thing: MyStr) -> ...: ...

  or

  class StringyThing:
    def __init__(s: str) -> None:
        self.s = s
  
  @get("/path/{thing:str}")
  def handle(thing: StringyThing) -> ...: ...

  The first case would be possible by traversing the MRO, but for the 2nd its not so simple (really, this is another item to add to the matrix I mentioned in the first bullet point, "can the path param type be inferred from the handler type, or not").

Having said all that, I'm wrong about stuff all the time, so if you feel strongly about it open a feature request.

Cheers.

[simon-lund]

I understand 👍 Thanks for the insight. Much appreciated :)

Given your arguments, it's a little "inconvenience" (if you are even bothered by that) compared to the complexity to avoid it.