Mailman 3 May 2022 - Python-ideas

PEP 671 (late-bound arg defaults), next round of discussion!
by Chris Angelico July 23, 2023

July 23, 2023

I've just updated PEP 671 https://www.python.org/dev/peps/pep-0671/ with some additional information about the reference implementation, and some clarifications elsewhere. *PEP 671: Syntax for late-bound function argument defaults* Questions, for you all: 1) If this feature existed in Python 3.11 exactly as described, would you use it? 2) Independently: Is the syntactic distinction between "=" and "=>" a cognitive burden? (It's absolutely valid to say "yes" and "yes", and feel free to … [View More]

43 364

zip(x, y, z, strict=True)
by Ram Rachum Dec. 1, 2022

Dec. 1, 2022

Here's something that would have saved me some debugging yesterday: >>> zipped = zip(x, y, z, strict=True) I suggest that `strict=True` would ensure that all the iterables have been exhausted, raising an exception otherwise. This is useful in cases where you're assuming that the iterables all have the same lengths. When your assumption is wrong, you currently just get a shorter result, and it could take you a while to figure out why it's happening. What do you think?

27 179

Typescript-Like Notational Shortcuts
by kevinlu1248＠gmail.com July 1, 2022

July 1, 2022

On the theme of the addition of pip operators to indicate union, I was wondering what people think of using the following shortcuts for type hints. * type[] be a short-hand for List[type] * [type1, type2, type3] be a shorthand for Tuple[type1, type2, type3] * similar ideas for dictionaries and callables with (perhaps with javascript-like arrow notations?) I just think something like this would be easier to read. For example, a lot of functions that return tuples generally are immediately … [View More]

3 2

disallow assignment to unknown ssl.SSLContext attributes
by Thomas Grainger June 10, 2022

June 10, 2022

I was debugging some code that was using TLSv1.2 when I expected it to only support TLSv1.3, I tracked it down to a call to: context.miunimum_version = ssl.TLSVersion.TLSv1_3 it should have been: context.minimum_version = ssl.TLSVersion.TLSv1_3 I'd like invalid attribute assignment to be prevented at runtime

13 32

Expand the try-expect syntax to support conditional expect block
by Nadav Misgav June 4, 2022

June 4, 2022

Hello, I was thinking of a way to expand the current try-expect block to support condinitial expect block. I was imagining the new syntax as try: expression block expect Exception if condition expression block where the expect expression block would only run if the condition is met else it would raise the exception, for example the following code try: config = get_config() except Exception: if use_default: config = default else: raise would be converted … [View More]

8 11

Opt-in “iter def” and/or “gen def” syntax for generator functions
by armload_lakes0c＠icloud.com June 1, 2022

June 1, 2022

