Python 3.7 - Event Loop

इवेंट लूप




python

इवेंट लूप

प्रस्तावना

ईवेंट लूप हर एसिंसीओ एप्लिकेशन का मूल है। इवेंट लूप असिंक्रोनस कार्य और कॉलबैक चलाते हैं, नेटवर्क IO संचालन करते हैं, और उपप्रोसेस चलाते हैं।

एप्लिकेशन डेवलपर्स को आम तौर पर उच्च-स्तर के एसिंसीओ कार्यों का उपयोग करना चाहिए, जैसे कि asyncio.run() , और लूप ऑब्जेक्ट को संदर्भित करने या इसके तरीकों को कॉल करने की आवश्यकता शायद ही कभी होनी चाहिए। यह खंड ज्यादातर निचले स्तर के कोड, पुस्तकालयों और रूपरेखा के लेखकों के लिए है, जिन्हें इवेंट लूप व्यवहार पर बेहतर नियंत्रण की आवश्यकता है।

इवेंट लूप प्राप्त करना

इवेंट लूप को प्राप्त करने, सेट करने या बनाने के लिए निम्न निम्न-स्तरीय फ़ंक्शंस का उपयोग किया जा सकता है:

asyncio.get_running_loop()

चालू OS लूप में चालू ईवेंट लूप वापस करें।

यदि कोई रनिंग इवेंट लूप नहीं है, तो RuntimeError को उठाया जाता है। यह फ़ंक्शन केवल एक coroutine या एक कॉलबैक से बुलाया जा सकता है।

संस्करण 3.7 में नया।

asyncio.get_event_loop()

वर्तमान ईवेंट लूप प्राप्त करें। यदि वर्तमान OS थ्रेड में कोई वर्तमान ईवेंट लूप सेट नहीं है और set_event_loop() को अभी तक नहीं बुलाया गया है, तो asyncio एक नया ईवेंट लूप बनाएगा और इसे वर्तमान के रूप में सेट करेगा।

क्योंकि इस फ़ंक्शन में जटिल व्यवहार होता है (विशेषकर जब कस्टम ईवेंट लूप नीतियां उपयोग में होती हैं), तो get_running_loop() फ़ंक्शन का उपयोग करके coroutines और callbacks में get_event_loop() को प्राथमिकता दी जाती है।

मैन्युअल रूप से इवेंट लूप बनाने और बंद करने के लिए निचले स्तर के कार्यों का उपयोग करने के बजाय asyncio.run() फ़ंक्शन का उपयोग करने पर भी विचार करें।

asyncio.set_event_loop(loop)

वर्तमान ओएस थ्रेड के लिए एक वर्तमान ईवेंट लूप के रूप में लूप सेट करें।

asyncio.new_event_loop()

एक नया ईवेंट लूप ऑब्जेक्ट बनाएँ।

ध्यान दें कि get_event_loop() , set_event_loop() , और new_event_loop() फ़ंक्शन को कस्टम ईवेंट लूप नीति सेट करके बदला जा सकता है।

अंतर्वस्तु

इस दस्तावेज़ पृष्ठ में निम्नलिखित अनुभाग हैं:

इवेंट लूप के तरीके

इवेंट लूप में निम्न-स्तरीय API हैं:

लूप को चलाना और रोकना

loop.run_until_complete(future)

भविष्य तक चलाएं ( भविष्य का एक उदाहरण) पूरा हो गया है।

यदि तर्क एक coroutine ऑब्जेक्ट है, तो यह अंतर्निहित रूप से asyncio.Task रूप में चलने के लिए निर्धारित है।

भविष्य का परिणाम लौटाएँ या उसका अपवाद बढ़ाएँ।

loop.run_forever()

इवेंट लूप को तब तक चलाएँ जब तक कि stop() कहलाता।

अगर stop() को run_forever() कहा जाता है, तो लूप I / O चयनकर्ता को शून्य के टाइमआउट के साथ एक बार पोल करेगा, I / O ईवेंट्स (और जो पहले से शेड्यूल किए गए थे) के जवाब में शेड्यूल किए गए सभी कॉलबैक चलाएंगे, और फिर बाहर निकलें।

यदि run_forever() चल रहा है, तो stop() कहा जाता है, लूप कॉलबैक के वर्तमान बैच को चलाएगा और फिर बाहर निकल जाएगा। ध्यान दें कि कॉलबैक द्वारा निर्धारित नए कॉलबैक इस मामले में नहीं चलेंगे; इसके बजाय, वे अगली बार run_forever() या run_until_complete() कहते हैं।

loop.stop()

इवेंट लूप बंद करें।

loop.is_running()

यदि इवेंट लूप वर्तमान में चल रहा है, तो True लौटें।

loop.is_closed()

ईवेंट लूप बंद होने पर True लौटें।

loop.close()

इवेंट लूप बंद करें।

जब यह फ़ंक्शन कहा जाता है तो लूप चलना चाहिए। किसी भी लंबित कॉलबैक को छोड़ दिया जाएगा।

यह विधि सभी कतारों को साफ करती है और निष्पादक को बंद कर देती है, लेकिन निष्पादक के समाप्त होने की प्रतीक्षा नहीं करती है।

यह विधि निष्प्राण और अपरिवर्तनीय है। ईवेंट लूप बंद होने के बाद किसी अन्य तरीके को नहीं बुलाया जाना चाहिए।

coroutine loop.shutdown_asyncgens()

वर्तमान में सभी को एसिंक्रोनस जेनरेटर ऑब्जेक्ट को एक aclose() कॉल के साथ बंद करने के लिए aclose() करें। इस पद्धति को कॉल करने के बाद, ईवेंट लूप एक चेतावनी जारी करेगा यदि एक नया एसिंक्रोनस जनरेटर पुनरावृत्त होता है। इसका उपयोग सभी अनुसूचित अतुल्यकालिक जनरेटर को मज़बूती से अंतिम रूप देने के लिए किया जाना चाहिए।

ध्यान दें कि asyncio.run() का उपयोग करने पर इस फ़ंक्शन को कॉल करने की कोई आवश्यकता नहीं है।

उदाहरण:

try:
    loop.run_forever()
finally:
    loop.run_until_complete(loop.shutdown_asyncgens())
    loop.close()

संस्करण 3.6 में नया।

शेड्यूलिंग कॉलबैक

loop.call_soon(callback, *args, context=None)

ईवेंट लूप के अगले पुनरावृत्ति पर आर्ग तर्क के साथ बुलाए जाने वाले कॉलबैक को शेड्यूल करें।

कॉलबैक उस क्रम में कहा जाता है जिसमें वे पंजीकृत हैं। प्रत्येक कॉलबैक को एक बार बिल्कुल कॉल किया जाएगा।

एक वैकल्पिक कीवर्ड-केवल संदर्भ तर्क एक कस्टम संदर्भ को निर्दिष्ट करने की अनुमति देता है। कॉलबैक को चलाने के लिए contextvars.Context । वर्तमान संदर्भ का उपयोग तब किया जाता है जब कोई संदर्भ प्रदान नहीं किया जाता है।

Handle का एक उदाहरण दिया गया है, जिसका उपयोग बाद में कॉलबैक को रद्द करने के लिए किया जा सकता है।

यह तरीका थ्रेड-सेफ नहीं है।

loop.call_soon_threadsafe(callback, *args, context=None)

loop.call_soon() का एक थ्रेड-सुरक्षित प्रकार। किसी अन्य थ्रेड से कॉलबैक को शेड्यूल करने के लिए उपयोग किया जाना चाहिए।

प्रलेखन की संक्षिप्तता और बहुस्तरीय अनुभाग देखें।

संस्करण 3.7 में परिवर्तित: संदर्भ कीवर्ड-केवल पैरामीटर जोड़ा गया था। अधिक विवरण के लिए पीईपी 567 देखें।

ध्यान दें

अधिकांश asyncio शेड्यूलिंग फ़ंक्शन कीवर्ड तर्क पारित करने की अनुमति नहीं देते हैं। ऐसा करने के लिए, functools.partial() उपयोग करें:

# will schedule "print("Hello", flush=True)"
loop.call_soon(
    functools.partial(print, "Hello", flush=True))

आंशिक वस्तुओं का उपयोग करना आमतौर पर लैम्ब्डा का उपयोग करने की तुलना में अधिक सुविधाजनक होता है, क्योंकि एस्सिनसियो आंशिक वस्तुओं को डीबग और त्रुटि संदेशों में बेहतर रूप से प्रस्तुत कर सकता है।

