# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Danial Behzadi <dani.behzi@ubuntu.com>, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# Revisto <theRevisto@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
# arman mohebali <armanmohebali@outlook.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-01 04:48+0000\n"
"PO-Revision-Date: 2026-09-14 12:05+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: Persian (https://github.com/python/python-docs-fa/)\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 3.6\n"

msgid "Streams"
msgstr "جریان‌ها"

msgid "**Source code:** :source:`Lib/asyncio/streams.py`"
msgstr "**کد منبع:** :source:`Lib/asyncio/streams.py`"

msgid "Streams are high-level async/await-ready primitives to work with network connections.  Streams allow sending and receiving data without using callbacks or low-level protocols and transports."
msgstr "جریان‌ها اولیه‌های سطح بالای آماده برای ناهمگام و await هستند که برای کار با اتصال‌های شبکه‌ای به کار می‌روند. جریان‌ها امکان ارسال و دریافت داده را بدون استفاده از کال‌بک‌ها یا پروتکل‌ها و انتقال‌های سطح پایین فراهم می‌کنند."

msgid "Here is an example of a TCP echo client written using asyncio streams::"
msgstr "در اینجا مثالی از یک کلاینت اکوی TCP نوشته‌شده با استفاده از جریان‌های asyncio آمده است::"

msgid ""
"import asyncio\n"
"\n"
"async def tcp_echo_client(message):\n"
"    reader, writer = await asyncio.open_connection(\n"
"        '127.0.0.1', 8888)\n"
"\n"
"    print(f'Send: {message!r}')\n"
"    writer.write(message.encode())\n"
"    await writer.drain()\n"
"\n"
"    data = await reader.read(100)\n"
"    print(f'Received: {data.decode()!r}')\n"
"\n"
"    print('Close the connection')\n"
"    writer.close()\n"
"    await writer.wait_closed()\n"
"\n"
"asyncio.run(tcp_echo_client('Hello World!'))"
msgstr ""
"import asyncio\n"
"\n"
"async def tcp_echo_client(message):\n"
"    reader, writer = await asyncio.open_connection(\n"
"        '127.0.0.1', 8888)\n"
"\n"
"    print(f'Send: {message!r}')\n"
"    writer.write(message.encode())\n"
"    await writer.drain()\n"
"\n"
"    data = await reader.read(100)\n"
"    print(f'Received: {data.decode()!r}')\n"
"\n"
"    print('Close the connection')\n"
"    writer.close()\n"
"    await writer.wait_closed()\n"
"\n"
"asyncio.run(tcp_echo_client('Hello World!'))"

msgid "See also the `Examples`_ section below."
msgstr "همچنین بخش `Examples`_ را در زیر ببینید."

msgid "Stream Functions"
msgstr "توابع جریان"

msgid "The following top-level asyncio functions can be used to create and work with streams:"
msgstr "می‌توان از توابع سطح‌بالای asyncio زیر برای ایجاد و کار با جریان‌ها استفاده کرد:"

msgid "Establish a network connection and return a pair of ``(reader, writer)`` objects."
msgstr "اتصال شبکه‌ای برقرار می‌کند و یک جفت شیء ``(reader, writer)`` را برمی‌گرداند."

msgid "The returned *reader* and *writer* objects are instances of :class:`StreamReader` and :class:`StreamWriter` classes."
msgstr "اشیای *reader* و *writer* برگردانده‌شده، نمونه‌هایی از کلاس‌های :class:`StreamReader` و :class:`StreamWriter` هستند."

msgid "*limit* determines the buffer size limit used by the returned :class:`StreamReader` instance.  By default the *limit* is set to 64 KiB."
msgstr "*limit* محدودیت اندازه‌ی بافر مورد استفاده‌ی نمونه‌ی :class:`StreamReader` برگردانده‌شده را تعیین می‌کند. به‌طور پیش‌فرض، *limit* روی ۶۴ KiB تنظیم شده است."

msgid "The rest of the arguments are passed directly to :meth:`loop.create_connection`."
msgstr "بقیه‌ی آرگومان‌ها مستقیماً به :meth:`loop.create_connection` ارسال می‌شوند."

