Is it possible to define a function usable in Python in Mojo?

[paugier]

It would be great if we could use from Python a function defined in a Mojo file.

For example it could be possible to create a Python native extension importable from Python by compiling AOT a Mojo file.

Alternatively, there could be a mechanism to import a mojo file in Python. Something like

from mojo import import_module

my_mojo_mod = import_module("my_mojo_mod")

result = my_mojo_mod.my_great_mojo_func(...)

It seems to me that such kinds of interactions would help a lot adoption of Mojo by Python users. Do you plan to support such features?

Note that this question is related to #546

[manatlan]

currently, I've red somewhere that it's possible ... thru ctype ...
I need that too ... and I'm searching it .... will post it here, when i'll find it

[manatlan]

found it :
https://github.com/rd4com/mojo-learning/blob/main/tutorials/calling-mojo-functions-in-python.md

[rarebreed]

The example used there isn't really the same as importing a module. It is basically doing FFI (Foreign Function Interface) using the ctypes module to marshall the data to/from python and mojo. While that can be useful, it's the same technique you can use from python to call into a C library and invoke a function through a function pointer

[rarebreed]

I think to do this, you would need to use the python C API and convert the python.h types to mojo equivalents. This is effectively the same as writing a C shared library using the types declared in the header (and the implementation details required).

It would be really interesting though, if there was a way to have mlir make this easier? They also have C/C++ interop on their roadmap which would make this easier I suspect

https://docs.modular.com/mojo/roadmap.html#cc-interop

[paugier]

Note that Pythran, a Python/Numpy compiler producing native extensions importable in Python, does this.

At least for simple builtin types and Numpy arrays it should not be too difficult for Mojo.

Representing the Mojo classes in Python might be more complicated.

[rarebreed]

Yeah, that's essentially what mojo would need to do. It would need to be able to create a shared library with a C ABI so that it can dynamically link to libpython to extend it with the new features. It would need a compiler mode to

• be compatible with the types from python.h
• generate a dynamic .so/dll/dylib library

Which is actually something else I hope mojo does relatively soon. Let us compile to a shared library so that other mojo applications or even other languages can link to it (or at least make some kind of FFI call with it). One of the things I did find sometimes frustrating with rust, is that it really wants you to statically link all the intermediate files together into a standalone binary. This makes distribution easy. But it also makes compile times worse, and prevents an easier way to add dynamic functionality.

[paugier]

See https://github.com/ihnorton/mojo-ffi

[prabhuramachandran]

https://gist.github.com/richardkiss/4f1fc7e948ddb7e8dba1e9a907662073

[JackKelly]

I would love to be able to call libraries written in Mojo from CPython.

I'm about to start writing a library for high speed IO & compute for chunked, compressed, multi-dimensional data. Some of the library's users (including me) are ML folks. But many of the library's users aren't doing ML. And some users are on highly constrained compute environments, where installing new software requires many months of discussions with overworked and understaffed IT departments.

So, even though I'm excited about Mojo, I know I can't force users of my library to use Mojo.

If CPython can't call Mojo then Mojo becomes "viral" like the GPL license. Code that uses Mojo forces all downstream users of that code to also use Mojo. I think that will harm adoption of Mojo! And I'd love to see Mojo do well! I'd love to see a super simple way for CPython users to install and use libraries written in Mojo!

[paugier]

I guess you can explain your needs in this issue #1423. Here, this is just a "discussion".

[paugier]

The answer is that there is not yet a good and robust mechanism to use Mojo from Python. It should be added but Mojo is not ready yet. There is an issue about adding this feature to Mojo roadmap #1423

In the mean time, one can use hacks using ctypes/cffi, but IMHO this can't be used "in production". Anyway, Mojo is not ready yet to be used "in production" outside Modular.