शेड्यूलिंग में कॉलबैक में देरी हुई

इवेंट लूप भविष्य में किसी बिंदु पर कॉलबैक फ़ंक्शन को शेड्यूल करने के लिए तंत्र प्रदान करता है। इवेंट लूप समय को ट्रैक करने के लिए मोनोटोनिक घड़ियों का उपयोग करता है।

loop.call_later(delay, callback, *args, context=None)

दिए गए विलंब संख्या के सेकंड के बाद कॉल करने के लिए शेड्यूल कॉलबैक (या तो एक इंट या फ्लोट हो सकता है)।

TimerHandle का एक उदाहरण दिया गया है, जिसका उपयोग कॉलबैक को रद्द करने के लिए किया जा सकता है।

कॉलबैक को एक बार ही कॉल किया जाएगा। यदि दो कॉलबैक ठीक उसी समय के लिए निर्धारित हैं, तो जिस क्रम में उन्हें बुलाया जाता है, वह अपरिभाषित है।

वैकल्पिक पोजिशनल आर्ग्स कॉलबैक में पास हो जाएगा जब इसे कॉल किया जाएगा। यदि आप चाहते हैं कि कॉलबैक को कीवर्ड तर्कों के साथ कहा जाए, तो वह functools.partial() उपयोग functools.partial()

एक वैकल्पिक कीवर्ड-केवल संदर्भ तर्क एक कस्टम संदर्भ को निर्दिष्ट करने की अनुमति देता है। कॉलबैक को चलाने के लिए contextvars.Context । वर्तमान संदर्भ का उपयोग तब किया जाता है जब कोई संदर्भ प्रदान नहीं किया जाता है।

संस्करण 3.7 में परिवर्तित: संदर्भ कीवर्ड-केवल पैरामीटर जोड़ा गया था। अधिक विवरण के लिए पीईपी 567 देखें।

संस्करण 3.7.1 में परिवर्तित: पायथन 3.7.0 और पहले डिफ़ॉल्ट ईवेंट लूप कार्यान्वयन के साथ, देरी एक दिन से अधिक नहीं हो सकती थी। यह पायथन 3.7.1 में तय किया गया है।

loop.call_at(when, callback, *args, context=None)

दिए गए loop.time() जब एक इंट या फ्लोट), loop.time() रूप में एक ही समय संदर्भ का उपयोग करके कॉलबैक को शेड्यूल किया जाना है।

इस विधि का व्यवहार loop.call_later() के समान है।

TimerHandle का एक उदाहरण दिया गया है, जिसका उपयोग कॉलबैक को रद्द करने के लिए किया जा सकता है।

संस्करण 3.7 में परिवर्तित: संदर्भ कीवर्ड-केवल पैरामीटर जोड़ा गया था। अधिक विवरण के लिए पीईपी 567 देखें।

संस्करण 3.7.1 में परिवर्तित: पायथन 3.7.0 और पहले के डिफ़ॉल्ट इवेंट लूप कार्यान्वयन में, जब और वर्तमान समय के बीच का अंतर एक दिन से अधिक नहीं हो सकता था। यह पायथन 3.7.1 में तय किया गया है।

loop.time()

इवेंट लूप की आंतरिक मोनोटोनिक घड़ी के अनुसार, float वैल्यू के रूप में वर्तमान समय लौटाएं।

ध्यान दें

टाइमआउट (सापेक्ष विलंब या पूर्ण होने पर ) एक दिन से अधिक नहीं होना चाहिए।

यह भी देखें

asyncio.sleep() फ़ंक्शन।

वायदा और कार्य बनाना

loop.create_future()

ईवेंट लूप से जुड़ी हुई Future ऑब्जेक्ट बनाएं।

यह एसिंको में फ्यूचर्स बनाने का पसंदीदा तरीका है। यह थर्ड-पार्टी ईवेंट लूप्स को फ्यूचर ऑब्जेक्ट (बेहतर प्रदर्शन या इंस्ट्रूमेंटेशन के साथ) के वैकल्पिक कार्यान्वयन प्रदान करता है।

संस्करण 3.5.2 में नया।

loop.create_task(coro)

एक Coroutines के निष्पादन को शेड्यूल करें। asyncio.Task ऑब्जेक्ट वापस करें।

थर्ड-पार्टी इवेंट लूप्स इंटरऑपरेबिलिटी के लिए asyncio.Task अपने उपवर्ग का उपयोग कर सकते हैं। इस स्थिति में, परिणाम प्रकार asyncio.Task का एक उपवर्ग है।

loop.set_task_factory(factory)

एक कार्य कारखाना सेट करें जिसका उपयोग loop.create_task() द्वारा किया जाएगा।

यदि कारखाना None तो डिफ़ॉल्ट कार्य कारखाना स्थापित किया जाएगा। अन्यथा, कारखाने को हस्ताक्षर मिलान (loop, coro) साथ एक कॉल करने योग्य होना चाहिए, जहां लूप सक्रिय ईवेंट लूप का संदर्भ है, और कोरो कॉरटीन ऑब्जेक्ट है। Future योग्य को एक Future वापस आना चाहिए। Future वस्तु।

loop.get_task_factory()

यदि None डिफ़ॉल्ट उपयोग में है तो टास्क फैक्ट्री या None लौटाएं।

नेटवर्क कनेक्शन खोलना

coroutine loop.create_connection(protocol_factory, host=None, port=None, *, ssl=None, family=0, proto=0, flags=0, sock=None, local_addr=None, server_hostname=None, ssl_handshake_timeout=None)

होस्ट और पोर्ट द्वारा निर्दिष्ट दिए गए पते पर एक स्ट्रीमिंग परिवहन कनेक्शन खोलें।

सॉकेट परिवार मेजबान के आधार पर या तो AF_INET या AF_INET6 हो सकता है (या पारिवारिक तर्क, यदि प्रदान किया गया हो)।

सॉकेट प्रकार SOCK_STREAM होगा।

प्रोटोकॉल_फैक्टिंग एक एसिंकोस्को प्रोटोकॉल कार्यान्वयन को वापस करने योग्य कॉलिबल होना चाहिए।

यह विधि पृष्ठभूमि में कनेक्शन स्थापित करने का प्रयास करेगी। सफल होने पर, यह (transport, protocol) जोड़ी देता है।

अंतर्निहित ऑपरेशन का कालानुक्रमिक सारांश इस प्रकार है:

  1. कनेक्शन स्थापित किया गया है और इसके लिए एक transport बनाया गया है।
  2. प्रोटोकॉल_फैक्टिंग को तर्कों के बिना कहा जाता है और एक प्रोटोकॉल उदाहरण वापस करने की उम्मीद की जाती है।
  3. प्रोटोकॉल उदाहरण को उसके connection_made() पद्धति से कॉल करके परिवहन के साथ जोड़ा जाता है।
  4. सफलता पर ए (transport, protocol) टपल लौटाया जाता है।

निर्मित परिवहन कार्यान्वयन-निर्भर द्विदिश धारा है।

अन्य तर्क:

  • ssl : यदि दिया गया और गलत नहीं है, तो एक एसएसएल / टीएलएस परिवहन बनाया जाता है (डिफ़ॉल्ट रूप से एक सादा टीसीपी परिवहन बनाया जाता है)। यदि ssl एक ssl.SSLContext ऑब्जेक्ट है, तो इस संदर्भ का उपयोग ट्रांसपोर्ट बनाने के लिए किया जाता है; यदि ssl True , तो ssl.create_default_context() से ssl.create_default_context() गए डिफ़ॉल्ट संदर्भ का उपयोग किया जाता है।

  • server_hostname सेट या होस्टनाम को ओवरराइड करता है कि लक्ष्य सर्वर के प्रमाण पत्र के खिलाफ मिलान किया जाएगा। केवल पास होना चाहिए अगर ssl कोई None । डिफ़ॉल्ट रूप से होस्ट तर्क का मान उपयोग किया जाता है। यदि होस्ट खाली है, तो कोई डिफ़ॉल्ट नहीं है और आपको server_hostname के लिए एक मान पास करना होगा। यदि server_hostname एक खाली स्ट्रिंग है, तो होस्टनाम मिलान अक्षम है (जो कि एक गंभीर सुरक्षा जोखिम है, जो संभावित मानव-मध्य हमलों के लिए अनुमति देता है)।
  • परिवार , प्रोटो , झंडे वैकल्पिक पता परिवार, प्रोटोकॉल और झंडे मेजबान समाधान के लिए getaddrinfo () के माध्यम से पारित करने के लिए कर रहे हैं। यदि दिया जाता है, तो इन सभी को संबंधित socket मॉड्यूल स्थिरांक से पूर्णांक होना चाहिए।
  • जुर्राब , अगर दिया जाता है, तो परिवहन द्वारा उपयोग की जाने वाली एक मौजूदा, पहले से ही जुड़ी हुई socket.socket होनी चाहिए। यदि जुर्राब दिया गया है, मेजबान , बंदरगाह , परिवार , प्रोटो , झंडे और local_addr में से कोई भी निर्दिष्ट नहीं किया जाना चाहिए।
  • local_addr , यदि दिया गया है, तो एक (local_host, local_port) tuple स्थानीय रूप से सॉकेट को बांधने के लिए उपयोग किया जाता है। स्थानीय_होस्ट और local_port को getaddrinfo() का उपयोग करके देखा जाता है, इसी तरह होस्ट और पोर्ट के लिए
  • ssl_handshake_timeout (TLS कनेक्शन के लिए) कनेक्शन निरस्त करने से पहले TLS हैंडशेक के पूरा होने का इंतजार करने के लिए सेकंड में समय है। 60.0 सेकंड अगर None (डिफ़ॉल्ट)।

