Mailman 3 ডিসেম্বর 2023 - Python-list

Re: Python 3.12.1, Windows 11: shebang line #!/usr/bin/env python3 doesn't work any more
by Félix An 23 জানুয়ারি, 2024

23 জানুয়ারি, 2024

On 2023-12-25 12:36, Mike Dewhirst wrote: > > 3. You cannot trust Microsoft. You can trust Python Software Foundation. Python from PSF works the same in all environments - or if not it is a bug. Python from Microsoft is tweaked to satisfy their aforementioned strategy of locking in users to Windows. > I strongly disagree with this. I don't get all the irrational hate for Microsoft that exists within the Linux community. In recent years, Microsoft has made great contributions to the everyday life of Linux users. VS Code is based on open source and available on Linux, .NET is now on Linux, Windows has WSL2 and Visual Studio Linux development tools to help you develop software for Linux, SQL Server (despite still being commercial software except for the Express and Developer versions) is on Linux, etc.

8 29

mypy question
by Karsten Hilbert 13 জানুয়ারি, 2024

13 জানুয়ারি, 2024

Hi all, I am not sure why mypy thinks this gmPG2.py:554: error: Argument "queries" to "run_rw_queries" has incompatible type "List[Dict[str, str]]"; expected "List[Dict[str, Union[str, List[Any], Dict[str, Any]]]]" [arg-type] rows, idx = run_rw_queries(link_obj = conn, queries = queries, return_data = True) ^~~~~~~ should be flagged. The intent is for "queries" to be a list of dicts with keys of str and values of str OR list of anything OR dict with keys of str and values of anything I'd have thunk list[dict[str,str]] matches that ? This is on Python 3.11.2 with mypy 1.0.1 on Debian. Karsten -- GPG 40BE 5B0E C98E 1713 AFA6 5BC0 3BEA AC80 7D4F C89B

6 18

What is Install-Paths-To in WHEEL file?
by Left Right 2 জানুয়ারি, 2024

2 জানুয়ারি, 2024

Hello list. I'm trying to understand the contents of Wheel files. I was reading https://peps.python.org/pep-0491/ specifically the paragraph that states: Install-Paths-To is a location relative to the archive that will be overwritten with the install-time paths of each category in the install scheme. See the install paths section. May appear 0 or more times. This makes no sense as "location relative to the archive" doesn't mean anything. Archive's location (did you mean filesystem path?) may not exist (eg. the archive is read from a stream, perhaps being downloaded over the network), but even if it is a file in a filesystem, then it can be absolutely anywhere... If this paragraph is interpreted literally then, say a command s.a. pip install /tmp/distribution-*.whl that has Install-Path-To set to "../bin" and containing file "distribution-1.0/data/bash" would write this file as "/bin/bash" -- that cannot be right, or is it? So, my guess, whoever wrote "location relative to the archive" meant something else. But what? What was this feature trying to accomplish? The whole passage makes no sense... Why would anyone want to overwrite paths s.a. platlib or purelib _by installing some package_? This sounds like it would just break the whole Python installation... Thanks!

5 18

ANN: EmPy 4.0.1
by Erik Max Francis 31 ডিসেম্বর, 2023

31 ডিসেম্বর, 2023

