[Question] Is it proper to use union with Any to work against type-narrowing?

[Azureblade3808]

I've been playing with some black magics to make my coding work easier, and got some code like -

from __future__ import annotations

from typing import Any, Final, TypeVar

_T = TypeVar("_T")

def create_property(init_value: _T) -> _T:
    """
    Creates a writeable property with given initial value and
    pretends that it's just a plain variable.
    """
    ...  # Implmentation omitted here.

class C:
    # This is a private property, and we will use it as if it's a plain variable.
    __v: int = create_property(0)

    # This is the public version of `__v`.  It's declared `Final` to prevent writing.
    # In fact, it shares a same instance with `__v` which is a property, so they
    # always share a same value.
    v: Final = __v

    def __init__(self) -> None:
        self.__v += 1

c0 = C()
assert c0.v == 1

c1 = C()
assert c1.v == 1

Writing __v with any non-int value, or writing v with any value, would be rejected by type-checker. And type of v was inferred as int as expected.

And then I experimented with some tuple property -

class C:
    __v: tuple[int, ...] = create_property(())
    v: Final = __v

In this case, type of v was inferred as tuple[()] instead of tuple[int, ...] due to type-narrowing, which was expectable but beated my purpose. As a solution, I changed the signature of create_property to -

def create_property(init_value: _T) -> _T | Any:
    ...

Since then, everything worked perfectly, except for that type of v was inferred as tuple[()] | tuple[int, ...] instead of just tuple[int, ...], which was somehow acceptable.

Here is the question -
Am I doing right to use union with Any this way?

[erictraut]

Converting to a discussion topic since this is a question rather than a bug report or enhancement request.

[erictraut]

You're definitely using the type system in a "creative" way here. ;)

The reason you're seeing this behavior is because v doesn't have a declared type, so its type is being inferred. If you want to declare its type to be tuple[int, ...], you can use the following:

    v: Final[tuple[int, ...]] = __v

[Azureblade3808]

In fact, I was trying to avoid explicitly annotating the type of v.

v and __v should almost always have the same type, and I think it could redundant to write the same type more than once, especially when the type itself could be very long in some cases.

I just want to make sure that such usage of Any doesn't violate some design rule of Pylance/Pyright.

[erictraut]

No, it doesn't violate a design rule.

[Azureblade3808]

Thank you.