pipx

Love it, bookmarked. I first saw this idea at https://jmw.name/projects/linear-clock/ and then later I wrote a TUI version for myself I had tickmarks for stuff (when to go to bed to sleep for 7.5h and wake up near sunrise, things like that). I was working on adding a config file format. Then I lost the project due to a mishap with a pipx flag... https://github.com/pypa/pipx/issues/1324#issuecomment-211885... ;_; o7 One day maybe I'll come back and do it in Rust.

While we're posting not-nice things, I'll throw my current favorite out: pipx ( https://github.com/pypa/pipx ). I use Python's Poetry to build a wheel and then pipx to install it. Super-easy, barely an inconvenience :)

Python has zipapps (https://peps.python.org/pep-0441/), which are standardized and similar to JARs. You can build a zipapp that includes your application's dependencies using a tool like shiv or PEX, only with binary extensions the artifacts are still per-platform: https://github.com/linkedin/shiv#gotchas. I recommend users to install my Python programs with pipx (https://github.com/pypa/pipx). I think it is the best option when the audience is at all technical. pipx makes such a big difference for managing Python applications. It avoids the version conflicts of `pip install --user` and the pain of manually creating per-application venvs. In general, it provides a reasonable user experience. Because of this user-friendliness, I can recommend pipx as the primary installation method and expect people to succeed at installing the program wit

thank you! That's amazingly helpful. I had no idea pipx was a thing For others: https://github.com/pypa/pipx It's also in the Fedora repos: dnf install -y pipx

A development version of pipx supports a feature that address this pain point. See pull request #916 [1] In your script example.py, you would specify your dependencies in a special comment like this: # Requirements: # requests import requests ... Then you could run the script like this: pipx run file:example.py This would install the dependencies in a temporary virtual environment, and run the script in that virtual environment. [1] https://github.com/pypa/pipx/pull/916

You can try https://github.com/jaraco/pip-run or https://github.com/PyAr/fades (or eventually pipx: https://github.com/pypa/pipx/issues/913). They don't require a build step. For example, #! /usr/bin/env -S pip-run Jinja2==3.* from jinja2 import Environment env = Environment(autoescape=True) template = env.from_string("Hello, {{ name }}!") print(template.render(name="world")) There is a downside. Because pip-run recreates the virtualenv every time, the script takes a second to start up. pipx will cache virtualenvs once the single-file script feature is released. I haven't used fades yet. Edit: fades caches virtualenvs. #! /usr/bin/env fades from jinja2 import Environment # fades Jinja2==3.* env = Environment(autoescape=True) template = env.from_string("Hello, {{ name }}!") print(template.render(name="world"))

As mentioned in Getting Started, with `pipx`: `pipx install harlequin` From the pipx documentation: > This automatically creates a virtual environment, installs the package, and adds the package's associated applications (entry points) to a location on your PATH. It makes the command available globally, but sandboxes the package in its own virtual environment. https://github.com/pypa/pipx

pipx has merged, though not yet released, support for single-file scripts with dependencies (https://github.com/pypa/pipx/issues/913). There is also pip-run (https://github.com/jaraco/pip-run) with similar functionality to the new feature in pipx and other options. Their approach of listing dependencies in a comment at the top pf the script has been standardized (with minor differences) in a recent PEP: https://peps.python.org/pep-0722/. All of this looks good for the future of Python scripts. I have already adopted pipx run script.py in a project: https://github.com/dbohdan/structured-text-tools/blob/d8dc1a.... It has been convenient and has not caused me problems so far.

Good overview. There are quite a few on there I was not aware of. That said, I am not sure the organizational schema makes a tone of sense. I would assume most users that come across this would be looking for a package manager for a specific platform and then weighing the options of binary/source/etc., instead of the other way around. Also, pipx (https://github.com/pypa/pipx) would be a good addition to the list. I'd add it but I'm not sure where it would go. Maybe every section? It's cross platform and handles both binary and source based app distributions.

What benefit would joining your cult bestow upon me that brew does not already? My brew list is intentionally very short and my faffing about desire is limited. Generally I use brew to pull in asdf (https://github.com/asdf-vm/asdf) to install programming languages/tooling, it works flawlessly. I use Pipx (https://github.com/pypa/pipx) to install python thingies (such as yt-dlp) as a cli. Go and Rust handle binaries in their languages beautifully and without issues.

pipx might get this ability: https://github.com/pypa/pipx/pull/916

As detailed in the other answers, there are two parts to this: 1) Creating a python package from your project (and possibly share this on pypi), and 2) Making this package available as an end-user application. For step 2 you can use nuitka or similar, but if your audience is somewhat developer-oriented, you can also propose for them to use pipx: https://github.com/pypa/pipx.