Mailman 3 March 2023 - Typing-sig

Opened and changed typing issues week 2023-W11
by Typing Bot March 20, 2023

March 20, 2023

The following is an overview of all issues and pull requests in the typing repository on GitHub with the label 'topic: feature' that were opened or updated last week, excluding closed issues. --------------------------------------------------- The following issues and pull requests were opened last week: #1371 Proposal: Programmatically create types opened by @NeilGirdhar https://github.com/python/typing/issues/1371 #1372 Add PartialApplication opened by @NeilGirdhar https://github.com/python/typing/issues/1372 --------------------------------------------------- The following issues and pull requests were updated last week: #213 Introduce an Intersection opened by @ilevkivskyi https://github.com/python/typing/issues/213 #256 Possible to distinguish between Sequence[str]/Iterable[str] and str? opened by @jtatum https://github.com/python/typing/issues/256 #802 Wrapper/Proxy Generic Type opened by @hatal175 https://github.com/python/typing/issues/802 #1273 Type mappings for generics opened by @jonathanslenders https://github.com/python/typing/issues/1273 #1362 Union of empty tuple should return `Never` opened by @randolf-scholz https://github.com/python/typing/issues/1362 --------------------------------------------------- All issues and pull requests with the label 'topic: feature' can be viewed under the following URL: https://github.com/python/typing/issues?q=label%3A%22topic%3A+feature%22

1 0

PyCon 2023 Typing Summit: Interest form
by S Pradeep Kumar March 16, 2023

March 16, 2023

Hello all, PyCon 2023 is just a few months out. Jelle and I are looking forward to organizing the Typing Summit this year. We plan to be in-person in Salt Lake City, as we did last year. We have confirmed the Typing Summit with PyCon and will announce the exact date soon (tentatively a day before the main conference talks). We will try to record the event for those who cannot make it. For those who haven't attended before, the Typing Summit is a 3-4 hour event with a series of presentations and group discussions related to type checking. You can find the 2022 summit here: https://youtu.be/BNTkWQfqP_c If you are interested in attending, please fill out this form: https://forms.gle/yv1WnDoAVscg21vW8. This way, we can get a sense of the expected number of attendees and the topics you want to hear about. In a few weeks, we will send out another mail to typing-sig calling for presenters. Let us know if you have any questions. Best, Jelle Zijlstra Pradeep Kumar Srinivasan

1 2

`__class_getitem__` returning a mix of GenericAlias and concrete classes?
by Sebastian Berg March 16, 2023

March 16, 2023