संस्करण 3.7 में नया: ssl_handshake_timeout पैरामीटर।

संस्करण 3.6 में परिवर्तित: सभी TCP कनेक्शन के लिए डिफ़ॉल्ट रूप से TCP_NODELAY सॉकेट विकल्प सेट किया गया है।

3.5 संस्करण में परिवर्तित: ProactorEventLoop में SSL / TLS के लिए जोड़ा गया समर्थन।

यह भी देखें

open_connection() फ़ंक्शन एक उच्च-स्तरीय वैकल्पिक एपीआई है। यह ( StreamReader , StreamWriter ) की एक जोड़ी लौटाता है जिसका उपयोग सीधे async / प्रतीक्षा कोड में किया जा सकता है।

coroutine loop.create_datagram_endpoint(protocol_factory, local_addr=None, remote_addr=None, *, family=0, proto=0, flags=0, reuse_address=None, reuse_port=None, allow_broadcast=None, sock=None)

डेटाग्राम कनेक्शन बनाएँ।

सॉकेट परिवार या तो AF_INET , AF_INET6 , या AF_UNIX , जो होस्ट (या परिवार के तर्क, यदि प्रदान किया गया) पर निर्भर करता है।

सॉकेट प्रकार SOCK_DGRAM होगा।

प्रोटोकॉल_फैक्टिंग एक प्रोटोकॉल लागू करने के लिए वापस आने योग्य होना चाहिए।

(transport, protocol) एक सफलता पर एक वापसी है।

अन्य तर्क:

  • local_addr , यदि दिया गया है, तो एक (local_host, local_port) tuple स्थानीय रूप से सॉकेट को बांधने के लिए उपयोग किया जाता है। स्थानीय_होस्ट और local_port को getaddrinfo() का उपयोग करके देखा जाता है।
  • Remote_addr , यदि दिया जाता है, तो एक (remote_host, remote_port) Remote_host , Remote_port (remote_host, remote_port) tuple है जिसका उपयोग सॉकेट को दूरस्थ पते से जोड़ने के लिए किया जाता है। दूरस्थ_होस्ट और रिमोट_पोर्ट को getaddrinfo() का उपयोग करके देखा जाता है।
  • परिवार , प्रोटो , झंडे वैकल्पिक पता परिवार, प्रोटोकॉल और झंडे मेजबान समाधान के लिए getaddrinfo() माध्यम से पारित करने के लिए कर रहे हैं। यदि दिया जाता है, तो इन सभी को संबंधित socket मॉड्यूल स्थिरांक से पूर्णांक होना चाहिए।
  • reuse_address कर्नेल को TIME_WAIT स्थिति में एक स्थानीय सॉकेट का पुन: उपयोग करने के लिए कहता है, उसके प्राकृतिक समय समाप्ति की प्रतीक्षा किए बिना। यदि निर्दिष्ट नहीं किया गया तो स्वचालित रूप से यूनिक्स पर True सेट हो जाएगा।
  • reuse_port इस एंडपॉइंट को उसी पोर्ट से बाउंड करने की अनुमति देने के लिए कर्नेल को बताता है, क्योंकि अन्य मौजूदा एंडपॉइंट्स बाध्य हैं, इसलिए जब तक वे सभी इस ध्वज को बनाते समय सेट नहीं करते। यह विकल्प विंडोज और कुछ यूनिक्स पर समर्थित नहीं है। यदि SO_REUSEPORT स्थिरांक परिभाषित नहीं है, तो यह क्षमता असमर्थित है।
  • allow_broadcast कर्नेल को इस समापन बिंदु को प्रसारण पते पर संदेश भेजने की अनुमति देने के लिए कहता है।
  • sock वैकल्पिक रूप से एक preexisting का उपयोग करने के लिए निर्दिष्ट किया जा सकता है, जो पहले से ही जुड़ा हुआ है, परिवहन द्वारा उपयोग की जाने वाली socket.socket वस्तु यदि निर्दिष्ट किया गया है, तो local_addr और Remote_addr को छोड़ दिया जाना चाहिए ( None होना चाहिए)।

Windows पर, ProactorEventLoop साथ, यह विधि समर्थित नहीं है।

यूडीपी इको क्लाइंट प्रोटोकॉल और यूडीपी इको सर्वर प्रोटोकॉल उदाहरण देखें।

संस्करण 3.4.4 में परिवर्तित: परिवार , प्रोटो , झंडे , reuse_address , reuse_port, * allow_broadcast , और जुर्राब पैरामीटर जोड़े गए।

coroutine loop.create_unix_connection(protocol_factory, path=None, *, ssl=None, sock=None, server_hostname=None, ssl_handshake_timeout=None)

एक यूनिक्स कनेक्शन बनाएं।

सॉकेट परिवार AF_UNIX होगा; सॉकेट प्रकार SOCK_STREAM होगा।

(transport, protocol) एक सफलता पर एक वापसी है।

पथ एक यूनिक्स डोमेन सॉकेट का नाम है और इसकी आवश्यकता होती है, जब तक कि एक जुर्राब पैरामीटर निर्दिष्ट नहीं किया जाता है। सार यूनिक्स सॉकेट, str , bytes और Path पथ समर्थित हैं।

इस विधि के तर्कों के बारे में जानकारी के लिए loop.create_connection() विधि का प्रलेखन देखें।

उपलब्धता: यूनिक्स।

संस्करण 3.7 में नया: ssl_handshake_timeout पैरामीटर।

संस्करण 3.7 में परिवर्तित: पथ पैरामीटर अब पथ-जैसा ऑब्जेक्ट हो सकता है

नेटवर्क सर्वर बनाना

coroutine loop.create_server(protocol_factory, host=None, port=None, *, family=socket.AF_UNSPEC, flags=socket.AI_PASSIVE, sock=None, backlog=100, ssl=None, reuse_address=None, reuse_port=None, ssl_handshake_timeout=None, start_serving=True)

होस्ट पते के पोर्ट पर सुनने के लिए एक टीसीपी सर्वर (सॉकेट प्रकार SOCK_STREAM ) बनाएं।

Server ऑब्जेक्ट लौटाता है।

