it-swarm.com.de

Wie speichere ich Anfragen (Python) in eine Datei?

Verwendung der Bibliothek requests (in Python) nach einer Anforderung

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

um alle Cookies in einer Datei zu behalten und dann die Cookies aus einer Datei wiederherzustellen.

32
agrynchuk

Es gibt keine unmittelbare Möglichkeit, dies zu tun, aber es ist nicht schwer.

Sie können ein CookieJar-Objekt aus der Sitzung als session.cookies abrufen. Mit pickle können Sie es in einer Datei speichern.

Ein vollständiges Beispiel:

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

Laden ist dann:

session = requests.session()  # or an existing session

with open('somefile', 'rb') as f:
    session.cookies.update(pickle.load(f))

Die Anforderungsbibliothek verwendet die requests.cookies.RequestsCookieJar()-Unterklasse , die das Beizen und eine dict-ähnliche API explizit unterstützt, und Sie können die RequestsCookieJar.update()-Methode verwenden, um eine vorhandene Session-Cookie-Dose mit den aus einer Pickle-Datei geladenen Dateien zu aktualisieren.

48
madjar

Nach einem Aufruf wie r = requests.get() wird r.cookies eine RequestsCookieJar zurückgeben, die Sie direkt pickle , d. H.

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

Wenn Sie Ihre Cookies in einem für Menschen lesbaren Format speichern möchten, müssen Sie die RequestsCookieJar in eine LWPCookieJar extrahieren.

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

Wenn die Antwort auf @ miracle2k erweitert wird, werden die Anforderungen Sessions dokumentiert mit einem beliebigen cookielibCookieJar zusammenarbeiten. Die LWPCookieJar (und MozillaCookieJar) können ihre Cookies speichern und von und in eine Datei laden. Hier ist ein vollständiger Code-Snippet, der Cookies für eine Anforderungssitzung speichert und lädt. Der ignore_discard-Parameter wird verwendet, um mit httpbin für den Test zu arbeiten, aber Sie möchten ihn möglicherweise nicht in den echten Code einschließen.

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

Dies wird die Arbeit erledigen:

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

Die CookieJar-API erfordert jedoch, dass Sie load () und save () manuell aufrufen. Wenn Sie sich nicht für das Format "cookies.txt" interessieren, habe ich eine ShelvedCookieJar - Implementierung, die auf Änderungen bestehen bleibt.

8
miracle2k

Ich habe festgestellt, dass die anderen Antworten Probleme hatten:

  • Sie gelten nicht für Sitzungen.
  • Sie haben nicht richtig gespeichert und geladen. Nur der Name und der Wert des Cookies wurden gespeichert, das Ablaufdatum, der Domänenname usw. ging verloren.

Diese Antwort behebt diese beiden Probleme:

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

Rufen Sie dann einfach save_cookies(session, filename) zum Speichern oder load_cookies(session, filename) zum Laden auf. So einfach ist das.

7
MattClimbs

Ich biete einen Weg von Json an:

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

und

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

Sie können das Cookie-Objekt direkt in Position bringen:

cookies = pickle.dumps(session.cookies)

In der Diktendarstellung fehlen viele Informationen: Ablauf, Domäne, Pfad ...

Dies hängt von der Verwendung ab, die Sie mit den Cookies verwenden möchten. Wenn Sie jedoch keine Informationen zum Ablauf haben, sollten Sie beispielsweise die Logik implementieren, um den Ablauf von Hand zu verfolgen.

Durch das Beizen des zurückgegebenen Objekts in der Bibliothek können Sie den Status leicht rekonstruieren. Anschließend können Sie die Implementierung der Bibliothek weiterleiten.

Offensichtlich muss auf diese Weise der Verbraucher des ausgewählten Objekts dieselbe Bibliothek verwenden

2
JackNova

dtheodors Antwort erhielt dort 95%, außer dieser:

session = requests.session(cookies=cookies)

Für mich führt dies zu einer Ausnahme, dass session () keine Argumente akzeptiert.

Ich habe das Problem gelöst, indem ich die Schlüssel/Werte von cookie.get_dict genommen und sie manuell zur Sitzung hinzugefügt habe:

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

code für Python 3

Beachten Sie, dass die meisten Cookies im Internet Netscape-Cookies sind. Wenn Sie Cookies im Format Mozilla cookies.txt (das auch von den Browsern Lynx und Netscape verwendet wird) auf Festplatte speichern möchten, verwenden Sie MozillaCookieJar

from http.cookiejar import MozillaCookieJar
import requests

s = requests.Session()
s.cookies = MozillaCookieJar('cookies.txt')
# or s.cookies = MozillaCookieJar() and later use s.cookies.filename = 'cookies.txt' or pass the file name to save method.

response = s.get('https://www.msn.com')

s.cookies.save()

die Datei wird überschrieben, wenn sie bereits vorhanden ist, und alle darin enthaltenen Cookies werden gelöscht. Gespeicherte Cookies können später mit den Methoden load () oder revert () wiederhergestellt werden.

Beachten Sie, dass die save () -Methode ohnehin keine Session-Cookies speichert, es sei denn Sie fragen anders, indem Sie ein echtes ignore_discard-Argument übergeben.

s.cookies.save(ignore_discard=True)

mit der Lademethode:

laden Sie Cookies aus einer Datei.

Alte Cookies bleiben erhalten, sofern sie nicht durch neu geladene Cookies überschrieben werden.

s.cookies.load()

using revert method:

Löschen Sie alle Cookies und laden Sie die Cookies aus einer gespeicherten Datei erneut.

s.cookies.revert()

sie müssen möglicherweise auch ein echtes ignore_discard-Argument in load- oder revert-Methoden übergeben.

Hinweis zur Verwendung von MozillaCookieJar:

Hinweis Dadurch gehen Informationen über RFC 2965-Cookies und auch über .__ verloren. neuere oder nicht standardmäßige Cookie-Attribute wie port.

mehr lesen

0
Sameh Farouk

Einfache Möglichkeit, Cookies in eine Liste von Diktaten zu konvertieren und in json oder db ..__ zu speichern. Dies sind Klassenmethoden, die das Attribut session haben.

def dump_cookies(self):
    cookies = []
    for c in self.session.cookies:
        cookies.append({
            "name": c.name,
            "value": c.value,
            "domain": c.domain,
            "path": c.path,
            "expires": c.expires
        })
    return cookies

def load_cookies(self, cookies):
    for c in cookies:
        self.session.cookies.set(**c)

Wir brauchen nur fünf Parameter wie: name, value, domain, path, expires

0
Mikhail Bulygin