Mailman 3 - Typing-sig

by S Pradeep Kumar

Hello all, User-friendly Callable syntax is something we all want to see. However, there has been no real movement on the discussion in the last one month. People have had differing opinions based on design principles, stats, and personal experience. This has led to half a dozen proposals with some subtle and not-so-subtle differences [1]. And Guido pointed out that we want to settle on a full proposal instead of going for a partial PEP now and settling on the remaining details in a later PEP. How about we meet up over a zoom call and discuss some of the key concerns? Things proceed noticeably faster when people from the typing community are able to get in the same (virtual) room (I saw that with PEP 646 and the typing summit). We don't have to reach a consensus in the first meeting itself. It's more a way to break the deadlock and make progress. Date: 10 am San Francisco time (6 pm UK time), Monday, September 13, 2021. Date is flexible. Duration: 1 hour. If there is enough interest, I can set up the video call and share the link and agenda. If you're interested in presenting pros and cons for your favorite proposal, reply to this mail. [1]: Document containing the various proposals and use cases: https://docs.google.com/document/d/11VkNk9N8whxS1SrBv2BNN1Csl5yeTlgG7WyLrCB… -- S Pradeep Kumar

9 hours, 58 minutes

7
17
1 0

Next tensor typing meeting: Monday 13th

by Matthew Rahtz

Hi all, Our next tensor typing meeting will be *Monday the 13th at 6pm London time / 10am San Francisco time *at http://meet.google.com/fft-dzjq-ksu. Agenda is yet to be confirmed. As always, notes and recordings from past meetings are available here <https://docs.google.com/document/d/1oaG0V2ZE5BRDjd9N-Tr1N0IKGwZQcraIlZ0N8ay…> . Thanks! Matthew

2 days, 3 hours

1
4
1 0

Literals in dynamic type checking

by Paul Bryan

Background typing.Literal was defined with static type checking in mind. During static type checking, Literal requires the value being checked to be a literal value, matching one of the Literal value(s) specified. In a static type checking context, this behaviour is both intuitive and obvious. Problem During dynamic type checking, Literal can be specified in a type hint, but there is no obvious way to determine at runtime whether the value being checked is sourced from a Python literal or elsewhere. For example, it could have been loaded from JSON. Furthermore, it is not necessarily desirable to make such a determination at runtime. Pydantic currently validates a value against a Literal type hint without regard to whether it is a Python literal. It appears to simply check for type and value equality against the defined Literal values in the type hint. (This is originally how I interpreted Literal would behave when I first encountered it.) I believe this makes Pydantic’s use of Literal incompatible with static type checking tools like mypy. Ideas 1. Codify Pydantic’s current behavior without changing static type checking behavior (in PEP 586 or elsewhere) This would lead to many situations where code would pass type checking at runtime, but fail static type checking due to constraints on literal values. 2. Relax Literal’s “literalness” static type checking behavior I believe this would conflict with developers’ objectives of keeping the value “safe” by requiring it be literally supplied, not allowing it to be deserialized or built dynamically. (Discussed previously on this list.) 3. Just use Enum I would argue Enum is unnecessary verbose, requiring the definition of a class, separate members, subclassing and dunders (e.g. __str__) to handle string values. It requires unnecessary naming of values, and requires avoiding “invalid” names. (3.11’s StrEnum could mitigate some of this?) 4. Define a new “relaxed” Literal type hint Define a new type hint, paralleling Literal’s syntax, relaxing the requirement that the value be an actual literal. Candidate names like Figure[...], Value[...], enum[...]. It would likely not be included in stdlib, so would likely be implemented by dynamic type checking libraries. What are your thoughts? Thanks in advance for your consideration.

3 days, 7 hours

4
9
0 0

seeking feedback on a proposed deprecation library to be used at type checking time (in pytype)

by Yilei Yang

