just

Would creating a `main.py` with the dependencies installed either as a uv project or inline work for you? One thing I did recently was create a one-off script with functions to exercise a piece of equipment connected to the PC via USB, and pass that to my coworkers. I created a `main.py` and uv add'ed the library. Then when I wanted to use the script in the REPL, I just did `uv run python -i main.py`. This let me just call functions I defined in there, like `set_led_on_equipment(led='green', on=True)` directly in the REPL, rather than having to modify the script body and re-run it every time. Edit: another idea that I just had is to use just[0] and modify your justfile accordingly, e.g. `just pything` and in your justfile, `pything` target is actually `uv run --with x,y,z ipython` Edit edit: I guess the above doesn't even require just, it

If someone is interested in pursuing this approach further, there exist a polyglot task runner named 'just' [1]. [1] https://github.com/casey/just?tab=readme-ov-file#shebang-rec...

Just is better choice imho https://github.com/casey/just

The 21st century way might be some combination of watchexec[1] and just[2] but you can't assume the availability of these tools. You can almost assume the availability of make but a lot of distros (hello, Ubuntu) omit basic build tools. Admittedly I used an LLM recently to write me a Makefile because my brain doesn't have the capacity to remember all make's idiosyncrasies every few years that I touch a Makefile. Once the file is done, it's done, and it was easy to pare down from the verbosity that the LLM coughed up. I also wanted targets for intermediate build files (long story) so that would have required excessive poring over the man page. [1]: https://github.com/kurtbuilds/checkexec [2]: https://github.com/casey/just

I manage a monorepo at my workplace. Different devs with various levels of seniority are on/off boarded on the project, some on mac some on linux. At first I offered mise as the recommended tool, and after a while I declared it's the only supported way to build the project and boom! All support requests that used to end with "oooh my XYZ's version was not matching the project's requirement" are gone now. I like asdf but it has quirks. Mise has been a better companion for me past few years. I also hear people say "but my node/ruby/elixir/java/foo version manager will break. My team uses that tool in our other projects, etc, etc" then I only have to show them what an amazing drop-in replacement mise is and nothing breaks; there's no going back for them. I just hope muse stays mise, and doesn't become just[1] (whom I also install via mise) [

and another alternative: just https://github.com/casey/just

This is excellent modern replacement for part where Makefiles get messy: https://github.com/casey/just

If you want to use make, power to you, it’s definitely a useful tool. (What I’m trying to say is I’m bashing make, not you.) That being said, I absolutely hate make, there are so many footguns and weird quirks and implicit behavior that always end up biting me. I find that 90% of the time what I actually want is a command runner like Just (https://github.com/casey/just) and have the make file contain the absolute sheer minimum required to build code. While we’re at it, CMake is another build tool with the same problems as make - powerful, with an ugly syntax, unintuitive semantics, hidden dragons, and a manual that’s torturous to read.

Or this https://github.com/casey/just

just is a great command runner[1], not a shell script. Looks like it is needed if you build from source or install from Github releases. Alternatively, use `brew install philocalyst/tap/infat`(haven't done it myself but I bet it has just as a dependency anyway) [1] https://github.com/casey/just

FYI with pipefail enabled, if one of the pipes fails, your step will fail, there will be no error output, you won't know why it failed. Pipefail also doesn't prevent more complex error states. For example this step from your config: curl -L "https://github.com/casey/just/releases/download/${{ matrix.just-version }}/just-${{ matrix.just-version }}-x86_64-apple-darwin.tar.gz" \ | sudo tar -C /usr/local/bin -xzv just Here's the different error conditions you will run into: 1. curl succeeds, sudo succeeds, tar succeeds, but just fails to extract from the tarball. Tar reports error, step fails. 2. curl succeeds, sudo succeeds, tar fails. Sudo reports error, step fails. 3. curl succeeds, sudo fails. Shell reports error, step fails. 4. curl begins running. sudo begins running in a subshell/pipe. tar begins running under th

This is why I've become a huge fan of Just, which is just a command runner, not a build caching system or anything. It allows you to define a central interface into your project (largely what I find people justify using Make for), but smoothes out so many of the weird little bumps you run into from "using Make wrong." Plus, you can an any point just drop into running a script in a different language as your command, so it basically "supports bash scripts" too. https://github.com/casey/just