PoolTimeout એટલે HTTPXને સેટ કરેલા રાહ જોવાના સમયમાં પૂલમાંથી જોડાણ મળ્યું નહીં. તે પ્રોક્સી તરફના નવા TCP જોડાણના ટાઇમઆઉટનો પુરાવો નથી. બીજી વિનંતી હજી તમારી પ્રોસેસની અંદર રાહ જોતી હોય શકે છે.

ક્લાયન્ટ એક જોડાણ આપે અને પહેલો સ્ટ્રીમિંગ પ્રતિસાદ ખુલ્લો રહી જાય તો આ સહેલાઈથી ફરી બની શકે છે. બીજી વિનંતી શરૂ કરવાથી એ જોડાણ જાતે મુક્ત થતું નથી.

સ્ટ્રીમિંગ પ્રતિસાદની જવાબદારી સ્પષ્ટ રાખો

import httpx

limits = httpx.Limits(
    max_connections=1,
    max_keepalive_connections=1,
)
timeout = httpx.Timeout(
    connect=5, read=10, write=10, pool=1
)

with httpx.Client(
    proxy="http://203.0.113.10:8080",
    trust_env=False,
    limits=limits,
    timeout=timeout,
) as client:
    with client.stream("GET", "https://example.com/") as response:
        print(response.status_code)
        for chunk in response.iter_bytes():
            print(len(chunk))

    next_response = client.get("https://example.com/")
    print(next_response.status_code)

ચલાવતાં પહેલાં દસ્તાવેજનું પ્રોક્સી સરનામું બદલો. આગલી વિનંતી સ્ટ્રીમ કૉન્ટેક્સ્ટમાંથી નીકળ્યા પછી શરૂ થાય છે. કોડ લૂપ તોડે કે અપવાદ આપે તો પણ બહાર નીકળવાથી પ્રતિસાદ બંધ થાય છે.

client.send(request, stream=True) જેવા મેન્યુઅલ સ્ટ્રીમિંગમાં છેલ્લે બંધ કરવાની જવાબદારી તમારા કોડની છે. AsyncClientમાં સંબંધિત મેન્યુઅલ સફાઈ માટે response.aclose()ને await કરવામાં આવે છે. ન વાંચેલો પ્રતિસાદ બંધ કરવાથી ક્ષમતા ખાલી થાય છે, પણ નીચેનું જોડાણ ફરી વાપરવાને બદલે છોડવું પડી શકે છે.

અપવાદનું નામ વાંચો

ConnectTimeout જોડાણ સ્થાપવા વિશે છે. ReadTimeout પ્રતિસાદ ડેટાની રાહ વિશે છે. PoolTimeout જોડાણની જગ્યા મેળવવા વિશે છે. ફક્ત «પ્રોક્સી ટાઇમઆઉટ» નોંધવાથી સુધારો પસંદ કરવા માટેનો ફરક ખોવાય છે.

એન્ડપોઇન્ટ IP બદલતાં પહેલાં ખુલ્લા પ્રતિસાદ, સમવર્તી કામ અને જોડાણ મર્યાદા જુઓ. યોગ્ય સમવર્તી ભાર માટે મોટો પૂલ યોગ્ય હોય શકે, પણ ક્યારેય બંધ ન થતા પ્રતિસાદ સુધારતો નથી. તે ફક્ત ઍપને કબજે કરવા વધુ ક્ષમતા આપે છે.

આખા કામમાં ક્લાયન્ટ ફરી વાપરી શકાય એવો રાખો. દરેક વિનંતી ચાલતી દેખાય તે માટે ક્લાયન્ટ ફરી બનાવવાથી જીવનચક્રની સમસ્યા છુપાઈ શકે છે અને જોડાણનું પુનઃવપરાશ ગુમાય છે.

સંબંધિત લેખો