Python demandes de récupérer un fichier à partir d'une url locale

Je suis à l'aide de Python les demandes bibliothèque dans une méthode de ma demande. Le corps de la méthode ressemble à ceci:

def handle_remote_file(url, **kwargs):
    response = requests.get(url, ...)
    buff = StringIO.StringIO()
    buff.write(response.content)
    ...
    return True

J'aimerais écrire des tests unitaires pour cette méthode, cependant, ce que je veux faire est de faire passer un faux local url de la forme:

class RemoteTest(TestCase):
    def setUp(self):
        self.url = 'file:///tmp/dummy.txt'

    def test_handle_remote_file(self):
        self.assertTrue(handle_remote_file(self.url))

Quand je l'appelle demandes.obtenir avec une url locale, j'ai eu l' KeyError l'exception ci-dessous:

requests.get('file:///tmp/dummy.txt')

/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/requests/packages/urllib3/poolmanager.pyc in connection_from_host(self, host, port, scheme)
76 
77         # Make a fresh ConnectionPool of the desired type
78         pool_cls = pool_classes_by_scheme[scheme]
79         pool = pool_cls(host, port, **self.connection_pool_kw)
80 

KeyError: 'file'

La question est de savoir comment puis-je passer une url locale à demandes.obtenir?

PS: j'ai pris l'exemple ci-dessus. Il est possible qu'il contient de nombreuses erreurs.

Pouvez-vous utiliser pur local python serveur web?

InformationsquelleAutor ozgur | 2012-04-12

Comme @WooParadog expliqué demandes bibliothèque ne sais pas comment gérer les fichiers locaux. Bien que, de la version actuelle permet de définir le transport des adaptateurs.

Par conséquent, vous pouvez simplement définir vous propre adaptateur qui sera capable de gérer des fichiers locaux, par exemple:

from requests_testadapter import Resp

class LocalFileAdapter(requests.adapters.HTTPAdapter):
    def build_response_from_file(self, request):
        file_path = request.url[7:]
        with open(file_path, 'rb') as file:
            buff = bytearray(os.path.getsize(file_path))
            file.readinto(buff)
            resp = Resp(buff)
            r = self.build_response(request, resp)

            return r

    def send(self, request, stream=False, timeout=None,
             verify=True, cert=None, proxies=None):

        return self.build_response_from_file(request)

requests_session = requests.session()
requests_session.mount('file://', LocalFileAdapter())
requests_session.get('file://<some_local_path>')

Je suis en utilisant demandes-testadapter module dans l'exemple ci-dessus.

InformationsquelleAutor b1r3k

Voici un adaptateur de transport que j'ai écrit qui est plus plein de fonctionnalités que b1r3k et n'a pas de dépendances supplémentaires au-delà des Demandes d'elle-même. Je n'ai pas testé de manière exhaustive, mais de ce que j'ai essayé semble être exempt de bogues.

import requests
import os, sys
if sys.version_info.major < 3:
from urllib import url2pathname
else:
from urllib.request import url2pathname
class LocalFileAdapter(requests.adapters.BaseAdapter):
"""Protocol Adapter to allow Requests to GET file://URLs
@todo: Properly handle non-empty hostname portions.
"""
@staticmethod
def _chkpath(method, path):
"""Return an HTTP status for the given filesystem path."""
if method.lower() in ('put', 'delete'):
return 501, "Not Implemented"  # TODO
elif method.lower() not in ('get', 'head'):
return 405, "Method Not Allowed"
elif os.path.isdir(path):
return 400, "Path Not A File"
elif not os.path.isfile(path):
return 404, "File Not Found"
elif not os.access(path, os.R_OK):
return 403, "Access Denied"
else:
return 200, "OK"
def send(self, req, **kwargs):  # pylint: disable=unused-argument
"""Return the file specified by the given request
@type req: C{PreparedRequest}
@todo: Should I bother filling `response.headers` and processing
If-Modified-Since and friends using `os.stat`?
"""
path = os.path.normcase(os.path.normpath(url2pathname(req.path_url)))
response = requests.Response()
response.status_code, response.reason = self._chkpath(req.method, path)
if response.status_code == 200 and req.method.lower() != 'head':
try:
response.raw = open(path, 'rb')
except (OSError, IOError) as err:
response.status_code = 500
response.reason = str(err)
if isinstance(req.url, bytes):
response.url = req.url.decode('utf-8')
else:
response.url = req.url
response.request = req
response.connection = self
return response
def close(self):
pass

(Malgré le nom, il a été entièrement écrit avant que je pense à vérifier Google, de sorte qu'il n'a rien à voir avec b1r3k de l'.) Comme avec les autres répondre, suivez ce avec:

requests_session = requests.session()
requests_session.mount('file://', LocalFileAdapter())
r = requests_session.get('file:///path/to/your/file')

tx. quelque chose est en tort sur toute la ligne, sauf (OSError, IOError), err:. Mon remplacement a l'exception de (OSError, IOError) comme erreur:
À l'époque, j'ai fait le post, j'ai été en utilisant uniquement les Demandes en Python 2.x. Je vais corriger mon post dès que je peux, prenez quelques minutes pour tester les modifications.
Du bon travail. Toutefois, il ne faut pas travailler les URLs comme ../foo.bar. Cependant, il a été simple de changer la méthode d'envoi afin de ne pas utiliser req.path_url() mais utilise à la place de quelque chose qui enlève le file:// et conserve le reste.
Le non-support des Url relatives est intentionnelle. Au niveau de cette couche de la pile, toute URL qui n'est pas déjà l'absolu n'est pas valide, puisque toute l'architecture bien conçue qui opère au niveau de cette couche de la pile, il manque le contexte pour savoir comment les Url relatives sont destinés à être résolu. (En gros, vous êtes censé les rendre absolue avant de les nourrir à la Demande en utilisant quelque chose comme urlparse.urljoin (Python 2) ou urllib.parse.urljoin (Python 3).)

InformationsquelleAutor ssokolow

packages/urllib3/poolmanager.py assez bien explique. Les demandes ne prend pas en charge locale de l'url.

pool_classes_by_scheme = {                                                        
'http': HTTPConnectionPool,                                                   
'https': HTTPSConnectionPool,                                              
}

InformationsquelleAutor WooParadog

5

Dans un projet récent, j'ai eu le même problème. Car les demandes ne prend pas en charge les fichiers "régime", je vais patch notre code pour charger le contenu local. Tout d'abord, de définir une fonction pour remplacer requests.get:
```
def local_get(self, url):
"Fetch a stream from local files."
p_url = six.moves.urllib.parse.urlparse(url)
if p_url.scheme != 'file':
raise ValueError("Expected file scheme")
filename = six.moves.urllib.request.url2pathname(p_url.path)
return open(filename, 'rb')
```
Puis, quelque part dans l'installation d'essai ou la décoration de la fonction de test, j'utilise mock.patch de patch la fonction obtenir sur demande:
```
@mock.patch('requests.get', local_get)
def test_handle_remote_file(self):
...
```
Cette technique est un peu fragile, il ne faut pas les aider si le code sous-jacent appels requests.request ou construit un Session et les appels. Il y a peut être un moyen de demandes de correctifs à un niveau inférieur à l'appui de file: Url, mais dans mon enquête initiale, il ne semble pas être évident de point de crochet, je suis donc allé avec cette approche plus simple.

InformationsquelleAutor Jason R. Coombs

Vous devez vous connecter pour publier un commentaire.