msgid "The *sock* argument transfers ownership of the socket to the :class:`StreamWriter` created. To close the socket, call its :meth:`~asyncio.StreamWriter.close` method."
msgstr "آرگومان *sock* مالکیت سوکت را به :class:`StreamWriter` ایجادشده منتقل می‌کند. برای بستن سوکت، متد :meth:`~asyncio.StreamWriter.close` آن را فراخوانی کنید."

msgid "Added the *ssl_handshake_timeout* parameter."
msgstr "پارامتر *ssl_handshake_timeout* افزوده شد."

msgid "Added the *happy_eyeballs_delay* and *interleave* parameters."
msgstr "پارامترهای *happy_eyeballs_delay* و *interleave* افزوده شدند."

msgid "Removed the *loop* parameter."
msgstr "پارامتر *loop* حذف شد."

msgid "Added the *ssl_shutdown_timeout* parameter."
msgstr "پارامتر *ssl_shutdown_timeout* افزوده شد."

msgid "Start a socket server."
msgstr "یک سرور سوکت راه‌اندازی کنید."

msgid "The *client_connected_cb* callback is called whenever a new client connection is established.  It receives a ``(reader, writer)`` pair as two arguments, instances of the :class:`StreamReader` and :class:`StreamWriter` classes."
msgstr "کال‌بک *client_connected_cb* هر زمان که یک اتصال کلاینت جدید برقرار شود، فراخوانی می‌شود. این کال‌بک یک جفت ``(reader, writer)`` را به‌عنوان دو آرگومان دریافت می‌کند که نمونه‌هایی از کلاس‌های :class:`StreamReader` و :class:`StreamWriter` هستند."

msgid "*client_connected_cb* can be a plain callable or a :ref:`coroutine function <coroutine>`; if it is a coroutine function, it will be automatically scheduled as a :class:`Task`."
msgstr "*client_connected_cb* می‌تواند یک فراخوانی‌پذیر ساده یا یک :ref:`تابع هم‌روال <coroutine>` باشد؛ اگر تابع هم‌روال باشد، به‌طور خودکار به‌عنوان یک :class:`Task` زمان‌بندی می‌شود."

msgid "The rest of the arguments are passed directly to :meth:`loop.create_server`."
msgstr "بقیه‌ی آرگومان‌ها مستقیماً به :meth:`loop.create_server` ارسال می‌شوند."

msgid "The *sock* argument transfers ownership of the socket to the server created. To close the socket, call the server's :meth:`~asyncio.Server.close` method."
msgstr "آرگومان *sock* مالکیت سوکت را به سرور ایجادشده منتقل می‌کند. برای بستن سوکت، متد :meth:`~asyncio.Server.close` سرور را فراخوانی کنید."

msgid "Added the *ssl_handshake_timeout* and *start_serving* parameters."
msgstr "پارامترهای *ssl_handshake_timeout* و *start_serving* اضافه شدند."

msgid "Added the *keep_alive* parameter."
msgstr "پارامتر *keep_alive* اضافه شد."

msgid "Unix Sockets"
msgstr "سوکت‌های یونیکس"

msgid "Establish a Unix socket connection and return a pair of ``(reader, writer)``."
msgstr "اتصال سوکت یونیکس را برقرار می‌کند و یک جفت ``(reader, writer)`` را برمی‌گرداند."

msgid "Similar to :func:`open_connection` but operates on Unix sockets."
msgstr "مشابه :func:`open_connection` است، اما روی سوکت‌های یونیکس عمل می‌کند."

msgid "See also the documentation of :meth:`loop.create_unix_connection`."
msgstr "همچنین مستندات :meth:`loop.create_unix_connection` را ببینید."

msgid "Availability"
msgstr "دسترس‌پذیری"

msgid "Added the *ssl_handshake_timeout* parameter. The *path* parameter can now be a :term:`path-like object`"
msgstr "پارامتر *ssl_handshake_timeout* افزوده شد. پارامتر *path* اکنون می‌تواند یک :term:`path-like object` باشد"

msgid "Start a Unix socket server."
msgstr "یک سرور سوکت یونیکس را راه‌اندازی کنید."

msgid "Similar to :func:`start_server` but works with Unix sockets."
msgstr "مشابه :func:`start_server` است، اما با سوکت‌های یونیکس کار می‌کند."

