How to use the gevent.event function in gevent

def setup_remote_actuation(self, vip_destination):
            event = gevent.event.Event()
            agent = Agent(address=vip_destination)
            gevent.spawn(agent.core.run, event)
            event.wait(timeout=15)
            return agent

app = Flask(__name__)
app.config['DEBUG'] = False
app.config['WTF_CSRF_ENABLED'] = True
app.config['SECRET_KEY'] = ''.join(random.choice(string.lowercase) for x in range(random.randint(16, 32)))
app.jinja_env.filters['bootstrap_is_hidden_field'] = is_hidden_field_filter

login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'

config = {}

logger = logging.getLogger(__name__)

authenticator = Authenticator()
first_cfg_received = gevent.event.Event()

# keys used for adding new drones to the system
drone_keys = []

@app.before_first_request
def initialize():
    gevent.spawn(config_subscriber)
    # wait until we have received the first config publish
    first_cfg_received.wait()


def config_subscriber():
    global config
    ctx = zmq.Context()
    subscriber_socket = ctx.socket(zmq.SUB)
    subscriber_socket.connect('ipc://configPublisher')

def __init__(self, actor_config, directory="./", idle_trigger=False, idle_time=10):
        Actor.__init__(self, actor_config)
        self.reading = event.Event()
        self.reading.set()
        self.pool.createQueue("outbox")

def __init__(self, store, node):
        self.store = store
        self.node = node

        # retrieval task queue
        self.queue = gevent.queue.Queue(16)
        # recovery signal
        self._recovery = None

        self.event = gevent.event.Event()

        self.last_known_header = None

def __init__(self, fabricclass, fabricconfig, mgmtbusconfig):
        self.chassis_id = os.getpid()

        self.fts = {}
        self.poweroff = gevent.event.AsyncResult()

        self.fabric_class = fabricclass
        self.fabric_config = fabricconfig
        self.fabric = minemeld.fabric.factory(
            self.fabric_class,
            self,
            self.fabric_config
        )

        self.mgmtbus = minemeld.mgmtbus.slave_hub_factory(
            mgmtbusconfig['slave'],
            mgmtbusconfig['transport']['class'],
            mgmtbusconfig['transport']['config']
        )
        self.mgmtbus.add_failure_listener(self.mgmtbus_failed)
        self.mgmtbus.request_chassis_rpc_channel(self)

def _add_table(self, name, priority, create_if_missing=True):
        self.current_tables_lock.acquire()
        if len(self.current_tables) < self.max_tables:
            try:
                result = self._open_table(
                    name,
                    create_if_missing=create_if_missing
                )
            finally:
                self.current_tables_lock.release()
            return result
        self.current_tables_lock.release()

        future_table = gevent.event.AsyncResult()
        self.add_queue.put((
            priority,
            (future_table, name, create_if_missing)
        ))
        self._process_queue()

        return future_table.get()

sync_start_block: BlockNumber,
        required_confirmations: BlockTimeout,
        poll_interval: float,
        matrix_servers: Optional[List[str]] = None,
    ):
        super().__init__()

        self.web3 = web3
        self.registry_address = contracts[CONTRACT_TOKEN_NETWORK_REGISTRY].address
        self.user_deposit_contract = contracts[CONTRACT_USER_DEPOSIT]
        self.service_token_address = self.user_deposit_contract.functions.token().call()
        self.chain_id = ChainID(web3.eth.chainId)
        self.address = private_key_to_address(private_key)
        self.required_confirmations = required_confirmations
        self._poll_interval = poll_interval
        self._is_running = gevent.event.Event()

        log.info("PFS payment address", address=self.address)

        self.database = PFSDatabase(
            filename=db_filename,
            pfs_address=self.address,
            sync_start_block=sync_start_block,
            token_network_registry_address=to_canonical_address(self.registry_address),
            chain_id=self.chain_id,
            user_deposit_contract_address=to_canonical_address(self.user_deposit_contract.address),
            allow_create=True,
        )

        self.blockchain_state = BlockchainState(
            latest_committed_block=self.database.get_latest_committed_block(),
            token_network_registry_address=to_canonical_address(self.registry_address),

if len(g) == 0:
            continue

        p = multiprocessing.Process(
            target=_run_chassis,
            args=(
                config.fabric,
                config.mgmtbus,
                g
            )
        )
        processes.append(p)
        p.start()

    processes_lock = gevent.lock.BoundedSemaphore()
    signal_received = gevent.event.Event()

    gevent.signal(signal.SIGINT, _sigint_handler)
    gevent.signal(signal.SIGTERM, _sigterm_handler)

    try:
        mbusmaster = minemeld.mgmtbus.master_factory(
            config=config.mgmtbus['master'],
            comm_class=config.mgmtbus['transport']['class'],
            comm_config=config.mgmtbus['transport']['config'],
            nodes=config.nodes.keys(),
            num_chassis=len(processes)
        )
        mbusmaster.start()
        mbusmaster.wait_for_chassis(timeout=10)
        # here nodes are all CONNECTED, fabric and mgmtbus up, with mgmtbus
        # dispatching and fabric not dispatching

def _broadcast(self, brtype, stream_name, input=None, muxer='ts', pre_access=''):
        if self._shuttingDown.isSet():
            return

        # Start/stop broadcast with VLC
        # Logger
        if brtype == True:
            broadcast = 'startBroadcast'
        else:
            broadcast = 'stopBroadcast'

        logger = logging.getLogger("VlcClient_" + broadcast)
        # Clear AsyncResult
        self._result = gevent.event.AsyncResult()
        # Get lock
        self._resultlock.acquire()
        # Write message to VLC socket
        if brtype == True:
            self._write(VlcMessage.request.startBroadcast(
                stream_name, input, self._out_port, muxer, pre_access))
        else:
            self._write(VlcMessage.request.stopBroadcast(stream_name))

        try:
            gevent.sleep()
            result = self._result.get(timeout=self._resulttimeout)
            if result == False:
                logger.error(broadcast + " error")
                raise VlcException(broadcast + " error")
        except gevent.Timeout:

# Create emitter and bind to gateway payloads
        self.packets.on((RECV, OPCode.DISPATCH), self.handle_dispatch)
        self.packets.on((RECV, OPCode.HEARTBEAT), self.handle_heartbeat)
        self.packets.on((RECV, OPCode.HEARTBEAT_ACK), self.handle_heartbeat_acknowledge)
        self.packets.on((RECV, OPCode.RECONNECT), self.handle_reconnect)
        self.packets.on((RECV, OPCode.INVALID_SESSION), self.handle_invalid_session)
        self.packets.on((RECV, OPCode.HELLO), self.handle_hello)

        # Bind to ready payload
        self.events.on('Ready', self.on_ready)
        self.events.on('Resumed', self.on_resumed)

        # Websocket connection
        self.ws = None
        self.ws_event = gevent.event.Event()
        self._zlib = None
        self._buffer = None

        # State
        self.seq = 0
        self.session_id = None
        self.reconnects = 0
        self.shutting_down = False
        self.replaying = False
        self.replayed_events = 0

        # Cached gateway URL
        self._cached_gateway_url = None

        # Heartbeat
        self._heartbeat_task = None