तर्क:

  • प्रोटोकॉल_फैक्टिंग एक प्रोटोकॉल लागू करने के लिए वापस आने योग्य होना चाहिए।
  • होस्ट पैरामीटर को कई प्रकारों में सेट किया जा सकता है जो यह निर्धारित करते हैं कि सर्वर कहाँ सुन रहा होगा:
    • यदि होस्ट एक स्ट्रिंग है, तो टीसीपी सर्वर होस्ट द्वारा निर्दिष्ट एकल नेटवर्क इंटरफ़ेस से जुड़ा है।
    • यदि होस्ट स्ट्रिंग्स का एक अनुक्रम है, तो टीसीपी सर्वर अनुक्रम द्वारा निर्दिष्ट सभी नेटवर्क इंटरफेस के लिए बाध्य है।
    • यदि होस्ट एक खाली स्ट्रिंग है या None , तो सभी इंटरफेस मान लिए गए हैं और कई सॉकेट की सूची वापस कर दी जाएगी (IPv4 के लिए सबसे अधिक संभावना है और IPv6 के लिए एक और एक)।
  • परिवार को सॉकेट के लिए सेट किया जा सकता है। AF_INET या IPv6 का उपयोग करने के लिए सॉकेट को मजबूर करने के लिए AF_INET या AF_INET6 । यदि सेट नहीं किया गया है, तो परिवार को मेजबान नाम ( AF_UNSPEC लिए चूक) से निर्धारित किया जाएगा।
  • फ्लैट्स getaddrinfo() लिए एक बिटमास्क है।
  • sock वैकल्पिक रूप से preexisting सॉकेट ऑब्जेक्ट का उपयोग करने के लिए निर्दिष्ट किया जा सकता है। यदि निर्दिष्ट किया गया है, तो होस्ट और पोर्ट निर्दिष्ट नहीं होना चाहिए।
  • बैकलॉग listen() लिए पारित कतारबद्ध कनेक्शनों की अधिकतम संख्या है listen() (100 में चूक)।
  • एसएसएल को ssl.SSLContext उदाहरण में सेट किया जा सकता है ताकि स्वीकृत कनेक्शन पर TLS को सक्षम किया जा सके।
  • reuse_address कर्नेल को TIME_WAIT स्थिति में एक स्थानीय सॉकेट का पुन: उपयोग करने के लिए कहता है, उसके प्राकृतिक समय समाप्ति की प्रतीक्षा किए बिना। यदि निर्दिष्ट नहीं किया गया तो स्वचालित रूप से यूनिक्स पर True सेट हो जाएगा।
  • reuse_port इस एंडपॉइंट को उसी पोर्ट से बाउंड करने की अनुमति देने के लिए कर्नेल को बताता है, क्योंकि अन्य मौजूदा एंडपॉइंट्स बाध्य हैं, इसलिए जब तक वे सभी इस ध्वज को बनाते समय सेट नहीं करते। यह विकल्प विंडोज पर समर्थित नहीं है।
  • ssl_handshake_timeout (TLS सर्वर के लिए) कनेक्शन निरस्त करने से पहले TLS हैंडशेक के पूरा होने का इंतजार करने के लिए सेकंड में समय है। 60.0 सेकंड अगर None (डिफ़ॉल्ट)।
  • start_serves को True (डिफ़ॉल्ट) पर सेट करने से सृजित सर्वर तुरंत कनेक्शन स्वीकार करना शुरू कर देता है। False सेट होने पर, उपयोगकर्ता को कनेक्शन स्वीकार करने के लिए सर्वर बनाने के लिए Server.start_serving() या Server.serve_forever() पर इंतजार करना चाहिए।

संस्करण 3.7 में नया: जोड़ा गया ssl_handshake_timeout और start_serves पैरामीटर।

संस्करण 3.6 में परिवर्तित: सभी TCP कनेक्शन के लिए डिफ़ॉल्ट रूप से TCP_NODELAY सॉकेट विकल्प सेट किया गया है।

3.5 संस्करण में परिवर्तित: ProactorEventLoop में SSL / TLS के लिए जोड़ा गया समर्थन।

संस्करण 3.5.1 में परिवर्तित: होस्ट पैरामीटर स्ट्रिंग्स का एक क्रम हो सकता है।

यह भी देखें

start_server() फ़ंक्शन एक उच्च-स्तरीय वैकल्पिक एपीआई है जो start_server() और start_server() एक जोड़ी को लौटाता है जिसका उपयोग एक async / प्रतीक्षा कोड में किया जा सकता है।

coroutine loop.create_unix_server(protocol_factory, path=None, *, sock=None, backlog=100, ssl=None, ssl_handshake_timeout=None, start_serving=True)

loop.create_server() समान लेकिन AF_UNIX सॉकेट परिवार के साथ काम करता है।

पथ एक यूनिक्स डोमेन सॉकेट का नाम है, और इसकी आवश्यकता होती है, जब तक कि एक जुर्राब तर्क प्रदान नहीं किया जाता है। सार यूनिक्स सॉकेट, str , bytes और Path पथ समर्थित हैं।

इस विधि के तर्कों के बारे में जानकारी के लिए loop.create_server() विधि का प्रलेखन देखें।

उपलब्धता: यूनिक्स।

संस्करण 3.7 में नया: ssl_handshake_timeout और start_serves पैरामीटर।

संस्करण 3.7 में परिवर्तित: पथ पैरामीटर अब Path ऑब्जेक्ट हो सकता है।

coroutine loop.connect_accepted_socket(protocol_factory, sock, *, ssl=None, ssl_handshake_timeout=None)

ट्रांसपोर्ट / प्रोटोकॉल पेयर में पहले से स्वीकृत कनेक्शन को लपेटें।

इस पद्धति का उपयोग उन सर्वरों द्वारा किया जा सकता है जो asyncio के बाहर कनेक्शन स्वीकार करते हैं लेकिन उन्हें संभालने के लिए asyncio का उपयोग करते हैं।

पैरामीटर:

  • प्रोटोकॉल_फैक्टिंग एक प्रोटोकॉल लागू करने के लिए वापस आने योग्य होना चाहिए।
  • sock एक preexisting सॉकेट ऑब्जेक्ट है जो socket.accept से socket.accept
  • एसएसएल को ssl.SSLContext सेट किया जा सकता है ताकि स्वीकार किए गए कनेक्शन पर एसएसएल को सक्षम किया जा सके।
  • ssl_handshake_timeout (SSL कनेक्शन के लिए) कनेक्शन को समाप्त करने से पहले SSL हैंडशेक के पूरा होने का इंतजार करने के लिए सेकंड में समय है। 60.0 सेकंड अगर None (डिफ़ॉल्ट)।

एक (transport, protocol) जोड़ी देता है।

संस्करण 3.7 में नया: ssl_handshake_timeout पैरामीटर।

संस्करण 3.5.3 में नया।

फ़ाइलों को स्थानांतरित करना

coroutine loop.sendfile(transport, file, offset=0, count=None, *, fallback=True)

एक परिवहन पर एक फ़ाइल भेजें। भेजे गए बाइट्स की कुल संख्या लौटाएं।

यदि उपलब्ध हो तो विधि उच्च-प्रदर्शन os.sendfile() का उपयोग करती है।

फ़ाइल बाइनरी मोड में खोली गई एक नियमित फ़ाइल ऑब्जेक्ट होनी चाहिए।

ऑफसेट बताता है कि फ़ाइल को पढ़ना कहां से शुरू करना है। यदि निर्दिष्ट किया गया है, तो गिनती ईओटी तक पहुंचने के लिए फ़ाइल भेजने के विपरीत प्रसारित करने के लिए बाइट्स की कुल संख्या है। फ़ाइल की स्थिति हमेशा अपडेट की जाती है, भले ही यह विधि एक त्रुटि उठाती है, और file.tell() का उपयोग भेजे गए बाइट्स की वास्तविक संख्या प्राप्त करने के लिए किया जा सकता है।

फ़ॉलबैक सेट True asyncio को मैन्युअल रूप से पढ़ने और फ़ाइल भेजने के लिए सेट करता है जब प्लेटफ़ॉर्म सेंपल सिस्टम कॉल (जैसे विंडोज या यूनिक्स सॉकेट यूनिक्स पर) का समर्थन नहीं करता है।

SendfileNotAvailableError उठाएँ यदि सिस्टम SendfileNotAvailableError syscall का समर्थन नहीं करता है और फ़ालबैक False

संस्करण 3.7 में नया।

टीएलएस अपग्रेड

coroutine loop.start_tls(transport, protocol, sslcontext, *, server_side=False, server_hostname=None, ssl_handshake_timeout=None)

मौजूदा परिवहन-आधारित कनेक्शन को टीएलएस में अपग्रेड करें।

एक नया परिवहन उदाहरण लौटाएं, जो प्रोटोकॉल प्रतीक्षा के तुरंत बाद उपयोग करना शुरू कर देगा। Start_tls विधि के लिए दिया गया परिवहन उदाहरण फिर से उपयोग नहीं किया जाना चाहिए।

पैरामीटर:

  • परिवहन और प्रोटोकॉल उदाहरण है कि loop.create_server() और loop.create_connection() वापसी जैसे तरीके।
  • sslcontext : ssl.SSLContext का कॉन्फ़िगर उदाहरण।
  • server_side पास True जब सर्वर-साइड कनेक्शन अपग्रेड किया जा रहा है (जैसे loop.create_server() द्वारा बनाया गया)।
  • server_hostname : होस्ट नाम सेट या ओवरराइड करता है कि लक्ष्य सर्वर के प्रमाण पत्र का मिलान किया जाएगा।
  • ssl_handshake_timeout (TLS कनेक्शन के लिए) कनेक्शन निरस्त करने से पहले TLS हैंडशेक के पूरा होने का इंतजार करने के लिए सेकंड में समय है। 60.0 सेकंड अगर None (डिफ़ॉल्ट)।

