code: async def _worker_process(self) -> None:
          
          state = self.STATE_NONE
          timeout = None
  
          self._loop.call_soon(self._callback, False)
  
          # for repeat feature
          re_frame = 0
          re_time = 0
  
          re_data = re.compile(self.MATCH)
  
          # process queue data
          while True:
              try:
                  _LOGGER.debug("Reading State: %d, timeout: %s", state, timeout)
                  with async_timeout.timeout(timeout, loop=self._loop):
                      data = await self._que.get()
                  if data is None:
                      self._loop.call_soon(self._callback, None)
                      return
              except asyncio.TimeoutError:
                  _LOGGER.debug("Blocking timeout")
                  # reset motion detection
                  if state == self.STATE_MOTION:
                      state = self.STATE_NONE
                      self._loop.call_soon(self._callback, False)
                      timeout = None
                  # reset repeate state
                  if state == self.STATE_REPEAT:
                      state = self.STATE_NONE
                      timeout = None
                  continue
  
              frames = re_data.search(data)
              if frames:
                  # repeat not used
                  if self._repeat == 0 and state == self.STATE_NONE:
                      state = self.STATE_MOTION
                      self._loop.call_soon(self._callback, True)
                      timeout = self._time_reset
  
                  # repeat feature is on / first motion
                  if state == self.STATE_NONE:
                      state = self.STATE_REPEAT
                      timeout = self._time_repeat
                      re_frame = 0
                      re_time = time()
  
                  elif state == self.STATE_REPEAT:
                      re_frame += 1
  
                      # REPEAT ready?
                      if re_frame >= self._repeat:
                          state = self.STATE_MOTION
                          self._loop.call_soon(self._callback, True)
                          timeout = self._time_reset
                      else:
                          past = time() - re_time
                          timeout -= past
  
                      # REPEAT time down
                      if timeout <= 0:
                          _LOGGER.debug("Reset repeat to none")
                          state = self.STATE_NONE
                          timeout = None
  
                  continue
  
              _LOGGER.warning("Unknown data from queue!")
docs: This function processing data.