jurigged

Interesting. It appears that not many systems have been designed to enable hot reload in a thorough way. Here's another fun complication: what if I have a decorator that performs a code transform on the source code of the decorated function? If the code is changed, I would like to automatically re-run the transform on the new code. I made a (kind of awkward) protocol for this: https://github.com/breuleux/jurigged?tab=readme-ov-file#cust.... It's a little confusing even for me, so I should probably review it.

Yeah, I've been using this trick to implement a hot reload library, to only update the specific functions that are changed without re-executing modules: https://github.com/breuleux/jurigged I also use it in a multiple dispatch library (https://github.com/breuleux/ovld) to replace the entry point by specialized dispatch code in order to cut some overhead. It's fun. Also, why is every damn post these days somehow framed in an AI context? It's exhausting.

"Uses the jurigged library to watch and hot reload files" jurigged, https://github.com/breuleux/jurigged is flippin' great

Some of the basic hot-loading features can probably be approximated in Python. Here's some from my bookmarks(i've not tried them personally) - https://github.com/breuleux/jurigged - https://github.com/reloadware/reloadium I would imagine lisp can do this on a whole different level. Emacs seems like a testament to that. Basically the entire editor feels like eval()

I'm about to embark on my master's thesis, in a domain[1] which could realllllly use the "attach to running process; re-evaluate code and have the system just keep going" aspect of Lisp languages. I know Python best. But I have reached my breaking point with its syntax, and its lack of binding constructs, and lack of symbol datatype, quote, etc. I am intending to use Clojure ... but I have to ship this thing by May 2023 come hell or high water. All else being equal, I will proooobably be able to go further with Python. But I'm concerned it will hamstring me from doing the crucial feature of "extending the design [ie code] of a game as it runs" since, AFAIK, it's difficult to get a Lisp-ish experience of total live reloadability in Python... jurigged[2] and reloading[3] not withstanding. I know some common lisp so I'm not a total lisp noob

For the record, I have written a reloading library for Python called jurigged[0] that works on normal Python code and can indeed replace foo() when it's being called in a loop. There is also a way to do debug-and-fix-up, but only if you specify restart points in advance, unfortunately. It is probably still a good deal more limited to what can be done with CL, there are no miracles here, just saying the gap may not be that big. [0] https://github.com/breuleux/jurigged

I've been using jurigged [0] for hot code reloading which is great. It works by replacing code objects in place at the function level which naturally handles many cases like applying to existing objects, avoiding loading a module multiple times, etc. As others noted the actual source of this one is not there so it's hard to know what it's doing. The published package contains a binary shared library so I suppose it's written as a CPython extension. [0] https://github.com/breuleux/jurigged

I made an issue to track this so I don't forget and where it can be discussed further if needed: https://github.com/breuleux/jurigged/issues/2 Explicitly detecting changes to if __name__ == "__main__" is a good idea as well, I think. It's an easy pitfall and I can't really think of any situation where it would work, so I might as well warn the user. Thanks for the useful feedback :D

I am developing my own reloader in spirit of jrebel and how hotswapping works in javascript bundlers. While investigating the topic I found a lot of projects: - https://github.com/yiblet/inquest - https://github.com/mpolney/hotpatch - https://pypi.org/project/patchy/ - https://pypi.org/project/plone.reload/ - http://svn.python.org/projects/sandbox/trunk/xreload/ - https://pypi.org/project/hot_reload/ - https://pypi.org/project/Reloadr/ - https://pypi.org/project/hotswap/ - https://pypi.org/project/reloading/ - https://pypi.org/project/hotreload/ - https://pypi.org/project/livereload/ - https://pypi.org/project/reimport/ - https://pypi.org/project/livecoding/ - https://pypi.org/project/pylivecoding/ - https://pypi.org/project/nameko-hot-reload/ - https://github.com/albertz/PythonHotswap - https://github.com/mikr/pyqtboiler/blob/master/ba

For what it's worth, I'm working on my own reloader which does not require decorating anything: https://github.com/breuleux/jurigged (still a WIP, but it works well enough).

That's a bit awkward, I'm currently working on a package[1] that does more or less the same thing in more or less the same way (I think), except you don't need to decorate anything. Just run `python -m jurigged script.py` or `jurigged script.py` instead of `python script.py` and it will watch everything in the current working directory. There's still some bugs I have to iron out, though, it should be better in a month or so. Still, you can pip install it if you want. [1] https://github.com/breuleux/jurigged