Запросы Python - печатать весь HTTP-запрос (необработанный)?


198

При использовании requestsмодуля можно ли распечатать необработанный HTTP-запрос?

Мне нужны не только заголовки, но и строка запроса, заголовки и распечатка содержимого. Можно ли увидеть, что в конечном итоге строится из HTTP-запроса?


2
Это хороший вопрос. Судя по источнику, кажется, что нет никакого способа получить необработанное содержимое подготовленного запроса, и он сериализуется только при отправке. Кажется, это было бы неплохо.
Тим Пирс

Ну, вы могли бы также запустить wireshark и увидеть это таким образом.
RickyA

@qwrrty было бы трудно интегрировать это как requestsфункцию, так как это означало бы переписывание / обход urllib3и httplib. Смотрите трассировку стека ниже
goncalopp

Это сработало для меня - stackoverflow.com/questions/10588644/…
Ajay

Ответы:


217

Начиная с версии 1.2.3, в запросы добавлен объект PreparedRequest. Согласно документации «он содержит точные байты, которые будут отправлены на сервер».

Это можно использовать для печати запроса, например, так:

import requests

req = requests.Request('POST','http://stackoverflow.com',headers={'X-Custom':'Test'},data='a=1&b=2')
prepared = req.prepare()

def pretty_print_POST(req):
    """
    At this point it is completely built and ready
    to be fired; it is "prepared".

    However pay attention at the formatting used in 
    this function because it is programmed to be pretty 
    printed and may differ from the actual request.
    """
    print('{}\n{}\r\n{}\r\n\r\n{}'.format(
        '-----------START-----------',
        req.method + ' ' + req.url,
        '\r\n'.join('{}: {}'.format(k, v) for k, v in req.headers.items()),
        req.body,
    ))

pretty_print_POST(prepared)

который производит:

-----------START-----------
POST http://stackoverflow.com/
Content-Length: 7
X-Custom: Test

a=1&b=2

Затем вы можете отправить фактический запрос с этим:

s = requests.Session()
s.send(prepared)

Эти ссылки относятся к самой последней доступной документации, поэтому их содержание может измениться: Дополнительно - Подготовленные запросы и API - Классы более низкого уровня


2
Это гораздо надежнее, чем мой метод исправления обезьян. Обновление не requestsвызывает
затруднений

71
Если вы используете простые response = requests.post(...)(или requests.getили requests.put, и т. Д.) Методы, вы действительно можете PreparedResponseпройти response.request. Это может сэкономить на ручной обработке requests.Requestи requests.Session, если вам не нужен доступ к необработанным http-данным, прежде чем вы получите ответ.
Гершом

2
Хороший ответ. Однако вы можете захотеть обновить одну вещь: разрывы строк в HTTP должны быть \ r \ n, а не просто \ n.
LTC

3
как насчет части версии протокола HTTP сразу после URL? как 'HTTP / 1.1'? это не найдено при распечатке на вашем симпатичном принтере.
Саджук

1
Обновлен для использования CRLF, так как это то, что требуется RFC 2616, и это может быть проблемой для очень строгих парсеров
напрасно

56
import requests
response = requests.post('http://httpbin.org/post', data={'key1':'value1'})
print(response.request.body)
print(response.request.headers)

Я использую запросы версии 2.18.4 и Python 3


44

Примечание: этот ответ устарел. Более новые версии requests поддерживают получение содержимого запроса напрямую, как ответные документы AntonioHerraizS .

Невозможно получить истинное необработанное содержимое запроса requests, поскольку оно имеет дело только с объектами более высокого уровня, такими как заголовки и тип метода . requestsиспользует urllib3для отправки запросов, но urllib3 также не работает с необработанными данными - он использует httplib. Вот типичная трассировка стека запроса:

-> r= requests.get("http://google.com")
  /usr/local/lib/python2.7/dist-packages/requests/api.py(55)get()
-> return request('get', url, **kwargs)
  /usr/local/lib/python2.7/dist-packages/requests/api.py(44)request()
