* A recently-published PEP specificies how Python scripts can declare dependencies in opening comments.

* uv is a Python script-runner/package manager which scans for those dependencies, arranges for them to be met, and runs the script with those dependency modules available for importing

* If, in a Python script, you use the first line comment - the shebang line - to have the file invoked using uv rather than python itself, you'll get that effect automagically when "running" the Python script

The result: Python scripts which require setup of dependencies will now "just run".

  function transcribe() {
    # get the active conda environment
    active_env=$(conda info | grep "active environment" | awk '{print $4}')

    if [[ "$active_env" != "speechrec-env" ]]; then
      conda activate speechrec-env
    fi

    python /users/vunderba/dev/transcriber/transcribe.py "$@"
  }

Not so long ago I started pip-installing my scripts to keep things tidy. It seems now I can regress back to chaos again...

  [tools]
  uv = 'latest'

  [tasks.python_uv_task]
  run = """
  #!/usr/bin/env -S uv run --script
  # /// script
  # dependencies = ["requests<3", "rich"]
  # ///

  import requests
  # your code here 
  """

OP, you have a great idea and I’m stealing it. Do you use some non-.py suffix, or is seeing the exec bit at on a .py file enough of a signal for you to know that you can just run the file as a script (and it won’t use the system Python)?

Of course I have plenty of separate environments set up, but that's because I'm developing things I hope to share with others, so I need to keep close track of their specific dependencies (so I can specify them in package metadata). But even this stuff would generally work with a wide range of versions for those dependencies. I'd imagine this is equally true of small, one-off, personal automation scripts.

But, sure, if you have this problem, that's a great way to use the shebang line. (You can do similarly with Pipx, and I expect you'll be able to with Paper as well, although I might push that sort of thing into an optional add-on.)

    #! /usr/bin/env nix-shell
    #! nix-shell -i bash -p bash imagemagick

[1] https://treyhunner.com/2024/12/lazy-self-installing-python-scripts-with-uv/

"/usr/bin/env -S uv run": https://news.ycombinator.com/item?id=42198256

125 points, 45 comments

I recently switched over my python aliases to `uv run python` and it's been really quite pleasant, without needing to manage `.venv`s and the rest. No fuss about system installs for python or anything else either, which resolves the old global/user install problem (and is a boon on Debian). Also means you can invoke the REPL within a project/environment without any `activate`, which saves needing to think about it.

Only downside for calling a .py directly with uv is the cwd relative pathing to project/environment files, rather than relative to the .py file itself. There is an explicit switch for it, `--project`, which at least is not much of an ask (`uv run --project <path> <path>/script.py`), though a target relative project switch would be appreciated, to at least avoid the repetition.

    #!/usr/bin/env -S uv run --script

    /usr/bin/env '-S uv run --script' foo.py

I haven’t dove into uv as it just hasn’t been at the top of my list, but I will probably take the plunge soon.

I gave it an initial try thinking it might function as a drop in, but didn’t find any great guides, and just haven’t been back yet. But we’re ~8% into 2025 so it’s time.

    #! /usr/bin/env -S deno run

    #! /usr/bin/env -S deno run --allow-env --allow-read --allow-net

    /*usr/bin/env scryer-prolog "$0" "$@" ; exit #*/

> The way this works is that this test.pl is both a valid shell file and prolog file. When executing as shell the first line finds and executes /usr/bin/env after searching for the glob pattern /*usr/bin/env. env then executes scryer-prolog "test.pl" which runs the prolog file as a module and halts; of course prolog ignores the first line as a comment /* ... */. Then the shell continues and executes the next command after ; which is exit which stops execution so the rest of the file (which is not valid shell) is ignored. The # makes the shell evaluator ignore prolog comment closer */ to prevent it from printing an error.

This may be the best and worst thing I have ever created.

https://bundler.io/guides/bundler_in_a_single_file_ruby_script.html

Though I think the implementation could be improved upon

1. I copied their `curl | sh` install script and added a `uv tool install --python python3.12 my-tool` line at the end. So users can now install my CLI tool with a nice curl-pipe-sh one-liner.

2. I made a tiny pypi "installer" package that has "uv" as its only dependency. All it does is `uv tool install` my CLI tool.

Both methods install the CLI tool, python3.12 and all python dependencies in their own isolated environment. Users don't need to manage python virtual envs. They don't need to even have python installed for the curl-pipe-sh method.

I now get far fewer GitHub issues from users who have somehow mangled the complex dependencies of my tool.

I wrote it up with more detail and links to code:

https://aider.chat/2025/01/15/uv.html

I’ve been having a blast automating some macOS annoyances with small scripts that can use native macOS APIs directly, no more pyobjc.

I also wrote an app to bring the startup folder functionality from Windows to the Mac to help me run these scripts at startup more easily [2]

[1] https://github.com/mxcl/swift-sh

[2] https://github.com/FuzzyIdeas/StartupFolder

    #!/usr/bin/env python3

?

  #!/bin/sh
  #! -*- perl -*- -p
  eval 'exec perl -x -wS $0 ${1+"$@"}'
    if 0;

  # It's Perl code from this point.

If you want to do the same with javascript or typescript, you can just use bun, it will auto-install[1] the packages included in there.

    #!/usr/bin/env bun

I love having little custom command line apps in my ~/bin directory. I used to, a very long time ago, use Gambit Scheme for this, then moved on to Common Lisp command line apps. More recently I have been using Python for ~/bin scripts but since I use venv for each individual project on my laptop, having a global Python setup with dependencies for ~/bin is annoying. Using uv seems like a great idea, which I will try today: use uv for all command line apps and venv for all other Python coding projects.