Hi all, In NumPy, we have `np.dtype` as a superclass for all DTypes. This implements `__class_getitem__` for typing to allow `np.dtype[Any]` or `np.dtype[np.float64]` returning a `GenericAlias`. Now, `np.dtype[Any]` probably must return a GenericAlias. Maybe `np.dtype[something_that_makes_little_sense]` also. However, `np.dtype[np.float64]` is well defined, there is a concrete runtime subclass of `np.dtype` representing exactly that construct. This would be the same as `array.array['l']` if `array.array` had concrete subclasses implementation for each supported type. My question is: would it be possible or even better to returning the concrete class (probably only when it exists)? Or would that just confuse the typing step, e.g. because we cannot actually type that `np.dtype[np.float64] -> np.types.Float64DType`. (Also, this isn't a fixed set in theory, users can create new subclasses in principle.) Hopefully this is very obvious in one direction, but unfortunately, I have no idea. Thanks and Cheers, Sebastian

5 16

type hint of function exceptions
by david.froger＠mailoo.org March 13, 2023

March 13, 2023

Hi everyone, I've read https://stackoverflow.com/questions/44282268/python-type-hinting-with-excep… and especially the https://jonathan-scholbach.github.io/2023/02/06/what-does-it-mean-to-be-exc… blog post, but I want to keep coding with exceptions rather than returning `Ok | Err`. Here is a simple pattern I'm thinking to use, to let a function indicate the `Exception`s it may raised, which can be used: - by the developper as documentation, - by the static type checker for exhaustiveness ```python from typing import NoReturn, cast, TypeAlias class SomeError(Exception): ... class AnotherError(Exception): ... class StillAnotherError(Exception): ... FooError: TypeAlias = ValueError | SomeError | AnotherError def assert_never(value: NoReturn) -> NoReturn: # This also works at runtime as well assert False, f"This code should never be reached, got: {value}" def foo(i: int): if i == 0: raise ValueError("Must not be zero") elif i == 1: raise SomeError("Must not be one") elif i == 2: raise AnotherError("Must not be two") print("that's ok") try: foo(0) except Exception as e: e = cast(FooError, e) if isinstance(e, ValueError): print("value error") elif isinstance(e, SomeError): print("some error") else: assert_never(e) raise ``` It's far from being perfect, but it's simple and not too much intrusive nor obscure. In the above example, `mypy` can tell me which exception I forgot to manage: ``` foo.py:43: error: Argument 1 to "assert_never" has incompatible type "AnotherError"; expected "NoReturn" [arg-type] Found 1 error in 1 file (checked 1 source file) ``` What do you thing of this? Here is a proposal where the exception are annotated in the return type, and the try/except would directly check for exhaustiveness: ``` from typing import NoReturn, Annotated class SomeError(Exception): ... class AnotherError(Exception): ... class StillAnotherError(Exception): ... def assert_never(value: NoReturn) -> NoReturn: # This also works at runtime as well assert False, f"This code should never be reached, got: {value}" def Raises(exceptions): ... # TODO class NeverException(Exception): ... # TODO def foo(i: int) -> Annotated[None, Raises(ValueError | SomeError | AnotherError)]: if i == 0: ¦ raise ValueError("Must not be zero") elif i == 1: ¦ raise SomeError("Must not be one") elif i == 2: ¦ raise AnotherError("Must not be two") print("that's ok") try: foo(0) except ValueError: print("value error") except SomeError: print("some error") except NeverException: # static type checker warns here that AnotherError is not managed raise ``` and here is another fictive example with one intermediary function managing one of the 3 exceptions: ```python from typing import NoReturn, Annotated class SomeError(Exception): ... class AnotherError(Exception): ... class StillAnotherError(Exception): ... def assert_never(value: NoReturn) -> NoReturn: # This also works at runtime as well assert False, f"This code should never be reached, got: {value}" def Raises(exceptions): ... # TODO class NeverException(Exception): ... # TODO def foo(i: int) -> Annotated[None, Raises(ValueError | SomeError | AnotherError)]: if i == 0: ¦ raise ValueError("Must not be zero") elif i == 1: ¦ raise SomeError("Must not be one") elif i == 2: ¦ raise AnotherError("Must not be two") print("that's ok") def bar(i: int) -> Annotated[None, Raises(ValueError | SomeError)]: try: ¦ foo(i) except AnotherError: ¦ print("another error") try: foo(0) except ValueError: print("value error") except SomeError: print("some error") except NeverException: # no errer reported by the static type checker raise ``` Thanks!

3 4

How is `__hash__` typing supposed to work?
by Steven Troxler March 13, 2023

March 13, 2023

Do we have any docs or past discussions (I didn't find anything from a quick search) on the expected behavior of Hashable and `__hash__` typing rules. As far as I can tell, state of the art in typeshed is that: - object defines `__hash__` (I can see why, it's true at runtime for actual object types) - unhashable types explicitly "un-define" `__hash__` by setting a `ClassVar[None]` It appears to me that Mypy, Pyre, and Pyright both support this in the sense that they will type a list's `__hash__` attribute as `None`. But because upcasting list to object should be safe, all three type checkers say (a) you can do that and (b) `__hash__` is definitely not `None` once you do that. They diverge as to whether a list is a valid dict key (in the absence of upcasting); MyPy and Pyre both treat it as okay whereas Pyright says list is not hashable. I don't really have strong opinions about how this ought to work, but I'm a little surprised that I didn't easily find any discussion about both (a) declaring `object` to be hashable even though it has unhashable subtypes (b) the use of `ClassVar[None]` to declare incompatible overrides that introduce unsoundness My github PR search skills aren't great, so it may be this was discussed in typeshed PRs. It does look like at least in the past there was a decision not to really enforce hashability anyway at least in MyPy: https://github.com/python/typeshed/pull/6244. ------- Here are all three type checkers on a snippet illustrating: - directly asking about the type of `list.__hash__` (all of them say `None`) - passing `list` to a function taking an `object` and asking if `__hash__` is non-None (all of them say yes) - directly trying to create a dict with list keys (Mypy and Pyre both allow it, Pyright does not) Mypy: https://mypy-play.net/?mypy=latest&python=3.11&gist=174be7c81c486062cd662a1… Pyright: https://pyright-playground.decorator-factory.su/?gzip=H4sIAD1mDmQC_2VPzQrCM… Pyre: https://pyre-check.org/play?input=def%20takes_hashable(o%3A%20object)%20-%3…

2 1

Opened and changed typing issues week 2023-W10
by Typing Bot March 13, 2023

March 13, 2023

The following is an overview of all issues and pull requests in the typing repository on GitHub with the label 'topic: feature' that were opened or updated last week, excluding closed issues. --------------------------------------------------- The following issues and pull requests were opened last week: #1362 Union of empty tuple should return `Never` opened by @randolf-scholz https://github.com/python/typing/issues/1362 --------------------------------------------------- The following issues and pull requests were updated last week: #213 Introduce an Intersection opened by @ilevkivskyi https://github.com/python/typing/issues/213 #256 Possible to distinguish between Sequence[str]/Iterable[str] and str? opened by @jtatum https://github.com/python/typing/issues/256 #1039 Annotate function which return a specific module (e.g. `-> Literal[np]`) opened by @Conchylicultor https://github.com/python/typing/issues/1039 --------------------------------------------------- All issues and pull requests with the label 'topic: feature' can be viewed under the following URL: https://github.com/python/typing/issues?q=label%3A%22topic%3A+feature%22

1 0

Opened and changed typing issues week 2023-W09
by Typing Bot March 6, 2023

March 6, 2023

The following is an overview of all issues and pull requests in the typing repository on GitHub with the label 'topic: feature' that were opened or updated last week, excluding closed issues. --------------------------------------------------- The following issues and pull requests were updated last week: #256 Possible to distinguish between Sequence[str]/Iterable[str] and str? opened by @jtatum https://github.com/python/typing/issues/256 #1160 Allow `float("inf")` and `float("-inf")` in literals opened by @antonagestam https://github.com/python/typing/issues/1160 --------------------------------------------------- All issues and pull requests with the label 'topic: feature' can be viewed under the following URL: https://github.com/python/typing/issues?q=label%3A%22topic%3A+feature%22

1 0

Modeling functions with attributes
by Thomas Kehrenberg March 4, 2023

March 4, 2023

Consider this decorator from django: def csrf_exempt(view_func): """Mark function as being exempt from the CSRF view protection.""" # wrapping not strictly necessary here but is good practice @wraps(view_func) def wrapper_view(*args, **kwargs): return view_func(*args, **kwargs) wrapper_view.csrf_exempt = True # set function attribute return wrapper_view This kind of pattern is quite common in Python since PEP 232 added the ability to assign attributes to functions. But how should this be typed? If we annotate the return type simply as "Callable", we lose the information that `.csrf_exempt` has been set. The current way to annotate this is to use a callback protocol: P = ParamSpec("P") R = TypeVar("R", covariant=True) class CSRFExempt(Protocol[P, R]): csrf_exempt: bool # here is the attribute def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R: ... def csrf_exempt(view_func: Callable[P, R]) -> CSRFExempt[P, R]: @wraps(view_func) def wrapper_view(*args: P.args, **kwargs: P.kwargs) -> R: return view_func(*args, **kwargs) wrapper_view.csrf_exempt = True return cast(CSRFExempt[P, R], wrapper_view) This will result in the right types when decorating *functions*, but it will not result in the right types for *methods*. That is because callable classes are not bound as methods; only real functions are. But in our annotation, the return type of csrf_exempt() is not a function but a callable object. So, type checkers will mistakenly think that the function is not bound as a method when it actually is. You can try to solve this problem by making csrf_exempt() return a descriptor object when called on a method, but that leads to other problems as discussed here for example: https://mail.python.org/archives/list/typing-sig@python.org/thread/QZX5WN4N… Besides, at runtime there aren't actually any descriptor objects involved, so it would be nice if we could actually describe what happens at runtime. My proposal is to introduce a new `FunctionProtocol` type (alternative names `AttributedFunction` or `FunctionWithAttributes`) to accurately describe *functions* (not callable objects) with attributes. For the above example, it would look like this: class CSRFExempt(FunctionProtocol[P, R]): # now `FunctionProtocol` csrf_exempt: bool @staticmethod def __call__(*args: P.args, **kwargs: P.kwargs) -> R: ... A FunctionProtocol describes only real functions that can optionally have attributes. It is similar to TypedDict in that it cannot be used at runtime in any way. So, in contrast to Protocol, not even subclasses of FunctionProtocol can be instantiated and there will be no @runtime_checkable decorator. One problem is that there is no syntax in Python for specifying attribues on a function in the definition of the function itself. That is, we have to write: def a() -> None: pass a.publish = True instead of something like def a() with (publish = True) -> None: pass so, type checkers will unfortunately have to do extra work in keeping track of attributes: class Publishable(FunctionProtocol): publish: bool @staticmethod def __call__() -> None: ... def a() -> None: pass a.publish = True # type checker has to note that an attribute was set f: Publishable = a # this assignment is valid This creates a kind of spooky action at a distance, but I don't see a good way to avoid this (except to introduce new syntax). The example from above then becomes: class CSRFExempt(FunctionProtocol[P, R]): csrf_exempt: bool @staticmethod def __call__(*args: P.args, **kwargs: P.kwargs) -> R: ... def csrf_exempt(view_func: Callable[P, R]) -> CSRFExempt[P, R]: @wraps(view_func) def wrapper_view(*args: P.args, **kwargs: P.kwargs) -> R: return view_func(*args, **kwargs) wrapper_view.csrf_exempt = True return wrapper_view # type checker can verify that this is valid And this decorator will then work as expected with methods as well as functions. FunctionProtocol will inherit all the attributes that functions have: ('__module__', '__name__', '__qualname__', '__doc__', '__annotations__') Just as with TypedDict, you can create subtypes, that add even more attributes. One could even re-use the NotRequired[] annotation from TypedDicts to express that an attribute might not be set (but if it was set, it would have the specified type). Callable objects are incompatible with FunctionProtocol: class SimpleFunc(FunctionProtocol): # you can use `@staticmethod` here or add a `self`; both are fine def __call__(self) -> None: ... class MyCallable: def __call__(self) -> None: print("Hello, world!") f: SimpleFunc = MyCallable() # type error! g: SimpleFunc = lambda: None # OK The main concern I see with this proposal is the spooky action at a distance that type checkers will have to implement. I can't really say how difficult it would be. Best, Thomas

2 3

Re: Inline syntax for TypedDict
by Frodo821 March 4, 2023

March 4, 2023

This proposal is pretty wanted, but I have a trivial question: the syntax you proposed conflicts with the dict literal, but how to distinguish between TypedDict type literal and existing dict literal? Or do you mean to treat some kind of dict as a type? -- chihiro sakai

1 0