-> return session.request(method=method, url=url, **kwargs)
  /usr/local/lib/python2.7/dist-packages/requests/sessions.py(382)request()
-> resp = self.send(prep, **send_kwargs)
  /usr/local/lib/python2.7/dist-packages/requests/sessions.py(485)send()
-> r = adapter.send(request, **kwargs)
  /usr/local/lib/python2.7/dist-packages/requests/adapters.py(324)send()
-> timeout=timeout
  /usr/local/lib/python2.7/dist-packages/requests/packages/urllib3/connectionpool.py(478)urlopen()
-> body=body, headers=headers)
  /usr/local/lib/python2.7/dist-packages/requests/packages/urllib3/connectionpool.py(285)_make_request()
-> conn.request(method, url, **httplib_request_kw)
  /usr/lib/python2.7/httplib.py(958)request()
-> self._send_request(method, url, body, headers)

Внутри httplibмеханизма мы видим HTTPConnection._send_requestкосвенное использование HTTPConnection._send_output, которое в итоге создает необработанный запрос и тело (если оно существует) и использует HTTPConnection.sendдля их отправки по отдельности. sendнаконец доходит до розетки.

Поскольку для выполнения того, что вы хотите, нет никаких ловушек, в качестве последнего средства вы можете использовать обезьяну httplibдля получения контента. Это хрупкое решение, и вам может понадобиться адаптировать его, если оно httplibбудет изменено. Если вы намерены распространять программное обеспечение с использованием этого решения, вы можете рассмотреть возможность упаковки, httplibа не использовать систему, что легко, поскольку это чистый модуль Python.

Увы, без лишних слов, решение:

import requests
import httplib

def patch_send():
    old_send= httplib.HTTPConnection.send
    def new_send( self, data ):
        print data
        return old_send(self, data) #return is not necessary, but never hurts, in case the library is changed
    httplib.HTTPConnection.send= new_send

patch_send()
requests.get("http://www.python.org")

который дает результат:

GET / HTTP/1.1
Host: www.python.org
Accept-Encoding: gzip, deflate, compress
Accept: */*
User-Agent: python-requests/2.1.0 CPython/2.7.3 Linux/3.2.0-23-generic-pae

Привет, goncalopp, если я вызываю процедуру patch_send () 2 раза (после 2-го запроса), то она печатает данные дважды (таким образом, в 2 раза больше, чем вы показали выше)? Итак, если бы я сделал 3-й запрос, он напечатал бы его 3 раза и так далее ... Любая идея, как получить только вывод один раз? Заранее спасибо.
Опсталь

@opstalj: patch_sendпосле импорта вам не следует звонить несколько раз, только один разhttplib
goncalopp

40

Еще лучшей идеей является использование библиотекиques_toolbelt, которая может выводить как запросы, так и ответы в виде строк для печати на консоль. Он обрабатывает все сложные случаи с файлами и кодировками, которые вышеупомянутое решение не обрабатывает хорошо.

Это так просто, как это:

import requests
from requests_toolbelt.utils import dump

resp = requests.get('https://httpbin.org/redirect/5')
data = dump.dump_all(resp)
print(data.decode('utf-8'))

Источник: https://toolbelt.readthedocs.org/en/latest/dumputils.html.

Вы можете просто установить его, набрав:

pip install requests_toolbelt

2
Похоже, что это не выдает запрос без его отправки.
Добес Вандермер

1
dump_all не работает должным образом, так как я получаю «TypeError: не могу объединить объекты« str »и« UUID »из вызова.
rtaft

@rtaft: Пожалуйста, сообщите об этом как об ошибке в их репозитории github: github.com/sigmavirus24/requests-toolbelt/…
Эмиль Стенстрем

Он печатает дамп со знаками> и <, они являются частью фактического запроса?
Джей

1
@Jay Похоже, что они добавляются перед фактическим запросом / ответом на внешний вид ( github.com/requests/toolbelt/blob/master/requests_toolbelt/… ) и могут быть указаны путем передачи request_prefix = b '{some_request_prefix}', response_prefix = b '{some_response_prefix}' to dump_all ( github.com/requests/toolbelt/blob/master/requests_toolbelt/… )
Кристиан Реал-Флухарти,

7

Вот код, который делает то же самое, но с заголовками ответа:

import socket
def patch_requests():
    old_readline = socket._fileobject.readline
    if not hasattr(old_readline, 'patched'):
        def new_readline(self, size=-1):
            res = old_readline(self, size)
            print res,
            return res
        new_readline.patched = True
        socket._fileobject.readline = new_readline
patch_requests()

Я потратил много времени на поиски этого, поэтому оставляю это здесь, если кому-то нужно.


3

Я использую следующую функцию для форматирования запросов. Это похоже на @AntonioHerraizS, за исключением того, что оно также красиво печатает JSON-объекты в теле и помечает все части запроса.

format_json = functools.partial(json.dumps, indent=2, sort_keys=True)
indent = functools.partial(textwrap.indent, prefix='  ')

def format_prepared_request(req):
    """Pretty-format 'requests.PreparedRequest'

    Example:
        res = requests.post(...)
        print(format_prepared_request(res.request))

        req = requests.Request(...)
        req = req.prepare()
        print(format_prepared_request(res.request))
    """
    headers = '\n'.join(f'{k}: {v}' for k, v in req.headers.items())
    content_type = req.headers.get('Content-Type', '')
    if 'application/json' in content_type:
        try:
            body = format_json(json.loads(req.body))
        except json.JSONDecodeError:
            body = req.body
    else:
        body = req.body
    s = textwrap.dedent("""
    REQUEST
    =======
    endpoint: {method} {url}
    headers:
    {headers}
    body:
    {body}
    =======
    """).strip()
    s = s.format(
        method=req.method,
        url=req.url,
        headers=indent(headers),
        body=indent(body),
    )
    return s

И у меня есть аналогичная функция для форматирования ответа:

def format_response(resp):
    """Pretty-format 'requests.Response'"""
    headers = '\n'.join(f'{k}: {v}' for k, v in resp.headers.items())
    content_type = resp.headers.get('Content-Type', '')
    if 'application/json' in content_type:
        try:
            body = format_json(resp.json())
        except json.JSONDecodeError:
            body = resp.text
    else:
        body = resp.text
    s = textwrap.dedent("""
    RESPONSE
    ========
    status_code: {status_code}
    headers:
    {headers}
    body:
    {body}
    ========
    """).strip()

    s = s.format(
        status_code=resp.status_code,
        headers=indent(headers),
        body=indent(body),
    )
    return s

1

requestsподдерживает так называемые перехватчики событий (с 2.23 фактически есть только responseперехватчики). Хук может использоваться для запроса для печати полных данных пары запрос-ответ, включая эффективный URL, заголовки и тела, например:

import textwrap
import requests

def print_roundtrip(response, *args, **kwargs):
    format_headers = lambda d: '\n'.join(f'{k}: {v}' for k, v in d.items())
    print(textwrap.dedent('''
        ---------------- request ----------------
        {req.method} {req.url}
        {reqhdrs}

        {req.body}
        ---------------- response ----------------
        {res.status_code} {res.reason} {res.url}
        {reshdrs}

        {res.text}
    ''').format(
        req=response.request, 
        res=response, 
        reqhdrs=format_headers(response.request.headers), 
        reshdrs=format_headers(response.headers), 
    ))

requests.get('https://httpbin.org/', hooks={'response': print_roundtrip})

Запуск это печатает:

---------------- request ----------------
GET https://httpbin.org/
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive

None
---------------- response ----------------
200 OK https://httpbin.org/
Date: Thu, 14 May 2020 17:16:13 GMT
Content-Type: text/html; charset=utf-8
Content-Length: 9593
Connection: keep-alive
Server: gunicorn/19.9.0
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true

<!DOCTYPE html>
<html lang="en">
...
</html>

Вы можете изменить res.textна, res.contentесли ответ является двоичным.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.