I'm pleased to announce the release of EmPy 4.0.1. The 4._x_ series is a modernization of the software and a revamp of the EmPy system to update its feature set and make it more consistent with the latest Python versions and practices. EmPy 4._x_ was also relicensed to BSD. The 4._x_ series adds new markups, including inline comments, backquote literals, changed if-then-else extended expression, functional expressions, support for modern Pythonic controls, stringized and multiline significators, named escapes, diacritics, icons, and emojis. It adds support for configuration objects (replacing options dictionaries); native support for Unicode, file buffering, reference counted `sys.stdout` proxies and error dispatchers and handlers; fixes several serious bugs; has a set of full unit and system tests, an extensive builtin help system; and the online documention has been rewritten and expanded. Attempts have been made to make EmPy 4._x_ as backward compatible as is practical. Most common markup has not changed, the only changes being removal of `repr` (in favor of backquote literals); literal close parenthesis, bracket and brace markup; in-place markup has changed syntax (to make way for emojis); and custom markup is now parsed more sensibly. Most backward-incompatible changes are in the embedding interface. The `Interpreter` constructor and global `expand` function now require keyword arguments to prevent further backward compatibility problems, though effort has been made to make the behavior as backward compatible as possible. The supported environment variables have changed, as well as the filter, diversion and hook APIs, and options dictionaries no longer exist (in deference to configurations). For a comprehensive list of changes from 3._x_ to 4._x_, see: <http://www.alcyone.com/software/empy/ANNOUNCE.html#changes> ## Introduction: Welcome to EmPy! [EmPy](http://www.alcyone.com/software/empy/) is a powerful, robust and mature templating system for inserting Python code in template text. EmPy takes a source document, processes it, and produces output. This is accomplished via expansions, which are signals to the EmPy system where to act and are indicated with markup. Markup is set off by a customizable prefix (by default the at sign, `@`). EmPy can expand arbitrary Python expressions, statements and control structures in this way, as well as a variety of additional special forms. The remaining textual data is sent to the output, allowing Python to be used in effect as a markup language. EmPy also supports hooks, which can intercept and modify the behavior of a running interpreter; diversions, which allow recording and playback; filters, which are dynamic and can be chained together; and a dedicated user-customizable callback markup. The system is highly configurable via command line options, configuration files, and environment variables. An extensive API is also available for embedding EmPy functionality in your own Python programs. EmPy also has a supplemental library for additional non-essential features (`emlib`), a documentation building library used to create this documentation (`emdoc`), and an extensive help system (`emhelp`) which can be queried from the command line with the main executable `em.py` (`-h`/`--help`, `-H`/`--topics=TOPICS`). The base EmPy interpreter can function with only the `em.py`/`em` file/module available. EmPy can be used in a variety of roles, including as a templating system, a text processing system (preprocessing and/or postprocessing), a simple macro processor, a frontend for a content management system, annotating documents, for literate programming, as a souped-up text encoding converter, a text beautifier (with macros and filters), and many other purposes. ### Markup overview Expressions are embedded in text with the `@(...)` notation; variations include conditional expressions with `@(...?...!...)` and the ability to handle thrown exceptions with `@(...$...)`. As a shortcut, simple variables and expressions can be abbreviated as `@variable`, `(a)object.attribute`, `@sequence[index]`, `@function(arguments...)`, `@function{markup}{...}` and combinations. Full-fledged statements are embedded with `@{...}`. Control flow in terms of conditional or repeated expansion is available with `@[...]`. A `@` followed by any whitespace character (including a newline) expands to nothing, allowing string concatenations and line continuations. Line comments are indicated with `@#...` including the trailing newline. `@*...*` allows inline comments. Escapes are indicated with `@\...`; diacritics with `@^...`; icons with `@|...`; and emoji with `@:...:`. `@%...` and `@%%...%%` indicate "significators," which are distinctive forms of variable assignment intended to specify per-document identification information in a format easy to parse externally, _e.g._, to indicate metadata. In-place expressions are specified with `@$...$...$`. Context name and line number changes can be made with `@?...` and `@!...`, respectively. `@<...>` markup is customizable by the user and can be used for any desired purpose. `` @`...` `` allows literal escaping of any EmPy markup. And finally, a `@@` sequence (the prefix repeated once) expands to a single literal at sign. The prefix (which defaults to `@`) can be changed with `-p`/`--prefix=CHAR` (_environment variable:_ `EMPY_PREFIX`, _configuration variable:_ `prefix`). ### Getting the software The current version of EmPy is 4.0.1. The official URL for this Web site is <http://www.alcyone.com/software/empy/>. The latest version of the software is available in a tarball here: <http://www.alcyone.com/software/empy/empy-latest.tar.gz>. The software can be installed through PIP via this shell command: ``` % python3 -m pip install empy ... ``` For information about upgrading from 3._x_ to 4._x_, see <http://www.alcyone.com/software/empy/ANNOUNCE.html#changes>. ### Requirements EmPy works with any modern version of Python. Python version 3._x_ is expected to be the default and all source file references to the Python interpreter (_e.g._, the bangpath of the .py scripts) use `python3`. EmPy also has legacy support for versions of Python going back all the way to 2.3, with special emphasis on 2.7 regardless of its end-of-life status. It has no dependency requirements on any third-party modules and can run directly off of a stock Python interpreter. EmPy will run on any operating system with a full-featured Python interpreter; this includes, but is probably not limited to, Linux, Windows, and macOS (Darwin). Using EmPy requires knowledge of the [Python language](https://www.python.org/). EmPy is also compatible with several different Python implementations: | Implementation | Supported versions | Description | | --- | --- | --- | | CPython | 2.3 to 2.7; 3.0 and up | Standard implementation in C | | PyPy | 2.7; 3.2 and up | Implementation with just-in-time compiler | | IronPython | 2.7; 3.4 and up | Implementation for .NET CLR and Mono | | Jython | 2.7 (and up?) | Implementation for JVM | It's probable that EmPy is compatible with earlier versions than those listed here (potentially going all the way back to 2.3), but this has not been tested. Only a few .py module file(s) are needed to use EmPy; they can be installed system-wide through a distribution package, a third-party module/executable, or just dropped into any desired directory in the `PYTHONPATH`. A minimal installation need only install the em.py file, either as an importable module and an executable, or both, depending on the user's needs. EmPy also has optional support for several [third-party modules](#third-party-emoji-modules); see [Emoji markup](#emoji-markup) for details. The testing system included (the test.sh script and the tests and suites directories) is intended to run on Unix-like systems with a Bourne-like shell (_e.g._, sh, bash, zsh, etc.). EmPy is routinely tested with all supported versions of all available interpreters. If you find an incompatibility with your Python interpreter or operating system, [let me know](#reporting-bugs). ### License This software is licensed under [BSD (3-Clause)](https://opensource.org/licenses/bsd-3-clause/). ### Recent release history (since 3._x_) 4.0.1 (2023 Dec 24) : Add root context argument, serializers, and idents to interpreter; fix `setContext...` methods so they also modify the currents stack; better backward compatibility for `expand` function and `CompatibilityError`; fix inconsistent stack usage with `expand` method; add error dispatchers, cleaner error handling and `ignoreErrors`; have `expand` method/function raise exceptions to caller; eliminate need for `FullContext` class distinct from `Context`; support comments in "clean" controls; add `--no-none-symbol` option; add clearer errors for removed literal markup; add `Container` support class in `emlib`; hide non-standard proxy attributes and methods; support string errors (why not); update and expand tests; help subsystem and documentation updates. 4.0 (2023 Nov 29) : A major revamp, refresh, and modernization. Major new features include inline comments `@*...*`; backquote literals `` @`...` ``; chained if-then-else expressions; functional expressions `@f{...}`; full support for `@[try]`, `@[while ...]` and `@[with ...]` control markup; `@[defined ...]` control markup; stringized and multiline significators; named escapes `@\^{...}`; diacritics `@^...`; icons `@|...`; emojis `@:...:`; configurations; full Unicode and file buffering support; proxy now reference counted; hooks can override behavior; many bug fixes; an extensive builtin help system (`emhelp`); and rewritten and expanded documentation. Changes include relicensing to BSD, interpreter constructor now requires keyword arguments, `-d`/`--delete-on-error` instead of "fully buffered files"; cleaned up environment variables; "repr" markup replaced with emoji markup; remove literal markups `@)`, `@]`, `@}`; context line markup `@!...` no longer pre-adjusts line; custom markup `@<...>` now parsed more sensibly; filter shortcuts removed; context now track column and character count; auxiliary classes moved to `emlib` module; use `argv` instead of `argc` for interpreter arguments. See [Full list of changes between EmPy 3._x_ and 4.0](http://www.alcyone.com/software/empy/ANNOUNCE.html#full-list-of-change… for a more comprehensive list. -- Erik Max Francis && max(a)alcyone.com && http://www.alcyone.com/max/ San Jose, CA, USA && 37 18 N 121 57 W && Skype erikmaxfrancis To be refutable is not the least charm of a theory. -- Friedrich Nietzsche

