How to use the uplink.clients.io.state function in uplink

def test_execute(self, request_execution_mock):
        request, error = object(), Exception()
        fail = state.Fail(request, type(error), error, None)
        fail.execute(request_execution_mock)
        request_execution_mock.fail.assert_called_with(Exception, error, None)

def create_state(self, request):
        return state.AfterResponse(request, object())

def test_execute(self, request_execution_mock):
        request = object()
        sleep = state.Sleep(request, 10)
        sleep.execute(request_execution_mock)
        assert request_execution_mock.sleep.called

        args, _ = request_execution_mock.sleep.call_args
        callback = args[1]
        assert isinstance(callback, interfaces.SleepCallback)

        callback.on_success()
        assert request_execution_mock.state == state.BeforeRequest(request)

        error = Exception()
        callback.on_failure(Exception, error, None)
        assert request_execution_mock.state == state.AfterException(
            request, Exception, error, None
        )

def test_execute(self, request_execution_mock):
        request = object()
        send_request = state.SendRequest(request)
        send_request.execute(request_execution_mock)
        assert request_execution_mock.send.called

        args, _ = request_execution_mock.send.call_args
        callback = args[1]
        assert isinstance(callback, interfaces.InvokeCallback)

        response = object()
        callback.on_success(response)
        assert request_execution_mock.state == state.AfterResponse(
            request, response
        )

        error = Exception()
        callback.on_failure(Exception, error, None)
        assert request_execution_mock.state == state.AfterException(

def test_execute(self, request_execution_mock):
        request = object()
        sleep = state.Sleep(request, 10)
        sleep.execute(request_execution_mock)
        assert request_execution_mock.sleep.called

        args, _ = request_execution_mock.sleep.call_args
        callback = args[1]
        assert isinstance(callback, interfaces.SleepCallback)

        callback.on_success()
        assert request_execution_mock.state == state.BeforeRequest(request)

        error = Exception()
        callback.on_failure(Exception, error, None)
        assert request_execution_mock.state == state.AfterException(
            request, Exception, error, None
        )

def test_prepare(self):
        request = self._create_request_mock()
        target = self.create_state(request)
        output = target.prepare(request)
        assert output == state.BeforeRequest(request)

def action(previous_state):
        return state.WaitState(previous_state.request, seconds)

def action(_):
        return state.SendRequest(request)

def start(self, request):
        self._state = state.BeforeRequest(request)  # Start state
        return self._io.execute(self)

def action(_):
        return state.BeforeRequest(request)