msgid "If *cleanup_socket* is true then the Unix socket will automatically be removed from the filesystem when the server is closed, unless the socket has been replaced after the server has been created."
msgstr "اگر *cleanup_socket* درست باشد، سوکت یونیکس به‌طور خودکار هنگام بسته شدن سرور از سامانه فایل‌بندی حذف می‌شود، مگر اینکه سوکت پس از ایجاد سرور جایگزین شده باشد."

msgid "See also the documentation of :meth:`loop.create_unix_server`."
msgstr "همچنین مستندات :meth:`loop.create_unix_server` را ببینید."

msgid "Added the *ssl_handshake_timeout* and *start_serving* parameters. The *path* parameter can now be a :term:`path-like object`."
msgstr "پارامترهای *ssl_handshake_timeout* و *start_serving* افزوده شدند. پارامتر *path* اکنون می‌تواند یک :term:`path-like object` باشد."

msgid "Added the *cleanup_socket* parameter."
msgstr "پارامتر *cleanup_socket* اضافه شد."

msgid "StreamReader"
msgstr "StreamReader"

msgid "Represents a reader object that provides APIs to read data from the IO stream. As an :term:`asynchronous iterable`, the object supports the :keyword:`async for` statement."
msgstr "نشان‌دهنده‌ی یک شیء خواننده است که APIهایی برای خواندن داده از جریان ورودی/خروجی فراهم می‌کند. به‌عنوان یک :term:`پیمایش‌پذیر ناهمگام <asynchronous iterable>`، این شیء از دستور :keyword:`async for` پشتیبانی می‌کند."

msgid "It is not recommended to instantiate *StreamReader* objects directly; use :func:`open_connection` and :func:`start_server` instead."
msgstr "توصیه نمی‌شود اشیای *StreamReader* را مستقیماً نمونه‌سازی کنید؛ به‌جای آن از :func:`open_connection` و :func:`start_server` استفاده کنید."

msgid "Acknowledge the EOF."
msgstr "پایان پرونده را تأیید کنید."

msgid "Read up to *n* bytes from the stream."
msgstr "تا *n* بایت از جریان را بخوانید."

msgid "If *n* is not provided or set to ``-1``, read until EOF, then return all read :class:`bytes`. If EOF was received and the internal buffer is empty, return an empty ``bytes`` object."
msgstr "اگر *n* ارائه‌نشده باشد یا روی ``-1`` تنظیم شده باشد، تا EOF می‌خواند، سپس تمام :class:`bytes` خوانده‌شده را برمی‌گرداند. اگر EOF دریافت شده باشد و بافر داخلی خالی باشد، یک شیء ``bytes`` خالی برمی‌گرداند."

msgid "If *n* is ``0``, return an empty ``bytes`` object immediately."
msgstr "اگر *n* برابر ``0`` باشد، بلافاصله یک شیء ``bytes`` خالی برمی‌گرداند."

msgid "If *n* is positive, return at most *n* available ``bytes`` as soon as at least 1 byte is available in the internal buffer. If EOF is received before any byte is read, return an empty ``bytes`` object."
msgstr "اگر *n* مثبت باشد، به محض اینکه حداقل ۱ بایت در بافر داخلی در دسترس باشد، حداکثر *n* بایت در دسترس را به‌صورت ``bytes`` برمی‌گرداند. اگر EOF پیش از خوانده‌شدن هیچ بایتی دریافت شود، یک شیء ``bytes`` خالی برمی‌گرداند."

msgid "Read one line, where \"line\" is a sequence of bytes ending with ``\\n``."
msgstr "یک خط را بخوانید، که در آن «سطر» دنباله‌ای از بایت‌ها است که با ``\\n`` پایان می‌یابد."

msgid "If EOF is received and ``\\n`` was not found, the method returns partially read data."
msgstr "اگر EOF دریافت شود و ``\\n`` یافت نشود، متد داده‌های خوانده‌شده‌ی ناقص را برمی‌گرداند."

msgid "If EOF is received and the internal buffer is empty, return an empty ``bytes`` object."
msgstr "در صورتی که EOF دریافت شود و بافر داخلی خالی باشد، یک شیء ``bytes`` خالی برمی‌گرداند."

msgid "Read exactly *n* bytes."
msgstr "دقیقاً *n* بایت را بخوانید."