Hi everyone, I'm working on a proposal to introduce a deprecation library. It is intended to be used at type checking time, and will be supported by pytype. The primary benefit (over DeprecationWarning at runtime) is to provide deprecation signals at static analysis time (think type checking, linting, IDE support). **The gist of the deprecation library** ============================ The gist of the deprecation library is to use a data class Deprecated wrapped in a typing.Annotated to mark variables/methods/functions as deprecated. Here are a couple of examples: # API: @dataclasses.dataclass class Deprecated: reason: str # Usages: my_constant: Annotated[int, Deprecated("my_constant is deprecated.")] = 123 def do_something(name: str, arg: Annotated[Any, Deprecated("`arg` is deprecated.")] = None) -> None: # The parameter `arg` is deprecated def my_function(name: str) -> Annotated[str, Deprecated("my_function is deprecated.")]: # Putting Deprecated in the return value type marks the method/function as deprecated. class MyClass: def __init__(self) -> Annotated[None, Deprecated("MyClass is deprecated.")]: # Marking __init__ as deprecated makes the class deprecated It is a no-op at runtime, and per PEP 593 it should be ignored by type checkers that don't support it. We also intend to include a higher-level decorator that will be turned into the lower-level annotations at type checking time. Here is an example: # API: def deprecated(message: str, stacklevel: int = 2) -> Callable[[_T], _T]: def decorator(wrapped): @functools.wraps(wrapped) def wrapper(*args, **kwargs): warnings.warn(message, DeprecationWarning, stacklevel=stacklevel) return wrapped(*args, **kwargs) return wrapper return decorator # Usage: @deprecated("my_func is deprecated") def my_func(name): print(f"Called my_func with {name}") At type checking time, it turns the function to def my_func(name) -> Annotated[?, Deprecated("my_func is deprecated")]. ? is either a concrete type if the type checker can infer its return type, or Any if not. At runtime, it raises a DeprecationWarning whenever my_func is called. **Feedback I'm looking for** ====================== Above isn't very detailed nor a finalized design. But I hope the idea is just clear enough to seek some initial feedback. The things I'm specifically looking for are: * Would the use of these APIs cause issues for other type checkers? Per my interpretation of PEP 593, it shouldn't. I tested with pytype, mypy, pyright, and pyre, one hiccup I found is pyre thinks annotating __init__ with Annotated[None, Deprecated("")] is an error (Incompatible constructor annotation [17]: __init__ is annotated as returning typing.Annotated[None], but it should return None.) * Is there interest from other type checkers to support such a deprecation library, so that static analysis tooling can provide better support detecting the use of deprecated APIs? Thanks, Yilei

5 days, 10 hours

4
5
0 0

typing-extensions/backport: Dropping support for Python 2.7, 3.4, and 3.5

by Sebastian Rittau

We plan to drop support for Python 2.7, 3.4, and 3.5 for typing-extensions. [1] These Python versions have reached end-of-life for at least a year and tooling starts to be a problem. The Python 2 version of the library already has some omissions compared to the Python 3 version. Older versions (up to 3.10.0.2) will remain available for these Python versions. We also plan to drop the typing backport for Python 2.7 and 3.4. [2] This is what later became the typing module in Python proper. The Python 2 module had its last commit in 2019 and the Python 3 module was made obsolete with the introduction of typing in Python 3.5. Of course, old packages will remain available, but we will make no new releases. If you have any concerns, please voice them either here or in the linked GitHub issues. - Sebastian [1] https://github.com/python/typing/issues/867 [2] https://github.com/python/typing/issues/877

1 week, 5 days

1
0
0 0

Viability of letting TypedDict classes inherit from Generic without a PEP change

by isamodya＠gmail.com

