Reload package that was imported with *

I have this structure:

|-- handler
|   |-- __init__.py
|   |-- Layer1.py
|   |-- Layer2.py
|-- factory.py
|-- main.py

init.py file:

from os.path import dirname, basename, isfile, join
import glob

modules = glob.glob(join(dirname(__file__), "*.py"))
__all__ = [ basename(f)[:-3] for f in modules if isfile(f) and not f.endswith('__init__.py')]

Layer file includes class that looks as follows:

@ClassFactory.register(1)
class layer1:
    def __init__(self,string):
        self.do_something(string)


    def do_something(self, string):
        something...

and in main.py file I import as follows:

from handler import *

And calls the registry to run the class function:

    for key, value in sorted(ClassFactory.registry.items()):
        value("someValue")

I've been trying for hours to make it reload the files in handler package in main. My goal is to be able to change the files manually and then reload them while the interpreter is still running.
I tried many things, reload of importlib doesn't seem to reload the modules in handler. deepreload of Ipython.lib fails with NotImplementedError. I can't understand what am I doing wrong. When I did:

from handler import Layer1

I was able to reload Layer1 without any issue, but since I'm loading everything in the directory dynamically, it doesn't help and it has to be with *.
Also, I'm pretty sure that the fact that I'm loading the classes from registry adds another layer of complication, since the classes have to re-register themselves.

Would appreciate your help

Instead of:

from handler import *

Consider something more like:

import inspect, importlib

def import_from(module, dest = None):
    if dest is None:
        dest = globals()
    if hasattr(module, '__all__'):
        for item in module.__all__:
            dest[item] = getattr(module, item)
        return
    for name, value in inspect.getmembers(module):
        if name.startswith('_'):
            continue
        dest[name] = value

Used as:

import handler
import_from(handler)

### ...and later...
handler = importlib.reload(handler)
import_from(handler)

If the import_from helper is used from a different module, you'll want to pass in that module's globals() as the dest argument.

I ended up finding a simple solution:

Imports are

import handler
from handler import *

and for reload I did:

ClassFactory.registry.clear()

for i in handler.__all__:
    reload(globals()[i])

Which is simply accesses all the class names in global that are located in handler package and reload them in a loop.