msgid "Raise an :exc:`IncompleteReadError` if EOF is reached before *n* can be read.  Use the :attr:`IncompleteReadError.partial` attribute to get the partially read data."
msgstr "اگر پیش از خواندن *n* به EOF برسید، یک :exc:`IncompleteReadError` پرتاب می‌شود. برای دریافت داده‌هایی که به‌طور ناقص خوانده شده‌اند، از ویژگی :attr:`IncompleteReadError.partial` استفاده کنید."

msgid "Read data from the stream until *separator* is found."
msgstr "داده‌ها را از جریان می‌خواند تا *separator* یافت شود."

msgid "On success, the data and separator will be removed from the internal buffer (consumed). Returned data will include the separator at the end."
msgstr "در صورت موفقیت، داده و جداکننده از بافر داخلی حذف می‌شوند (مصرف می‌شوند). داده‌ی برگردانده‌شده شامل جداکننده در انتها خواهد بود."

msgid "If the amount of data read exceeds the configured stream limit, a :exc:`LimitOverrunError` exception is raised, and the data is left in the internal buffer and can be read again."
msgstr "اگر مقدار داده‌ی خوانده‌شده از محدودیت پیکربندی‌شده‌ی جریان بیشتر شود، استثنای :exc:`LimitOverrunError` پرتاب می‌شود و داده در بافر درونی باقی می‌ماند و می‌تواند دوباره خوانده شود."

msgid "If EOF is reached before the complete separator is found, an :exc:`IncompleteReadError` exception is raised, and the internal buffer is reset.  The :attr:`IncompleteReadError.partial` attribute may contain a portion of the separator."
msgstr "اگر پیش از پیدا شدن جداکننده‌ی کامل، به EOF رسیده شود، استثنای :exc:`IncompleteReadError` پرتاب می‌شود و بافر داخلی بازنشانی می‌شود. ویژگی :attr:`IncompleteReadError.partial` ممکن است شامل بخشی از جداکننده باشد."

msgid "The *separator* may also be a tuple of separators. In this case the return value will be the shortest possible that has any separator as the suffix. For the purposes of :exc:`LimitOverrunError`, the shortest possible separator is considered to be the one that matched."
msgstr "*separator* همچنین می‌تواند یک تاپل از جداسازها باشد. در این حالت، مقدار بازگشتی کوتاه‌ترین مقدار ممکن خواهد بود که یکی از جداسازها را به‌عنوان پسوند داشته باشد. از نظر :exc:`LimitOverrunError`، کوتاه‌ترین جداساز ممکن به‌عنوان جداسازی در نظر گرفته می‌شود که مطابقت داشته است."

msgid "The *separator* parameter may now be a :class:`tuple` of separators."
msgstr "اکنون پارامتر *separator* می‌تواند یک :class:`tuple` از جداکننده‌ها باشد."

msgid "Return ``True`` if the buffer is empty and :meth:`feed_eof` was called."
msgstr "اگر بافر خالی باشد و :meth:`feed_eof` فراخوانی شده باشد، ``True`` را برمی‌گرداند."

msgid "StreamWriter"
msgstr "StreamWriter"

msgid "Represents a writer object that provides APIs to write data to the IO stream."
msgstr "نشان‌دهنده‌ی یک شیء نویسنده است که APIهایی را برای نوشتن داده‌ها در جریان IO فراهم می‌کند."

msgid "It is not recommended to instantiate *StreamWriter* objects directly; use :func:`open_connection` and :func:`start_server` instead."
msgstr "نمونه‌سازی مستقیم اشیای *StreamWriter* توصیه نمی‌شود؛ در عوض از :func:`open_connection` و :func:`start_server` استفاده کنید."

msgid "The method attempts to write the *data* to the underlying socket immediately. If that fails, the data is queued in an internal write buffer until it can be sent."
msgstr "این متد تلاش می‌کند *data* را بلافاصله در سوکت زیرین بنویسد. اگر این کار با شکست مواجه شود، داده در یک بافر نوشتن داخلی در صف قرار می‌گیرد تا زمانی که بتوان آن را ارسال کرد."

msgid "The *data* buffer should be a bytes, bytearray, or C-contiguous one-dimensional memoryview object."
msgstr "بافر *data* باید یک شیء bytes، bytearray یا memoryview یک‌بعدی با چیدمان پیوسته در C (C-contiguous) باشد."

