Structural Subtyping

PEP 544 introduces the notion of structural subtyping or static duck typing to Python. Here's how it works:
 None: ...

    def reproduces(self) -> None: ...

    def responds_to_stimuli(self) -> None: ...

    def adapts(self) -> None: ...


class Human:

    def grows(self) -> None: pass

    def reproduces(self) -> None: pass

    def responds_to_stimuli(self) -> None: pass

    def adapts(self) -> None: pass

    def conscious(self) -> None: pass


H: OrganicOrganism = Human()
O: Human = OrganicOrganism() 
`}
language="python"
showLineNumbers={true}

/>
Type checking this with ``MyPy``  shows complaints  



But when you fix it 



You get 




Every human behaves like an organism in some way, 
but an organism may not behave like a human

How about a plant 

 None: pass

    def reproduces(self) -> None: pass

    def responds_to_stimuli(self) -> None: pass

    def adapts(self) -> None: pass

P: OrganicOrganism = Plant() #Ok
`}
language="python"
showLineNumbers={false}
/>


  Even though `Human` and `Plant` don't share a common ancestor,
   they both conform to the `OrganicOrganism` protocol because they exhibit
    the required methods. No need for inheritance here.

Ok we know all that, what's special

Let's say you have various classes representing different request or response objects, possibly from different libraries. You aim to consolidate these diverse objects and their methods into a unified class or adapter. You might expect these classes to inherit from a common base class. But, by using protocols, you can define a common interface that outlines the expected behavior of response objects with an abstracted one. This enables disparate classes to conform to the same structure without requiring a shared ancestry.

 Optional[str]:
        ...
    @property
    def p_all_cookies(self) -> Dict[str, str]:
        ...
    @property
    def p_is_connection_secure(self) -> bool:
        ...

    @property
    def p_base_url(self) -> str:
        ...
`}
language="python"
showLineNumbers={false}

/>

You can extend these different Request objects to where they adhere to the protocol.

 Optional[str]:
        return self.cookies.get(cookie_name)

    @property
    def p_cookies(self) -> Dict[str, str]:
        return self.cookies

    @property
    def p_is_connection_secure(self) -> bool:
        return self.url.is_secure

    @property
    def p_base_url(self) -> str:
        return str(self.base_url)
`}
language="python"
showLineNumbers={false}

/>

 Optional[str]:
        return self.cookie(cookie_name)

    @property
    def p_all_cookies(self) -> Dict[str, str]:
        return self.cookies

    @property
    def p_is_connection_secure(self) -> bool:
        return self.is_https

    @property
    def p_base_url(self) -> str:
        return self.base_url
`}
  language="python"
  showLineNumbers={false}
/>

As you can see these different libraries
 have different implementation over how they access 
 different request properties/methods, but with a protocol 
 you can define a unified way that all these different objects 
 adhere to, now for example if you want to create a function 
 that processes a given request you can annotate the request 
 parameter with ``RequestProtocol``, this means that his function
  will process any class that adheres to this protocol.
 None:

    # do anything with the shared methods
    process_request(req=RequestX(...)) # OK, no type issues 
    process_request(req=RequestX(...)) # OK, no type issues
`}
  language="python"
  showLineNumbers={false}
/>

Another use case is using `Protocol` to type function signatures.

 None:
        ...
`}
  language="python"
  showLineNumbers={false}
/>

Any function that is asynchronous, accepts an argument called `foo` of 
type  `Foo` and returns nothing, adheres to this protocol, a given function might be.

If you would have typed this function otherwise it would have been.

It's much easier to type functions using `Protocol`
instead of:
 Any: ...
`}
  language="python"
  showLineNumbers={false}
/>

If you annotate the protocol with `@runtime_checkable`, you're allowed access to `isinstance()` and `issubclass()` functions to check the type at runtime.

 Any:
	if not isinstance(bar,Bar): ... # do something 
`}
  language="python"
  showLineNumbers={false}
/>

You can also create a function that checks
 the signature of another function, if it adheres to the protocol or not, and provide helpful error messages over why the given object does not adhere to the protocol.

 None:
    sig = inspect.signature(f)
    if not (
        "foo" in sig.parameters
        and sig.parameters["foo"].annotation == Foo
    ):
        raise TypeError(
            f"Given function does not adhere to Bar protocol: {f}"
        )
`}
  language="python"
  showLineNumbers={false}
/>
Unclassified, raw

Python Protocols
