Estou coletando estatísticas em uma lista de sites e usando solicitações para simplificar. Aqui está o meu código:

data=[]
websites=['http://google.com', 'http://bbc.co.uk']
for w in websites:
    r= requests.get(w, verify=False)
    data.append( (r.url, len(r.content), r.elapsed.total_seconds(), str([(l.status_code, l.url) for l in r.history]), str(r.headers.items()), str(r.cookies.items())) )

Agora, quero requests.getexpirar após 10 segundos para que o loop não fique preso.

Essa pergunta também foi interessante antes, mas nenhuma das respostas é clara. Vou dar uma recompensa por isso para obter uma boa resposta.

Ouvi dizer que talvez não usar solicitações seja uma boa ideia, mas como devo obter as coisas boas que as solicitações oferecem. (os da tupla)

Que tal usar o eventlet? Se você deseja exceder o tempo limite da solicitação após 10 segundos, mesmo se os dados estiverem sendo recebidos, esse snippet funcionará para você:

import requests
import eventlet
eventlet.monkey_patch()

with eventlet.Timeout(10):
    requests.get("http://ipv4.download.thinkbroadband.com/1GB.zip", verify=False)

Defina o parâmetro timeout :

r = requests.get(w, verify=False, timeout=10) # 10 seconds

Contanto que você não defina stream=Trueessa solicitação, o requests.get()tempo limite da chamada será excedido se a conexão demorar mais de dez segundos ou se o servidor não enviar dados por mais de dez segundos.

ATUALIZAÇÃO: https://requests.readthedocs.io/en/master/user/advanced/#timeouts

Na nova versão do requests:

Se você especificar um único valor para o tempo limite, assim:

r = requests.get('https://github.com', timeout=5)

O valor do tempo limite será aplicado aos tempos limite connecte ao readtempo limite. Especifique uma tupla se desejar definir os valores separadamente:

r = requests.get('https://github.com', timeout=(3.05, 27))

Se o servidor remoto estiver muito lento, você pode pedir para as solicitações aguardarem uma resposta eternamente, passando None como um valor de tempo limite e, em seguida, recuperando uma xícara de café.

r = requests.get('https://github.com', timeout=None)

Minha resposta antiga (provavelmente desatualizada) (postada há muito tempo):

Existem outras maneiras de superar esse problema:

1. Use a TimeoutSauceclasse interna

De: https://github.com/kennethreitz/requests/issues/1928#issuecomment-35811896

import requests from requests.adapters import TimeoutSauce

class MyTimeout(TimeoutSauce):
    def __init__(self, *args, **kwargs):
        connect = kwargs.get('connect', 5)
        read = kwargs.get('read', connect)
        super(MyTimeout, self).__init__(connect=connect, read=read)

requests.adapters.TimeoutSauce = MyTimeout

Esse código deve fazer com que definamos o tempo limite de leitura como igual ao tempo limite de conexão, que é o valor do tempo limite que você passa na sua chamada Session.get (). (Observe que eu realmente não testei esse código, por isso pode precisar de alguma depuração rápida, apenas o escrevi diretamente na janela do GitHub.)

2. Use uma bifurcação de solicitações da kevinburke: https://github.com/kevinburke/requests/tree/connect-timeout

A partir de sua documentação: https://github.com/kevinburke/requests/blob/connect-timeout/docs/user/advanced.rst

Se você especificar um único valor para o tempo limite, assim:

r = requests.get('https://github.com', timeout=5)

O valor do tempo limite será aplicado aos tempos limite de conexão e leitura. Especifique uma tupla se desejar definir os valores separadamente:

r = requests.get('https://github.com', timeout=(3.05, 27))

O kevinburke solicitou que ele fosse mesclado no projeto de solicitações principais, mas ainda não foi aceito.

timeout = int(seconds)

Desde requests >= 2.4.0, você pode usar o timeoutargumento, ou seja:

requests.get('https://duckduckgo.com/', timeout=10)

Nota:

timeoutnão é um limite de tempo para o download completo da resposta; em vez disso, exceptionserá gerado se o servidor não emitir uma resposta por segundos de tempo limite (mais precisamente, se nenhum bytes tiver sido recebido no soquete subjacente por segundos de tempo limite). Se nenhum tempo limite for especificado explicitamente, as solicitações não atingirão o tempo limite.

Para criar um tempo limite, você pode usar sinais .

A melhor maneira de resolver esse caso é provavelmente

1. Defina uma exceção como manipulador para o sinal de alarme
2. Ligue para o sinal de alarme com um atraso de dez segundos
3. Chame a função dentro de um try-except-finallybloco.
4. O bloco de exceção é alcançado se a função expirar.
5. No bloco final, você cancela o alarme, para que não seja chamado mais tarde.

Aqui está um exemplo de código:

import signal
from time import sleep

class TimeoutException(Exception):
    """ Simple Exception to be called on timeouts. """
    pass

def _timeout(signum, frame):
    """ Raise an TimeoutException.

    This is intended for use as a signal handler.
    The signum and frame arguments passed to this are ignored.

    """
    # Raise TimeoutException with system default timeout message
    raise TimeoutException()

# Set the handler for the SIGALRM signal:
signal.signal(signal.SIGALRM, _timeout)
# Send the SIGALRM signal in 10 seconds:
signal.alarm(10)

try:    
    # Do our code:
    print('This will take 11 seconds...')
    sleep(11)
    print('done!')
except TimeoutException:
    print('It timed out!')
finally:
    # Abort the sending of the SIGALRM signal:
    signal.alarm(0)

Existem algumas advertências para isso:

1. Não é seguro para threads, os sinais são sempre entregues ao thread principal, portanto você não pode colocar isso em nenhum outro thread.
2. Há um pequeno atraso após o agendamento do sinal e a execução do código real. Isso significa que o exemplo expiraria, mesmo que dormisse apenas por dez segundos.

Mas, está tudo na biblioteca python padrão! Exceto pela importação da função sleep, é apenas uma importação. Se você vai usar timeouts em muitos lugares, você pode facilmente colocar TimeoutException, _timeout e singaling em uma função e apenas chamar isso. Ou você pode criar um decorador e colocá-lo em funções, veja a resposta abaixo.

Você também pode configurá-lo como um "gerenciador de contexto" para poder usá-lo com a withinstrução:

import signal
class Timeout():
    """ Timeout for use with the `with` statement. """

    class TimeoutException(Exception):
        """ Simple Exception to be called on timeouts. """
        pass

    def _timeout(signum, frame):
        """ Raise an TimeoutException.

        This is intended for use as a signal handler.
        The signum and frame arguments passed to this are ignored.

        """
        raise Timeout.TimeoutException()

    def __init__(self, timeout=10):
        self.timeout = timeout
        signal.signal(signal.SIGALRM, Timeout._timeout)

    def __enter__(self):
        signal.alarm(self.timeout)

    def __exit__(self, exc_type, exc_value, traceback):
        signal.alarm(0)
        return exc_type is Timeout.TimeoutException

# Demonstration:
from time import sleep

print('This is going to take maximum 10 seconds...')
with Timeout(10):
    sleep(15)
    print('No timeout?')
print('Done')

Uma possível desvantagem dessa abordagem do gerenciador de contexto é que você não pode saber se o código realmente expirou ou não.

Fontes e leitura recomendada:

• A documentação sobre sinais
• Esta resposta foi expirada por @David Narayan . Ele organizou o código acima como decorador .

Tente esta solicitação com tempo limite e tratamento de erros:

import requests
try: 
    url = "http://google.com"
    r = requests.get(url, timeout=10)
except requests.exceptions.Timeout as e: 
    print e

Definir stream=Truee usar r.iter_content(1024). Sim, de eventlet.Timeoutalguma forma, não funciona para mim.

try:
    start = time()
    timeout = 5
    with get(config['source']['online'], stream=True, timeout=timeout) as r:
        r.raise_for_status()
        content = bytes()
        content_gen = r.iter_content(1024)
        while True:
            if time()-start > timeout:
                raise TimeoutError('Time out! ({} seconds)'.format(timeout))
            try:
                content += next(content_gen)
            except StopIteration:
                break
        data = content.decode().split('\n')
        if len(data) in [0, 1]:
            raise ValueError('Bad requests data')
