Python 3.7

Streams




python

Streams

नेटवर्क कनेक्शन के साथ काम करने के लिए स्ट्रीम उच्च-स्तरीय async / प्रतीक्षित-तैयार प्राइमिटिव हैं। धाराएँ कॉलबैक या निम्न-स्तरीय प्रोटोकॉल और ट्रांसपोर्ट का उपयोग किए बिना डेटा भेजने और प्राप्त करने की अनुमति देती हैं।

यहां asyncio धाराओं का उपयोग करते हुए टीसीपी इको क्लाइंट का एक उदाहरण दिया गया है:

import asyncio

async def tcp_echo_client(message):
    reader, writer = await asyncio.open_connection(
        '127.0.0.1', 8888)

    print(f'Send: {message!r}')
    writer.write(message.encode())

    data = await reader.read(100)
    print(f'Received: {data.decode()!r}')

    print('Close the connection')
    writer.close()
    await writer.wait_closed()

asyncio.run(tcp_echo_client('Hello World!'))

नीचे दिए गए Examples अनुभाग भी देखें।

स्ट्रीम कार्य

निम्नलिखित शीर्ष-स्तर के एसिंसीओ कार्यों का उपयोग धाराओं के साथ बनाने और काम करने के लिए किया जा सकता है:

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

नेटवर्क कनेक्शन स्थापित करें और (reader, writer) ऑब्जेक्ट्स की एक जोड़ी लौटाएं।

लौटे पाठक और लेखक वस्तुएं StreamReader और StreamWriter वर्गों के उदाहरण हैं।

लूप तर्क वैकल्पिक होता है और हमेशा यह स्वचालित रूप से निर्धारित किया जा सकता है जब इस फ़ंक्शन को कोरटाइन से प्रतीक्षित किया जाता है।

सीमा रिटर्न StreamReader उदाहरण द्वारा उपयोग किए जाने वाले बफर आकार की सीमा निर्धारित करती है। डिफ़ॉल्ट रूप से सीमा 64 KiB पर सेट है।

बाकी तर्कों को सीधे loop.create_connection() पारित कर दिया जाता है।

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

coroutine asyncio.start_server(client_connected_cb, host=None, port=None, *, loop=None, limit=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)

सॉकेट सर्वर प्रारंभ करें।

जब भी कोई नया क्लाइंट कनेक्शन स्थापित होता है, तो client_connected_cb कॉलबैक कहा जाता है। यह दो तर्क के रूप में एक (reader, writer) जोड़ी प्राप्त करता है, StreamReader और StreamWriter वर्गों के उदाहरण।

client_connected_cb एक सादा कॉल करने योग्य या एक कोरटाइन फ़ंक्शन हो सकता है; यदि यह एक coroutine फ़ंक्शन है, तो यह स्वचालित रूप से Task रूप में अनुसूचित होगा।

लूप तर्क वैकल्पिक है और हमेशा यह स्वचालित रूप से निर्धारित किया जा सकता है जब इस विधि को कोरटाइन से प्रतीक्षित किया जाता है।

सीमा रिटर्न StreamReader उदाहरण द्वारा उपयोग किए जाने वाले बफर आकार की सीमा निर्धारित करती है। डिफ़ॉल्ट रूप से सीमा 64 KiB पर सेट है।

शेष तर्कों को सीधे loop.create_server() पारित कर दिया जाता है।

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

यूनिक्स सॉकेट्स

coroutine asyncio.open_unix_connection(path=None, *, loop=None, limit=None, ssl=None, sock=None, server_hostname=None, ssl_handshake_timeout=None)

यूनिक्स सॉकेट कनेक्शन स्थापित करें और (reader, writer) की एक जोड़ी लौटाएं।

open_connection() समान लेकिन यूनिक्स सॉकेट्स पर काम करता है।

loop.create_unix_connection() का प्रलेखन भी देखें।

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

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

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

coroutine asyncio.start_unix_server(client_connected_cb, path=None, *, loop=None, limit=None, sock=None, backlog=100, ssl=None, ssl_handshake_timeout=None, start_serving=True)

एक यूनिक्स सॉकेट सर्वर शुरू करें।

start_server() समान लेकिन यूनिक्स सॉकेट्स के साथ काम करता है।

loop.create_unix_server() का प्रलेखन भी देखें।

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

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

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

StreamReader

class asyncio.StreamReader

एक रीडर ऑब्जेक्ट का प्रतिनिधित्व करता है जो IO स्ट्रीम से डेटा पढ़ने के लिए API प्रदान करता है।

