Mailman 3 - Python-ideas

commonprefix
by Rob Cliffe 17 জুন, 2024

17 জুন, 2024

The os.path.commonprefix function basically returns the common initial characters (if any) shared by a sequence of strings, e.g. os.path.commonprefix(("Python is great!", "Python is not bad", "Python helps")) # returns "Python " This is purely a string manipulation function which bears no relation to actual file paths or whether they exist. I have found uses for it unrelated to file paths: (a) When updating a progress display by printing backspaces and overtyping, discover the common characters between the old and new values displayed, so as to print as few characters as possible (b) Find the first character position where two strings differ. I am sure there are many others. It seems to me that this function (or something similar) should not be in os.path, but somewhere else where it would be more visible. (There are a lot of "solutions" on the Internet to finding the common prefix of 2 or more than 2 strings, whose authors obviously don't know about os.path.commonprefix.) I'm not sure where, though. Possibilities include (1) a str.commonprefix function. Unfortunately it would have to be used like this str.commonprefix(<sequence of strings>) which would make it [I think] the only str function which couldn't be called as a string method. (2) in the sequence protocol. This would mean that it could apply not just to strings, but to any sequences. E.g. [ (1,2,3), (1,2,4) ].commonprefix() # Would return (1,2). [ (1,2,3), [1,2,4] ].commonprefix() # Mixed sequence types - undefined? One wrinkle: os.patch.commonprefix, if passed an empty sequence, returns an empty STRING. If this function were designed from scratch, it should probably return None. (3) a builtin commonprefix function. Again it could apply to any sequences. I also suspect that this function could be made more efficient. It sorts the sequence. While sorting is very fast (thanks, Uncle Tim!) it seems a bit OTT in this case. Thoughts? Best wishes Rob Cliffe

3 3

Re: commonprefix
by Rob Cliffe 17 জুন, 2024

17 জুন, 2024

The os.path.commonprefix function basically returns the common initial characters (if any) shared by a sequence of strings, e.g. os.path.commonprefix(("Python is great!", "Python is not bad", "Python helps")) # returns "Python " The following was wrong. os.path.commonprefix uses min and max, not sort. I withdraw it: I also suspect that this function could be made more efficient. It sorts the sequence. While sorting is very fast (thanks, Uncle Tim!) it seems a bit OTT in this case. Thoughts? Best wishes Rob Cliffe

1 0

Deprecate PEP 249 (DB-API 2.0)
by Soni L. 27 ফেব্রুয়ারি, 2024

27 ফেব্রুয়ারি, 2024

We would like to propose the following improvements to DB-API 2.0 that would require bumping it up to DB-API 3.0: - Get rid of SQL strings - Get rid of SQL strings - Use package resources to store what would otherwise be SQL strings While we cannot prevent someone from going out of their way to define package resources at runtime just so they can implement SQL injection, ultimately the goal is to provide a small speed bump so they don't feel so inclined to jump straight into SQL injection before trying to do easier, more secure things.

2 1

Abstract dataclasses and dataclass fields
by Steve Jorgensen 22 ডিসেম্বর, 2023

22 ডিসেম্বর, 2023

I am finding that it would be useful to be able to define a dataclass that is an abstract base class and define some of its field as abstract. As I am typing this, I realize that I could presumably write some code to implement what I'm asking for. Maybe it is a good enough idea to make part of the standard API in any case though? I'm thinking that a field would be made abstract by passing `abstract=True` as an argument to `dataclasses.field()`.

5 6

Re: Extract variable name from itself
by Dom Grigonis 9 নভেম্বর, 2023

9 নভেম্বর, 2023

