Python demandes - impression de l'ensemble de la requête http (raw)?

Tout en utilisant le demande module, est-il possible d'imprimer la crue de la requête HTTP?

Je ne veux pas uniquement les en-têtes, je veux la demande en ligne, les en-têtes et le contenu de la version papier. Est-il possible de voir ce qui, finalement, est construit à partir de la requête HTTP?

  • Jetez un oeil à this réponse
  • il est demandé au sujet du contenu de la demande, pas la réponse
  • C'est une bonne question. En regardant le source, il ne semble pas comme il existe un moyen d'obtenir le contenu brut d'un prêt demande, et c'est seulement sérialisé quand il est envoyé. Que semble que ce serait une bonne fonctionnalité.
  • Eh bien, vous pourriez aussi commencer à wireshark et le voir de cette façon.
  • il serait difficile de l'intégrer, comme un requests fonctionnalité, car cela signifierait la reécriture/contournant urllib3 et httplib. Voir la trace de la pile ci-dessous
  • Cela a fonctionné pour moi - stackoverflow.com/questions/10588644/...

InformationsquelleAutor huggie | 2013-12-18
  1. 158

    Depuis la v1.2.3 Demandes ajouté le PreparedRequest objet. Selon les documents "contient exact d'octets qui sera envoyé au serveur".

    On peut utiliser ce joli imprimer une demande, comme suit:

    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{}\n{}\n\n{}'.format(
        '-----------START-----------',
        req.method + ' ' + req.url,
        '\n'.join('{}: {}'.format(k, v) for k, v in req.headers.items()),
        req.body,
    ))

pretty_print_POST(prepared)

    qui produit:

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

a=1&b=2

    Ensuite, vous pouvez envoyer la demande réelle avec ceci:

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

    Ces liens sont à la documentation la plus récente disponible, de sorte qu'ils pourraient changer dans le contenu:
    Avancé - Préparé demandes et API - niveau Inférieur des classes

    • C'est beaucoup plus robuste que mon monkey patching méthode. La mise à niveau de requests est simple, donc je pense que cela devrait devenir la accepté de répondre à
    • Cela semble ont été ajoutées sur 2.0.0, cependant, ne pas 1.2.3
    • Je l'ai vu mentionné dans la documentation pour 1.2.3, mais je n'ai pas regardé le code. Si vous pouvez confirmer qu'il n'était pas présent jusqu'à ce que 2.0.0 je vais le changer pour éviter la confusion.
    • C'est une grande réponse, mais je pense qu'il y a une faute de frappe: dans la définition de la fonction, l'argument doit être "préparé", 'pas 'req'.
    • Si vous utilisez la simple response = requests.post(...) (ou requests.get ou requests.put, etc) méthodes, vous pouvez réellement obtenir la PreparedResponse par response.request. Il peut enregistrer les travaux de manipuler manuellement requests.Request et requests.Session, si vous n'avez pas besoin d'accéder à http brut de données avant de recevoir une réponse.
    • Maintenant accepté (et après je me rends compte que c'est culturellement OK pour modifier les accepté de répondre)
    • La bonne réponse. Une chose que vous souhaitez mettre à jour, c'est que les sauts de ligne en HTTP doit être \r\n pas seulement \n.
    • ce sujet de la version du protocole HTTP de la partie juste après l'url? comme 'HTTP/1.1' ? qui n'est pas trouvé lors de l'impression à l'aide de votre jolie imprimante.

    InformationsquelleAutor AntonioHerraizS
  2. 41

    Note: cette réponse est obsolète. Des versions plus récentes de requests en charge l'obtention de la demande de contenu directement, comme AntonioHerraizS réponse documents.

    Il n'est pas possible d'obtenir la vrai contenu brut de la demande de requests, puisqu'il ne traite qu'avec les objets de niveau supérieur, tels que les les en-têtes de et type de méthode. requests utilise urllib3 pour envoyer des demandes, mais urllib3 aussi ne traitent pas les données brutes - il utilise httplib. Voici un représentant de la trace de la pile d'une demande de:

    -> 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)

    À l'intérieur de la httplib des machines, nous pouvons voir HTTPConnection._send_request indirectement utilise HTTPConnection._send_output, qui finalement crée la demande brute et corps (si elle existe), et utilise HTTPConnection.send de les envoyer séparément. send enfin atteint le socket.

    Car il n'y a pas de crochets pour faire ce que vous voulez, comme un dernier recours, vous pouvez monkey patch httplib pour obtenir le contenu. C'est un fragile de la solution, et vous devrez peut-être l'adapter si httplib est changé. Si vous avez l'intention de distribuer le logiciel à l'aide de cette solution, vous pouvez envisager d'emballage httplib au lieu d'utiliser le système, ce qui est facile, car c'est un pur module python.

    Hélas, sans plus attendre, la solution:

    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")

    qui donne de la sortie:

    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
    • Salut goncalopp, si je l'appelle le patch_send procédure() une 2ème fois (après une 2e demande), puis il imprime les données deux fois (2x fois la sortie comme vous l'avez indiqué ci-dessus) ? Donc, si je fais une 3ème demande, il devrait l'imprimer 3x fois et ainsi de suite... Aucune idée comment faire pour obtenir uniquement la sortie une fois ? Merci à l'avance.
    • vous ne devez pas appeler patch_send plusieurs fois, une seule fois, après l'importation de httplib
    InformationsquelleAutor goncalopp
  3. 30

    Une bien meilleure idée est d'utiliser le requests_toolbelt de la bibliothèque, ce qui peut générer à la fois les demandes et les réponses sous forme de chaînes pour vous d'imprimer à la console. Il gère l'ensemble de la délicate cas avec les fichiers et les codages qui la solution ci-dessus ne gère pas bien.

    C'est aussi simple que cela:

    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'))

    Source: https://toolbelt.readthedocs.org/en/latest/dumputils.html

    Vous pouvez simplement l'installer en tapant:

    pip install requests_toolbelt
    • Cela ne semble pas vidage de la demande sans l'envoyer, cependant.
    • dump_all ne semble pas fonctionner correctement tant que je reçois "TypeError: ne peut pas concaténer 'str' et 'UUID " objets" à partir de l'appel.
    • Merci de nous le signaler comme un bug dans leur dépôt github: github.com/sigmavirus24/requests-toolbelt/...
    • C'est exactement ce que je cherchais. Merci!!!!
    • Il imprime le dump avec > et < les signes, sont-ils une partie de la demande réelle?
    InformationsquelleAutor Emil Stenström
  4. 30
    import requests
response = requests.post('http://httpbin.org/post', data={'key1':'value1'})
print(response.request.body)
print(response.request.headers)

    Je suis en utilisant demandes version 2.18.4 et Python 3

    InformationsquelleAutor Payman
  5. 6

    Voici un code qui fait la même chose, mais avec des en-têtes de réponse: 

    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()

    J'ai passé beaucoup de temps à chercher pour cela, donc je vais la laisser ici, si quelqu'un a besoin.

    • J'aime cette solution, même si elle n'est pas la solution, je suis à la recherche d'.
    InformationsquelleAutor denself
  6. 2

    J'ai utiliser la fonction suivante pour format demandes. C'est comme @AntonioHerraizS sauf qu'il sera assez-imprimer des objets JSON dans le corps, et les étiquettes de toutes les parties de la demande.

    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

    Et j'ai une fonction similaire au format de la réponse:

    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
    InformationsquelleAutor Ben