Jak zapisać pliki cookie żądania (python) do pliku?

Question

Jak korzystać z biblioteki requests (w python) po wniosek

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

aby wszystkie cookies w pliku, a następnie przywrócić ciasteczka z pliku.

Answer 1

Nie ma bezpośredniego sposobu, aby to zrobić, ale nie jest to trudne.

Możesz otrzymać obiekt CookieJar z sesji jako session.cookies. Możesz użyć requests.utils.dict_from_cookiejar, aby przekształcić go w dyktando. Następnie możesz użyć pickle, aby zapisać go do pliku (możesz także użyć shelve, jeśli chcesz przechowywać więcej niż jedną rzecz).

pełny przykład:

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) 

Ładowanie jest następnie:

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

Answer 2

Po zakończeniu rozmowy, takie jak r = requests.get(), r.cookies zwróci RequestsCookieJar które można bezpośrednio pickle, tj

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

Jeśli chcesz zachowaj pliki cookie w formacie czytelnym dla człowieka, musisz wykonać pewne czynności, aby wyodrębnić plik RequestsCookieJar do 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

To będzie wykonać zadanie:

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

CookieJar API wymaga skontaktowania load() i save() ręcznie choć. Jeśli nie dbasz o format plików cookie.txt, mam implementację ShelvedCookieJar, która będzie obowiązywała przy zmianie.

Answer 4

Rozszerzanie odpowiedzi @ miracle2k, żądania Session s to documented do pracy z dowolnymi cookielibCookieJar. LWPCookieJar (i MozillaCookieJar) można zapisać i załadować pliki cookie do i z pliku. Oto pełny fragment kodu, który zapisuje i ładuje pliki cookie dla sesji żądań. Parametr ignore_discard jest używany do pracy z protokołem httpbin dla testu, ale możesz nie chcieć dołączyć go do rzeczywistego kodu. Odpowiedź

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

dtheodor ma tam 95%, z wyjątkiem tego:

session = requests.session(cookies=cookies) 

Dla mnie to podnosi sesję wyjątku mówią() nie bierze argumenty.

pracowałem wokół niego, podejmując kluczy/wartości na cookie.get_dict i dodając je ręcznie do sesji przy użyciu:

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

Answer 6

znalazłem, że pozostałe odpowiedzi były problemy:

• Nie dotyczyły sesji.
• Nie zapisano i nie załadowano poprawnie.Zapisywano tylko nazwę i wartość pliku cookie, datę wygaśnięcia, nazwę domeny itp.

Ta odpowiedź rozwiązuje te dwa problemy:

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 

Następnie wystarczy zadzwonić save_cookies(session, filename) aby zapisać lub load_cookies(session, filename) do załadowania. Proste.

Answer 7

Oferuję drogę przez json:

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

i

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

Answer 8

Można marynowane ciasteczka object bezpośrednio:

cookies = pickle.dumps(session.cookies) 

reprezentacja DICT strzela dużo informacji: data wygaśnięcia, domena, ścieżka ...

To zależy od sposobu użycia plików cookie, ale jeśli nie masz informacji o wygaśnięciu, na przykład, powinieneś zaimplementować logikę, aby śledzić wygaśnięcie ręcznie.

Wytrawienie zwróconego obiektu biblioteki umożliwia łatwe odtworzenie stanu, a następnie można przekazać w implementacji biblioteki.

Oczywiście, w ten sposób, że konsument z marynowanych obiektu musi użyć tej samej biblioteki