संस्करण 3.7 में नया।

फ़ाइल विवरण देखने वाले

loop.add_reader(fd, callback, *args)

रीड उपलब्धता के लिए fd फाइल डिस्क्रिप्टर की निगरानी शुरू करें और रीडिंग के लिए fd उपलब्ध होने के बाद निर्दिष्ट तर्कों के साथ कॉलबैक को आमंत्रित करें।

loop.remove_reader(fd)

रीड उपलब्धता के लिए fd फ़ाइल डिस्क्रिप्टर की निगरानी करना बंद करें।

loop.add_writer(fd, callback, *args)

लिखने की उपलब्धता के लिए fd फाइल डिस्क्रिप्टर की निगरानी शुरू करें और लिखने के लिए fd उपलब्ध होने के बाद निर्दिष्ट तर्कों के साथ कॉलबैक वापस लाएं

functools.partial() करने के लिए कीवर्ड तर्कों को पास करने के लिए functools.partial() का उपयोग करें।

loop.remove_writer(fd)

लिखने की उपलब्धता के लिए fd फाइल डिस्क्रिप्टर की निगरानी करना बंद करें।

इन विधियों की कुछ सीमाओं के लिए प्लेटफ़ॉर्म सपोर्ट सेक्शन भी देखें।

सॉकेट ऑब्जेक्ट्स के साथ सीधे काम करना

सामान्य तौर पर, ट्रांसपोर्ट-आधारित APIs जैसे कि loop.create_connection() और loop.create_server() उपयोग करने वाले प्रोटोकॉल loop.create_connection() सीधे सॉकेट्स के साथ काम करने वाले कार्यान्वयन की तुलना में तेज़ होते हैं। हालांकि, कुछ उपयोग के मामले हैं जब प्रदर्शन महत्वपूर्ण नहीं है, और socket.socket ऑब्जेक्ट के साथ सीधे काम करना अधिक सुविधाजनक है।

coroutine loop.sock_recv(sock, nbytes)

जुर्राब से nbytes तक प्राप्त करें। socket.recv() . socket.recv() का अतुल्यकालिक संस्करण।

प्राप्त डेटा को बाइट्स ऑब्जेक्ट के रूप में लौटाएं।

जुर्राब एक गैर-अवरुद्ध सॉकेट होना चाहिए।

संस्करण 3.7 में बदला गया: भले ही इस विधि को हमेशा एक coroutine विधि के रूप में प्रलेखित किया गया था, पाइथन 3.7 के Future वापस आने से पहले रिलीज़। पाइथन 3.7 के बाद से यह एक async def विधि है।

coroutine loop.sock_recv_into(sock, buf)

बफ़ बफर में जुर्राब से डेटा प्राप्त करें। ब्लॉकिंग socket.recv_into() बाद बनाया गया socket.recv_into() विधि।

बफ़र को लिखे बाइट्स की संख्या वापस करें।

जुर्राब एक गैर-अवरुद्ध सॉकेट होना चाहिए।

संस्करण 3.7 में नया।

coroutine loop.sock_sendall(sock, data)

सॉकेट सॉकेट में डेटा भेजें। socket.sendall() का अतुल्यकालिक संस्करण।

यह विधि सॉकेट को तब तक भेजती रहती है जब तक या तो डेटा में सभी डेटा नहीं भेजे जाते हैं या कोई त्रुटि उत्पन्न होती है। सफलता पर None लौटाया जाता है। त्रुटि होने पर, एक अपवाद उठाया जाता है। इसके अतिरिक्त, यह निर्धारित करने का कोई तरीका नहीं है कि कनेक्शन के प्राप्त अंत तक कितना डेटा, यदि कोई हो, को सफलतापूर्वक संसाधित किया गया था।

जुर्राब एक गैर-अवरुद्ध सॉकेट होना चाहिए।

संस्करण 3.7 में परिवर्तित किया गया: भले ही विधि को हमेशा कॉरटीन विधि के रूप में प्रलेखित किया गया था, पाइथन 3.7 से पहले यह एक Future लौटा था। पाइथन 3.7 के बाद से, यह एक async def विधि है।

coroutine loop.sock_connect(sock, address)

पते पर रिमोट सॉकेट से कनेक्ट करें।

सॉकेट के असिंक्रोनस socket.connect()

जुर्राब एक गैर-अवरुद्ध सॉकेट होना चाहिए।

संस्करण 3.5.2 में परिवर्तित: address अब हल करने की आवश्यकता नहीं है। sock_connect यह sock_connect की कोशिश करेगा कि क्या पता पहले से ही socket.inet_pton() कॉल करके हल किया गया है। यदि नहीं, तो पते को हल करने के लिए getaddrinfo() का उपयोग किया जाएगा।

यह भी देखें

loop.create_connection() और open_connection()

coroutine loop.sock_accept(sock)

एक कनेक्शन स्वीकार करें। ब्लॉकिंग socket.accept विधि के बाद बनाया गया।

सॉकेट एक पते और कनेक्शन के लिए सुनने के लिए बाध्य होना चाहिए। रिटर्न वैल्यू एक जोड़ी (conn, address) जहां कनेक्शन पर डेटा भेजने और प्राप्त करने के लिए कॉन एक नया सॉकेट ऑब्जेक्ट है, और एड्रेस कनेक्शन के दूसरे छोर पर सॉकेट से जुड़ा एड्रेस है।

जुर्राब एक गैर-अवरुद्ध सॉकेट होना चाहिए।

संस्करण 3.7 में परिवर्तित किया गया: भले ही विधि को हमेशा कोरूटिन विधि के रूप में प्रलेखित किया गया था, पाइथन 3.7 से पहले यह एक Future लौटा था। पाइथन 3.7 के बाद से, यह एक async def विधि है।

यह भी देखें

loop.create_server() और start_server()

coroutine loop.sock_sendfile(sock, file, offset=0, count=None, *, fallback=True)

यदि संभव हो तो उच्च-प्रदर्शन os.sendfile() का उपयोग करके एक फ़ाइल भेजें। भेजे गए बाइट्स की कुल संख्या लौटाएं।

socket.sendfile() का एसिंक्रोनस वर्जन।

जुर्राब एक गैर-अवरुद्ध socket.socket होना चाहिए। SOCK_STREAM socket.socket

फ़ाइल बाइनरी मोड में एक नियमित फ़ाइल ऑब्जेक्ट खुली होनी चाहिए।

ऑफसेट बताता है कि फ़ाइल को पढ़ना कहां से शुरू करना है। यदि निर्दिष्ट किया गया है, तो गिनती ईओटी तक पहुंचने के लिए फ़ाइल भेजने के विपरीत प्रसारित करने के लिए बाइट्स की कुल संख्या है। फ़ाइल की स्थिति हमेशा अपडेट की जाती है, भले ही यह विधि एक त्रुटि उठाती है, और file.tell() का उपयोग भेजे गए बाइट्स की वास्तविक संख्या प्राप्त करने के लिए किया जा सकता है।

फ़ॉलबैक , जब True सेट होता है, तब asyncio मैन्युअल रूप से फाइल को पढ़ता है और भेजता है जब प्लेटफ़ॉर्म सेंफाइल syscall (जैसे विंडोज या SSL सॉकेट यूनिक्स पर) का समर्थन नहीं करता है।

यदि सिस्टम SendfileNotAvailableError syscall का समर्थन नहीं करता है तो SendfileNotAvailableError उठाएँ और फ़ॉलबैक False

जुर्राब एक गैर-अवरुद्ध सॉकेट होना चाहिए।

संस्करण 3.7 में नया।

डीएनएस

coroutine loop.getaddrinfo(host, port, *, family=0, type=0, proto=0, flags=0)

सॉकेट के असिंक्रोनस वर्जन socket.getaddrinfo()

coroutine loop.getnameinfo(sockaddr, flags=0)

सॉकेट के असिंक्रोनस वर्जन socket.getnameinfo()

संस्करण 3.7 में परिवर्तित: getaddrinfo और getnameinfo दोनों तरीकों को हमेशा एक कोरटाइन वापस करने के लिए प्रलेखित किया गया था, लेकिन पायथन 3.7 से पहले वे वास्तव में, Future वस्तुओं को वापस कर रहे थे। Python 3.7 से शुरू होने वाले दोनों तरीके coroutines हैं।

