Show HN: Localscope–Limit scope of Python functions for reproducible execution

I wrote myself a similar decorator for a completely different purpose – ensuring a function I'm going to serialise over the network doesn't have any outside dependencies

This is actually a cleaner API so might switch my code to it, amazing work

I was curious how this works - it's using the Python standard library disassembler: https://docs.python.org/3/library/dis.html

    for instruction in dis.get_instructions(code):
        ...

Nice! This approach can be used to implement coeffects (as e.g. seen in Hack [1]), by only passing explicit effect-producing objects. Imagine a function that's guaranteed to not write to any files, because it can't access `open()`, or can only access a version of `open()` that only accepts read-only access.

[1]: https://docs.hhvm.com/hack/contexts-and-capabilities/introdu...

> Everything works nicely, and you package the code in a function for later use but forget about the scale factor introduced earlier in the notebook.

You see a problem, you fix it with library, and I applaud that. You have to wonder though, how many years does it take for a reproducible notebook environment to implement out of scope variable guards..

Since I've started using Jupyter notebooks, I've wanted a feature to "undo" running a cell. This feels so important to for spontaneous exploration. This work feels like an important building block for this!

If you don't want pyhton flavored scope and lifetime rules, use another language :emothonless-face:

But how can you make sure that people annotate their functions with localscope?

I have this idea of tools which help you do the right thing and tools that let you do the wrong thing longer. Jupyter is already the latter sort of tool, and this is the bad kind of tool on top of the bad kind of tool.

Maybe I'm being naive, but it feels like if this is a problem for people they should be looking at how they write their code, not reaching for a library.