code: def run(self, build_requests=None, callback=None):
          
          if callback:
              self.callback = callback
          if build_requests:
              self.build_requests = build_requests
  
          def normalise_requests_err(e):
              try:
                  msg = e.message.args[1].strerror
              except:
                  try:
                      msg = e.message.args[0]
                  except:
                      msg = str(e)
              return msg
  
          while not self.done:
              try:
  
                  # get the server version info
                  if not self.server_version:
                      self.server_version = self.perform_request('version')
  
                      # if the server supports async mode, use it, as some views may only work in async mode
                      if self.server_version.capabilities and 'async' in self.server_version.capabilities:
                          self.update()
                          self.block = False
                      elif self.supports_blocking:
                          self.block = True
                      else:
                          raise BlockingNotSupportedError("Debugger requires blocking mode")
  
                  if self.block:
                      # synchronous requests
                      self.update()
                  else:
                      # async requests, block using a null request until the debugger stops again
                      res = self.perform_request('null', block=True)
                      if res.is_success:
                          self.server_version = res
                          self.update()
              except ConnectionError as e:
                  self.callback(error='Error: {}'.format(normalise_requests_err(e)))
                  self.server_version = None
                  time.sleep(1)
docs: Run the client in a loop, calling the callback each time the debugger
          stops.