पाइप के साथ काम करना

coroutine loop.connect_read_pipe(protocol_factory, pipe)

ईवेंट लूप में पाइप के रीड एंड को रजिस्टर करें।

प्रोटोकॉल_फैक्टिंग एक एसिंकोस्को प्रोटोकॉल कार्यान्वयन को वापस करने योग्य कॉलिबल होना चाहिए।

पाइप एक फ़ाइल जैसी वस्तु है

रिटर्न जोड़ी (transport, protocol) , जहां ट्रांसपोर्ट ReadTransport इंटरफेस का समर्थन करता है और प्रोटोकॉल प्रोटोकॉल_फैक्टिंग द्वारा ReadTransport से ReadTransport गई वस्तु है।

SelectorEventLoop इवेंट लूप के साथ, पाइप को नॉन-ब्लॉकिंग मोड पर सेट किया गया है।

coroutine loop.connect_write_pipe(protocol_factory, pipe)

ईवेंट लूप में पाइप का राइट एंड रजिस्टर करें।

प्रोटोकॉल_फैक्टिंग एक एसिंकोस्को प्रोटोकॉल कार्यान्वयन को वापस करने योग्य कॉलिबल होना चाहिए।

पाइप फ़ाइल जैसी वस्तु है

रिटर्न जोड़ी (transport, protocol) , जहां ट्रांसपोर्ट WriteTransport ट्रांसपोर्ट इंटरफेस का समर्थन करता है और प्रोटोकॉल प्रोटोकॉल_फैक्टिविटी द्वारा WriteTransport वस्तु है।

SelectorEventLoop इवेंट लूप के साथ, पाइप को नॉन-ब्लॉकिंग मोड पर सेट किया गया है।

ध्यान दें

SelectorEventLoop विंडोज पर उपरोक्त तरीकों का समर्थन नहीं करता है। Windows के बजाय ProactorEventLoop उपयोग करें।

यह भी देखें

loop.subprocess_exec() loop.subprocess_exec() और loop.subprocess_shell() विधियाँ।

यूनिक्स संकेत

loop.add_signal_handler(signum, callback, *args)

साइनबैक सिग्नल के लिए हैंडलर के रूप में कॉलबैक सेट करें।

यदि सिग्नल नंबर अमान्य या पहुंच से बाहर है, तो ValueError उठाएँ। हैंडलर सेट करने में कोई समस्या होने पर RuntimeError उठाएं।

functools.partial() करने के लिए कीवर्ड तर्कों को पास करने के लिए functools.partial() का उपयोग करें।

loop.remove_signal_handler(sig)

सिग सिग्नल के लिए हैंडलर निकालें।

True लौटें यदि सिग्नल हैंडलर को हटा दिया गया था, या False दिए गए सिग्नल के लिए कोई हैंडलर सेट नहीं किया गया था।

उपलब्धता: यूनिक्स।

यह भी देखें

signal मॉड्यूल।

थ्रेड या प्रक्रिया पूल में निष्पादन कोड

awaitable loop.run_in_executor(executor, func, *args)

निर्दिष्ट निष्पादक में कवक की व्यवस्था की जाए।

निष्पादक तर्क एक concurrent.futures.Executor होना चाहिए concurrent.futures.Executor उदाहरण। यदि निष्पादक None है, तो डिफ़ॉल्ट निष्पादक का उपयोग किया जाता है।

उदाहरण:

import asyncio
import concurrent.futures

def blocking_io():
    # File operations (such as logging) can block the
    # event loop: run them in a thread pool.
    with open('/dev/urandom', 'rb') as f:
        return f.read(100)

def cpu_bound():
    # CPU-bound operations will block the event loop:
    # in general it is preferable to run them in a
    # process pool.
    return sum(i * i for i in range(10 ** 7))

async def main():
    loop = asyncio.get_running_loop()

    ## Options:

    # 1. Run in the default loop's executor:
    result = await loop.run_in_executor(
        None, blocking_io)
    print('default thread pool', result)

    # 2. Run in a custom thread pool:
    with concurrent.futures.ThreadPoolExecutor() as pool:
        result = await loop.run_in_executor(
            pool, blocking_io)
        print('custom thread pool', result)

    # 3. Run in a custom process pool:
    with concurrent.futures.ProcessPoolExecutor() as pool:
        result = await loop.run_in_executor(
            pool, cpu_bound)
        print('custom process pool', result)

asyncio.run(main())

यह विधि एक Future वस्तु Future है।

functools.partial() करने के लिए कीवर्ड तर्कों को पास करने के लिए functools.partial() का उपयोग करें।

संस्करण 3.5.3 में परिवर्तित: loop.run_in_executor() अब थ्रेड पूल निष्पादक के max_workers को कॉन्फ़िगर नहीं करता है जो इसे बनाता है, बजाय इसे डिफ़ॉल्ट सेट करने के लिए थ्रेड पूल निष्पादक ( ThreadPoolExecutor ) तक छोड़ देता है।

loop.set_default_executor(executor)

निष्पादक को loop.run_in_executor() द्वारा प्रयुक्त डिफ़ॉल्ट निष्पादक के रूप में सेट करें। निष्पादक ThreadPoolExecutor का एक उदाहरण होना चाहिए।

संस्करण 3.7 के बाद से पदावनत: एक निष्पादक का उपयोग करना जो कि ThreadPoolExecutor का उदाहरण नहीं है, पदावनत है और पायथन 3.9 में एक त्रुटि को ट्रिगर करेगा।

निष्पादक को ThreadPoolExecutor का एक उदाहरण होना चाहिए।

एपीआई को संभालने में त्रुटि

घटना लूप में अपवादों को कैसे प्रबंधित किया जाता है, इसे अनुकूलित करने की अनुमति देता है।

loop.set_exception_handler(handler)

नए ईवेंट लूप अपवाद हैंडलर के रूप में हैंडलर सेट करें।

यदि हैंडलर None , तो डिफ़ॉल्ट अपवाद हैंडलर सेट किया जाएगा। अन्यथा, हैंडलर हस्ताक्षर मिलान (loop, context) साथ एक कॉल करने योग्य होना चाहिए, जहां loop सक्रिय ईवेंट लूप का context है, और context अपवाद के विवरण से युक्त एक प्रमुख वस्तु है (संदर्भ के लिए विवरण के लिए call_exception_handler() प्रलेखन देखें )।

loop.get_exception_handler()

वर्तमान अपवाद हैंडलर लौटाएं, या None भी कस्टम अपवाद हैंडलर सेट नहीं किया गया था।

संस्करण 3.5.2 में नया।

loop.default_exception_handler(context)

डिफ़ॉल्ट अपवाद हैंडलर।

इसे तब कहा जाता है जब कोई अपवाद होता है और कोई अपवाद हैंडलर सेट नहीं किया जाता है। यह एक कस्टम अपवाद हैंडलर द्वारा बुलाया जा सकता है जो डिफ़ॉल्ट हैंडलर व्यवहार को स्थगित करना चाहता है।

संदर्भ पैरामीटर का वही अर्थ है जो call_exception_handler()

loop.call_exception_handler(context)

वर्तमान ईवेंट लूप अपवाद हैंडलर को कॉल करें।

संदर्भ एक प्रमुख वस्तु है जिसमें निम्नलिखित कुंजियाँ हैं (नई कुंजी को भविष्य के पायथन संस्करणों में पेश किया जा सकता है):

  • 'संदेश': त्रुटि संदेश;
  • 'अपवाद' (वैकल्पिक): अपवाद वस्तु;
  • 'भविष्य' (वैकल्पिक): Future उदाहरण;
  • 'संभाल' (वैकल्पिक): Handle उदाहरण;
  • 'प्रोटोकॉल' (वैकल्पिक): प्रोटोकॉल उदाहरण;
  • 'परिवहन' (वैकल्पिक): transport उदाहरण;
  • 'सॉकेट' (वैकल्पिक): socket.socket उदाहरण।

ध्यान दें

इस विधि को उपवर्गित ईवेंट लूप में अतिभारित नहीं किया जाना चाहिए। कस्टम अपवाद हैंडलिंग के लिए, set_exception_handler() विधि का उपयोग करें।

डिबग मोड को सक्षम करना

loop.get_debug()

ईवेंट लूप का डीबग मोड ( bool ) प्राप्त करें।