except (exceptions.RequestException, ValueError, IndexError, KeyboardInterrupt,
        TimeoutError) as e:
    print(e)
    with open(config['source']['local']) as f:
        data = [line.strip() for line in f.readlines()]

A discussão está aqui https://redd.it/80kp1h

Isso pode ser um exagero, mas a fila de tarefas distribuídas do Celery tem um bom suporte para tempos limite.

Em particular, você pode definir um limite de tempo flexível que apenas gera uma exceção em seu processo (para que você possa limpar) e / ou um limite de tempo difícil que encerra a tarefa quando o limite de tempo é excedido.

Nos bastidores, isso usa a mesma abordagem de sinais como mencionado na sua postagem "antes", mas de uma maneira mais utilizável e gerenciável. E se a lista de sites que você está monitorando for longa, você poderá se beneficiar do seu principal recurso - todos os tipos de maneiras de gerenciar a execução de um grande número de tarefas.

Eu acredito que você pode usar multiprocessinge não depender de um pacote de terceiros:

import multiprocessing
import requests

def call_with_timeout(func, args, kwargs, timeout):
    manager = multiprocessing.Manager()
    return_dict = manager.dict()

    # define a wrapper of `return_dict` to store the result.
    def function(return_dict):
        return_dict['value'] = func(*args, **kwargs)

    p = multiprocessing.Process(target=function, args=(return_dict,))
    p.start()

    # Force a max. `timeout` or wait for the process to finish
    p.join(timeout)

    # If thread is still active, it didn't finish: raise TimeoutError
    if p.is_alive():
        p.terminate()
        p.join()
        raise TimeoutError
    else:
        return return_dict['value']

call_with_timeout(requests.get, args=(url,), kwargs={'timeout': 10}, timeout=60)

O tempo limite passado kwargsé o tempo limite para obter qualquer resposta do servidor, o argumento timeouté o tempo limite para obter a resposta completa .

timeout = (tempo limite de conexão, tempo limite de leitura de dados) ou fornecer um único argumento (tempo limite = 1)

import requests

try:
    req = requests.request('GET', 'https://www.google.com',timeout=(1,1))
    print(req)
except requests.ReadTimeout:
    print("READ TIME OUT")

este código funcionando para socketError 11004 e 10060 ......

# -*- encoding:UTF-8 -*-
__author__ = 'ACE'
import requests
from PyQt4.QtCore import *
from PyQt4.QtGui import *


class TimeOutModel(QThread):
    Existed = pyqtSignal(bool)
    TimeOut = pyqtSignal()

    def __init__(self, fun, timeout=500, parent=None):
        """
        @param fun: function or lambda
        @param timeout: ms
        """
        super(TimeOutModel, self).__init__(parent)
        self.fun = fun

        self.timeer = QTimer(self)
        self.timeer.setInterval(timeout)
        self.timeer.timeout.connect(self.time_timeout)
        self.Existed.connect(self.timeer.stop)
        self.timeer.start()

        self.setTerminationEnabled(True)

    def time_timeout(self):
        self.timeer.stop()
        self.TimeOut.emit()
        self.quit()
        self.terminate()

    def run(self):
        self.fun()


bb = lambda: requests.get("http://ipv4.download.thinkbroadband.com/1GB.zip")

a = QApplication([])

z = TimeOutModel(bb, 500)
print 'timeout'

a.exec_()

Apesar da pergunta ser sobre solicitações, acho isso muito fácil de fazer com o pycurl CURLOPT_TIMEOUT ou CURLOPT_TIMEOUT_MS.

Não é necessário rosquear ou sinalizar:

import pycurl
import StringIO

url = 'http://www.example.com/example.zip'
timeout_ms = 1000
raw = StringIO.StringIO()
c = pycurl.Curl()
c.setopt(pycurl.TIMEOUT_MS, timeout_ms)  # total timeout in milliseconds
c.setopt(pycurl.WRITEFUNCTION, raw.write)
c.setopt(pycurl.NOSIGNAL, 1)
c.setopt(pycurl.URL, url)
c.setopt(pycurl.HTTPGET, 1)
try:
    c.perform()
