Mailman 3 June 2020 - Python-ideas

PyLong_{As,From}ByteArray
by doodspav＠gmail.com 19 Jun '20

19 Jun '20

Unless I've misunderstood this API, and the `ByteArray` part doesn't refer to an array of bytes representing the value of `PyLong` in 2's complement, can we implement this in the public header? It's already available, it's just not exported (at least I can't use it, and it's not in the documentation). This would be beneficial for fixed width integer types, especially ones larger than `long long` (e.g. `__int128_t`), and shouldn't take much effort since it's already implemented privately (https://github.com/python/cpython/blob/04fc4f2a46b2fd083639deb872c3a3037fdb…). Possibly include a function to return the size of the would-be array to be used as a check? Also since I have nowhere else to ask it, what's with `PyLong_AsSignedType` doing type coercion for you, but `PyLong_AsUnsignedType` not? (At least that's what I gathered from the documentation)

1 0

EVENTFD(2) support
by doodspav＠gmail.com 18 Jun '20

18 Jun '20

Can we implement eventfd(2) as documented here <https://man7.org/linux/man-pages/man2/eventfd.2.html>? It would only be available on the Linux platform, and one of the benefits would be the ability to create synchronisation primitives on said platform that can block on normal threads, and be awaited on in coroutines (without busy looping inside said coroutine). Currently the best place I can think of to put it would be in one of the Networking and Interprocess Communication modules (possibly `select` or `socket`?). The fact that it's Linux only shouldn't be an issue, since much of the contents of `select` is OS dependent.

6 10

the 'z' string escape
by Soni L. 17 Jun '20

17 Jun '20

in Lua 5.2+, there's this string escape that allows you to put "whitespace" (in particular, including newlines) in a string literal, by skipping them entirely. now, unlike lua's long strings, python *does* have escapes in long strings. however, sometimes you have help text: "switches to toml config format. the old 'repos' " #cont "table is preserved as 'repos_old'" and... well yeah you can see what I did to make it work. if I used a long string here, I'd get a newline and a bunch of indentation in the middle. so I propose a \z string escape which lets me write the above as shown below: """switches to toml config format. the old 'repos' \z table is preserved as 'repos_old'""" (side note to avoid unnecessary comments: this help text refers to database tables and migrations. it's not about lua tables.)

6 12

Support infinite temporal types
by Alexander Hill 17 Jun '20

17 Jun '20

Hi all, I’d like to propose support for infinite dates, datetimes and timedeltas. They're very useful when you need to model ranges with one or both ends unbounded (e.g. “forever starting from June 15th 2020”). Without first-class infinite values, you can use None, or you can use the `min` and `max` attributes of Python’s datetime types, or some other arbitrary large values. Using None means you need to implement a path for None, and a path for everything else, and your various infinite values are indistinguishable. Using max/min means comparisons just work, but calculations need special treatment and you’re fundamentally misrepresenting your meaning. Temporal infinities give the best of both worlds: infinite values that interoperate seamlessly with the built-in types and behave sensibly and predictably. They’re also supported by Postgres! Usage examples: >>> from temporal_infinities import * >>> from datetime import * >>> DATETIME_POS_INF - datetime(2020, 6, 15) TIMEDELTA_POS_INF >>> DATETIME_NEG_INF < date(2020, 6, 15) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: '<' not supported between instances of 'DatetimeInfinity' and 'datetime.date' >>> DATE_NEG_INF < date(2020, 6, 15) True >>> date(2020, 6, 15) + TIMEDELTA_POS_INF DATE_POS_INF >>> TIMEDELTA_NEG_INF == TIMEDELTA_NEG_INF True My implementation is at https://github.com/AlexHillAlexHill/temporal-infinities <https://github.com/AlexHill/temporal-infinities> and is designed to be as consistent with the behaviour of floating-point infinities as possible. The expected behaviour of the various types is captured in test_matrix.csv, which is used to produce test cases. Blank cells indicate that a TypeError should be raised. It's tested back to Python 3.4. Previous discussion: https://mail.python.org/pipermail/python-ideas/2015-January/031414.html Thanks for your time! Alex

5 8

Doc preview in Github PR
by remi.lapeyre＠henki.fr 17 Jun '20

17 Jun '20

I think the possibility to have publish a preview when a PR changes the documentation was considered at one time but I can't find anything about this now. Has this been scraped?

3 2

String module name
by redradist＠gmail.com 16 Jun '20

16 Jun '20

What if we introduce the string module: ```python from "https://python.org/some_module.py" import name ... ``` It will add possibility to run code with complex name of module that cannot be presented as set of lexical items and also will allow to load the module from external location

4 5

For quicker execution, don't refcount objects that can't be deleted
by Jonathan Fine 16 Jun '20

16 Jun '20

Hi Here's something that might make code run quicker. The basic idea is to not refcount some objects that are sure never to be deleted. On a multicore machine, this might significantly reduce the number of cache invalidations (and perhaps misses). I lack many of the skills needed to investigate this further. Aside: This idea prompted by: Make `del x` an expression evaluating to `x` https://mail.python.org/archives/list/python-ideas@python.org/message/WVQNA… Consider >>> tuple(id(n) - id(0) for n in range(10)) (0, 32, 64, 96, 128, 160, 192, 224, 256, 288) Why? Small integers are stored at fixed locations, hence the arithmetic progression. Let's look at refcounts. >>> import sys >>> tuple(sys.getrefcount(n) for n in range(10)) (511, 837, 113, 54, 63, 35, 30, 20, 65, 17) These refcounts are variable numbers. They can be changed (within limits). >>> x = [0] * 100000 >>> tuple(sys.getrefcount(n) for n in range(10)) (100510, 837, 113, 54, 63, 35, 30, 20, 65, 17) The same happens with None. >>> sys.getrefcount(None) 8475 >>> x = [None] * 100000 >>> sys.getrefcount(None) 108475 For me the basic idea of the implementation would be to not refcount those objects, whose id lies in a certain range. As stated earlier, I suspect the main benefit will be on multicore machines being able to make better use of per-core caches. If anyone is interested, I suggest starting with None, to get a rough estimate of the possible benefits (and cost of implementation). As well as the python-ideas thread mentioned above, related to this is: https://stackoverflow.com/questions/14139111/python-disable-reference-count… -- Jonathan

9 15

Python WebAssembly Support
by redradist＠gmail.com 16 Jun '20

16 Jun '20

Hi all, I love Python, but as soon as I need to do something in browser I have to use ugly JavaScript !! Is there any future plans support for compiling CPython to WebAssembly using Emscripten ?

7 9

Keyword 'THIS'
by M Bfmv 15 Jun '20

15 Jun '20

Hey all. Ever had some list comprehension hell in your code? Me neither *whistles 418 happly*... I was thinking about this idea and while `this` keyword is equalevant to `self` i have to explain myself. English is not my main language, sorry for that :' ) Here is my pseudo code. ``` if [i for i in range(10) if i == 11]: print(this) Evaluate: [] ``` Another one ``` if [i for i in range(10) if i == 5]: print(this) Evaluate: [5] ``` As I try to show above. It would be neat to make a list comprhension if statement and use those results in the if condition as the `this` parameter Instead of declaring variables like ``` a = [i for i in range(10) if i == 5] if a: print(a) Evaluate: [5] ``` I hope I explained my idea well enough and hope to see something like this in the future. If anyone has questions on my interpretation please ask.

5 5

Operator ">" for functions
by artem6191 14 Jun '20

14 Jun '20

This operator will allow to send arguments to function only by certain values. Example: def some_function(a > (1, 2,3), b): # Some code some_function(1, 2) some_function(4, 2) # Error "Value '4' is not allowed for argument 'a'"

8 9