msgid "The method should be used along with the ``drain()`` method::"
msgstr "این متد باید همراه با متد ``drain()`` استفاده شود::"

msgid ""
"stream.write(data)\n"
"await stream.drain()"
msgstr ""
"stream.write(data)\n"
"await stream.drain()"

msgid "The method writes a list (or any iterable) of bytes to the underlying socket immediately. If that fails, the data is queued in an internal write buffer until it can be sent."
msgstr "این متد بلافاصله یک فهرست (یا هر پیمایش‌پذیری) از بایت‌ها را در سوکت زیرین می‌نویسد. اگر این کار با شکست مواجه شود، داده در یک بافر نوشتن داخلی در صف قرار می‌گیرد تا بتواند ارسال شود."

msgid ""
"stream.writelines(lines)\n"
"await stream.drain()"
msgstr ""
"stream.writelines(lines)\n"
"await stream.drain()"

msgid "The method closes the stream and the underlying socket."
msgstr "این متد جریان و سوکت زیربنایی را می‌بندد."

msgid "The method should be used, though not mandatory, along with the ``wait_closed()`` method::"
msgstr "این متد بهتر است، هرچند اجباری نیست، همراه با متد ``wait_closed()`` استفاده شود::"

msgid ""
"stream.close()\n"
"await stream.wait_closed()"
msgstr ""
"stream.close()\n"
"await stream.wait_closed()"

msgid "Return ``True`` if the underlying transport supports the :meth:`write_eof` method, ``False`` otherwise."
msgstr "اگر انتقال زیربنایی از متد :meth:`write_eof` پشتیبانی کند، ``True`` را برمی‌گرداند، در غیر این صورت ``False`` را برمی‌گرداند."

msgid "Close the write end of the stream after the buffered write data is flushed."
msgstr "پس از تخلیه‌شدن داده‌های نوشتاری بافرشده، پایانه نوشتاری جریان را ببندید."

msgid "Return the underlying asyncio transport."
msgstr "انتقال زیربنایی asyncio را برمی‌گرداند."

msgid "Access optional transport information; see :meth:`BaseTransport.get_extra_info` for details."
msgstr "به اطلاعات اختیاری انتقال دسترسی پیدا کنید؛ برای جزئیات، :meth:`BaseTransport.get_extra_info` را ببینید."

msgid "Wait until it is appropriate to resume writing to the stream. Example::"
msgstr "صبر کنید تا زمان مناسب برای ازسرگیری نوشتن در جریان برسد. مثال::"

msgid ""
"writer.write(data)\n"
"await writer.drain()"
msgstr ""
"writer.write(data)\n"
"await writer.drain()"

msgid "This is a flow control method that interacts with the underlying IO write buffer.  When the size of the buffer reaches the high watermark, *drain()* blocks until the size of the buffer is drained down to the low watermark and writing can be resumed.  When there is nothing to wait for, the :meth:`drain` returns immediately."
msgstr "این یک متد کنترل جریان است که با بافر نوشتاری زیربنایی IO تعامل دارد. هنگامی که اندازه‌ی بافر به آستانه‌ی بالا (high watermark) برسد، *drain()* مسدود می‌شود تا زمانی که بافر تخلیه شود و اندازه‌ی آن به آستانه‌ی پایین (low watermark) برسد و بتوان نوشتن را از سر گرفت. هنگامی که چیزی برای انتظار وجود نداشته باشد، :meth:`drain` بلافاصله بازمی‌گردد."

msgid "When the write buffer is below the high watermark, :meth:`drain` returns immediately without yielding to the event loop.  As a result, code which repeatedly calls ``write()`` followed by ``await drain()`` may prevent other tasks from running.  To prevent blocking behavior, yield to the event loop explicitly with ``await asyncio.sleep(0)`` (see :func:`asyncio.sleep`)."
msgstr "هنگامی که بافر نوشتن کمتر از آستانه بالا باشد، :meth:`drain` بلافاصله و بدون واگذاری کنترل به حلقه رویداد بازمی‌گردد. در نتیجه، کدی که به‌طور مکرر ``write()`` و سپس ``await drain()`` را فراخوانی می‌کند، ممکن است مانع اجرای سایر taskها شود. برای جلوگیری از رفتار مسدودکننده، به‌صراحت با ``await asyncio.sleep(0)`` کنترل را به حلقه رویداد واگذار کنید (به :func:`asyncio.sleep` مراجعه کنید)."

