Mailman 3 December 2017 - Python-ideas

Adding a thin wrapper class around the functions in stdlib.heapq
by bunslow Feb. 18, 2022

Feb. 18, 2022

Nothing so bombastic this time. The heapq functions are basically all named "heapsomething", and basically all take a "heap" for their first argument, with supplementary args coming after. It's a textbook example of the (hypothetical) Object Oriented Manifesto™ where defining a class increases type safety and programmers' conceptual clarity. There're practically no drawbacks, and the code to be added would be very simple. Updating the tests and docs would probably be harder. In pure Python, … [View More]

17 32

@classproperty, @abc.abstractclasspropery, etc.
by K. Richard Pixley Dec. 16, 2020

Dec. 16, 2020

There's a whole matrix of these and I'm wondering why the matrix is currently sparse rather than implementing them all. Or rather, why we can't stack them as: class foo(object): @classmethod @property def bar(cls, ...): ... Essentially the permutation are, I think: {'unadorned'|abc.abstract}{'normal'|static|class}{method|property|non-callable attribute}. concreteness implicit first arg type name comments {unadorned} {unadorned} method def foo(): exists … [View More]now {unadorned} {unadorned} property @property exists now {unadorned} {unadorned} non-callable attribute x = 2 exists now {unadorned} static method @staticmethod exists now {unadorned} static property @staticproperty proposing {unadorned} static non-callable attribute {degenerate case - variables don't have arguments} unnecessary {unadorned} class method @classmethod exists now {unadorned} class property @classproperty or @classmethod;@property proposing {unadorned} class non-callable attribute {degenerate case - variables don't have arguments} unnecessary abc.abstract {unadorned} method @abc.abstractmethod exists now abc.abstract {unadorned} property @abc.abstractproperty exists now abc.abstract {unadorned} non-callable attribute @abc.abstractattribute or @abc.abstract;@attribute proposing abc.abstract static method @abc.abstractstaticmethod exists now abc.abstract static property @abc.staticproperty proposing abc.abstract static non-callable attribute {degenerate case - variables don't have arguments} unnecessary abc.abstract class method @abc.abstractclassmethod exists now abc.abstract class property @abc.abstractclassproperty proposing abc.abstract class non-callable attribute {degenerate case - variables don't have arguments} unnecessary I think the meanings of the new ones are pretty straightforward, but in case they are not... @staticproperty - like @property only without an implicit first argument. Allows the property to be called directly from the class without requiring a throw-away instance. @classproperty - like @property, only the implicit first argument to the method is the class. Allows the property to be called directly from the class without requiring a throw-away instance. @abc.abstractattribute - a simple, non-callable variable that must be overridden in subclasses @abc.abstractstaticproperty - like @abc.abstractproperty only for @staticproperty @abc.abstractclassproperty - like @abc.abstractproperty only for @classproperty --rich [View Less]

10 15

Re: [Python-ideas] Allow star unpacking within an slice expression
by Neil Girdhar March 7, 2020

March 7, 2020

I didn't think of this when we were discussing 448. I ran into this today, so I agree with you that it would be nice to have this. Best, Neil On Monday, December 4, 2017 at 1:02:09 AM UTC-5, Eric Wieser wrote: > > Hi, > > I've been thinking about the * unpacking operator while writing some numpy > code. PEP 448 allows the following: > > values = 1, *some_tuple, 2 > object[(1, *some_tuple, 2)] > > It seems reasonable to me that it should be extended to … [View More]

2 2

Specify number of items to allocate for array.array() constructor
by Sven Rahmann Feb. 22, 2020

Feb. 22, 2020

At the moment, the array module of the standard library allows to create arrays of different numeric types and to initialize them from an iterable (eg, another array). What's missing is the possiblity to specify the final size of the array (number of items), especially for large arrays. I'm thinking of suffix arrays (a text indexing data structure) for large texts, eg the human genome and its reverse complement (about 6 billion characters from the alphabet ACGT). The suffix array is a long int … [View More]

14 20

Asynchronous exception handling around with/try statement borders
by Erik Bray Sept. 24, 2018

Sept. 24, 2018

Hi folks, I normally wouldn't bring something like this up here, except I think that there is possibility of something to be done--a language documentation clarification if nothing else, though possibly an actual code change as well. I've been having an argument with a colleague over the last couple days over the proper way order of statements when setting up a try/finally to perform cleanup of some action. On some level we're both being stubborn I think, and I'm not looking for resolution … [View More]as to who's right/wrong or I wouldn't bring it to this list in the first place. The original argument was over setting and later restoring os.environ, but we ended up arguing over threading.Lock.acquire/release which I think is a more interesting example of the problem, and he did raise a good point that I do want to bring up. </prologue> My colleague's contention is that given lock = threading.Lock() this is simply *wrong*: lock.acquire() try: do_something() finally: lock.release() whereas this is okay: with lock: do_something() Ignoring other details of how threading.Lock is actually implemented, assuming that Lock.__enter__ calls acquire() and Lock.__exit__ calls release() then as far as I've known ever since Python 2.5 first came out these two examples are semantically *equivalent*, and I can't find any way of reading PEP 343 or the Python language reference that would suggest otherwise. However, there *is* a difference, and has to do with how signals are handled, particularly w.r.t. context managers implemented in C (hence we are talking CPython specifically): If Lock.__enter__ is a pure Python method (even if it maybe calls some C methods), and a SIGINT is handled during execution of that method, then in almost all cases a KeyboardInterrupt exception will be raised from within Lock.__enter__--this means the suite under the with: statement is never evaluated, and Lock.__exit__ is never called. You can be fairly sure the KeyboardInterrupt will be raised from somewhere within a pure Python Lock.__enter__ because there will usually be at least one remaining opcode to be evaluated, such as RETURN_VALUE. Because of how delayed execution of signal handlers is implemented in the pyeval main loop, this means the signal handler for SIGINT will be called *before* RETURN_VALUE, resulting in the KeyboardInterrupt exception being raised. Standard stuff. However, if Lock.__enter__ is a PyCFunction things are quite different. If you look at how the SETUP_WITH opcode is implemented, it first calls the __enter__ method with _PyObjet_CallNoArg. If this returns NULL (i.e. an exception occurred in __enter__) then "goto error" is executed and the exception is raised. However if it returns non-NULL the finally block is set up with PyFrame_BlockSetup and execution proceeds to the next opcode. At this point a potentially waiting SIGINT is handled, resulting in KeyboardInterrupt being raised while inside the with statement's suite, and finally block, and hence Lock.__exit__ are entered. Long story short, because Lock.__enter__ is a C function, assuming that it succeeds normally then with lock: do_something() always guarantees that Lock.__exit__ will be called if a SIGINT was handled inside Lock.__enter__, whereas with lock.acquire() try: ... finally: lock.release() there is at last a small possibility that the SIGINT handler is called after the CALL_FUNCTION op but before the try/finally block is entered (e.g. before executing POP_TOP or SETUP_FINALLY). So the end result is that the lock is held and never released after the KeyboardInterrupt (whether or not it's handled somehow). Whereas, again, if Lock.__enter__ is a pure Python function there's less likely to be any difference (though I don't think the possibility can be ruled out entirely). At the very least I think this quirk of CPython should be mentioned somewhere (since in all other cases the semantic meaning of the "with:" statement is clear). However, I think it might be possible to gain more consistency between these cases if pending signals are checked/handled after any direct call to PyCFunction from within the ceval loop. Sorry for the tl;dr; any thoughts? [View Less]

7 15

Positional-only parameters
by Victor Stinner Sept. 11, 2018

Sept. 11, 2018

Hi, For technical reasons, many functions of the Python standard libraries implemented in C have positional-only parameters. Example: ------- $ ./python Python 3.7.0a0 (default, Feb 25 2017, 04:30:32) >>> help(str.replace) replace(self, old, new, count=-1, /) # <== notice "/" at the end ... >>> "a".replace("x", "y") # ok 'a' >>> "a".replace(old="x", new="y") # ERR! TypeError: replace() takes at least 2 arguments (0 given) ------- When converting the … [View More]

19 27

Implicit string literal concatenation considered harmful?
by Guido van Rossum March 14, 2018

March 14, 2018

I just spent a few minutes staring at a bug caused by a missing comma -- I got a mysterious argument count error because instead of foo('a', 'b') I had written foo('a' 'b'). This is a fairly common mistake, and IIRC at Google we even had a lint rule against this (there was also a Python dialect used for some specific purpose where this was explicitly forbidden). Now, with modern compiler technology, we can (and in fact do) evaluate compile-time string literal concatenation with the '+' … [View More]

51 165

Repurpose `assert' into a general-purpose check
by Ivan Pozdeev Jan. 17, 2018

Jan. 17, 2018

The `assert' statment was created the same as in previous languages like C/C++: a check to only do in debug mode, when you can't yet trust your code to manage and pass around internal data correctly. Examples are array bounds and object state integrity constraints. Unlike C, Python does the aforementioned checks all the time, i.e. it's effectively always in "debug mode". Furthermore, validation checks are an extremily common use case. I have been using assert in my in-house code for … [View More]

17 34

Allow to compile debug extension against release Python in Windows
by Ivan Pozdeev Jan. 7, 2018

Jan. 7, 2018

The Windows version of pyconfig.h has the following construct: if defined(_DEBUG) pragma comment(lib,"python37_d.lib") elif defined(Py_LIMITED_API) pragma comment(lib,"python3.lib") else pragma comment(lib,"python37.lib") endif /* … [View More]

2 1

Add an UML class diagram to the collections.abc module documentation
by Yahya Abou 'Imran Jan. 5, 2018

Jan. 5, 2018

We can find very usefull class diagramm to understand the hierarchy of the builtin Collection abstract class and interface in java. Some examples: http://www.falkhausen.de/Java-8/java.util/Collection-Hierarchy-simple.html http://www.falkhausen.de/Java-8/java.util/Collection-List.html But when I search about python's ABC, The more detailed I can find are those from the book of Luciano Ramalho Fluent Python: https://goo.gl/images/8JGjvM https://goo.gl/images/6xZqcA (I think they're done with … [View More]

11 34

a set of enum.Enum values rather than the construction of bit-sets as the "norm"?
by Paddy3118 Jan. 3, 2018

Jan. 3, 2018

Maybe it is time to deemphasize the creation and passing of what is, in effect, bit-sets <https://en.wikipedia.org/wiki/Bit_array>as a single argument, and instead promote the passing of a set of members of an enum.Enum <https://docs.python.org/3/library/enum.html> constants. Thi comes about because someone wrote a description, (since deleted), of constructing bit-sets to use in passing flags to, for example, the re.compile <https://docs.python.org/3/library/re.html#re.… [View More]

10 20

Improve ABCs _dump_registry() readability
by Yahya Abou 'Imran Dec. 31, 2017

Dec. 31, 2017

In python 2.7, ABCs's caches and registries are sets. But in python 3.6 they are WeakSet. In consequence, the output of _dump_registry() is almost useless: >>> from collections import abc >>> abc.Iterator._dump_registry() Class: collections.abc.Iterator Inv.counter: 40 _abc_cache: <_weakrefset.WeakSet object at 0x7f4b58fe2668> _abc_negative_cache: <_weakrefset.WeakSet object at 0x7f4b53283780> _abc_negative_cache_version: 40 _abc_registry: <_weakrefset.WeakSet … [View More]

4 7

Change the __repr__ of the `MappingView`s
by Yahya Abou 'Imran Dec. 31, 2017

Dec. 31, 2017

=== This proposition is purely aesthetic === At this time, the __repr__ of the mapping views is showing the whole mapping: >>> from collections.abc import ValuesView, KeysView, ItemsView >>> d = {3: 'three', 4: 'four'} >>> KeysView(d) KeysView({3: 'three', 4: 'four'}) >>> ValuesView(d) ValuesView({3: 'three', 4: 'four'}) >>> ItemsView(d) ItemsView({3: 'three', 4: 'four'}) Witch is not consistent with dict_keys, dict_values, dict_items: >>&… [View More]

2 1

Make MappingView inherit from Collection instead of Sized
by Yahya Abou 'Imran Dec. 29, 2017

Dec. 29, 2017

After I generate an UML diagram from collections.abc, I found very strange that MappingView inherit from Sized instead of Collection (new in python 3.6). Yes, MappingView only define __len__ and not __iter__ and __contains__, but all of its subclasses define them (KeysView, ValuesView and ItemViews). I tried to run the tests in test/test_collections.py after making this change and on only one fail : Traceback (most recent call last): File "/usr/lib/python3.6/test/test_collections.py", line … [View More]

2 1

Is there a reason some of the PyLong_As* functions don't call an object's __int__?
by Erik Bray Dec. 29, 2017

Dec. 29, 2017

IIUC, it seems to be carry-over from Python 2's PyLong API, but I don't see an obvious reason for it. In every case there's an explicit PyLong_Check first anyways, so not calling __int__ doesn't help for the common case of exact int objects; adding the fallback costs nothing in that case. I ran into this because I was passing an object that implements __int__ to the maxlen argument to deque(). On Python 2 this used PyInt_AsSsize_t which does fall back to calling __int__, whereas … [View More]

6 17

Re: [Python-ideas] Internal function idea
by Brett Cannon Dec. 29, 2017

Dec. 29, 2017

[removing Python-ideas-owner so any replies don't flood my inbox] On Sat, Dec 23, 2017, 09:23 William Rose, <william27.07.02(a)gmail.com> wrote: > I had an idea that it could be helpful to have local functions as well as > normal ones. They would be called the same way as normal ones but def would > be replaced by internal and inside they could only access variables they > have defined and inputs to them so no global variables or class variables. > I think this could be … [View More]

3 2

Re: [Python-ideas] Internal function idea
by Franklin? Lee Dec. 29, 2017

Dec. 29, 2017

On Thu, Dec 28, 2017 at 5:21 AM, William Rose <william27.07.02(a)gmail.com> wrote: > I agree with the point that it should allow builtin but the main purpose of > it is to not allow global variables But functions are also accessed using global names. What is your answer to the potential problem of programmers being reluctant to factor out code into new functions?

2 3

Re: [Python-ideas] a set of enum.Enum values rather than the construction of bit-sets as the "norm"?
by Paddy3118 Dec. 29, 2017

Dec. 29, 2017

Hi Inada, can I take your point as being that execution speed is an issue? I am coming from the "Python as higher level, more programmer-centric language"direction. In the past, useful but slow things have spurred actions to speed them up.

1 0

Deprecate "slice" on built-ins, move it to "types"?
by Joao S. O. Bueno Dec. 29, 2017

Dec. 29, 2017

This is probably too little to justify the compatibility breakage, but is there a motive for the "slice" type to be on built-ins ? (besides people forgot it there at PEP-3000 time?) It is normally used in super-specialized cases, mostly when one is implementing a Sequence type, and even there just for type-checking, not to create new slice objects. It seems to me it should lie on the "types" module (or some other place), rather than eat built-in namespace (which can confuse newcomers anyway).… [View More]

3 2

__intancehook__ special method
by Yahya Abou 'Imran Dec. 26, 2017

Dec. 26, 2017

Hello everybody! In a personnal project I feel the need (or the desire) to implement something like this: assert isinstance(1, PositiveInteger) assert not isinstance(-1, PositiveInteger) So I began looking a lot in the abc module, and I end unp using an __instancehook__ special method wich is called by __instancechek__ in the corresponding metaclass, just like the __subclasshook__ special method called by __subclasscheck__. The core idea is something like this: class MyMeta(type): def … [View More]

2 2

Repr of lambda
by Serhiy Storchaka Dec. 24, 2017

Dec. 24, 2017

Currently repr of doesn't contain much of information besides that it is a lambda. >>> lambda x: x**2 <function <lambda> at 0x7f3479b74488> All lambdas have the same repr, different only by unreadable hexadecimal address. What if include the signature and the expression of the lambda in its repr? >>> lambda x: x**2 <lambda x: x**2> This would return an old feature of Python 0.9.1 (https://twitter.com/dabeaz/status/934835068043956224). Repr of … [View More]

13 16

Support floating-point values in collections.Counter
by Joel Croteau Dec. 20, 2017

Dec. 20, 2017

It would be useful in many scenarios for values in collections.Counter to be allowed to be floating point. I know that Counter nominally emulates a multiset, which would suggest only integer values, but in a more general sense, it could be an accumulator of either floating point or integer data. As near as I can tell, Collection already does support float values in both Python 2.7 and 3.6, and the way the code is implemented, this change should be a no-op. All that is required is to update the … [View More]

6 7

Raise StopIteration with same value on subsequent `next`s
by Franklin? Lee Dec. 12, 2017

Dec. 12, 2017

Consider the following code, which creates a generator that immediately returns 1, and then catches the StopIteration twice. def generatorfunction(): if False: yield return 1 def get_return(gen): try: next(gen) except StopIteration as e: return e.value else: raise ValueError("Generator was not ready to stop.") gen = generatorfunction() get_return(gen) #=> 1 get_return(gen) #=> None The … [View More]

3 4

Decorator for creating enumeration?
by Kirill Balunov Dec. 10, 2017

Dec. 10, 2017

Since PEP 557 "Data Classes"[1] and PEP 526 "Syntax for Variable Annotations"[2] are accepted and become part of the language. Is it worth writing a proposal about decorator-version for creating an enumeration? Something like: from enum import enum @enum(unique=True, int_=False, flag=False, ...): class Color: RED : auto GREEN: auto BLUE : auto Despite the fact that Functional API to create enums already exists, it seems to me that decorator-version will allow to unify … [View More]

3 2

a sorting protocol dunder method?
by Chris Barker Dec. 9, 2017

Dec. 9, 2017

I can't believe this hasn't been brought up before, but searching the web, and python-ideas, and all the PEPs has found nothing (could be my lame google-fu), so here goes: Recent python has moved toward a "key" function for customized sorting: list.sort(key=key_fun) key is also used (according to https://docs.python.org/3.6/library/functools.html#functools.cmp_to_key) in: min(), max(), heapq.nlargest(), heapq.nsmallest(), itertools.groupby() with this fairly broad use, it seems it's … [View More]

20 37