Debugging with protocol

[u/LopsidedAd4492]

Am I the only one who gets frustrated debugging Python code that relies heavily on Protocol?
I understand why it’s useful. Structural typing is elegant, and it gives you a lot of flexibility.
But when you’re trying to understand an unfamiliar codebase, it can be painful. You see a variable typed as a Protocol, jump to its definition, and… there’s no implementation. Now you have to hunt through the codebase to figure out which concrete class is actually being passed around.
In a large project, that can make understanding the execution flow much harder than it needs to be.
Maybe it’s just a tooling issue, or maybe I’m still getting used to Python after years of Java, but I’m curious how other people deal with this. Does it eventually become second nature?

[u/thee_gummbini]

the use of protocol should be abstract, and your IDE and type checker should be able to enforce correctness and find calling types. Like the declaration of a protocol literally means "anything that matches this abstract type, and this is all we care about or know about what is passed to us," and an IDE and LSP can find all callers to show the concrete types

[u/LopsidedAd4492 → u/thee_gummbini]

I understand the meaning
What still annoys is that you can not jump to the implementation

[u/thee_gummbini → u/LopsidedAd4492]

The thing is that there is no single implementation, that's the point - when you use a protocol class in a type annotation, you're saying "anything as long as it has these attrs/methods with this signature." If your IDE can't jump you to the definition of the protocol itself then that's a bug with your editor, but there is no implementation to jump to.

The reason you use them, most commonly, is that you expect arbitrary 3rd party callers that you don't know in advance.

So e.g. say I don't know about collections.abc and I want to write a function that takes anything with a length:

``` class Sized(Protocol): def len(self) -> int: ...

def twice_as_long(item: Sized) -> int: return len(item) * 2

any of these are fine

twice_as_long([1,2,3]) twice_as_long({"hey": "sup"})

class AlwaysFiveLen: def len(self) -> int: return 5

twice_as_long(AlwaysFiveLen()) ```

What would it mean to go to the implementation for Sized? i can use an IDE or a LSP to locate all the times my function is called and look at what gets passed to it, and then look at the implementations of those objects, I can add a breakpoint and inspect the objects that are passed, but there is no way to jump to "the implementation of a protocol" because it doesn't exist.

One of the reasons its called "protocol" is that you're offering something for someone else to use, you as the author of the thing that consumes the protocol are not supposed to know how any class implements the protocol, you have specified exactly how much you need to know - if you have some object with these attrs/methods, you can implement them however you want as long as they accept and return the right types.