Sequence now lives at collections.abc. BTW, float is not a supertype of int (issubclass(int, float) == False). Normaly, It is acceptable to use int instead of float, but speaking of variance, it is more precise to use numbers.Real:

issubclass(Integral, Real) == True
issubclass(int, Real) == True
issubclass(float, Real) == True
issubclass(complex, Real) == False

With the dump function:

from ast import dump, parse

st = parse("thing = list[str]()")
print(dump(st, indent=4))

st = parse("thing: list[str] = []")
print(dump(st, indent=4))

The first one, has a implicit call to the constructor that need infer the type annotation of the result. BTW, the second form is a direct statement with a explicit type annotation, more recommended. When you see the AST of both statements, you can see the overload of calling the constructor and the use of AnnAssign (assign with type annotation) vs Assign:

thing = list[str]()

Module(
    body=[
        Assign(
            targets=[
                Name(id='thing', ctx=Store())],
            value=Call(
                func=Subscript(
                    value=Name(id='list', ctx=Load()),
                    slice=Name(id='str', ctx=Load()),
                    ctx=Load()),
                args=[],
                keywords=[]))],
    type_ignores=[])

thing: list[str] = []

Module(
    body=[
        AnnAssign(
            target=Name(id='thing', ctx=Store()),
            annotation=Subscript(
                value=Name(id='list', ctx=Load()),
                slice=Name(id='str', ctx=Load()),
                ctx=Load()),
            value=List(elts=[], ctx=Load()),
            simple=1)],
    type_ignores=[])