Load a class dynamically

I have a software that dynamically adds modules at startup.
The start happens after the start of my Python program, so I cannot import the modules with a normal "import DynModule", but have to do this during runtime.

Therefore I would like to do something like this:

def load_module():
    try:
        import site
        site.addsitedir(r"C:\Users\...")
        from DynModule import Foo
		
     except (ModuleNotFoundError, ImportError) as e:
        logger.error("Could not import the dynamic module")
		
		class AccessClass(Process):
			def __init__(self):
				Process.__init__(self)
				logger.info("Placeholder class instance")
			
			def do_something(self):
				logger.info("Placeholder does something")
				
    else:
        class AccessClass(Process):
			def __init__(self):
				Process.__init__(self)
				logger.info("The right class instance to use the dynamically loaded module")
			
			def do_something(self):
				logger.info("Actually does something")

And then do something like this in the main program:

def action_on_load(self):
	from loader import load_module, AccessClass
	
	load_module()
	self._access = AccessClass()
	self._access.do_something() # prints "Actually does something"

However, I cannot import AccessClass as it is defined inside the try-except clause.

How can I proceed and get this to work?

The problem isn't that its defined in the try statement, but that it's defined in the function, where the name AccessClass is a local variable. You can declare the name as global:

def load_module():
    global AccessClass
    ...

because a class statement is like a fancy assignment statement: it defines a class, then binds it to a name. Note, though, that the class won't be assigned to the name until you actually call the function. In your main program, you'd need to write something like

def action_on_load(self):
    import loader  # No AccessClass yet
    
    loader.load_module()  # Now loader.AccessClass is defined.
    self._access = loader.AccessClass()
    self._access.do_something() # prints "Actually does something"

Or, you can simply return the class:

def load_module():
    ...

    return AccessClass


def action_on_load(self):
    from loader import load_module
    
    AccessClass = load_module()
    self._access = AccessClass()
    self._access.do_something() # prints "Actually does something"