msgid "Upgrade an existing stream-based connection to TLS."
msgstr "ارتقای یک اتصال مبتنی بر جریان موجود به TLS."

msgid "Parameters:"
msgstr "پارامترها:"

msgid "*sslcontext*: a configured instance of :class:`~ssl.SSLContext`."
msgstr "*sslcontext*: یک نمونه‌ی پیکربندی‌شده از :class:`~ssl.SSLContext`."

msgid "*server_hostname*: sets or overrides the host name that the target server's certificate will be matched against."
msgstr "*server_hostname*: نام میزبانی را که گواهی‌ی سرور هدف با آن مطابقت داده خواهد شد، تنظیم یا بازنویسی می‌کند."

msgid "*ssl_handshake_timeout* is the time in seconds to wait for the TLS handshake to complete before aborting the connection.  ``60.0`` seconds if ``None`` (default)."
msgstr "*ssl_handshake_timeout* مدت زمان انتظار به ثانیه برای تکمیل دست‌دهی TLS پیش از قطع اتصال است. اگر ``None`` باشد، ``60.0`` ثانیه (پیش‌فرض)."

msgid "*ssl_shutdown_timeout* is the time in seconds to wait for the SSL shutdown to complete before aborting the connection. ``30.0`` seconds if ``None`` (default)."
msgstr "*ssl_shutdown_timeout* زمان بر حسب ثانیه است که باید برای تکمیل خاموش‌سازی SSL پیش از قطع اتصال منتظر بمانید. اگر ``None`` باشد، ``30.0`` ثانیه است (پیش‌فرض)."

msgid "Raises a ``ValueError`` if ``sslcontext.check_hostname`` is ``True`` and ``server_hostname`` is not supplied."
msgstr "اگر ``sslcontext.check_hostname`` برابر با ``True`` باشد و ``server_hostname`` فراهم نشده باشد، یک ``ValueError`` بالا می‌آورد."

msgid "Return ``True`` if the stream is closed or in the process of being closed."
msgstr "اگر جریان بسته باشد یا در حال بسته شدن باشد، ``True`` را برمی‌گرداند."

msgid "Wait until the stream is closed."
msgstr "صبر کنید تا جریان بسته شود."

msgid "Should be called after :meth:`close` to wait until the underlying connection is closed, ensuring that all data has been flushed before e.g. exiting the program."
msgstr "باید پس از :meth:`close` فراخوانی شود تا منتظر بماند تا اتصال زیربنایی بسته شود، و اطمینان حاصل شود که تمام داده‌ها پیش از اقداماتی مانند خروج از برنامه تخلیه شده‌اند."

msgid "Examples"
msgstr "مثال‌ها"

msgid "TCP echo client using streams"
msgstr "کلاینت اکوی TCP با استفاده از استریم‌ها"

msgid "TCP echo client using the :func:`asyncio.open_connection` function::"
msgstr "کلاینت اکوی TCP با استفاده از تابع :func:`asyncio.open_connection`::"

msgid "The :ref:`TCP echo client protocol <asyncio_example_tcp_echo_client_protocol>` example uses the low-level :meth:`loop.create_connection` method."
msgstr "مثال :ref:`پروتکل کلاینت اکو TCP <asyncio_example_tcp_echo_client_protocol>` از متد سطح پایین :meth:`loop.create_connection` استفاده می‌کند."

msgid "TCP echo server using streams"
msgstr "سرور اکوی TCP با استفاده از جریان‌ها"

msgid "TCP echo server using the :func:`asyncio.start_server` function::"
msgstr "سرور اکو TCP با استفاده از تابع :func:`asyncio.start_server`::"

