Come salvare i cookie delle richieste (python) in un file?

Question

Come utilizzare la libreria requests (in python) dopo una richiesta

#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
import requests 
bot = requests.session() 
bot.get('http://google.com') 

per mantenere tutti i cookie in un file e quindi ripristinare i cookie da un file.

Answer 1

Non c'è un modo immediato per farlo, ma non è difficile da fare.

È possibile ottenere un oggetto CookieJar dalla sessione come session.cookies. È possibile utilizzare requests.utils.dict_from_cookiejar per trasformarlo in un dettato. Quindi, è possibile utilizzare pickle per memorizzarlo in un file (è inoltre possibile utilizzare shelve se è necessario archiviare più di una cosa).

Un esempio completo:

import requests, requests.utils, pickle 
session = requests.session() 
# Make some calls 
with open('somefile', 'w') as f: 
    pickle.dump(requests.utils.dict_from_cookiejar(session.cookies), f) 

carico è quindi:

with open('somefile') as f: 
    cookies = requests.utils.cookiejar_from_dict(pickle.load(f)) 
    session = requests.session(cookies=cookies) 

Answer 2

Dopo una chiamata, come r = requests.get(), r.cookies restituirà un RequestsCookieJar cui potete accedere direttamente pickle, cioè

import pickle 
def save_cookies(requests_cookiejar, filename): 
    with open(filename, 'wb') as f: 
     pickle.dump(requests_cookiejar, f) 

def load_cookies(filename): 
    with open(filename, 'rb') as f: 
     return pickle.load(f) 

#save cookies 
r = requests.get(url) 
save_cookies(r.cookies, filename) 

#load cookies and do a request 
requests.get(url, cookies=load_cookies(filename)) 

Se si desidera salva i tuoi cookie in formato leggibile dall'uomo, devi fare del lavoro per estrarre lo RequestsCookieJar in un LWPCookieJar.

import cookielib 
def save_cookies_lwp(cookiejar, filename): 
    lwp_cookiejar = cookielib.LWPCookieJar() 
    for c in cookiejar: 
     args = dict(vars(c).items()) 
     args['rest'] = args['_rest'] 
     del args['_rest'] 
     c = cookielib.Cookie(**args) 
     lwp_cookiejar.set_cookie(c) 
    lwp_cookiejar.save(filename, ignore_discard=True) 

def load_cookies_from_lwp(filename): 
    lwp_cookiejar = cookielib.LWPCookieJar() 
    lwp_cookiejar.load(filename, ignore_discard=True) 
    return lwp_cookiejar 

#save human-readable 
r = requests.get(url) 
save_cookies_lwp(r.cookies, filename) 

#you can pass a LWPCookieJar directly to requests 
requests.get(url, cookies=load_cookies_from_lwp(filename)) 

Answer 3

questo farà il lavoro:

session.cookies = LWPCookieJar('cookies.txt') 

L'API Cookiejar richiede di chiamare load() e save() manualmente però. Se non ti interessa il formato cookies.txt, ho un'implementazione ShelvedCookieJar che continuerà a cambiare.

Answer 4

Espandendo sulla risposta di @ miracle2k, le richieste Session s sono documented per funzionare con qualsiasi cookielibCookieJar. LWPCookieJar (e MozillaCookieJar) possono salvare e caricare i loro cookie da e verso un file. Ecco uno snippet di codice completo che salverà e caricherà i cookie per una sessione di richieste. Il parametro ignore_discard viene utilizzato per lavorare con httpbin per il test, ma potresti non voler includere il tuo nel codice reale. risposta

import os 
from cookielib import LWPCookieJar 

import requests 


s = requests.Session() 
s.cookies = LWPCookieJar('cookiejar') 
if not os.path.exists('cookiejar'): 
    # Create a new cookies file and set our Session's cookies 
    print('setting cookies') 
    s.cookies.save() 
    r = s.get('http://httpbin.org/cookies/set?k1=v1&k2=v2') 
else: 
    # Load saved cookies from the file and use them in a request 
    print('loading saved cookies') 
    s.cookies.load(ignore_discard=True) 
    r = s.get('http://httpbin.org/cookies') 
print(r.text) 
# Save the session's cookies back to the file 
s.cookies.save(ignore_discard=True) 

Answer 5

di dtheodor ottenuto il 95% lì, tranne questo:

session = requests.session(cookies=cookies) 

Per me questo solleva una sessione un'eccezione dicendo() non prende argomenti.

ho lavorato intorno ad esso prendendo le chiavi/valori sulla cookie.get_dict e aggiungendo manualmente alla sessione utilizzando:

session.cookies.set(cookies.keys()[n],cookies.values()[n]) 

Answer 6

ho scoperto che le altre risposte hanno avuto problemi:

• Non si applicavano alle sessioni.
• Non sono stati salvati e caricati correttamente.Sono stati salvati solo il nome e il valore del cookie, la data di scadenza, il nome del dominio, ecc.

Questa risposta risolve questi due problemi:

import requests.cookies 

def save_cookies(session, filename): 
    if not os.path.isdir(os.path.dirname(filename)): 
     return False 
    with open(filename, 'w') as f: 
     f.truncate() 
     pickle.dump(session.cookies._cookies, f) 


def load_cookies(session, filename): 
    if not os.path.isfile(filename): 
     return False 

    with open(filename) as f: 
     cookies = pickle.load(f) 
     if cookies: 
      jar = requests.cookies.RequestsCookieJar() 
      jar._cookies = cookies 
      session.cookies = jar 
     else: 
      return False 

Poi basta chiamare save_cookies(session, filename) per salvare o load_cookies(session, filename) da caricare. Semplice come quella.

Answer 7

mi offrono un modo per JSON:

# to save cookie 
import json 
with open('cookie.txt', 'w') as f: 
    json.dump(requests.utils.dict_from_cookiejar(bot.cookies), f) 

e

# to load cookie 
import json 
with open('cookie.txt', 'r') as f: 
    cookie = requests.utils.cookiejar_from_dict(json.load(f)) 

Answer 8

È possibile salamoia i biscotti oggetto direttamente:

cookies = pickle.dumps(session.cookies) 

La rappresentazione dict manca un sacco di informazioni: scadenza, dominio, percorso ...

Dipende dall'utilizzo che si intende fare con i cookie, ma se non si hanno informazioni sulla scadenza, ad esempio, è necessario implementare la logica per tenere traccia della scadenza a mano.

Il decollo dell'oggetto libreria restituito consente di ricostruire facilmente lo stato, quindi è possibile eseguire il relay sull'implementazione della libreria.

Ovviamente, in questo modo, il consumatore dell'oggetto in salamoia deve utilizzare la stessa libreria