class_docstr: NetGear_Async can generate the same performance as NetGear API at about one-third the memory consumption, and also provide complete server-client handling with various
  options to use variable protocols/patterns similar to NetGear, but lacks in term of flexibility as it supports only a few NetGear's Exclusive Modes.
  
  NetGear_Async is built on `zmq.asyncio`, and powered by a high-performance asyncio event loop called uvloop to achieve unwatchable high-speed and lag-free video streaming
  over the network with minimal resource constraints. NetGear_Async can transfer thousands of frames in just a few seconds without causing any significant load on your
  system.
  
  NetGear_Async provides complete server-client handling and options to use variable protocols/patterns similar to NetGear API. Furthermore, NetGear_Async allows us to define
   our custom Server as source to transform frames easily before sending them across the network.
  
  NetGear_Async now supports additional **bidirectional data transmission** between receiver(client) and sender(server) while transferring frames.
  Users can easily build complex applications such as like _Real-Time Video Chat_ in just few lines of code.
  
  In addition to all this, NetGear_Async API also provides internal wrapper around VideoGear, which itself provides internal access to both CamGear and PiGear APIs, thereby
  granting it exclusive power for transferring frames incoming from any source to the network.
  
  NetGear_Async as of now supports four ZeroMQ messaging patterns:
  
  - `zmq.PAIR` _(ZMQ Pair Pattern)_
  - `zmq.REQ/zmq.REP` _(ZMQ Request/Reply Pattern)_
  - `zmq.PUB/zmq.SUB` _(ZMQ Publish/Subscribe Pattern)_
  - `zmq.PUSH/zmq.PULL` _(ZMQ Push/Pull Pattern)_
  
  Whereas supported protocol are: `tcp` and `ipc`.
docstr: Launches an asynchronous generators and loop executors for respective task.
docstr_tok: ["Launches","an","asynchronous","generators","and","loop","executors","for","respective","task","."]
code: def launch(self):
      """
      Launches an asynchronous generators and loop executors for respective task.
      """
      # check if receive mode enabled
      if self.__receive_mode:
          if self.__logging:
              logger.debug(
                  "Launching NetGear_Async asynchronous generator!"
              )
          # run loop executor for Receiver asynchronous generator
          self.loop.run_in_executor(None, self.recv_generator)
      else:
          # Otherwise launch Server handler
          if self.__logging:
              logger.debug(
                  "Creating NetGear_Async asynchronous server handler!"
              )
          # create task for Server Handler
          self.task = asyncio.ensure_future(self.__server_handler())
      # return instance
      return self
  
file_path: vidgear/vidgear/gears/asyncio/netgear_async.py
imports: import cv2
  import sys
  import numpy
  import asyncio
  import inspect
  import logging
  import string
  import secrets
  import platform
  from collections import deque
  from ..helper import logger_handler, import_dependency_safe, logcurr_vidgear_ver
  from ..videogear import VideoGear
label_desc: Use image node_id 2 for calling the NetGear_Async obj's underlying member method code with example usage: obj.launch() and returns: self