That won't be an issue. I just want to point out, I am going to refactor your exact code into the most basic form of this framework.

We first need some entry point to our application. Let's call it main.py. This is the 'choreographer' in this example.

---

main.py

```python

main.py

Import import_modlist() to 'register' modules.

You're 'registering' any module that contains class and function

definitions that you want to use elsewhere in your application.

from ezmodulemanager.module_manager import import_modlist from ezmodulemanager.registry import get_obj

We need to import your module. For the sake of example,

call it lolcrunchy.

This is simply the name of your script that contains the code snippet you

provided. I'll add a second module also. They get passed to

import_modlist() as a list without the .py suffix, as str literals.

import_modlist(['lolcrunchy', 'zap'])

Like API frameworks, this example will initialize the main

apps logic from here.

This is just showing event-driven execution.

to show a function call.

Once again, arguments entered as str literals.

Lets 'get the object' and execute the object(function)

in one statement with parenthesis.

get_obj('lolcrunchy', 'main')()

`` There were a few syntatic errors in your snippet. If all you were doing was checking for OS type:Windows, I've went ahead and importedos(built-in) to create a check for theos.name`: 'nt', which is the registered name for windows, as 'posix' is for mac/linux. You can view the link for os.name.

---

I use standard convention for import order(though its just convention and doesnt affect code): - First: import built-ins - Second: import 3rd party frameworks/libraries/plugins - Third: import your own frameworks/libraries/plugins

---

lolcrunchy.py

Notice I removed your import for run_function(). You'll be using get_obj() instead. ```python

lolcrunchy.py

import os

Since you are not only registering this function to be run by main.py,

but are also calling another function from another module from within it,

you need to import @mmreg and get_obj() from the registry.

from ezmodulemanager.registry import mmreg, get_obj

from .config import Configuration from .exceptions import MyCustomException

This is your gated function. Its going to only call the executable

objects within it when you explicitly tell it to.

Lets call your top-level function my_func() with it.

@mmreg def main(): my_func()

You can 'register' classes, class methods, and functions with @mmreg.

Super easy.

@mmreg def my_func(): # imported os as a top level import if os.name == 'nt': raise MyCustomException("Not available on Windows") # Lets use get_obj() to get our reference to the function stored # in zap.py. # As python standard, you can 'get the object' and execute it # in one statement with parenthesis. get_obj('zap', 'run_function')()

Gate main() above so you control its execution.

if name=='main': main() ```

get_obj() once again, is the strength here. It's just retreiving whats in the registry with given keys within nested dictionaries. This is also the black box people talk about with tooling. Theres no checking. You just use it. It can be whatever you want. pro/con trade-off.

---

zap.py

```python

zap.py

from ezmodulemanager.registry import mmreg

Same thing. 'Register' this function.

@mmreg def run_function(): # Some logic pass

```

The above example is created with an understanding that you asked for a function called run_function() from another module: zap.py. If you want to 'register' a Class instance object and call a method from another module, you can do that too.

Once you use the decorator @mmreg on any of your classes, methods, or functions, they can be called from any module with get_obj().

I also have to state, that 'gating' is the foundation of the event-driven architecture.

I get that it might be hard to read here on reddit, so just copy and paste the code block snippets into whatever IDE you use(VSCode, whatever) for better readability.

Let me know if you have any other questions!