यह सीधे स्ट्रीमरएडर ऑब्जेक्ट्स को तत्काल करने के लिए अनुशंसित नहीं है; इसके बजाय open_connection() और start_server() उपयोग करें।

coroutine read(n=-1)

N बाइट तक पढ़ें। यदि n प्रदान नहीं किया गया है, या -1 सेट किया गया है, तो EOF तक पढ़ें और सभी पढ़े गए बाइट्स वापस करें

यदि ईओएफ प्राप्त हुआ था और आंतरिक बफर खाली है, तो एक खाली bytes ऑब्जेक्ट वापस करें।

coroutine readline()

एक पंक्ति पढ़ें, जहां "लाइन" बाइट्स का एक क्रम है, जो \n साथ समाप्त होता है।

यदि EOF प्राप्त होता है और \n नहीं मिला, तो विधि आंशिक रूप से डेटा को पढ़ती है।

यदि ईओएफ प्राप्त हुआ है और आंतरिक बफर खाली है, तो एक खाली bytes ऑब्जेक्ट वापस करें।

coroutine readexactly(n)

बिल्कुल n बाइट्स पढ़ें।

यदि EOF को पढ़ा जा सकता है, उससे पहले यदि EOF तक पहुँच जाता है, तो एक IncompleteReadError उठाएँ। आंशिक रूप से पढ़ने के लिए डेटा प्राप्त करने के लिए IncompleteReadError.partial विशेषता का उपयोग करें।

coroutine readuntil(separator=b'\n')

विभाजक मिलने तक स्ट्रीम से डेटा पढ़ें।

सफलता पर, डेटा और विभाजक को आंतरिक बफर (भस्म) से हटा दिया जाएगा। लौटाए गए डेटा में अंत में विभाजक शामिल होगा।

यदि डेटा पढ़ने की मात्रा कॉन्फ़िगर स्ट्रीम सीमा से अधिक है, तो एक LimitOverrunError अपवाद उठाया जाता है, और डेटा को आंतरिक बफर में छोड़ दिया जाता है और फिर से पढ़ा जा सकता है।

यदि पूर्ण विभाजक पाए जाने से पहले ईओएफ पहुंच जाता है, तो एक IncompleteReadError अपवाद उठाया जाता है, और आंतरिक बफर रीसेट हो जाता है। IncompleteReadError.partial विशेषता में विभाजक का एक भाग हो सकता है।

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

at_eof()

यदि बफर खाली है और feed_eof() कहा जाता था, तो True लौटें।

StreamWriter

class asyncio.StreamWriter

एक लेखक ऑब्जेक्ट का प्रतिनिधित्व करता है जो IO स्ट्रीम को डेटा लिखने के लिए API प्रदान करता है।

यह सीधे StreamWriter वस्तुओं को तत्काल करने के लिए अनुशंसित नहीं है; इसके बजाय open_connection() और start_server() उपयोग करें।

can_write_eof()

सही लौटें यदि अंतर्निहित ट्रांसपोर्ट write_eof() विधि का समर्थन करता है, तो गलत अन्यथा।

write_eof()

बफ़र किए गए डेटा को फ़्लश करने के बाद स्ट्रीम का राइट एंड बंद करें।

transport

अंतर्निहित asyncio परिवहन लौटें।

get_extra_info(name, default=None)

वैकल्पिक परिवहन जानकारी; विवरण के लिए BaseTransport.get_extra_info() देखें।

write(data)

डेटा को स्ट्रीम पर लिखें।

यह विधि प्रवाह नियंत्रण के अधीन नहीं है। write() लिए कॉल write() drain() द्वारा पीछा किया जाना चाहिए drain()

writelines(data)

स्ट्रीम को बाइट्स की एक सूची (या कोई पुनरावृत्ति) लिखें।

यह विधि प्रवाह नियंत्रण के अधीन नहीं है। drain() लिए कॉल का पालन किया जाना चाहिए।

coroutine drain()

तब तक प्रतीक्षा करें जब तक कि धारा को लिखना फिर से शुरू करना उचित न हो। उदाहरण:

writer.write(data)
await writer.drain()

यह एक प्रवाह नियंत्रण विधि है जो अंतर्निहित IO लिखने वाले बफर के साथ इंटरैक्ट करती है। जब बफर का आकार उच्च वॉटरमार्क तक पहुंच जाता है, तो नाली () ब्लॉक तक बफर के आकार को कम वॉटरमार्क तक सूखा दिया जाता है और लेखन फिर से शुरू किया जा सकता है। जब प्रतीक्षा करने के लिए कुछ नहीं होता है, तो drain() तुरंत लौट आती है।

close()

धारा बंद करो।