msgid ""
"import asyncio\n"
"\n"
"async def handle_echo(reader, writer):\n"
"    data = await reader.read(100)\n"
"    message = data.decode()\n"
"    addr = writer.get_extra_info('peername')\n"
"\n"
"    print(f\"Received {message!r} from {addr!r}\")\n"
"\n"
"    print(f\"Send: {message!r}\")\n"
"    writer.write(data)\n"
"    await writer.drain()\n"
"\n"
"    print(\"Close the connection\")\n"
"    writer.close()\n"
"    await writer.wait_closed()\n"
"\n"
"async def main():\n"
"    server = await asyncio.start_server(\n"
"        handle_echo, '127.0.0.1', 8888)\n"
"\n"
"    addrs = ', '.join(str(sock.getsockname()) for sock in server.sockets)\n"
"    print(f'Serving on {addrs}')\n"
"\n"
"    async with server:\n"
"        await server.serve_forever()\n"
"\n"
"asyncio.run(main())"
msgstr ""
"import asyncio\n"
"\n"
"async def handle_echo(reader, writer):\n"
"    data = await reader.read(100)\n"
"    message = data.decode()\n"
"    addr = writer.get_extra_info('peername')\n"
"\n"
"    print(f\"Received {message!r} from {addr!r}\")\n"
"\n"
"    print(f\"Send: {message!r}\")\n"
"    writer.write(data)\n"
"    await writer.drain()\n"
"\n"
"    print(\"Close the connection\")\n"
"    writer.close()\n"
"    await writer.wait_closed()\n"
"\n"
"async def main():\n"
"    server = await asyncio.start_server(\n"
"        handle_echo, '127.0.0.1', 8888)\n"
"\n"
"    addrs = ', '.join(str(sock.getsockname()) for sock in server.sockets)\n"
"    print(f'Serving on {addrs}')\n"
"\n"
"    async with server:\n"
"        await server.serve_forever()\n"
"\n"
"asyncio.run(main())"

msgid "The :ref:`TCP echo server protocol <asyncio_example_tcp_echo_server_protocol>` example uses the :meth:`loop.create_server` method."
msgstr "مثال :ref:`پروتکل سرور اکوی TCP <asyncio_example_tcp_echo_server_protocol>` از متد :meth:`loop.create_server` استفاده می‌کند."

msgid "Get HTTP headers"
msgstr "دریافت سرآیندهای HTTP"

msgid "Simple example querying HTTP headers of the URL passed on the command line::"
msgstr "مثال ساده‌ای برای پرس‌وجوی سرآیندهای HTTP مربوط به URL داده‌شده در خط فرمان::"

msgid ""
"import asyncio\n"
"import urllib.parse\n"
"import sys\n"
"\n"
"async def print_http_headers(url):\n"
"    url = urllib.parse.urlsplit(url)\n"
"    if url.scheme == 'https':\n"
"        reader, writer = await asyncio.open_connection(\n"
"            url.hostname, 443, ssl=True)\n"
"    else:\n"
"        reader, writer = await asyncio.open_connection(\n"
"            url.hostname, 80)\n"
"\n"
"    query = (\n"
"        f\"HEAD {url.path or '/'} HTTP/1.0\\r\\n\"\n"
"        f\"Host: {url.hostname}\\r\\n\"\n"
"        f\"\\r\\n\"\n"
"    )\n"
"\n"
"    writer.write(query.encode('latin-1'))\n"
"    while True:\n"
"        line = await reader.readline()\n"
"        if not line:\n"
"            break\n"
"\n"
"        line = line.decode('latin1').rstrip()\n"
"        if line:\n"
"            print(f'HTTP header> {line}')\n"
"\n"
"    # Ignore the body, close the socket\n"
"    writer.close()\n"
"    await writer.wait_closed()\n"
"\n"
"url = sys.argv[1]\n"
"asyncio.run(print_http_headers(url))"
msgstr ""
"import asyncio\n"
"import urllib.parse\n"
"import sys\n"
"\n"
"async def print_http_headers(url):\n"
"    url = urllib.parse.urlsplit(url)\n"
"    if url.scheme == 'https':\n"
"        reader, writer = await asyncio.open_connection(\n"
"            url.hostname, 443, ssl=True)\n"
"    else:\n"
"        reader, writer = await asyncio.open_connection(\n"
"            url.hostname, 80)\n"
"\n"
"    query = (\n"
"        f\"HEAD {url.path or '/'} HTTP/1.0\\r\\n\"\n"
"        f\"Host: {url.hostname}\\r\\n\"\n"
"        f\"\\r\\n\"\n"
"    )\n"
"\n"
"    writer.write(query.encode('latin-1'))\n"
"    while True:\n"
"        line = await reader.readline()\n"
"        if not line:\n"
"            break\n"
"\n"
"        line = line.decode('latin1').rstrip()\n"
"        if line:\n"
"            print(f'HTTP header> {line}')\n"
"\n"
"    # Ignore the body, close the socket\n"
"    writer.close()\n"
"    await writer.wait_closed()\n"
"\n"
"url = sys.argv[1]\n"
"asyncio.run(print_http_headers(url))"

