Function initialize_many

lantz/driver.py:497–573

Initialize a group of drivers. :param drivers: an iterable of drivers. :param register_finalizer: register driver.finalize method to be called at python exit. :param on_initializing: a callable to be executed BEFORE initialization. It takes the driver as the

(drivers, register_finalizer=True,
                    on_initializing=None, on_initialized=None, on_exception=None,
                    concurrent=False, dependencies=None)

def initialize_many(drivers, register_finalizer=True,
                    on_initializing=None, on_initialized=None, on_exception=None,
                    concurrent=False, dependencies=None):
    """Initialize a group of drivers.

    :param drivers: an iterable of drivers.
    :param register_finalizer: register driver.finalize method to be called at python exit.
    :param on_initializing: a callable to be executed BEFORE initialization.
                            It takes the driver as the first argument.
    :param on_initialized: a callable to be executed AFTER initialization.
                           It takes the driver as the first argument.
    :param on_exception: a callable to be executed in case an exception occurs.
                         It takes the offending driver as the first argument and the
                         exception as the second one.
    :param concurrent: indicates that drivers with satisfied dependencies
                       should be initialized concurrently.
    :param dependencies: indicates which drivers depend on others to be initialized.
                         each key is a driver name, and the corresponding
                         value is an iterable with its dependencies.
    """

    if dependencies:
        names = {driver.name: driver for driver in drivers}

        groups = _solve_dependencies(dependencies, set(names.keys()))
        drivers = tuple(tuple(names[name] for name in group) for group in groups)
        for subset in drivers:
            initialize_many(subset, register_finalizer,
                            on_initializing, on_initialized, on_exception,
                            concurrent)
        return

    if concurrent:
        def _finalize(d):
            def _inner_finalize(f):
                atexit.register(d.finalize)
            return _inner_finalize

        def _done(d):
            def _inner(f):
                ex = f.exception()
                if ex:
                    if not on_exception:
                        raise ex
                    on_exception(d, ex)
                else:
                    if on_initialized:
                        on_initialized(d)
            return _inner

        futs = []
        for driver in drivers:
            if on_initializing:
                on_initializing(driver)
            fut = driver.initialize_async()
            if register_finalizer:
                fut.add_done_callback(_finalize(driver))
            fut.add_done_callback(_done(driver))