is_closing()

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

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

coroutine wait_closed()

तब तक प्रतीक्षा करें जब तक धारा बंद न हो जाए।

अंतर्निहित कनेक्शन बंद होने तक प्रतीक्षा करने के लिए close() बाद बुलाया जाना चाहिए।

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

उदाहरण

स्ट्रीमों का उपयोग करते हुए टीसीपी इको क्लाइंट

open_connection() फ़ंक्शन का उपयोग करते हुए टीसीपी इको क्लाइंट

import asyncio

async def tcp_echo_client(message):
    reader, writer = await asyncio.open_connection(
        '127.0.0.1', 8888)

    print(f'Send: {message!r}')
    writer.write(message.encode())

    data = await reader.read(100)
    print(f'Received: {data.decode()!r}')

    print('Close the connection')
    writer.close()

asyncio.run(tcp_echo_client('Hello World!'))

यह भी देखें

टीसीपी इको क्लाइंट प्रोटोकॉल उदाहरण निम्न-स्तरीय loop.create_connection() loop.create_connection() विधि का उपयोग करता है।

धाराओं का उपयोग करते हुए टीसीपी इको सर्वर

start_server() फ़ंक्शन का उपयोग करते हुए टीसीपी इको सर्वर:

import asyncio

async def handle_echo(reader, writer):
    data = await reader.read(100)
    message = data.decode()
    addr = writer.get_extra_info('peername')

    print(f"Received {message!r} from {addr!r}")

    print(f"Send: {message!r}")
    writer.write(data)
    await writer.drain()

    print("Close the connection")
    writer.close()

async def main():
    server = await asyncio.start_server(
        handle_echo, '127.0.0.1', 8888)

    addr = server.sockets[0].getsockname()
    print(f'Serving on {addr}')

    async with server:
        await server.serve_forever()

asyncio.run(main())

यह भी देखें

TCP इको सर्वर प्रोटोकॉल उदाहरण loop.create_server() विधि का उपयोग करता है।

HTTP हेडर प्राप्त करें

कमांड लाइन पर पारित URL के HTTP हेडर को क्वेरी करते हुए सरल उदाहरण:

import asyncio
import urllib.parse
import sys

async def print_http_headers(url):
    url = urllib.parse.urlsplit(url)
    if url.scheme == 'https':
        reader, writer = await asyncio.open_connection(
            url.hostname, 443, ssl=True)
    else:
        reader, writer = await asyncio.open_connection(
            url.hostname, 80)

    query = (
        f"HEAD {url.path or '/'} HTTP/1.0\r\n"
        f"Host: {url.hostname}\r\n"
        f"\r\n"
    )

    writer.write(query.encode('latin-1'))
    while True:
        line = await reader.readline()
        if not line:
            break

        line = line.decode('latin1').rstrip()
        if line:
            print(f'HTTP header> {line}')

    # Ignore the body, close the socket
    writer.close()

url = sys.argv[1]
asyncio.run(print_http_headers(url))

उपयोग:

python example.py http://example.com/path/page.html

या HTTPS के साथ:

python example.py https://example.com/path/page.html

धाराओं का उपयोग करके डेटा की प्रतीक्षा करने के लिए एक खुला सॉकेट पंजीकृत करें

Coroutine प्रतीक्षा कर रहा है जब तक कि एक सॉकेट open_connection() फ़ंक्शन का उपयोग करके डेटा प्राप्त नहीं करता है:

import asyncio
import socket

async def wait_for_data():
    # Get a reference to the current event loop because
    # we want to access low-level APIs.
    loop = asyncio.get_running_loop()

    # Create a pair of connected sockets.
    rsock, wsock = socket.socketpair()

    # Register the open socket to wait for data.
    reader, writer = await asyncio.open_connection(sock=rsock)

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

    # Wait for data
    data = await reader.read(100)

    # Got data, we are done: close the socket
    print("Received:", data.decode())
    writer.close()

    # Close the second socket
    wsock.close()

asyncio.run(wait_for_data())

यह भी देखें

एक प्रोटोकॉल उदाहरण का उपयोग करके डेटा के लिए प्रतीक्षा करने के लिए एक खुला सॉकेट रजिस्टर एक निम्न-स्तर प्रोटोकॉल और loop.create_connection() विधि का उपयोग करता है।

पढ़ने की घटनाओं के उदाहरण के लिए फ़ाइल डिस्क्रिप्टर देखने के लिए निम्न स्तर के loop.add_reader() का उपयोग किया जाता है। फ़ाइल विवरणक देखने के लिए विधि loop.add_reader() का उपयोग करता है।