1 0

Re: mypy question
by Greg Ewing 31 ডিসেম্বর, 2023

31 ডিসেম্বর, 2023

On 31/12/23 10:06 am, Thomas Passin wrote: > my suggestion above does > work, *except* that you cannot mix-and-match different DictTypex types Have you tried declaring the argument as a Mapping instead of a dict? Seeing as Thomas Passin's Sequence experiment worked, it seems like this should work too. -- Greg

2 1

Re: Aw: Re: mypy question
by Greg Ewing 31 ডিসেম্বর, 2023

31 ডিসেম্বর, 2023

On 31/12/23 8:05 am, Chris Angelico wrote: > Ah, I think you've hit on the problem there. Consider this: > > def add_item(stuff: dict[str: str | int]): > stuff["spam"] = "ham" > stuff["vooom"] = 1_000_000 Yep, that's it exactly. It's not the union itself that's the problem, but the fact that there's a *mutable container* containing that type. -- Greg

1 0

Are there any easy-to-use Visual Studio C# WinForms-like GUI designers in the Python world for Tk?
by Félix An 30 ডিসেম্বর, 2023

30 ডিসেম্বর, 2023

I'm used to C# WinForms, which has an easy-to-use drag-and-drop GUI designer in Visual Studio. Is there anything similar for Tk? How about Qt? What do you recommend as the easiest way to create GUI programs in Python, similar to the ease of use of C# WinForms?