msgid "Usage::"
msgstr "استفاده::"

msgid "python example.py http://example.com/path/page.html"
msgstr "python example.py http://example.com/path/page.html"

msgid "or with HTTPS::"
msgstr "یا با HTTPS::"

msgid "python example.py https://example.com/path/page.html"
msgstr "python example.py https://example.com/path/page.html"

msgid "Register an open socket to wait for data using streams"
msgstr "ثبت یک سوکت باز برای انتظار داده با استفاده از جریان‌ها"

msgid "Coroutine waiting until a socket receives data using the :func:`open_connection` function::"
msgstr "هم‌روالی که با استفاده از تابع :func:`open_connection` منتظر می‌ماند تا یک سوکت داده دریافت کند::"

msgid ""
"import asyncio\n"
"import socket\n"
"\n"
"async def wait_for_data():\n"
"    # Get a reference to the current event loop because\n"
"    # we want to access low-level APIs.\n"
"    loop = asyncio.get_running_loop()\n"
"\n"
"    # Create a pair of connected sockets.\n"
"    rsock, wsock = socket.socketpair()\n"
"\n"
"    # Register the open socket to wait for data.\n"
"    reader, writer = await asyncio.open_connection(sock=rsock)\n"
"\n"
"    # Simulate the reception of data from the network\n"
"    loop.call_soon(wsock.send, 'abc'.encode())\n"
"\n"
"    # Wait for data\n"
"    data = await reader.read(100)\n"
"\n"
"    # Got data, we are done: close the socket\n"
"    print(\"Received:\", data.decode())\n"
"    writer.close()\n"
"    await writer.wait_closed()\n"
"\n"
"    # Close the second socket\n"
"    wsock.close()\n"
"\n"
"asyncio.run(wait_for_data())"
msgstr ""
"import asyncio\n"
"import socket\n"
"\n"
"async def wait_for_data():\n"
"    # Get a reference to the current event loop because\n"
"    # we want to access low-level APIs.\n"
"    loop = asyncio.get_running_loop()\n"
"\n"
"    # Create a pair of connected sockets.\n"
"    rsock, wsock = socket.socketpair()\n"
"\n"
"    # Register the open socket to wait for data.\n"
"    reader, writer = await asyncio.open_connection(sock=rsock)\n"
"\n"
"    # Simulate the reception of data from the network\n"
"    loop.call_soon(wsock.send, 'abc'.encode())\n"
"\n"
"    # Wait for data\n"
"    data = await reader.read(100)\n"
"\n"
"    # Got data, we are done: close the socket\n"
"    print(\"Received:\", data.decode())\n"
"    writer.close()\n"
"    await writer.wait_closed()\n"
"\n"
"    # Close the second socket\n"
"    wsock.close()\n"
"\n"
"asyncio.run(wait_for_data())"

msgid "The :ref:`register an open socket to wait for data using a protocol <asyncio_example_create_connection>` example uses a low-level protocol and the :meth:`loop.create_connection` method."
msgstr "مثال :ref:`ثبت یک سوکت باز برای انتظار داده با استفاده از یک پروتکل <asyncio_example_create_connection>` از یک پروتکل سطح پایین و متد :meth:`loop.create_connection` استفاده می‌کند."

msgid "The :ref:`watch a file descriptor for read events <asyncio_example_watch_fd>` example uses the low-level :meth:`loop.add_reader` method to watch a file descriptor."
msgstr "مثال :ref:`پایش یک توصیف‌گر پرونده برای رویدادهای خواندن <asyncio_example_watch_fd>` از متد سطح پایین :meth:`loop.add_reader` برای پایش یک توصیف‌گر پرونده استفاده می‌کند."