> the output will have the expression text This is exactly what I want. If there was an extra check for validity at parser level, it is a plus. > You want to produce a name, that is an identifier <https://docs.python.org/3/reference/lexical_analysis.html#identifiers>. Not necessarily, I want the first part of f’{expr=}’. There are outputs: a) `expr=repr(expr)` b) `repr(expr)` why is it a bad idea to have: c) `expr` without `repr(expr)`? This does cover `identifier only` case as well, but is not limited to it. Is it difficult to achieve? Apologies if I am missing something, but if you know the workings of python, could you point me to where f’{expr=}' is parsed and compiled? Obviously I might be wrong, but it is difficult to believe that it is done in such way, that I can have B, A&B, but not A without B. Would appreciate if you convinced me with some support for your rather strong statements. Regards, DG > On 23 Sep 2023, at 23:18, Tiago Illipronti Girardi <tiagoigirardi(a)gmail.com> wrote: > > I think I did something wrong and we are responding to one another instead of the list, please correct this if you can. > > Let's start with `f'{name=}'`. This is from the docs <https://docs.python.org/3/reference/lexical_analysis.html#f-strings> (the link has the docs for f-strings, so read it): > > When the equal sign '=' is provided, the output will have the expression text, the '=' and the evaluated value. Spaces after the opening brace '{', within the expression and after the '=' are all retained in the output. By default, the '=' causes the repr() <https://docs.python.org/3/library/functions.html#repr> of the expression to be provided, unless there is a format specified. When a format is specified it defaults to the str() <https://docs.python.org/3/library/stdtypes.html#str> of the expression unless a conversion '!r' is declared. > > That's not what you want. You want to produce a name, that is an identifier <https://docs.python.org/3/reference/lexical_analysis.html#identifiers>. The semantics of name binding are described here <https://docs.python.org/3/reference/executionmodel.html#naming-and-binding>. Which means that you cannot infer the name from the value. > Python only deals with values, not names. The names are how you refer to the values. That is the semantics. There's no inverse transformation embedded in the language. That's what everyone is trying to communicate to you. > If you pay close attention to the execution model <https://docs.python.org/3/reference/executionmodel.html#naming-and-binding> there is a link from the name to the object but not the other way around, so you can't get it from the object. That's it. You need to change the whole execution model (that is the interpreter) to get what you want > > Em sáb., 23 de set. de 2023 às 13:16, Dom Grigonis <dom.grigonis(a)gmail.com <mailto:dom.grigonis@gmail.com>> escreveu: > > >> On 23 Sep 2023, at 18:00, Tiago Illipronti Girardi <tiagoigirardi(a)gmail.com <mailto:tiagoigirardi@gmail.com>> wrote: >> >> The `f'{obj!fmt}'` syntax formats the `obj` with `repr` if `fmt` is `r`, with `str` if it is `s`, or with `ascii` if its `a`. >> With a new format `id` or `i` it would do nothing, but it could signal to an editor that it is an identifier (editors, I believe, already parse the contents of the curly brackets on f-strings). > I know the formatting syntax, I wasn’t clear what your point was. I see now that you are referring to new syntax which does nothing apart from signalling the editor. > > Your suggestion is leaning towards python adapting to the editor, while I would argue that things are simpler and more robust if editors treat code expression as code expression and strings as strings. Making a mess here does seem like too big of a cost for not so profound benefits of what I am proposing. > >> Identifiers are syntactical constructs in python, they only have semantics given a context, and more than one identifier can have the same semantic meaning in a given context, which makes your proposal a no-go from start. > Can you elaborate on this? > > Given f’{expr=}’ syntax already exists, how is this an issue for my proposal? > >> Except if we were to change the whole execution model of the language. > Although I am open to be proven wrong. Could you give an explanation why stripping `repr(expr)` part from f’{expr=}’ and leaving expr literal is problematic, given substituting expr literal is already being done? > > >> However, for the "change this identifier from this to that" case (which is an editor problem), subclassing `typing.LiteralString` would basically solve the problem: >> >> ``` >> x = 6 >> print(typing.Id('x') = f'{x}') >> ``` >> >> Or import Id from typing to save some keystrokes. >> >> With an interpreter change to the f-string we could do something like: >> >> ``` >> print(f'In this context {x!id} means the horizontal coordinate') >> ``` >> >> or without one and just changing the typing module: >> >> ``` >> print('In this context', typing.Id('x'), 'means the horizontal coordinate') >> ``` > I get all of the above, it just doesn’t seem elegant solution to a much more simpler approach that I am proposing. From my individual POV, the extra complication cost of your approach pretty much outweighs the subtle benefits of my proposal. > >> And with editor support, changing `x` to `y` would cleanly change the references to the variables/identifiers. >> But this use case is essentially impossible for the interpreter alone to solve: it needs editor support. > (above) > >> The other cases that you cite are kinda nonsensical (as I already wrote above). > No, you have just stated this (at least in this manner) for the first time. Care to explain how keeping dictionary keys in sync with identifiers or having extra syntactic via f-string construction check is “nonsensical”? I agree that these might not be the top practices, but given python is often used as a plugin / prototyping language, I would argue that some things are just plainly useful in certain cases. Python already allows many practices that are discouraged. This one would definitely be on a lower end of such risks. > >> Hope I was clear, and best regards >> >> Tiago I Girardi >> >> >> Em sáb., 23 de set. de 2023 às 10:53, Dom Grigonis <dom.grigonis(a)gmail.com <mailto:dom.grigonis@gmail.com>> escreveu: >> >>> On 23 Sep 2023, at 16:24, Tiago Illipronti Girardi <tiagoigirardi(a)gmail.com <mailto:tiagoigirardi@gmail.com>> wrote: >>> >>> but: >>> 1. There are costs doing it in python. And easy implementation doing it in editor (with the typing support it's almost already done). >> What are those costs? >> >>> 2. The f-string functionality is not there right now, but f'{name!id}' would leverage what is there and, with editor support, give the exact `nameof`` support even without further interpret support. >> What do you mean by f’{name!id}’ ? I don’t understand your point here. >> >> Are you proposing f’{name!id}’ syntax for it? My whole point is to do this in f-strings. >> >> Namely my proposal is f’{=expr}’. >> >> `nameof` function is out of the question - it has no benefits over f-string implementation. >> >>> The other use cases you mention are easily dealt with, assuming editor and typing.LiteralString (subclassed) support. >> Can you elaborate? I have only basic user knowledge about typing library and use it sparsely. >> >> But from what I know, tying this to typing does not seem like a good idea. It is very basic functionality and from my POV stands at lower level, while typing is optional feature and not everyone uses it or even needs to know it. >> >> DG >> —Evaluation of deferred evaluation can be deferred, but not indefinitely — >> >> >>> Em sáb., 23 de set. de 2023 às 09:51, Dom Grigonis <dom.grigonis(a)gmail.com <mailto:dom.grigonis@gmail.com>> escreveu: >>>> This is the only use case I can think of. >>> Yes, probably most common one, but I have mentioned couple more. >>> >>> 1. Keeping dictionary keys in sync with variable name. >>> 2. eval / exec statements. Although eval / exec are not recommended in high standard production code, python is widely used in plugins for various apps. E.g. Alfred / Sublime text, where exec/eval can be very useful. Why not have a method to do it a bit more robustly? >>> >>> Given python being flexible multipurpose interpreted language, I am sure more use cases would surface. >>> >>>> Couldn’t we just subclass typing.LiteralString to typing.Id or something for this “functionality” and let editing tools deal with it. >>> >>> “Could”, but: >>> 1. There are benefits doing it in python. And undesired costs of implementing this in editor (see my later e-mails) >>> 2. The f-string functionality for it is already there: >>> f'{a=}'.rstrip(f'{a}') >>> # or a bit better >>> f'{a=}'.split('=')[0] >>> # = exactly what I am proposing (Except the unneeded evaluation part) >>> So if it is already there, why not have it done well given there is little to none overall cost to it? I think cost implementing such things in Editor is much greater. >>> >>> Regards, >>> DG >> >