4 3

Re: mypy question
by Greg Ewing 30 ডিসেম্বর, 2023

30 ডিসেম্বর, 2023

On 30/12/23 4:02 am, Karsten Hilbert wrote: > def run_rw_queries ( > link_obj:_TLnkObj=None, > queries:list[dict[str, str | list | dict[str, Any]]]=None, > Given that I would have thought that passing in > list[dict[str, str]] for "queries" ought to be type safe. dict[str, str] is not a subtype of dict[str, str | something_else] because you can assign a value of type something_else to the latter but not the former. In this case it happens to be okay because the function is (presumably) treating the dict passed in as immutable, but MyPy has no way to be sure of that. You could try declaring it as a collections.Mapping, which is immutable. -- Greg

2 1

Re: How/where to store calibration values - written by program A, read by program B
by Chris Green 30 ডিসেম্বর, 2023

30 ডিসেম্বর, 2023

Peter J. Holzer <hjp-python(a)hjp.at> wrote: > [-- text/plain, encoding quoted-printable, charset: us-ascii, 40 lines --] > > On 2023-12-29 09:01:24 -0800, Grant Edwards via Python-list wrote: > > On 2023-12-28, Peter J. Holzer via Python-list <python-list(a)python.org> wrote: > > > On 2023-12-28 05:20:07 +0000, rbowman via Python-list wrote: > > >> On Wed, 27 Dec 2023 03:53:42 -0600, Greg Walters wrote: > > >> > The biggest caveat is that the shared variable MUST exist before it can > > >> > be examined or used (not surprising). > > >> > > >> There are a few other questions. Let's say config.py contains a variable > > >> like 'font' that is a user set preference or a calibration value > > >> calculated by A to keep with the thread title. Assuming both scripts are > > >> running, how does the change get propagated to B after it is set in A > > > > > > It isn't. The variable is set purely in memory. This is a mechanism to > > > share a value between multiple modules used by the same process, not to > > > share between multiple processes (whether they run the same or different > > > scripts) > > > > > >> and written to the shared file? > > > > > > Nothing is ever written to a file. > > > > Then how does it help the OP to propogate clibration values from one > > program to another or from one program run to the next run? > > It doesn't. See his second mail in this thread, where he explains it in > a bit more detail. I think he might be a bit confused in his > terminology. > If I am the OP (I suspect I may be) I have gone with JSON stored in a file to provide what I need. The Python json package is very simple to use and with an 'indent=' setting the resulting json is reasonably human readable which is all I need. Thus programs simply read the values from the json file into a dictionary of dictionaries and the 'updater of values' program can write them back after changes. -- Chris Green ·

1 0

Re: How/where to store calibration values - written by program A, read by program B
by rbowman 30 ডিসেম্বর, 2023

30 ডিসেম্বর, 2023

On Wed, 27 Dec 2023 03:53:42 -0600, Greg Walters wrote: > The biggest caveat is that the shared variable MUST exist before it can > be examined or used (not surprising). There are a few other questions. Let's say config.py contains a variable like 'font' that is a user set preference or a calibration value calculated by A to keep with the thread title. Assuming both scripts are running, how does the change get propagated to B after it is set in A and written to the shared file? Is there a mechanism to allow both scripts to make updates? The easy way out is to assume the changes will be picked up when the scripts are restarted but this is not always acceptable.

4 4