Bring back the hooks from 0.x to 1.x

In the 0.x versions were 5 hooks:
('args', 'pre_request', 'pre_send', 'post_request', 'response')

In 1.x there's only one: response

I've seen quite a few packages that used these hooks to manipulate the requests objects before sending them, and now in v1.x there's not even a single hook that allows them to do so.

This functionality is very much needed, and without it quite a few packages simple cannot adapt to v1.x, and their alternative is to the [sort-of-a-fork requests-transition](https://github.com/LuminosoInsight/python-requests-transition)


We ased for package maintainers and authors that used the hooks extensively to comment on the change and received little feedback. I made use of one as well (args), but adapted with a small bit of work. I find it hard to believe that people can simply not make due without them.


We should throw together some better documentation perhaps


I agree that you can work around the missing 'args' hook by overloading, but there's not a clean way to work around the missing 'pre_request' hook, which allowed you to modify the request object before it is being sent.

from sessions.py:

```
    # Create the Request.
    req = Request()
    req.method = method.upper()
    req.url = url
    req.headers = headers
    req.files = files
    req.data = data
    req.params = params
    req.auth = auth
    req.cookies = cookies
    req.hooks = hooks

    # Prepare the Request.
    prep = req.prepare()

    # Send the request.
    send_kwargs = {
        'stream': stream,
        'timeout': timeout,
        'verify': verify,
        'cert': cert,
        'proxies': proxies,
        'allow_redirects': allow_redirects,
        'req': req,
    }
    resp = self.send(prep, **send_kwargs)
```

I don't see another way to mess with the request before it is being prepared, except for patching/replacing requests.sessions.Request, which obviously is not a good solution.


although the hooks mechanism was cleaner, if you could just extract the code that creates the request into another method, whoever that wants to manipulate would simply overload/decorate it, and that would work just fine


That's exactly what we did Request() returns a PreparedRequest, which is fully mutable :)


@grzn, You can do that yourself.

``` python
request = Request(
    'GET',
    'http://example.com',
    #...
)

p = request.prepare()

s = requests.Session()
s.send(p, stream=True, verify=False,
# etc
)
```


@kennethreitz but some things are much harder/tricky to change after you've prepared the requests, and even so the way to modify is to overload the send method and modify the argument it receives. that's ugly

@sigmavirus24 yes you can do that yourself by inheriting the Session class and replacing the request method with a similar functionality, but thats also ugly -- this method is quite long and does a number of things and I don't duplicate the whole damn thing.

all i'm asking it to take the 10 lines that create the requests before 'preparing it' and extract it to a separate method. overloading such method would be the equivalent for the old pre_request hook

and also, some documentation on this in the hooks page would help :)


In light of #1170, I think it is fair to close this.