except pycurl.error:
    traceback.print_exc() # error generated on timeout
    pass # or just pass if you don't want to print the error

Caso esteja usando a opção, stream=Truevocê pode fazer o seguinte:

r = requests.get(
    'http://url_to_large_file',
    timeout=1,  # relevant only for underlying socket
    stream=True)

with open('/tmp/out_file.txt'), 'wb') as f:
    start_time = time.time()
    for chunk in r.iter_content(chunk_size=1024):
        if chunk:  # filter out keep-alive new chunks
            f.write(chunk)
        if time.time() - start_time > 8:
            raise Exception('Request took longer than 8s')

A solução não precisa de sinais ou multiprocessamento.

Apenas mais uma solução (obtida em http://docs.python-requests.org/en/master/user/advanced/#streaming-uploads )

Antes do upload, você pode descobrir o tamanho do conteúdo:

TOO_LONG = 10*1024*1024  # 10 Mb
big_url = "http://ipv4.download.thinkbroadband.com/1GB.zip"
r = requests.get(big_url, stream=True)
print (r.headers['content-length'])
# 1073741824  

if int(r.headers['content-length']) < TOO_LONG:
    # upload content:
    content = r.content

Mas tenha cuidado, um remetente pode configurar um valor incorreto no campo de resposta 'comprimento do conteúdo'.

Se for o caso, crie um thread de watchdog que atrapalhe o estado interno das solicitações após 10 segundos, por exemplo:

• fecha o soquete subjacente e, idealmente,
• aciona uma exceção se os pedidos tentarem novamente a operação

Observe que, dependendo das bibliotecas do sistema, talvez você não consiga definir o prazo na resolução do DNS.

Bem, tentei muitas soluções nesta página e ainda enfrentava instabilidades, interrupções aleatórias, baixo desempenho das conexões.

Agora estou usando o Curl e estou muito feliz com a funcionalidade de "tempo máximo" e com as performances globais, mesmo com uma implementação tão ruim:

content=commands.getoutput('curl -m6 -Ss "http://mywebsite.xyz"')

Aqui, eu defini um parâmetro de tempo máximo de 6 segundos, englobando o tempo de conexão e transferência.

Tenho certeza que o Curl tem uma boa ligação python, se você preferir manter a sintaxe python :)

Existe um pacote chamado timeout-decorator que você pode usar para atingir o tempo limite de qualquer função python.

@timeout_decorator.timeout(5)
def mytest():
    print("Start")
    for i in range(1,10):
        time.sleep(1)
        print("{} seconds have passed".format(i))

Ele usa a abordagem de sinais sugerida por algumas respostas. Como alternativa, você pode dizer para usar o multiprocessamento em vez de sinais (por exemplo, se você estiver em um ambiente com vários threads).

Estou usando as solicitações 2.2.1 e o eventlet não funcionou para mim. Em vez disso, consegui usar o tempo limite do gevent, pois o gevent é usado no meu serviço para o gunicorn.

import gevent
import gevent.monkey
gevent.monkey.patch_all(subprocess=True)
try:
    with gevent.Timeout(5):
        ret = requests.get(url)
        print ret.status_code, ret.content
except gevent.timeout.Timeout as e:
    print "timeout: {}".format(e.message)

Observe que gevent.timeout.Timeout não é capturado pelo tratamento geral de exceções. Portanto, capture gevent.timeout.Timeout ou passe explicitamente uma exceção diferente para ser usada da seguinte maneira: with gevent.Timeout(5, requests.exceptions.Timeout):embora nenhuma mensagem seja passada quando essa exceção for gerada.

Eu vim com uma solução mais direta que é reconhecidamente feia, mas resolve o problema real. É mais ou menos assim:

resp = requests.get(some_url, stream=True)
resp.raw._fp.fp._sock.settimeout(read_timeout)
# This will load the entire response even though stream is set
content = resp.content

Você pode ler a explicação completa aqui