डिफ़ॉल्ट मान True यदि पर्यावरण चर PYTHONASYNCIODEBUG एक गैर-रिक्त स्ट्रिंग, PYTHONASYNCIODEBUG पर सेट है।

loop.set_debug(enabled: bool)

ईवेंट लूप का डीबग मोड सेट करें।

संस्करण 3.7 में परिवर्तित: नए -X dev कमांड लाइन विकल्प का उपयोग अब डिबग मोड को सक्षम करने के लिए भी किया जा सकता है।

यह भी देखें

एसिंको का डिबग मोड

उपप्रकार चल रहा है

इस उपधाराओं में वर्णित विधियाँ निम्न स्तर की हैं। इसके बजाय नियमित रूप से async / प्रतीक्षा कोड उच्च-स्तरीय asyncio.create_subprocess_shell() और asyncio.create_subprocess_exec() सुविधा कार्यों का उपयोग करने पर विचार करता है ।

ध्यान दें

विंडोज पर डिफ़ॉल्ट एसिनसियो इवेंट लूप उपप्रोसेस का समर्थन नहीं करता है। देखें विंडोज पर उपप्रक्रिया समर्थन जानकारी के लिए।

coroutine loop.subprocess_exec(protocol_factory, *args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)

एक या अधिक स्ट्रिंग द्वारा निर्दिष्ट तर्कों से एक उपप्रक्रिया बनाएं आर्ग

args द्वारा दर्शाए गए तार की एक सूची होनी चाहिए:

पहला स्ट्रिंग प्रोग्राम निष्पादन योग्य निर्दिष्ट करता है, और शेष स्ट्रिंग तर्क निर्दिष्ट करते हैं। साथ में, स्ट्रिंग तर्क argv कार्यक्रम का निर्माण करते हैं।

यह मानक पुस्तकालय subprocess.Popen वर्ग के समान है जिसे shell=False पहले तर्क के रूप में पारित तार की सूची के साथ बुलाया गया है; हालाँकि, जहाँ subprocess.Popen एक भी तर्क है जो तार की सूची है, सबप्रोसेस_सेक्स कई स्ट्रिंग तर्क लेता है।

Protocol_factory का एक उपवर्ग लौटने एक प्रतिदेय होना चाहिए asyncio.SubprocessProtocol वर्ग।

अन्य पैरामीटर:

  • स्टड : या तो एक फाइल की तरह ऑब्जेक्ट जो उपप्रोसेस के मानक इनपुट स्ट्रीम का उपयोग करने के लिए एक पाइप का प्रतिनिधित्व करता है connect_write_pipe() , या subprocess.PIPE निरंतर (डिफ़ॉल्ट)। डिफ़ॉल्ट रूप से एक नया पाइप बनाया जाएगा और जुड़ा होगा।
  • stdout : या तो एक फाइल जैसी वस्तु जो उपप्रोसेस के मानक आउटपुट स्ट्रीम का उपयोग करने के लिए पाइप का प्रतिनिधित्व करती है connect_read_pipe() , या subprocess.PIPE निरंतर (डिफ़ॉल्ट)। डिफ़ॉल्ट रूप से एक नया पाइप बनाया जाएगा और जुड़ा होगा।
  • stderr : या तो एक फाइल जैसी वस्तु जो उपप्रकार की मानक त्रुटि स्ट्रीम से जुड़े होने के लिए पाइप का प्रतिनिधित्व करती है connect_read_pipe() , या subprocess.PIPE (डिफ़ॉल्ट) या subprocess.STDOUT स्थिरांक में से एक।

    डिफ़ॉल्ट रूप से एक नया पाइप बनाया जाएगा और जुड़ा होगा। जब subprocess.STDOUT निर्दिष्ट किया जाता है, तो उपप्रक्रम की मानक त्रुटि धारा मानक आउटपुट स्ट्रीम के समान पाइप से जुड़ी होगी।

  • अन्य सभी कीवर्ड तर्क को पास किया जाता subprocess.Popen व्याख्या के बिना, के लिए छोड़कर bufsize , universal_newlines और खोल , जिस पर सभी निर्दिष्ट नहीं किया जाना चाहिए।

subprocess.Popen अन्य तर्कों पर प्रलेखन के लिए वर्ग का निर्माता देखें ।

की एक जोड़ी लौटाता है (transport, protocol) , जहां परिवहन asyncio.SubprocessTransport बेस क्लास और प्रोटोकॉल के अनुरूप होता है, प्रोटोकॉल_फैक्टिंग द्वारा त्वरित वस्तु है ।

coroutine loop.subprocess_shell(protocol_factory, cmd, *, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)

से एक उपप्रक्रिया बनाएं cmd , जो एक हो सकता है str या एक bytes स्ट्रिंग के लिए इनकोडिंग फाइल सिस्टम एन्कोडिंग , मंच के "खोल" सिंटैक्स का उपयोग।

यह मानक पुस्तकालय subprocess.Popen वर्ग के समान है जिसे कहा जाता है shell=True

Protocol_factory का एक उपवर्ग लौटने एक प्रतिदेय होना चाहिए asyncio.SubprocessProtocol वर्ग।

loop.subprocess_exec() शेष तर्कों के बारे में अधिक जानकारी के लिए देखें ।

की एक जोड़ी लौटाता है (transport, protocol) , जहां परिवहन asyncio.SubprocessTransport बेस क्लास और प्रोटोकॉल के अनुरूप होता है, प्रोटोकॉल_फैक्टिंग द्वारा त्वरित वस्तु है ।

ध्यान दें

यह सुनिश्चित करने के लिए आवेदन की ज़िम्मेदारी है कि शेल इंजेक्शन भेद्यता से बचने के लिए सभी व्हाट्सएप और विशेष पात्रों को उचित रूप से उद्धृत किया गया है। shlex.quote() ठीक तरह से कार्य तार में खाली स्थान के और विशेष वर्ण खोल आदेशों के निर्माण के लिए इस्तेमाल किया जा जा रहे हैं कि बचने के लिए इस्तेमाल किया जा सकता।

कॉलबैक हैंडल

class asyncio.Handle

एक कॉलबैक आवरण वस्तु द्वारा दिया loop.call_soon() , loop.call_soon_threadsafe()

cancel()

कॉलबैक रद्द करें। यदि कॉलबैक पहले ही रद्द या निष्पादित हो चुका है, तो इस पद्धति का कोई प्रभाव नहीं है।

cancelled()

True कॉलबैक रद्द होने पर वापस लौटें ।

संस्करण 3.7 में नया।

class asyncio.TimerHandle

कॉलबैक रैपर ऑब्जेक्ट द्वारा लौटाया गया loop.call_later() , और loop.call_at()

यह वर्ग उपवर्ग है Handle

when()

float सेकंड के रूप में एक निर्धारित कॉलबैक समय लौटाएं ।

समय निरपेक्ष टाइमस्टैम्प है, उसी समय संदर्भ का उपयोग करते हुए loop.time()

संस्करण 3.7 में नया।

सर्वर ऑब्जेक्ट

सर्वर वस्तुओं द्वारा बनाई गई हैं loop.create_server() , loop.create_unix_server() , start_server() , और start_unix_server() कार्य करता है।

कक्षा को सीधे मत करो।

class asyncio.Server

सर्वर ऑब्जेक्ट एसिंक्रोनस संदर्भ प्रबंधक हैं। जब एक async with बयान में इस्तेमाल किया जाता है , तो यह गारंटी दी जाती है कि सर्वर ऑब्जेक्ट बंद हो गया है और async with बयान पूरा होने पर नए कनेक्शन स्वीकार नहीं कर रहा है:

srv = await loop.create_server(...)

async with srv:
    # some code

# At this point, srv is closed and no longer accepts new connections.

संस्करण 3.7 में परिवर्तित: पायथन 3.7 के बाद से सर्वर ऑब्जेक्ट एक अतुल्यकालिक संदर्भ प्रबंधक है।

close()

सेवारत बंद करें: सुनने वाले सॉकेट बंद करें और sockets विशेषता सेट करें None

मौजूदा आवक क्लाइंट कनेक्शन का प्रतिनिधित्व करने वाले सॉकेट्स को खुला छोड़ दिया जाता है।

सर्वर को एसिंक्रोनस रूप से बंद कर दिया जाता है, wait_closed() सर्वर के बंद होने तक प्रतीक्षा करने के लिए कोरटाइन का उपयोग करें।

get_loop()

सर्वर ऑब्जेक्ट से जुड़े ईवेंट लूप को वापस करें।

संस्करण 3.7 में नया।

coroutine start_serving()