After getting used to writing async functions, I’ve been wanting use a similar syntax to declare generator functions. Something along the lines of `iter def my_iterator() -> T` and/or `gen def my_generator() -> (T, U, V)` Obviously, for backwards compatibility, this would need to be optional or have an opt-in mechanism. Would a feature like this be at all within the realm of possibility? I’d be happy to write up a much longer discussion if so. (I found a short discussion of such a … [View More]

6 9

Python array multiplication for negative values should throw an error
by fjwillemsen＠icloud.com June 1, 2022

June 1, 2022

Hopefully this is not a duplicate of an existing thread or in the wrong section, first time posting here. In Python, array multiplication is quite useful to repeat an existing array, e.g. [1,2,3] * 2 becomes [1,2,3,4,5,6]. Multiplication by 0 yields an empty array: [1,2,3] * 0 becomes []. However, operations such as [numpy array] * -1 are very common to get the inverse of an array of numbers. The confusion here stems from the lack of type checking: while the programmer should check whether … [View More]

7 8

Awaiting until a condition is met
by Aaron Fink May 31, 2022

May 31, 2022

Hello. I've been thinking it would be nice to be able to use await to suspend execution until a condition is met (as represented by a function or lambda which returns a boolean. Currently, as far as I can tell, the way to accomplish this is with a while loop which frequently checks the condition, suspending execution in between checks. My use case is in robotics, so I'll use that. Here's a minimal version of my current approach. start_moving_to(dest) while distance_to(dest) > tolerance: … [View More]

6 6

Enhance flexibility of dataclass repr
by Steve Jorgensen May 30, 2022

May 30, 2022

The desire for this came up for me in relation to a set of dataclasses used to define a tree structure where each item has a reference to its parent. Including the complete expansion of the parent (with its children and its parent with its children, etc.) is WAY too much information, but at the same time, I do want to at least identify the parent. Currently, the only way to get what I'm looking for is to write a custom `__repr__` from scratch. It would be great if there was at least 1 way to … [View More]

1 1

Provide an asynchronus equivalent to itertools.chain, and possibly more of itertools
by rammers2＠hotmail.co.uk May 28, 2022

May 28, 2022

I recently started to dive into asynchronous programming in Python. My program iterates over text from posts on a website and analyses it. I wanted to add the ability to asynchronously apply the same analysis to posts from multiple websites. It seemed likely to me that this would be something people commonly want to do, but I was surprised to find no built-in solution. There are a few relevant stack overflow posts: https://stackoverflow.com/questions/55299564/join-multiple-async-generators… … [View More]

1 0

TextIOBase: Make tell() and seek() pythonic
by mguinhos＠gmail.com May 27, 2022

May 27, 2022

seek() and tell() works with opaque values, called cookies. This is close to low level details, but it is not pythonic. (Non-pythonic and non-portable behaviour) Currently feeding seek() with wrong values could lead to unexpected behaviour. There should be a safer abstraction to these two basic functions. More details in the issue: https://github.com/python/cpython/issues/93101#issue-1244996658

7 12

Re: Popular Python Package 'ctx' Hijacked to Steal AWS Keys
by George Fischhof May 25, 2022

May 25, 2022

Turritopsis Dohrnii Teo En Ming <tdtemccna(a)gmail.com> ezt írta (időpont: 2022. máj. 25., Sze, 15:49): > Subject: Popular Python Package 'ctx' Hijacked to Steal AWS Keys > > Good day from Singapore, > > Sharing this article for more awareness. > > Article: Popular PyPI Package 'ctx' and PHP Library 'phpass' Hijacked > to Steal AWS Keys > Link: > https://thehackernews.com/2022/05/pypi-package-ctx-and-php-library-phpass.h… > > Thank you. > > … [View More]

1 0

Whitespace handling for indexing
by Jan Costandius May 25, 2022

May 25, 2022

I think that it would be beneficial for PEP 8 conformance, in the case of large nested dicts, if one were able to separate dict indices by a newline. What I mean is shown below: foo["bar"] ["baz"] ["eggs"] ["spam"] = 1

6 5

Would it be desirable to save the state of functools.cache?
by Neil Girdhar May 24, 2022

May 24, 2022

Would it be desirable to save the state of functools.cache between program executions? For example, by providing cache_state property on the cache that is pickle-able.

2 1

`importlib.resources` access whole directories as resources
by tankimarshal2＠gmail.com May 18, 2022

May 18, 2022

An `importlib.resources.as_file` equivalent but for whole directories. To access a directory of files in a package and load them (for example, a skybox with 6 faces), one would need to use `as_file` 6 times with 6 context managers. Moreover, if the API required a path to a folder that contained the 6 images, this would require manual extraction.

7 15

Re: Time to relax some restrictions on the walrus operator?
by Steven D'Aprano May 16, 2022

May 16, 2022

On Sun, May 08, 2022 at 04:00:47PM +0100, Rob Cliffe wrote: > Yes, I know unrestricted use of the walrus can lead to obfuscated code > (and some of Steven's examples below might be cited as instances 😁). They're intended as the simplest, least obfuscatory examples of using the walrus operator that is not pointless. That is, an example of the walrus as a sub-expression embedded inside another expression. If you think my examples are obfuscated, then that is an argument in … [View More]

3 2

Improving -x switch on CLI interface
by Rafael Nunes May 15, 2022

May 15, 2022

Hi. What about improving the -x switch by passing the number of lines to ignore? Ex: -x (default=1 line) -x n (Python will ignore first n lines of file). I think it will allow us to execute some Windows commands before running python. Install modules, etc... Thanks in advance. -- Rafael Nunes nunes.rafael(a)gmail.com

3 3

Re: `importlib.resources` access whole directories as resources
by Ray Chen May 15, 2022

May 15, 2022

How would I go about doing it myself then?

1 0

Re: `importlib.resources` access whole directories as resources
by Ray Chen May 15, 2022

May 15, 2022

An example is when an API asks for a folder that contains a set of images, and reads each image one by one. Having a folder is also useful for globbing and selecting certain files.

1 0

Re: Heterogeneous numeric data in statistics library
by Christopher Barker May 15, 2022

May 15, 2022

> > > >I was going to suggest the same thing: type casting can have > >non-obvious effects, so explicit is better than implicit in this case. > > Aye. Did you mean to send this just to me and not the list? > nope -- I know i"m in the minority but i really wish lists had reply-to set to the list. Bringing it back on. A pandas DataFrame comes with a conversion facility as a distinct > method, but it only copes with some basic types (int, float), and most > of … [View More]

1 0

Fwd: Re: Heterogeneous numeric data in statistics library
by Christopher Barker May 15, 2022

May 15, 2022

accidentally sent off list. -CHB ---------- Forwarded message --------- From: Christopher Barker <pythonchb(a)gmail.com> Date: Fri, May 13, 2022 at 8:14 PM Subject: Re: [Python-ideas] Re: Heterogeneous numeric data in statistics library To: Cameron Simpson <cs(a)cskk.id.au> On Thu, May 12, 2022 at 5:06 PM Cameron Simpson <cs(a)cskk.id.au > - a rule like the above requiring homogeneous data > - some convenience functions to produce homongenous data from mixed data … [View More]

1 0

Heterogeneous numeric data in statistics library
by Steven D'Aprano May 13, 2022

May 13, 2022

Users of the statistics module, how often do you use it with heterogeneous data (mixed numeric types)? Currently most of the functions try hard to honour homogeneous data, e.g. if your data is Decimal or Fraction, you will (usually) get Decimal or Fraction results: >>> statistics.variance([Decimal('0.5'), Decimal(2)/3, Decimal(5)/2]) Decimal('1.231481481481481481481481481') >>> statistics.variance([Fraction(1, 2), Fraction(2, 3), Fraction(5, 2)]) Fraction(133, 108) With … [View More]

6 5

Formatted structural patterns
by Matsuoka Takuo May 13, 2022

May 13, 2022

I would like to propose a new type of pattern for structural pattern matching. A motivation will be described later below. The pattern may be written in a form like {<literal or variable>} (with braces), where <literal or variable> is either a literal pattern or an identifier (or "NAME" in the structural pattern matching terminology in the language reference, meaning whatever the name of a variable can be). At matching against a value, it should be evaluated to the series of … [View More]characters held as the string format(<literal or variable>) returned (if computed successfully) by the built-in function ``format``. If those series of characters is a valid pattern of another type, then the pattern should be matched as the obtained pattern. Otherwise, an exception must be raised. Here are simple examples to clarify the idea. ``` subject = "x" pattern = "a" print(format(pattern)) # --> a match subject: case {pattern}: # interpreted as 'case a', so binds the subject # value to the variable "a" print(eval(format(pattern))) # --> x # For comparison, match subject: case pattern: # binds the subject value to the variable "pattern" print(pattern) # --> x # Some more examples. print(format(a)) # --> x match subject: case {a}: # interpreted as 'case x', so binds the subject value to # the variable "x" print(eval(format(a))) # --> x case {"a"}: # interpreted as 'case a' pass case "a": # matches a string equal to "a" pass case {'"a"'}: # interpreted as 'case "a"', so matches a string # equal to "a" pass ``` What if you format an object other than strings? Sometimes, a pattern of this type can be used like a value pattern. ``` from dataclasses import dataclass @dataclass class Point: x: int y: int point = Point(x=0, y=0) print(format(point)) # --> Point(x=0, y=0) match subject: case {point}: # interpreted as 'case Point(x=0, y=0)', and matches # a Point object at coordinates x=0, y=0 pass case point: # binds the subject value to the variable "point" pass ``` Motivation ---------- Consider what control you can have over a match statement using parameters. I'm considering the following context. Suppose you would like to define a function for which a match statement would be useful to make it do one of its steps. The definition of the function you write may look like ``` def f(*args): <some procedure> # Do a step with a match statement match <expression>: case <pattern 1> if <condition 1>: <procedure 1> case <pattern 2> if <condition 2>: <procedure 2> case ... ... ...... <another procedure> ``` Of the parts of the match statement, <expression>, <condition i> and <procedure i> will be expressions or series of statements, and can contain many parameters (variables) whose value may vary with arguments passed to the function. Through these parameters, what the match statement does can be controlled. I'm talking about such control. However, note the parts <pattern i> cannot contain parameters other than value patterns in them. This is rather restricted control. In order to have more control over patterns, one thing you might try may be to specify with an expression a string whose content will be the pattern you'd like to use, which can then be considered to be given parametrized by the value of variables contained in the expression, and do, e.g., ``` exec( f"""match subject: case {pattern}: pass """ ) ``` where the variable "pattern" in the braces holds the prametrized pattern as its value (or you could put the expression for the string directly between the braces). However, there is a problem with this approach that this done in the local scope doesn't do assignments, but only updates locals() directly, which means, if you want to use e.g., a captured value in some procedure later, then you would be able to get it not by simply writing the name of the variable for it but only by doing eval of that name, or by doing exec of the whole statement (or more) containing the variable, which would again only update locals(). This will be inconvenient since you can't necessarily just exec the whole code for your function since returning or yielding values can't be done with exec. Introduction of the proposed type of pattern would solve this problem since that would enable you to achieve what you want simply with ``` match subject: case {pattern}: pass ``` Best regards, Takuo Matsuoka [View Less]

1 0

New Tool Proposal
by anthony.flury May 11, 2022

May 11, 2022

A proposal for a new tool to be implemented - It is often the case that developer write Code in Python and then convert to a C extension module for performance regions. A C extension module has a lot of boiler plate code - for instance the Structures required for each class, the functions for Module initialization etc. My Idea is a simple tool that uses introspection tools to take a Python module and to generate the relevant boiler plate for the module - including blank functions … [View More]

5 5

Time to relax some restrictions on the walrus operator?
by Steven D'Aprano May 10, 2022

May 10, 2022

I don't have an opinion one way or the other, but there is a discussion on Discourse about the walrus operator: https://discuss.python.org/t/walrus-fails-with/15606/1 Just a quick straw poll, how would people feel about relaxing the restriction on the walrus operator so that iterable unpacking is allowed? # Currently a syntax error. results = (1, 2, (a, b) := (3, 4), 5) which would create the following bindings: results = (1, 2, (3, 4), 5) a = 3 b = 4 A more … [View More]

9 19