"import wat" would be great, but Python has some restrictions about modules not being callable. That's why I ended up with longer `from wat import wat`. Not sure but maybe this would be more convenient `import wat; wat.wat / object`

Python has code execution at import time. Just grab the global context, and overwrite the module with a callable.

Afaik the import sets the module in the importing module's context only after the code in the imported module is run.

Edit: Oh, you don't mean in the importing module's globals, you mean `sys.modules`. Yeah that works!

actually, no you were right about what I meant but i'll claim credit for helping you realize there was a better way XD

Check out the module “q”! It’s callable, its author talked about how great it would be to have a module level __call__ because the way it was made callable is super wonky.

> the way it was made callable is super wonky.

why do you say it's wonky? it's just

    sys.modules[__name__] = wat

According to the official python documentation [0] of sys.modules:

> This is a dictionary that maps module names to modules which have already been loaded. This can be manipulated to force reloading of modules and other tricks.

Thus, the modules dictionary is being used as intended, and it has the desired effect. Nothing wonky about that.

Of course, a __call__ method would be better because you could still keep the other functions inside the module. But for a single-function import like "wat" it seems quite natural and sane.

[0] https://docs.python.org/fr/3/library/sys.html

look at what q does: https://github.com/zestyping/q/blob/cbad74095e20017f33d3ab75...

Thank you all, I learned from you that it's possible to have a callable module. Although `sys.modules[__name__] = wat` looks like a black magic and I'm a bit afraid of locking out to other importable things in this package, I think I'll go for it.

It is kinda black magic, and I think it's not something people would expect. You can import other things just fine though:

    import sys

    def wat(): print("wat")
    def bar(): print("bar")

    wat.wat = wat
    wat.bar = bar

    sys.modules[__name__] = wat

...

    >>> import wat
    >>> wat()
    wat
    >>> from wat import bar
    >>> bar()
    bar

Edit: I think a better way would be to instead add __call__ to the current module somehow though.

See snoop[0], which does just this. It also has an install function that registers it in builtins, making it universally available.

[0] https://pypi.org/project/snoop/

I wrote this a long while ago: https://pypi.org/project/funkify/