Python Language
Python Requests Post

Introduction

Simple Post

from requests import post

foo = post('http://httpbin.org/post', data = {'key':'value'})

Réalisera une simple opération HTTP POST. Les données publiées peuvent être dans les formats les plus courants, mais les paires de valeurs clés sont les plus répandues.

Les entêtes

Les en-têtes peuvent être visualisés:

print(foo.headers)

Un exemple de réponse:

{'Content-Length': '439', 'X-Processed-Time': '0.000802993774414', 'X-Powered-By': 'Flask', 'Server': 'meinheld/0.6.1', 'Connection': 'keep-alive', 'Via': '1.1 vegur', 'Access-Control-Allow-Credentials': 'true', 'Date': 'Sun, 21 May 2017 20:56:05 GMT', 'Access-Control-Allow-Origin': '*', 'Content-Type': 'application/json'}

Les en-têtes peuvent également être préparés avant la publication:

headers = {'Cache-Control':'max-age=0',
        'Upgrade-Insecure-Requests':'1',
        'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36',
        'Content-Type':'application/x-www-form-urlencoded',
        'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
        'Referer':'https://www.groupon.com/signup',
        'Accept-Encoding':'gzip, deflate, br',
        'Accept-Language':'es-ES,es;q=0.8'
        }

 foo = post('http://httpbin.org/post', headers=headers, data = {'key':'value'})

Codage

Le codage peut être défini et visualisé de la même manière:

 print(foo.encoding)

'utf-8'

foo.encoding = 'ISO-8859-1'

Vérification SSL

Requests par défaut valide les certificats SSL des domaines. Cela peut être remplacé:

foo = post('http://httpbin.org/post', data = {'key':'value'}, verify=False)

Redirection

Toute redirection sera suivie (par exemple http à https), cela peut également être modifié:

foo = post('http://httpbin.org/post', data = {'key':'value'}, allow_redirects=False)

Si la post-opération a été redirigée, cette valeur est accessible:

print(foo.url) 

Un historique complet des redirections peut être consulté:

print(foo.history) 

Données codées par formulaire

from requests import post

payload = {'key1' : 'value1',
           'key2' : 'value2'
           }

foo = post('http://httpbin.org/post', data=payload)

Pour transmettre des données encodées avec la post-opération, les données doivent être structurées en tant que dictionnaire et fournies en tant que paramètre de données.

Si les données ne veulent pas être encodées, il suffit de transmettre une chaîne ou un entier au paramètre data.

Fournissez le dictionnaire au paramètre json pour que Requests formate automatiquement les données:

from requests import post

payload = {'key1' : 'value1', 'key2' : 'value2'}

foo = post('http://httpbin.org/post', json=payload)

Téléchargement de fichiers

Avec le module Requests, il suffit de fournir un .read() fichier par opposition au contenu récupéré avec .read() :

from requests import post

files = {'file' : open('data.txt', 'rb')}

foo = post('http://http.org/post', files=files)

Le nom de fichier, le type de contenu et les en-têtes peuvent également être définis:

files = {'file': ('report.xls', open('report.xls', 'rb'), 'application/vnd.ms-excel', {'Expires': '0'})}

foo = requests.post('http://httpbin.org/post', files=files)

Les chaînes peuvent également être envoyées sous forme de fichier, tant qu'elles sont fournies en tant que paramètre de files .

Plusieurs fichiers

Plusieurs fichiers peuvent être fournis à peu près comme un seul fichier:

multiple_files = [
    ('images', ('foo.png', open('foo.png', 'rb'), 'image/png')),
    ('images', ('bar.png', open('bar.png', 'rb'), 'image/png'))]

foo = post('http://httpbin.org/post', files=multiple_files)

Les réponses

Les codes de réponse peuvent être consultés à partir d'une opération postérieure:

from requests import post

foo = post('http://httpbin.org/post', data={'data' : 'value'})
print(foo.status_code)

Données renvoyées

Accéder aux données renvoyées:

foo = post('http://httpbin.org/post', data={'data' : 'value'})
print(foo.text)

Réponses brutes

Dans les cas où vous devez accéder à l’objet urllib3 response.HTTPResponse sous-jacent, vous pouvez procéder comme suit:

foo = post('http://httpbin.org/post', data={'data' : 'value'})
res = foo.raw

print(res.read())

Authentification

Authentification HTTP simple

L'authentification HTTP simple peut être réalisée avec les éléments suivants:

from requests import post

foo = post('http://natas0.natas.labs.overthewire.org', auth=('natas0', 'natas0'))

C'est techniquement court pour ce qui suit:

from requests import post
from requests.auth import HTTPBasicAuth

foo = post('http://natas0.natas.labs.overthewire.org', auth=HTTPBasicAuth('natas0', 'natas0'))

Authentification HTTP Digest

L’authentification HTTP Digest se fait de manière très similaire, Requests fournit un objet différent pour cela:

from requests import post
from requests.auth import HTTPDigestAuth

foo = post('http://natas0.natas.labs.overthewire.org', auth=HTTPDigestAuth('natas0', 'natas0'))

Authentification personnalisée

Dans certains cas, les mécanismes d'authentification intégrés peuvent ne pas suffire, imaginez cet exemple:

Un serveur est configuré pour accepter l'authentification si l'expéditeur dispose de la chaîne d'agent utilisateur appropriée, d'une certaine valeur d'en-tête et fournit les informations d'identification correctes via l'authentification de base HTTP. Pour y parvenir, une classe d'authentification personnalisée doit être préparée, sous-classant AuthBase, qui est la base pour les implémentations d'authentification Requests:

from requests.auth import AuthBase
from requests.auth import _basic_auth_str
from requests._internal_utils import to_native_string

class CustomAuth(AuthBase):

    def __init__(self, secret_header, user_agent , username, password):
        # setup any auth-related data here
        self.secret_header =  secret_header
        self.user_agent = user_agent
        self.username = username
        self.password = password

    def __call__(self, r):
        # modify and return the request
        r.headers['X-Secret'] = self.secret_header
        r.headers['User-Agent'] = self.user_agent
        r.headers['Authorization'] = _basic_auth_str(self.username, self.password)
        
        return r

Cela peut ensuite être utilisé avec le code suivant:

foo = get('http://test.com/admin', auth=CustomAuth('SecretHeader', 'CustomUserAgent', 'user', 'password' ))

Des procurations

Chaque opération POST de requête peut être configurée pour utiliser des proxy réseau

Proxy HTTP / S

from requests import post

proxies = {
  'http': 'http://192.168.0.128:3128',
  'https': 'http://192.168.0.127:1080',
   }

foo = requests.post('http://httpbin.org/post', proxies=proxies)

L'authentification de base HTTP peut être fournie de cette manière:

proxies = {'http': 'http://user:[email protected]:312'}
foo = requests.post('http://httpbin.org/post', proxies=proxies)

SOCKS Proxies

L'utilisation de proxys de chaussettes nécessite des requests[socks] dépendances tierces requests[socks] , une fois installées, les proxys de chaussettes sont utilisés de manière très similaire à HTTPBasicAuth:

proxies = {
'http': 'socks5://user:pass@host:port',
'https': 'socks5://user:pass@host:port'
}

foo = requests.post('http://httpbin.org/post', proxies=proxies)