3 3

re.match(pattern, string, require=True)
by Ram Rachum 22 অক্টোবর, 2023

22 অক্টোবর, 2023

Hey, I bet this has been discussed before but I couldn't find it. I'd appreciate it if anyone could point me to that thread. I'm sick of seeing "AttributeError: 'NoneType' object has no attribute 'foo'" whenever there's a `re.match` operation that fails while the code expects it to succeed. What do you think about a flag `require` such that `re.match(pattern, string, require=True)` would either return a match or raise an exception with an actually useful message? Thanks, Ram.

9 17

Descriptor __get__ and __set__ argument discrepancy
by Dom Grigonis 19 অক্টোবর, 2023

19 অক্টোবর, 2023

Hi all, Quick question. def __get__(self, instance, owner): def __set__(self, instance, value): Is there a reason why `__set__` does not have owner in it’s arguments while `__get__` does? Regards, DG

3 7

Non-aware operators PEP505
by Dom Grigonis 16 অক্টোবর, 2023

16 অক্টোবর, 2023

Hi all, Just want to follow up on discussions from before by saying that I came to a conclusion that from my POV non-aware operators would be an excellent addition to python. The number of times that I need to write: pal = None if self.pal is None else self.pal.rgb_to_cmy() or alternatively: pal = None if self.pal is None: pal = self.pal.rgb_to_cmy() is still fairly high. The first one is one-line, but its readability is, although not the worst, but is not satisfactory in the context of other practices I have employed. The second one has good readability, but it takes 3 lines for operation, which I think shouldn’t take more than 1 line. —— Now following up on my thoughts on deferred evaluation this case could be solved by its side effect, which is allowing user to control evaluation order. However, I think it would be more suitable for corner cases and more complex tool building due to its verbosity and readability, which I think would be better than many corner-case hacks, but nowhere as elegant as say non-aware operator syntax. So I think regardless of whether deferred evaluation is ever implemented, this PEP( https://peps.python.org/pep-0505/ <https://peps.python.org/pep-0505/>) could be a very useful addition given the frequency of such cases. —— Even a minimal implementation of it for would be very useful, say simple binary operator with __has_value__ object protocol. —— Maybe someone knows a better way to write the example above? Regards, DG

1 0

SyntaxError: cannot use assignment expressions with attribute
by Dom Grigonis 10 অক্টোবর, 2023

10 অক্টোবর, 2023

Is there a reason why this is not allowed? return (self.mode := self.mode_valid(mode))

4 8

Re: Extract variable name from itself
by Eric V. Smith 28 সেপ্টেম্বর, 2023

28 সেপ্টেম্বর, 2023

5 23