TypeVars of generic classes not shown, duplicate ancestors/subclasses listed

[Terrance]

Expected Behavior

• Generic classes, in usage and in definition, should include TypeVar parameters.

Actual Behavior

• TypeVar parameters are omitted from usage.
• TypeVar parameters are shown on definition, but only as part of the constructor (though this is the most common case).
• typing.Generic is listed as an ancestor twice.
• The class is listed as a subclass of itself once per reference that completes the generic.

Steps to Reproduce

Sample code

from typing import Generic, TypeVar

T = TypeVar("T")

class Foo(Generic[T]):
    """A generic class."""

    def __init__(self, x: T):
        self.x = x

def a() -> Foo[int]:
    return Foo(1)

def b() -> Foo[str]:
    return Foo("b")

def c() -> Foo[bool]:
    return Foo(True)

def d() -> Foo:
    return Foo(None)

Build and output

$ pdoc3 --html --config show_type_annotations=True --config show_source_code=False test

Foo is listed as a subclass three times, for each of a, b, c (as d doesn't define T).

Additional info

• pdoc version: 0.7.1

[kernc]

Thanks for a nice bug report! Welcome to unravel some of those bullets yourself if you have time. 😁

[Terrance]

It looks like this is down to Python 3.5's half-baked typing -- str(inspect.Parameter) doesn't include it there, but it does on 3.7 and the output is much more useful:

[kernc]

Thanks for investigating! Since you enumerated several issues that would require exceptions in distinct places, since advanced typing usage as per your example is admittedly rather uncommon, and since the issues appear to be resolved in environments with up-to-date dependencies (i.e. a recommended workaround), I humbly vote to close.

[kernc]

TypeVar parameters are omitted from usage.

If you mean Foo.x is not documented inside an Arguments section, that's because it's lacking a PEP-224 docstring.

[Terrance]

that would require exceptions in distinct places

Indeed, I had a quick go at special-casing it but it's non-trivial -- one can look at Generic.__args__, a tuple of the TypeVar classes, but for usage you then need to properly stringify the classes, which could themselves be generics...

TypeVar parameters are omitted from usage

By which I mean Foo in def a() -> Foo should be Foo[int].

I humbly vote to close

Agreed, seeing as it seems to work fine with the full typing system. 🙂