Hello typing-sig, I have started couple of threads before about adding `Generic` support for `TypedDict`. But this thread is specifically to get an idea about the viability to let `TypedDict` classes inherit from `Generic` **without a PEP change**. Specifically the impact on type checker implementations. The discussion was started in https://bugs.python.org/issue44863 (and associated PR: https://github.com/python/cpython/pull/27663). Copied (with minor edits) my reasoning from https://bugs.python.org/issue44863 :: TypedDict PEP-589 says: A TypedDict cannot inherit from both a TypedDict type and a non-TypedDict base class. So the current run time implementation has: `if type(base) is not _TypedDictMeta: raise TypeError(...)` This restricts the user from defining generic TypedDicts in the natural class based syntax: `class Pager(TypedDict, Generic[T]): ...` Although PEP 589 doesn't explicitly state generic support. I believe it is complete in covering all semantic details even with Generics. Even structural subtyping because it says: "Value types behave invariantly, since TypedDict objects are mutable." I have tried putting together a PEP from guidance of typing-sig <https://github.com/sransara/py-generic-typeddict/blob/master/pep-9999.rst>. There is not much new contributions by that draft, except for specifying the alternative syntax and being more explicit about Generics: 1. relaxing this line from PEP-589 and be explicit to include Generic: "A TypedDict cannot inherit from both a TypedDict type and a non-TypedDict base class." (IMO by thinking `Generic` as a mixin even this is not needed) 2. may be syntax for generic in the alternative syntax (side note: collecting typevars from the values is hard to implement because of forward refs) 3. Some explicit generic examples for good measure So I'm wondering if it would be possible to relax the constraint: TypedDict inheritance to include Generic. In my point of view `Generic` is more of a mixin, so it doesn't go against the PEP 589. Or is this change really big enough to warrant a new PEP or PEP update? My understanding was that during initial implementation this was not done for the sake of implementation simplicity (days before PEP-560). All that said, a new PEP would be a good way to notify the type checkers of this capability. Please let me know your thoughts.

1 week, 5 days

2
1
1 0

Definition-site variance for TypeVar

by Sergei Lebedev

Hi everyone, Type variables allow to specify their variance at construction time, i.e variance is currently a property of a type variable. This is problematic for cases when a type variable is used outside of a generic class. For example, T_co = TypeVar("T", covariant=True) def callback(value: T_co): ... or ListT = list[T_co] I am curious, if we could instead deprecate the variance parameters and make variance local to the generic class definition. Specifically, * all type variables are created invariant; * a type variable can be annotated as covariant and contravariant using unary + and - operators respectively; * these operators are only allowed when a type variable is referenced in the bases of a class definition. For example, here T = TypeVar("T") class Source(Generic[+T]): ... the class Source is covariant in T. Wdyt? Sergei

2 weeks

2
1
0 0

Re: Definition-site variance for TypeVar

by Gobot1234

There is a pep currently being written to support this, go to https://github.com/python/typing/issues/813 for the discussion about this.

2 weeks

1
0
0 0

How to extend Type or how to type a wrapper class

by Patrick Arminio

Hi everyone! I'm trying to type a decorator that returns a Wrapper class of another class. The idea is that I have a wrapper class that only adds a couple of properties to the original class, something like this: ```python from typing import Type, TypeVar, Generic _T = TypeVar("_T") class Wrapper(Generic[_T]): wrap: Type[_T] enhanced: bool = True def __init__(self, cls: Type[_T]) -> None: self.wrap = cls def __call__(self, *args, **kwargs): ... def enhance(cls: Type[_T]) -> Type[_T]: return Wrapper(cls) # type: ignore class X: ... EnhanceX = enhance(X) reveal_type(EnhanceX) reveal_type(EnhanceX.enhanced) ``` The user using the class doesn't really need to know that it has been "enhanced", as it should work as it was before. My initial idea was to extend `Type` from typings, but that's not possible. What would you suggest to do here? Should I type all the methods on `Wrapper` to basically behave as if they were from `self.wrap`? not sure if that's actually possibile There's also a possibility where I'm doing something silly with what I'm trying to do, but it should make sense for my use case 😊

2 weeks, 2 days

2
1
0 0

How to pass a reference to a protocol class

by Andreas Stenius

Hi, I’m in a position, where I’d like to be able to pass a reference to a Protocol Class, however, I can’t find a way to describe that variable with the current type system, as Type[ProtocolClass] means a class implementing said protocol, where I want the protocol itself, while ProtocolClass means an instance of a class implementing the protocol. So I haven’t figured out if PEP 544 specifies a type that describes the Protocol class itself, rather than just its compatible implementations. I tried to file this as a mypy bug <https://github.com/python/mypy/issues/10988>, but no response yet, and alas, figure it may even be overlooked by the PEP in question. Anyway, I’d very much appreciate a few more eyes and input on this matter. Thank you, Cheers This is a cross post from https://discuss.python.org/t/how-to-pass-a-reference-to-a-protocol-class/10… Reported MyPy Issue: https://github.com/python/mypy/issues/10988

3 weeks, 5 days

1
1
0 0

2021

2020

2019

2018

Typing-sig