Mailman 3 June 2021 - Python-ideas

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

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

Bringing the print statement back
by Guido van Rossum March 2, 2022

March 2, 2022

In Python 3.10 we will no longer be burdened by the old parser (though 3rd party tooling needs to catch up). One thing that the PEG parser makes possible in about 20 lines of code is something not entirely different from the old print statement. I have a prototype: Python 3.10.0a0 (heads/print-statement-dirty:5ed19fcc1a, Jun 9 2020, 16:31:17) [Clang 11.0.0 (clang-1100.0.33.8)] on darwin Type "help", "copyright", "credits" or "license" for more information. Cannot read termcap database; using … [View More]dumb terminal settings. >>> print 2+2 4 >>> print "hello world" hello world >>> print "hello", input("Name:") Name:Guido hello Guido >>> print 1, 2, 3, sep=", " 1, 2, 3 >>> But wait, there's more! The same syntax will make it possible to call *any* function: >>> len "abc" 3 >>> Or any method: >>> import sys >>> sys.getrefcount "abc" 24 >>> Really, *any* method: >>> class C: ... def foo(self, arg): print arg ... >>> C().foo 2+2 4 >>> There are downsides too, though. For example, you can't call a method without arguments: >>> print <built-in function print> >>> Worse, the first argument cannot start with a parenthesis or bracket: >>> print (1, 2, 3) 1 2 3 >>> C().foo (1, 2, 3) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: C.foo() takes 2 positional arguments but 4 were given >>> print (2+2), 42 4 (None, 42) >>> C().foo [0] Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'method' object is not subscriptable >>> No, it's not April 1st. I am seriously proposing this (but I'll withdraw it if the response is a resounding "boo, hiss"). After all, we currently have a bunch of complexity in the parser just to give a helpful error message to people used to Python 2's print statement: >>> print 1, 2, 3 File "<stdin>", line 1 print 1, 2, 3 ^ SyntaxError: Missing parentheses in call to 'print'. Did you mean print(1, 2, 3)? >>> And IIRC there have been a number of aborted attempts at syntactic hacks to allow people to call functions (like print) without parentheses, although (I think) none of them made it into a PEP. The PEG parser makes this much simpler, because it can simply backtrack -- by placing the grammar rule for this syntax (tentatively called "call statement") last in the list of alternatives for "small statement" we ensure that everything that's a valid expression statement (including print() calls) is still an expression statement with exactly the same meaning, while still allowing parameter-less function calls, without lexical hacks. (There is no code in my prototype that checks for a space after 'print' -- it just checks that there's a name, number or string following a name, which is never legal syntax.) One possible extension I didn't pursue (yet -- dare me!) is to allow parameter-less calls inside other expressions. For example, my prototype does not support things like this: >>> a = (len "abc") File "<stdin>", line 1 a = (len "abc") ^ SyntaxError: invalid syntax >>> I think that strikes a reasonable balance between usability and reduced detection of common errors. I could also dial it back a bit, e.g. maybe it's too much to allow 'C().foo x' and we should only allow dotted names (sufficient to access functions in imported modules and method calls on variables). Or maybe we should only allow simple names (allowing 'len x' but disallowing 'sys.getrefcount x'. Or maybe we should really only bring back print statements. I believe there are some other languages that support a similar grammar (Ruby? R? Raku?) but I haven't investigated. Thoughts? -- --Guido van Rossum (python.org/~guido) *Pronouns: he/him **(why is my pronoun here?)* <http://feministing.com/2015/02/03/how-using-they-as-a-singular-pronoun-can-…> [View Less]

42 66

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

Feb. 17, 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

Allow syntax "func(arg=x if condition)"
by Peter O'Connor Jan. 19, 2022

Jan. 19, 2022

I often find that python lacks a nice way to say "only pass an argument under this condition". (See previous python-list email in "Idea: Deferred Default Arguments?") Example 1: Defining a list with conditional elements include_bd = True current_way = ['a'] + (['b'] if include_bd else [])+['c']+(['d'] if include_bd else []) new_way = ['a', 'b' if include_bd, 'c', 'd' if include_bd] also_new_way = list('a', 'b' if include_bd, 'c', 'd' if include_bd) Example 2: Deferring to … [View More]

6 9

copy-paste code snippets to the python console
by Raymond Bisdorff Aug. 15, 2021

Aug. 15, 2021

Dear Python developers, It would be helpful, if the following issue with copy-pasting python code-snippets into the standard shell console, could be investigated and corrected. https://stackoverflow.com/questions/2501208/copying-and-pasting-code-into-t… In particular, copying and pasting from sphinx python and pycon code-blocks with copy button (only >>> and ... lines), is at present not generally working due to the "the shell-s de-indent cmd" need for empty lines. See … [View More]

2 1

Pre PEP: Python Literals (was custom strings before)
by Thomas Güttler July 11, 2021

July 11, 2021

Thank you Guido, Chris, Matt and Richard for your feedback to my last email. Here is an updated version called "Template Literals". I am looking for a core developer who can sponsor this PEP. Please speak up if you want to help me. Regards, Thomas Güttler Source and updates: Pre-PEP 9999 <https://github.com/guettli/peps/blob/master/pep-9999.rst> PEP: 9999 Title: Template Literals Author: Thomas Güttler <info at thomas-guettler.de> Sponsor: TODO Status: Draft Type: Standards … [View More]Track Content-Type: text/x-rst </dev/peps/pep-0012> Created: 08-Jun-2021 Python-Version: TODO Post-History: 08-Jun-2021 ------------------------------ Contents - Abstract <#abstract> - Motivation <#motivation> - Rationale <#rationale> - Specification <#specification> - Security Implications <#security-implications> - Reference Implementation <#reference-implementation> - Alternative Ideas <#alternative-ideas> - Rejected Ideas <#rejected-ideas> - Open Issues <#open-issues> - References <#references> - Copyright <#copyright> Abstract <#id6> This PEP adds Template Literals to Python. To avoid code injection like XSS or SQL-injection Template Literals can help you to write save Python code. Template Literals provide an easy way to access the local and global variables (like f-strings), so that passing a dictionary to the Template is not necessary. Motivation <#id7> In the context of web development Python can do more than providing REST APIs via http. With the trend to Server-Side-Rendering, we face a fundamental question: How to create HTML with Python? If you use the FrOW pattern (HTML fragments over the wire) [1] <#frow>, then you will be writing small methods returning small HTML fragments. As a developer I want to pass escaped data into template literals to be as simple as possible. Rationale <#id8> Imagine you want to create a small HTML fragment in Python, and return it as HTTP-Response: HttpResponse(f''' <h1>Hi {name}</h1> Your messages: {messages}''') The problem in above example is, that no escaping gets done. In above example "name" and "messages" should be treated differently. The variable "name" should get escaped. For example if the name is "Mary & Bob", the result should be "Mary & Bob". The variable "messages" contains HTML which is already escaped. It should not be escaped again. Most frameworks have a way to do this conditional escaping. For example Django uses conditional_escape() <https://docs.djangoproject.com/en/3.2/ref/utils/#django.utils.html.conditio…> [2] <#id2> With the help of conditional_escape() the above problem could be solved like this: HttpResponse(f''' <h1>Hi {conditional_escape(name)}</h1> Your messages: {conditional_escape(messages)}''') This solution has two drawbacks: 1. It is too verbose. Typing "conditional_escape(...)" again and again is cumbersome. 2. If a conditional_escape() gets forgotten Cross-site scripting attacks could be possible, since malicious users could inject HTML. Specification <#id9> Template Literals use backticks (like JavaScript Template Literals <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_…> [3] <#id4>) Example: name = 'Mary & Bob' messages = `<ul><li>message1</li><li>message2</li></ul>` return HttpResponse(` <h1>Hi {name}</h1> Your messages: {messages} Today: {datetime.date.today()}`) Expressions within curly braces get handled liked in f-strings (PEP-498). The Template Literal creates an instance of the new class types.TemplateLiteral. types.TemplateLiteral has two attributes: - template: The raw string inside the backticks. - tokens: A list of tuples: (value, is_literal). For above example this would mean: template = ''' <h1>Hi {name}</h1> Your messages: {messages} Today: {datetime.date.today()}''' tokens = [ ('\n <h1>Hi ', True), ('Mary & Bob', False), ('</h1>\n Your messages: ', True), (<TemplateLiteral "<ul><li>message1</li><li>message2</li></ul>">, False), ('\n\n Today: ', True), (<datetime.date(2021, 6, 9)>, False) ] It is outside this PEP how a consumer of TemplateLiteral handles this data structure. For example the Django web framework could transform a TemplateLiteral to a SafeString like this: def template_literal_to_safestring(template_literal): return mark_safe( ''.join( [ conditional_escape(value) if not is_literal else value for (value, is_literal) in template_literal.tokens ] ) ) This PEP is not related or constraint to the Django framework. It is even not related to HTML. It can be used for any kind of templating. Security Implications <#id10> Template Literals can execute arbitrary code (like f-strings). Template Literals get created by Python developers, not by users. If you want to make templates available for users (for example if you develop a CMS), then please use a different solution. Reference Implementation <#id11> TODO Alternative Ideas <#id12> Instead of backticks for example t'...' could be used. Rejected Ideas <#id13> TODO Open Issues <#id14> TODO References <#id15> [1] <#id1> FrOW, "HTML Fragments Over the Wire". Frameworks like Unpoly, Hotwire or htmx. [2] <#id3> https://docs.djangoproject.com/en/3.2/ref/utils/#django.utils.html.conditio… [3] <#id5> https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_… Copyright <#id16> This document is placed in the public domain or under the CC0-1.0-Universal license, whichever is more permissive. [View Less]

19 56

Implementing a 'but' statement in for-iterations
by Max Shouman June 29, 2021

June 29, 2021

This is more of a syntactic sugar than an actual new feature, but... Exactly, 'but' is the idea: a special keyword to be used in for statements to exclude values from the iterable. E.g., when iterating over a generator: >>> for i in range(0, 10) but (2, 8): would implicitly create a new generator comprehensively, as in: >>> for i in (j for j in range(0, 10) if j not in [2, 8]): It might not add such a feature to justify the definition of a but_stmt in python.gram, but it's … [View More]

8 12

joining paths without worrying about a leading slash
by Zbigniew Jędrzejewski-Szmek June 28, 2021

June 28, 2021

[this is a continuation of https://bugs.python.org/issue44452] pathlib.Path() has a concatenation operator "/" that allows the right-hand-side argument to be an absolute path, which causes the left-hand-side argument to be ignored: >>> pathlib.Path('/foo') / '/bar' PosixPath('/bar') >>> pathlib.Path('/var/tmp/instroot') / '/some/path' / '/suffix' PosixPath('/suffix') This follows the precedent set by os.path.join(), and probably makes sense in the scenario of simulating a … [View More]user typing 'cd' commands in a shell. But it doesn't work nicely in the case of combining paths from two different "namespaces", where we never want to go "up". For example: a web server takes an URL, strips the host, and wants to look up a file: https://example.com/some/path → "/some/path" → /src/www/root + /some/path → /src/www/root/some/path or we are constructing a container image and need to refer to a file in the container: <container foo> + /etc/shadow → /var/lib/machines/foo + /etc/shadow → /var/lib/machines/foo/etc/shadow To do this kind of operation correctly with pathlib.Path, the user needs to do two operations: verify that the rhs argument contains no '..' [*], and strip leading slashes: >>> lhs = pathlib.Path('/some/namespace/') >>> rhs = '/some/path/to/add' >>> if '..' in pathlib.Path(rhs).parts: raise ValueError >>> path = lhs / rhs.lstrip('/') Those last two lines are rather verbose, non-obvious. Also the .lstrip() operation attaches on the right side, but operates on the left side, earlier than the "/", which is overall not very nice. Proposal: add "//"-operator to pathlib.PosixPath() that means "concatenate a rhs path that is underneath the lhs". It would disallow paths with '..', and concatenate paths as relative to the specified lhs: >>> lhs = pathlib.Path('/some/namespace/') >>> lhs // "a/b/c" PosixPath('/some/namespace/a/b/c') >>> lhs // "/a/b/c" PosixPath('/some/namespace/a/b/c') >>> lhs // "a/../b/c" ValueError: cannot use // with a path with '..' on the right This would be useful for operations on containers, combining paths from namespaces like fs paths and URL components, looking up files underneath an unpacked archive, etc. [*] Why completely disallow '..' ? Components with '..' cannot be correctly resolved without access to the filesystem, because a component may be a symlink, and then "a/b/../." may not be "a/.", but something completely different. Thus, since the goal is to have a path underneath lhs, I think it's best to forbid '..'. In principle '..' at the beginning can be resolved reliably, by simply ignoring it, '/../../../whatever' is the same as '/whatever/'. But it's a tiny corner case, and I think it's better to disallow that too. Zbyszek [View Less]

3 6

An alternate idea for escaping in string interpolation
by Bruce Leban June 27, 2021

June 27, 2021

This is a response in part to Thomas Güttler's "Pre PEP: Python Literals" but I am starting a separate thread because I think it deserves separate discussion, and it's not a direct response to that proposal. Here's the problem: we want to allow escaping in strings to prevent injection in HTML, SQL, etc. Proposed solutions generally concentrate on a new kind of escaped format string. I won't go into detail on why I don't like these ideas because others have already covered that ground. … [View More]

3 3

concurrent.futures.ProcessPoolExecutor(restart_workers=True)
by Ram Rachum June 26, 2021

June 26, 2021

Hi guys, I want to have a version of `concurrent.futures.ProcessPoolExecutor` in which every worker process shuts down after each task. I want this because I believe I have a memory leak in my program that I wasn't able to fix. (Possibly it's in C extensions that I use.) Since I'm going to use a process pool anyway, I'm hoping to sidestep this memory leak by launching every task on a worker process that shuts down after it's done. A few years back when I was working at Dell, they did … [View More]

3 4

Subject=Re: Re: concurrent.futures.ProcessPoolExecutor(restart_workers=True)
by Ram Rachum June 26, 2021

June 26, 2021

Thank you, that's helpful. Though I really like the future interface, I've used it many times while I never used `multiprocessing.pool.Pool` or its `AsyncResult`. I worry that some of the expectations I've grown to have from `Future` objects would be broken here. It would be nice if this feature existed in `concurrent.futures`. Thanks, Ram.

1 0

Adding a `wait_in_order` function to concurrent.futures
by santiago.basulto＠gmail.com June 26, 2021

June 26, 2021

Hello list, it's my first email here, so let me know if this is in any way out of order. I've been working a lot with concurrent.futures lately. I find both `wait` and `as_completed` very useful, but something I'm usually lacking is a `wait` version where the order of the futures is preserved. I quickly hacked a proof of concept to discuss with you and see if anybody else would find it useful: https://gist.github.com/santiagobasulto/10b689ba5fcadf307ffc5cd4f4ae00ec I also realized that the … [View More]

2 3

Extension methods in Python
by Johan Vergeer June 25, 2021

June 25, 2021

After working with Kotlin for a while I really started to like the idea of extension methods. I delivers a great way to extend the language without having to add features to the language itself. As a practical example I would like to take a first item from a list my_list = [] first = my_list[0] # This will obviously throw an error In this case it would be great to create an extension method like def list.first_or_none(self): if len(self): return self[0] return None Or ... … [View More]

17 77

Fill in missing contextvars/asyncio task support
by Mark Gordon June 23, 2021

June 23, 2021

With normal synchronous code you can use `contextvars.Context.run()` to change what context code is executing within. However, there is no analagous concept for asyncio code. I'm proposing something similar, for example: coro = foo() my_context = convextvars.Context() await asyncio.run_in_context(coro) Currently the workaround is to run the coroutine on a separate task. coro = foo() my_context = convextvars.Context() await my_context.run(asycnio.create_task, coro) However this is not … [View More]

4 9

Off topic: Rational discursive thought and helping others
by Jonathan Fine June 22, 2021

June 22, 2021

Off-topic Someone on this list wrote: Mu. > > https://en.wikipedia.org/wiki/Mu_(negative)#%22Unasking%22_the_question This is a koan, a device in Zen Buddhism used by a teacher to help the student liberate themselves from being imprisoned by rational discursive thought. Here is another koan. A Zen student told Ummon: "Brilliancy of Buddha illuminates the whole universe." Before he finished the phrase Ummon asked: "You are reciting another's poem, are you not?" "Yes," answered the … [View More]

1 0

Deprecate sum of lists
by Oliver Margetts June 22, 2021

June 22, 2021

Hi all, I came across the following performance issue with the sum function while summing lists: https://bugs.python.org/issue18305 It's been discussed previously in this list and other issues. The rationale in that ticket makes the case that performance won't be fixed because sum() should not be treated as a generic way to concatenate sequences (and there is documentation saying this). Having non-linear complexity is not a suitable way to discourage this behaviour though. Non-linearity is … [View More]

21 63

Allow modifying message of TypeError from NotImplemented
by wyz23x2＠163.com June 19, 2021

June 19, 2021

Python raises TypeError when NotImplemented is returned from __add__, __invert__ etc. and __radd__ etc. aren't available. However, this disallows the customization of error messages. For example, in Python 3.8, __float__ etc. were removed from complex to allow methods like __rfloat__. But this makes abs(z) undiscoverable for many users. The original error message is very helpful. I suggest to make a way for this usage. Maybe NotImplementedType can accept *args, and NotImplemented can be … [View More]

4 3

channel or message queue in asyncio
by zhongquan789＠gmail.com June 19, 2021

June 19, 2021

Functionalities are similar to Go channel but with topics or consumers like a message queue. Possible syntax: ```python async def main(): ch = Channel() await ch.put(1) # put await ch.get() # get await ch.close() # close c1 = ch.consumer() c2 = ch.consumer() async for data in c1: # two consumer are indpendent ... async for data in c2: # async … [View More]

2 1

"except;" - semicolon after except, to get rid of indentation when doing error recovery
by Soni L. June 17, 2021

June 17, 2021

Sometimes it would be useful to be able to write: def foo(): try: return thing() except ValueError; try: return otherthing() except ValueError; try: return yetotherthing() except ValueError; if shouldraise(): raise But currently this needs to be written like so: def foo(): try: return thing() except ValueError: try: return otherthing() except ValueError: try: … [View More]

5 8

Introduce constant variables in Python
by Shreyan Avigyan June 17, 2021

June 17, 2021

Many times a programmer would want a variable that will be a constant. The programmer could have been careless and suddenly changed a very important variable. Proposed syntax, constant variable = 10 variable = 20 # Error Now constant means making a variable value immutable. It means now we can neither change the variable to point to another value nor the value itself anymore. For example, if we have a list we cannot change it. If we try to then "Error". So for lists, constant variable = ["… [View More]

10 16

Receive filtered warnings
by kasium June 15, 2021

June 15, 2021

Hello all, I recently opened a feature request for pytest (https://github.com/pytest-dev/pytest/issues/8768) to find out if a warnings filter capture anything. Basic use-case: In big project with a lot of dependencies, the warnings filter list can grow a lot. Currently the only safe way to find out if a filter is still needed, is to remove it and then to run your code. Therefore it would be nice to have a more automatic approach. Suggestion for the warnings module: A new method wich returns … [View More]

1 0

Define functions without parentheses (if no parameters given)
by Boštjan Mejak June 11, 2021

June 11, 2021

The syntax to define a class looks like this: class MyClass: pass Nice and neat. *** And the syntax to define a function looks like this: def my_function(): pass Hmmm... *** What if we could define functions (that don't have any parameters) like this: def my_function: pass *** Is that a possible scenario at this point, or even desirable?

7 9

Custom-Strings: Combine f-strings and condtional_escape()
by Thomas Güttler June 8, 2021

June 8, 2021

Hi, I have a crazy idea how to extend Python for web development. What do you think? What are the next steps? Original: https://github.com/guettli/python-custom-strings Python Custom Strings Python Custom Strings want to combine two great things: - Python's f-strings <https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-litera…> - Django's conditional_escape() <https://docs.djangoproject.com/en/3.2/ref/utils/#django.utils.html.conditio…> Python … [View More]Custom Strings is a proposal to enhance Python, to give developers new ways to create escaped strings. The Python Custom Strings proposal is not related to Django or HTML. This text uses HTML and Django just as an example. <https://github.com/guettli/python-custom-strings/blob/main/README.md#motiva…> Motivation I could create HTML in Python with the help of Django's format_html() <https://docs.djangoproject.com/en/3.2/ref/utils/#django.utils.html.format_h…> like this: html = format_html(''' <h1>Hi {username}</h1> Your messages: {messages}''', username=username, messages=messages ) With "username" being a simple string that gets quoted. For example Mary & Bob will get Mary & Bob. With "messages" being a previously escaped string. For example <ul><li>line1</li><li>line2</li></ul>. It does not get escaped, since it is already escaped. This "magic" detection whether escaping should be done or not gets handled by conditional_escape() <https://docs.djangoproject.com/en/3.2/ref/utils/#django.utils.html.conditio…> . <https://github.com/guettli/python-custom-strings/blob/main/README.md#goal> Goal I would like to shorten the above code to something similar to this: html = h''' <h1>Hi {username}</h1> Your messages: {messages}''' The developer should not need to type these line: username=username, messages=messages These lines are meaningless and distracting. Avoiding them reduces the cognitive load, especially for the reader of the code. <https://github.com/guettli/python-custom-strings/blob/main/README.md#custom…> Customization To make this customizable, the user needs to define the methods which should get used. In the above example the h prefix of this snippet: html = h''' <h1>Hi {username}</h1> Your messages: {messages}''' Should be executed like html = mark_safe(''' <h1>Hi {username}</h1> Your messages: {messages}''', username=conditional_escape(username), messages=conditional_escape(message)) Python does not know about these methods mark_safe() and conditional_escape(). So we need a way to define that. <https://github.com/guettli/python-custom-strings/blob/main/README.md#defini…>Defining custom strings Somehow, there needs to be a definition of the custom strings. Up to now I open concerning "how to define custom strings?". The syntax could look like this: register_custom_string('h', pre_return, pre_insert) With pre_return() and pre_insert() being methods which get executed to create the custom string. In the above example you would use this: register_custom_string('h', mark_safe, conditional_escape) This is just a first idea. I guess there are better ways to define both methods. Please speak up if you have a better idea. The letter h is just an example. The developer should be able to choose his prefered character. Replacing the already used letteres like r, b, u is not possible and results in an exception. TODO: What should happen if register_custom_string() gets called twice for the same character? <https://github.com/guettli/python-custom-strings/blob/main/README.md#what-i…>What is inside curly braces? In the above example, we just use a variable name. But having more is better. Custom strings are meant for developers, so arbitrary code execution is fine. Arbitrary code in curly braces should be allowed: html = h'''...{my_object.my_method(some_arg)}...''' <https://github.com/guettli/python-custom-strings/blob/main/README.md#why-no…>Why not just this hack? Instead of h'...' you could use this hack to get the desired implementation: def h(html): """ Django's format_html() on steroids """ def replacer(match): call_frame = sys._getframe(3) return conditional_escape( eval(match.group(1), call_frame.f_globals, call_frame.f_locals)) return mark_safe(re.sub(r'{(.*?)}', replacer, html)) The above implementation has one big drawback: IDEs and linters don't know that variables get used inside the custom string. This means IDEs and linters think variables (or imports) don't get used and act accordingly. Nevertheless it makes no sense to type myvar=mvar again and again, just to make IDEs/linters happy. <https://github.com/guettli/python-custom-strings/blob/main/README.md#concer…> Concerns "Custom strings will downgrade Python to the level of PHP". I think Separation of Concerns makes sense. But sometimes Locality of Behaviour <https://htmx.org/essays/locality-of-behaviour/> makes more sense. It really depends on the context. Sometimes it makes sense to have external templates, sometimes it makes senes to have inline templates. Don't judge this proposal just because your context never requires external templates. <https://github.com/guettli/python-custom-strings/blob/main/README.md#backgr…> Background If you use the html-fragments-over-the-wire approach to web development (for example with htmx <https://htmx.org/>), then you create many small methods returning small html snippets. If you have small methods, then keeping the HTML inside one file together with your Python logic simplifies the development process. (See Locality of Behaviour (LoB) <https://htmx.org/essays/locality-of-behaviour/>) I guess a lot of people won't like this. Nevertheless some people like to mix Python and HTML. Those people who don't like this, still can create HTML in the way they like it. <https://github.com/guettli/python-custom-strings/blob/main/README.md#pep> PEP? Do you think this could make it to a PEP? Please let me know: Just create an issue here at Github. [View Less]

5 9

Re: [Python-Dev] reversed enumerate
by Tushar Sadhwani June 6, 2021

June 6, 2021

Instead of changing how `reversed()` works, wouldn't a `reversed=True` property on `enumerate` itself (which checks if the iterable being reversible) suffice?

1 0