Add support for partial/full specialization of Generic interfaces

[nicoddemus]

No description provided.

[nicoddemus]

I'm not sure this is 100% correct: the interface declares that every implementation should support any type as the parameter to foo, like FooGeneric does below.

Specialization is specializing T to str, which violates the AnInterface interface.

FooGeneric works out of the box now, without the changes in _interface.py in this PR.

I'm not sure the use case for Specialization is totally valid.

[mv-per]

It does work, but let's say I wrongfully implement Specialization as:

    @interface.ImplementsInterface(AnInterface)
    class Specialization:
        def foo(self, v: int) -> str:
            return str(v) + "bar"

The above code works on runtime and on type_checking. However, it's clear that foo(self, v: int) -> str differs from foo(self, v: T) -> T but neither mypy or interface can see this Liskov substitution principle violation.

If we use Protocol directly, we would have something like:

    from typing import TypeVar, Protocol

    T = TypeVar("T")

    class AnInterface(Protocol[T]):
        def foo(self, v: T) -> T:
            ...

    class Specialization(AnInterface[str]):
        def foo(self, v: int) -> str:
            return str(v) + "bar"

    spec = Specialization()
    assert spec.foo(1) == "1bar"

what would cause:

src/oop_ext/interface/_tests/test_interface.py:1129: error: Argument 1 of "foo" is incompatible with supertype "AnInterface"; supertype defines the argument type as "str"  [override]
src/oop_ext/interface/_tests/test_interface.py:1129: note: This violates the Liskov substitution principle
src/oop_ext/interface/_tests/test_interface.py:1129: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides

Seems like mypy is not properly checking the interface's structure

[nicoddemus]

but neither mypy or interface can see this Liskov substitution principle violation.

mypy does not know about our Interface implementation at all, that's why -- it cannot konw that Specialization and AnInterface are related at all.

For new interface hierarchies, we should consider using plain ABC classes and/or Protocols, as they are natively interpreted by mypy.

(Btw in you example you are not supposed to subclass from AnInterface).

[sonarqubecloud]

Kudos, SonarCloud Quality Gate passed!   

0 Bugs
0 Vulnerabilities
0 Security Hotspots
1 Code Smell

No Coverage information
0.0% Duplication

[nicoddemus]

As we discussed, in the end this does not seem to be the right approach. 👍