Repository navigation
Expand file tree
/
Copy pathasyncio-stream.po
More file actions
650 lines (549 loc) · 24.9 KB
/
Copy pathasyncio-stream.po
File metadata and controls
650 lines (549 loc) · 24.9 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Dmytro Kazanzhy, 2024
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-04-25 14:19+0000\n"
"PO-Revision-Date: 2021-06-28 00:55+0000\n"
"Last-Translator: Dmytro Kazanzhy, 2024\n"
"Language-Team: Ukrainian (https://app.transifex.com/python-doc/teams/5390/"
"uk/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: uk\n"
"Plural-Forms: nplurals=4; plural=(n % 1 == 0 && n % 10 == 1 && n % 100 != "
"11 ? 0 : n % 1 == 0 && n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 12 || n % "
"100 > 14) ? 1 : n % 1 == 0 && (n % 10 ==0 || (n % 10 >=5 && n % 10 <=9) || "
"(n % 100 >=11 && n % 100 <=14 )) ? 2: 3);\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 ""
"Потоки — це високорівневі асинхронні/готові до очікування примітиви для "
"роботи з мережевими підключеннями. Потоки дозволяють надсилати й отримувати "
"дані без використання зворотних викликів або низькорівневих протоколів і "
"транспортів."
msgid "Here is an example of a TCP echo client written using asyncio streams::"
msgstr ""
"Ось приклад клієнта відлуння TCP, написаного з використанням асинхронних "
"потоків::"
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 ""
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 ""
"Наступні асинхронні функції верхнього рівня можна використовувати для "
"створення та роботи з потоками:"
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`. За замовчуванням *обмеження* встановлено "
"на 64 КБ."
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 ""
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 ""
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 ""
msgid "Added the *ssl_handshake_timeout* and *start_serving* parameters."
msgstr "Додано параметри *ssl_handshake_timeout* і *start_serving*."
msgid "Added the *keep_alive* parameter."
msgstr ""
msgid "Unix Sockets"
msgstr "Unix-сокети"
msgid ""
"Establish a Unix socket connection and return a pair of ``(reader, writer)``."
msgstr ""
"Встановіть з’єднання через сокет Unix і поверніть пару ``(reader, writer)``."
msgid "Similar to :func:`open_connection` but operates on Unix sockets."
msgstr "Подібно до :func:`open_connection`, але працює на сокетах Unix."
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 "Запустіть сокет-сервер Unix."
msgid "Similar to :func:`start_server` but works with Unix sockets."
msgstr "Подібно до :func:`start_server`, але працює з сокетами Unix."
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 "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 ""
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 ""
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 ""
msgid "If *n* is ``0``, return an empty ``bytes`` object immediately."
msgstr ""
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 ""
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 ""
"Викликати :exc:`IncompleteReadError`, якщо EOF досягнуто до того, як *n* "
"можна буде прочитати. Використовуйте атрибут :attr:`IncompleteReadError."
"partial`, щоб отримати частково прочитані дані."
msgid "Read data from the stream until *separator* is found."
msgstr "Читати дані з потоку, доки не буде знайдено *роздільник*."
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 ""
msgid "The *separator* parameter may now be a :class:`tuple` of separators."
msgstr ""
msgid "Return ``True`` if the buffer is empty and :meth:`feed_eof` was called."
msgstr ""
"Повертає ``True``, якщо буфер порожній і було викликано :meth:`feed_eof`."
msgid "StreamWriter"
msgstr "StreamWriter"
msgid ""
"Represents a writer object that provides APIs to write data to the IO stream."
msgstr ""
"Представляє об’єкт запису, який надає API для запису даних у потік вводу-"
"виводу."
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 ""
"Метод намагається негайно записати *дані* в основний сокет. Якщо це не "
"вдається, дані ставляться в чергу у внутрішній буфер запису, доки їх не буде "
"надіслано."
msgid "The method should be used along with the ``drain()`` method::"
msgstr "Цей метод слід використовувати разом із методом ``drain()``:"
msgid ""
"stream.write(data)\n"
"await stream.drain()"
msgstr ""
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 ""
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 ""
msgid ""
"stream.close()\n"
"await stream.wait_closed()"
msgstr ""
msgid ""
"Return ``True`` if the underlying transport supports the :meth:`write_eof` "
"method, ``False`` otherwise."
msgstr ""
"Повертає ``True``, якщо основний транспорт підтримує метод :meth:"
"`write_eof`, ``False`` інакше."
msgid ""
"Close the write end of the stream after the buffered write data is flushed."
msgstr ""
"Закрийте кінець запису потоку після очищення буферизованих даних запису."
msgid "Return the underlying asyncio transport."
msgstr "Повернути базовий асинхронний транспорт."
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 ""
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 ""
"Це метод керування потоком, який взаємодіє з базовим буфером запису вводу-"
"виводу. Коли розмір буфера досягає верхнього водяного знака, *drain()* "
"блокує, доки розмір буфера не зменшиться до низького водяного знака, і запис "
"можна буде відновити. Коли нема чого чекати, :meth:`drain` повертається "
"негайно."
msgid "Upgrade an existing stream-based connection to TLS."
msgstr ""
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 ""
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 ""
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 ""
msgid "Examples"
msgstr "Приклади"
msgid "TCP echo client using streams"
msgstr "TCP echo client використовує потоки"
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 echo client protocol "
"<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 ""
msgid ""
"The :ref:`TCP echo server protocol "
"<asyncio_example_tcp_echo_server_protocol>` example uses the :meth:`loop."
"create_server` method."
msgstr ""
"У прикладі :ref:`TCP echo server protocol "
"<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 ""
msgid "Usage::"
msgstr "Використання::"
msgid "python example.py http://example.com/path/page.html"
msgstr ""
msgid "or with HTTPS::"
msgstr "або з HTTPS::"
msgid "python example.py https://example.com/path/page.html"
msgstr ""
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 ""
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` для спостереження за файловим дескриптором."