Updated-TaskExecutor

                devices.setdefault(device_type, dict())[device_uuid] = device

            else:

                if not exclude_managed_by_controller:

                    LOGGER.debug('device managed by controller = {:s}'.format(str(device_uuid)))

                    device_type = DeviceTypeEnum._value2member_map_[device.device_type]

                    LOGGER.debug('device_type not exlude by controller = {:s}'.format(str(device_type)))

                    devices.setdefault(device_type, dict())[device_uuid] = device

                else:

                    device_type = DeviceTypeEnum._value2member_map_[controller.device_type]

                    LOGGER.debug('device_type = {:s}'.format(str(device_type)))

                    devices.setdefault(device_type, dict())[controller.device_id.device_uuid.uuid] = controller

        return devices

    # ----- Service-related methods ------------------------------------------------------------------------------------

    def get_service_handlers(

        self, connection : Connection, service : Service, **service_handler_settings

    ) -> Dict[DeviceTypeEnum, Tuple['_ServiceHandler', Dict[str, Device]]]:

        connection_device_types : Dict[DeviceTypeEnum, Dict[str, Device]] = self.get_devices_from_connection(

        # WARNING: exclude_managed_by_controller should be True, changed to False for test purposes.

        # For Ryu SDN controller we need to know the underlying devices we are traversing.

        # Elaborate proper logic to resolve this case.

        connection_device_types_excluded : Dict[DeviceTypeEnum, Dict[str, Device]] = self.get_devices_from_connection(

            connection, exclude_managed_by_controller=True

        )

        LOGGER.debug('connection_device_types_excluded = {:s}'.format(str(connection_device_types_excluded)))

        connection_device_types_included : Dict[DeviceTypeEnum, Dict[str, Device]] = self.get_devices_from_connection(

            connection, exclude_managed_by_controller=False

        )

        LOGGER.debug('connection_device_types_included = {:s}'.format(str(connection_device_types_included)))

        service_handlers : Dict[DeviceTypeEnum, Tuple['_ServiceHandler', Dict[str, Device]]] = dict()

        for device_type, connection_devices in connection_device_types.items():

        for device_type, connection_devices in connection_device_types_excluded.items():

            try:

                service_handler_class = get_service_handler_class(

                    self._service_handler_factory, service, connection_devices)

                    self._service_handler_factory, service, connection_devices

                )

                LOGGER.debug('service_handler_class IN CONNECTION DEVICE TYPE EXCLUDED = {:s}'.format(str(service_handler_class.__name__)))

                service_handler = service_handler_class(service, self, **service_handler_settings)

                service_handlers[device_type] = (service_handler, connection_devices)

                LOGGER.debug('service_handler IN CONNECTION DEVICE TYPE EXCLUDED = {:s}'.format(str(service_handler)))

                connection_devices_included = connection_device_types_included.get(device_type, connection_devices)

                LOGGER.debug('connection_devices_included IN CONNECTION DEVICE TYPE EXCLUDED = {:s}'.format(str(connection_devices_included)))

                service_handlers[device_type] = (service_handler, connection_devices_included)

                LOGGER.debug('service_handlers IN CONNECTION DEVICE TYPE EXCLUDED = {:s}'.format(str(service_handlers)))

            except (

                UnsatisfiedFilterException, UnsupportedFilterFieldException,

                UnsupportedFilterFieldValueException