Right, that would be a wrong pipe direction. Fun fact: It's already possible to do "wat | foo" or "wat << foo" (if you're more familiar with C++ iostream), it has the same effect as "wat / foo"

"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/

You're completely right. `dir()` does the same in terms of functionality. In fact, my tool makes use of `dir` under the hood. I just wanted to make it more readable, and to combine `dir`, `type`, `repr`, `len`, `inspect`, etc. into one easily accessible place.

even just

  print(name.__doc__)

works for many kinds of names in Python.

Yes, that has the same effect as installing the package. So if you feel uncomfortable, you can either install the pip package (and of course review the installed code) or review the decoded string before executing it. It's not that obfuscated anyways, it's still quite readable.

got it, thanks.

It's the parentheses that drove me crazy. As people already noted, it's for faster typing, at the cost of the division magic as you noted. If it's more familiar to you, it works with `wat(object)` syntax as well.

I love it

Interactive file picker to traverse through directories tree in a terminal

Bulk rename tool based on regular expressions to rename multiple files at once.