88msgstr ""
99"Project-Id-Version : Python 3.14\n "
1010"Report-Msgid-Bugs-To : \n "
11- "POT-Creation-Date : 2025-10-05 14:11 +0000\n "
11+ "POT-Creation-Date : 2025-10-15 14:16 +0000\n "
1212"PO-Revision-Date : 2025-09-16 00:00+0000\n "
1313"Language-Team : Indonesian (https://app.transifex.com/python-doc/teams/5390/ "
1414"id/)\n "
@@ -28,15 +28,15 @@ msgid ""
2828msgstr ""
2929
3030msgid ""
31- "You might be curious about some key :mod:`!asyncio` concepts. You'll be "
32- "comfortably able to answer these questions by the end of this article :"
31+ "You might be curious about some key :mod:`!asyncio` concepts. By the end of "
32+ "this article, you'll be able to comfortably answer these questions:"
3333msgstr ""
3434
3535msgid "What's happening behind the scenes when an object is awaited?"
3636msgstr ""
3737
3838msgid ""
39- "How does :mod:`!asyncio` differentiate between a task which doesn't need CPU- "
39+ "How does :mod:`!asyncio` differentiate between a task which doesn't need CPU "
4040"time (such as a network request or file read) as opposed to a task that does "
4141"(such as computing n-factorial)?"
4242msgstr ""
@@ -68,7 +68,7 @@ msgstr ""
6868
6969msgid ""
7070"In part 1, we'll cover the main, high-level building blocks of :mod:`!"
71- "asyncio`: the event loop, coroutine functions, coroutine objects, tasks and "
71+ "asyncio`: the event loop, coroutine functions, coroutine objects, tasks, and "
7272"``await``."
7373msgstr ""
7474
@@ -92,7 +92,7 @@ msgid ""
9292"event loop will then select another job from its pool and invoke it. You can "
9393"*roughly* think of the collection of jobs as a queue: jobs are added and "
9494"then processed one at a time, generally (but not always) in order. This "
95- "process repeats indefinitely with the event loop cycling endlessly onwards. "
95+ "process repeats indefinitely, with the event loop cycling endlessly onwards. "
9696"If there are no more jobs pending execution, the event loop is smart enough "
9797"to rest and avoid needlessly wasting CPU cycles, and will come back when "
9898"there's more work to be done."
@@ -357,7 +357,7 @@ msgstr ""
357357msgid ""
358358"Generally speaking, when the awaited task finishes (``dig_the_hole_task``), "
359359"the original task or coroutine (``plant_a_tree()``) is added back to the "
360- "event loops to-do list to be resumed."
360+ "event loop's to-do list to be resumed."
361361msgstr ""
362362
363363msgid ""
@@ -395,7 +395,7 @@ msgstr ""
395395msgid ""
396396"The first statement in the coroutine ``main()`` creates ``task_b`` and "
397397"schedules it for execution via the event loop. Then, ``coro_a()`` is "
398- "repeatedly awaited. Control never cedes to the event loop which is why we "
398+ "repeatedly awaited. Control never cedes to the event loop, which is why we "
399399"see the output of all three ``coro_a()`` invocations before ``coro_b()``'s "
400400"output:"
401401msgstr ""
@@ -426,18 +426,18 @@ msgid ""
426426"This behavior of ``await coroutine`` can trip a lot of people up! That "
427427"example highlights how using only ``await coroutine`` could unintentionally "
428428"hog control from other tasks and effectively stall the event loop. :func:"
429- "`asyncio.run` can help you detect such occurences via the ``debug=True`` "
430- "flag which accordingly enables :ref:`debug mode <asyncio-debug-mode>`. Among "
431- "other things, it will log any coroutines that monopolize execution for 100ms "
432- "or longer."
429+ "`asyncio.run` can help you detect such occurrences via the ``debug=True`` "
430+ "flag, which enables :ref:`debug mode <asyncio-debug-mode>`. Among other "
431+ "things, it will log any coroutines that monopolize execution for 100ms or "
432+ "longer."
433433msgstr ""
434434
435435msgid ""
436436"The design intentionally trades off some conceptual clarity around usage of "
437437"``await`` for improved performance. Each time a task is awaited, control "
438438"needs to be passed all the way up the call stack to the event loop. That "
439- "might sound minor, but in a large program with many ``await``'s and a deep "
440- "callstack that overhead can add up to a meaningful performance drag."
439+ "might sound minor, but in a large program with many ``await`` statements and "
440+ "a deep call stack, that overhead can add up to a meaningful performance drag."
441441msgstr ""
442442
443443msgid "A conceptual overview part 2: the nuts and bolts"
@@ -461,7 +461,7 @@ msgid ""
461461"resume a coroutine. If the coroutine was paused and is now being resumed, "
462462"the argument ``arg`` will be sent in as the return value of the ``yield`` "
463463"statement which originally paused it. If the coroutine is being used for the "
464- "first time (as opposed to being resumed) ``arg`` must be ``None``."
464+ "first time (as opposed to being resumed), ``arg`` must be ``None``."
465465msgstr ""
466466
467467msgid ""
@@ -493,12 +493,12 @@ msgid ""
493493msgstr ""
494494
495495msgid ""
496- ":ref:`yield <yieldexpr>`, like usual, pauses execution and returns control "
497- "to the caller. In the example above, the ``yield``, on line 3, is called by "
496+ ":ref:`yield <yieldexpr>`, as usual, pauses execution and returns control to "
497+ "the caller. In the example above, the ``yield``, on line 3, is called by "
498498"``... = await rock`` on line 11. More broadly speaking, ``await`` calls the :"
499499"meth:`~object.__await__` method of the given object. ``await`` also does one "
500500"more very special thing: it propagates (or \" passes along\" ) any ``yield``\\ "
501- "s it receives up the call- chain. In this case, that's back to ``... = "
501+ "s it receives up the call chain. In this case, that's back to ``... = "
502502"coroutine.send(None)`` on line 16."
503503msgstr ""
504504
@@ -562,12 +562,12 @@ msgid ""
562562msgstr ""
563563
564564msgid ""
565- "A future has a few important attributes. One is its state which can be "
566- "either \" pending\" , \" cancelled\" or \" done\" . Another is its result, which "
565+ "A future has a few important attributes. One is its state, which can be "
566+ "either \" pending\" , \" cancelled\" , or \" done\" . Another is its result, which "
567567"is set when the state transitions to done. Unlike a coroutine, a future does "
568568"not represent the actual computation to be done; instead, it represents the "
569569"status and result of that computation, kind of like a status light (red, "
570- "yellow or green) or indicator."
570+ "yellow, or green) or indicator."
571571msgstr ""
572572
573573msgid ""
@@ -594,10 +594,10 @@ msgid ""
594594msgstr ""
595595
596596msgid ""
597- "This snippet registers a few tasks with the event loop and then awaits a "
598- "coroutine wrapped in a task: ``async_sleep(3)``. We want that task to finish "
599- "only after three seconds have elapsed, but without preventing other tasks "
600- "from running."
597+ "This snippet registers a few tasks with the event loop and then awaits the "
598+ "task created by ``asyncio.create_task``, which wraps the ``async_sleep(3)`` "
599+ "coroutine. We want that task to finish only after three seconds have "
600+ "elapsed, but without preventing other tasks from running."
601601msgstr ""
602602
603603msgid ""
@@ -646,8 +646,8 @@ msgid ""
646646msgstr ""
647647
648648msgid ""
649- "Below, we'll use a rather bare object, ``YieldToEventLoop()``, to ``yield`` "
650- "from ``__await__`` in order to cede control to the event loop. This is "
649+ "Below, we use a rather bare ``YieldToEventLoop()`` object to ``yield`` from "
650+ "its ``__await__`` method, ceding control to the event loop. This is "
651651"effectively the same as calling ``asyncio.sleep(0)``, but this approach "
652652"offers more clarity, not to mention it's somewhat cheating to use ``asyncio."
653653"sleep`` when showcasing how to implement it!"
@@ -659,12 +659,12 @@ msgid ""
659659"which runs the coroutine ``_sleep_watcher(...)``, will be invoked once per "
660660"full cycle of the event loop. On each resumption, it'll check the time and "
661661"if not enough has elapsed, then it'll pause once again and hand control back "
662- "to the event loop. Eventually, enough time will have elapsed, and "
663- "``_sleep_watcher(...)`` will mark the future as done, and then itself finish "
664- "too by breaking out of the infinite ``while`` loop. Given this helper task "
665- "is only invoked once per cycle of the event loop, you'd be correct to note "
666- "that this asynchronous sleep will sleep *at least* three seconds, rather "
667- "than exactly three seconds. Note this is also of true of ``asyncio.sleep``."
662+ "to the event loop. Once enough time has elapsed, ``_sleep_watcher(...)`` "
663+ "marks the future as done and completes by exiting its infinite ``while`` "
664+ "loop. Given this helper task is only invoked once per cycle of the event "
665+ "loop, you'd be correct to note that this asynchronous sleep will sleep *at "
666+ "least* three seconds, rather than exactly three seconds. Note this is also "
667+ "true of ``asyncio.sleep``."
668668msgstr ""
669669
670670msgid ""
@@ -713,7 +713,7 @@ msgid ""
713713msgstr ""
714714
715715msgid ""
716- "But, that's all for now. Hopefully you're ready to more confidently dive "
717- "into some async programming or check out advanced topics in the :mod:`rest "
718- "of the documentation <asyncio>`."
716+ "But that's all for now. Hopefully you're ready to more confidently dive into "
717+ "some async programming or check out advanced topics in the :mod:`rest of the "
718+ "documentation <asyncio>`."
719719msgstr ""
0 commit comments