कनेक्शन स्वीकार करना शुरू करें।

यह विधि idempotent है, इसलिए यह तब कहा जा सकता है जब सर्वर पहले से ही सेवारत है।

Start_serving केवल कीवर्ड वाला पैरामीटर loop.create_server() और start_server() एक सर्वर उद्देश्य यह है कि कनेक्शन शुरू में स्वीकार नहीं कर रहा बनाने की अनुमति देता है। इस स्थिति में Server.start_serving() , या Server.serve_forever() सर्वर को कनेक्शन स्वीकार करना शुरू करने के लिए इस्तेमाल किया जा सकता है।

संस्करण 3.7 में नया।

coroutine serve_forever()

तब तक कनेक्शन स्वीकार करना शुरू करें, जब तक कि कोरटाइन रद्द न हो जाए। serve_forever कार्य रद्द करने से सर्वर बंद हो जाता है।

यदि सर्वर पहले से ही कनेक्शन स्वीकार कर रहा है तो इस विधि को बुलाया जा सकता है। serve_forever प्रति सर्वर ऑब्जेक्ट में केवल एक ही कार्य मौजूद हो सकता है ।

उदाहरण:

async def client_connected(reader, writer):
    # Communicate with the client with
    # reader/writer streams.  For example:
    await reader.readline()

async def main(host, port):
    srv = await asyncio.start_server(
        client_connected, host, port)
    await srv.serve_forever()

asyncio.run(main('127.0.0.1', 0))

संस्करण 3.7 में नया।

is_serving()

True यदि सर्वर नए कनेक्शन स्वीकार कर रहा है तो वापस लौटें ।

संस्करण 3.7 में नया।

coroutine wait_closed()

close() विधि पूर्ण होने तक प्रतीक्षा करें ।

sockets

उन socket.socket वस्तुओं की सूची, जिन्हें सर्वर सुन रहा है, या None यदि सर्वर बंद है।

संस्करण 3.7 में परिवर्तित: पहले पायथन 3.7 से पहले Server.sockets सर्वर सॉकेट्स की एक आंतरिक सूची को सीधे वापस किया जाता था। 3.7 में उस सूची की एक प्रति लौटा दी गई है।

इवेंट लूप कार्यान्वयन

asyncio दो अलग-अलग इवेंट लूप कार्यान्वयन के साथ जहाज: SelectorEventLoop और ProactorEventLoop

डिफ़ॉल्ट रूप से asyncio SelectorEventLoop सभी प्लेटफार्मों पर उपयोग करने के लिए कॉन्फ़िगर किया गया है।

class asyncio.SelectorEventLoop

selectors मॉड्यूल पर आधारित एक ईवेंट लूप ।

दिए गए प्लेटफ़ॉर्म के लिए उपलब्ध सबसे कुशल चयनकर्ता का उपयोग करता है। मैन्युअल रूप से उपयोग किए जाने वाले सटीक चयनकर्ता को मैन्युअल रूप से कॉन्फ़िगर करना भी संभव है:

import asyncio
import selectors

selector = selectors.SelectSelector()
loop = asyncio.SelectorEventLoop(selector)
asyncio.set_event_loop(loop)

उपलब्धता: यूनिक्स, विंडोज।

class asyncio.ProactorEventLoop

विंडोज के लिए एक ईवेंट लूप जो "I / O कम्पलीशन पोर्ट्स" (IOCP) का उपयोग करता है।

उपलब्धता: विंडोज।

ProactorEventLoop विंडोज पर उपयोग करने का एक उदाहरण :

import asyncio
import sys

if sys.platform == 'win32':
    loop = asyncio.ProactorEventLoop()
    asyncio.set_event_loop(loop)
class asyncio.AbstractEventLoop

एसिंको-कम्प्लायंट इवेंट लूप्स के लिए सार बेस क्लास।

घटना लूप तरीके अनुभाग सभी तरीकों कि का एक वैकल्पिक कार्यान्वयन को सूचीबद्ध करता है AbstractEventLoop परिभाषित किया जाना चाहिए था।

उदाहरण

नोट इस अनुभाग के सभी उदाहरण है कि उद्देश्यपूर्ण कैसे इस तरह के रूप निम्न स्तर घटना पाश एपीआई, उपयोग करने के लिए दिखाने के run_forever() और loop.call_soon() । आधुनिक asyncio अनुप्रयोगों को शायद ही कभी इस तरह से लिखने की आवश्यकता होती है; उच्च-स्तरीय कार्यों का उपयोग करने पर विचार करें asyncio.run()

हेलो वर्ल्ड विथ call_soon ()

loop.call_soon() कॉलबैक शेड्यूल करने के लिए विधि का उपयोग करने वाला एक उदाहरण । कॉलबैक प्रदर्शित करता है "Hello World" और फिर ईवेंट लूप रोकता है:

import asyncio

def hello_world(loop):
    """A callback to print 'Hello World' and stop the event loop"""
    print('Hello World')
    loop.stop()

loop = asyncio.get_event_loop()

# Schedule a call to hello_world()
loop.call_soon(hello_world, loop)

# Blocking call interrupted by loop.stop()
try:
    loop.run_forever()
finally:
    loop.close()

यह भी देखें

एक कोरोइन और फ़ंक्शन के साथ बनाया गया एक समान हैलो वर्ल्ड उदाहरण asyncio.run()

Call_later () के साथ वर्तमान दिनांक प्रदर्शित करें

कॉलबैक का एक उदाहरण जो वर्तमान तारीख को हर सेकंड प्रदर्शित करता है। कॉलबैक loop.call_later() 5 सेकंड के बाद स्वयं को फिर से आकार देने के लिए विधि का उपयोग करता है , और फिर इवेंट लूप को रोकता है:

import asyncio
import datetime

def display_date(end_time, loop):
    print(datetime.datetime.now())
    if (loop.time() + 1.0) < end_time:
        loop.call_later(1, display_date, end_time, loop)
    else:
        loop.stop()

loop = asyncio.get_event_loop()

# Schedule the first call to display_date()
end_time = loop.time() + 5.0
loop.call_soon(display_date, end_time, loop)

# Blocking call interrupted by loop.stop()
try:
    loop.run_forever()
finally:
    loop.close()

यह भी देखें

कोरटाइन और फ़ंक्शन के साथ बनाई गई एक समान वर्तमान तिथि उदाहरण asyncio.run()

पढ़ने की घटनाओं के लिए एक फ़ाइल विवरणक देखें

प्रतीक्षा करें जब तक कि किसी फाइल डिस्क्रिप्टर ने loop.add_reader() विधि का उपयोग करके कुछ डेटा प्राप्त नहीं किया और तब इवेंट लूप बंद करें:

import asyncio
from socket import socketpair

# Create a pair of connected file descriptors
rsock, wsock = socketpair()

loop = asyncio.get_event_loop()

def reader():
    data = rsock.recv(100)
    print("Received:", data.decode())

    # We are done: unregister the file descriptor
    loop.remove_reader(rsock)

    # Stop the event loop
    loop.stop()

# Register the file descriptor for read event
loop.add_reader(rsock, reader)

# Simulate the reception of data from the network
loop.call_soon(wsock.send, 'abc'.encode())

try:
    # Run the event loop
    loop.run_forever()
finally:
    # We are done. Close sockets and the event loop.
    rsock.close()
    wsock.close()
    loop.close()

यह भी देखें

  • ट्रांसपोर्ट, प्रोटोकॉल और विधि का उपयोग करके एक समान example loop.create_connection()
  • उच्च-स्तरीय फ़ंक्शन और धाराओं का उपयोग करते हुए एक और समान example open_connection()

SIGINT और SIGTERM के लिए सिग्नल हैंडलर सेट करें

(यह signals उदाहरण केवल यूनिक्स पर काम करता है।)

सिग्नल के लिए रजिस्टर SIGINT और विधि SIGTERM का उपयोग कर loop.add_signal_handler() :

import asyncio
import functools
import os
import signal

def ask_exit(signame):
    print("got signal %s: exit" % signame)
    loop.stop()

async def main():
    loop = asyncio.get_running_loop()

    for signame in {'SIGINT', 'SIGTERM'}:
        loop.add_signal_handler(
            getattr(signal, signame),
            functools.partial(ask_exit, signame))

    await asyncio.sleep(3600)

print("Event loop running for 1 hour, press Ctrl+C to interrupt.")
print(f"pid {os.getpid()}: send SIGINT or SIGTERM to exit.")

asyncio.run(main())

Original text