Update translation from Transifex

Amended not to change the statistics, they were broken because of migration

Author: GitHub Action's update-translation job

library/__future__.po

@@ -5,15 +5,16 @@
 #
 # Translators:
 # Maciej Olko <maciej.olko@gmail.com>, 2023
+# Transifex Bot <>, 2023
 #
 #, fuzzy
 msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.11\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2023-05-12 14:12+0000\n"
+"POT-Creation-Date: 2023-05-19 14:13+0000\n"
 "PO-Revision-Date: 2021-06-28 00:54+0000\n"
-"Last-Translator: Maciej Olko <maciej.olko@gmail.com>, 2023\n"
+"Last-Translator: Transifex Bot <>, 2023\n"
 "Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"

library/__main__.po

@@ -0,0 +1,317 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2001-2023, Python Software Foundation
+# This file is distributed under the same license as the Python package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+# Translators:
+# Transifex Bot <>, 2023
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: Python 3.11\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2023-05-19 14:13+0000\n"
+"PO-Revision-Date: 2021-06-28 00:54+0000\n"
+"Last-Translator: Transifex Bot <>, 2023\n"
+"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: pl\n"
+"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "
+"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "
+"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"
+
+msgid ":mod:`__main__` --- Top-level code environment"
+msgstr ""
+
+msgid ""
+"In Python, the special name ``__main__`` is used for two important "
+"constructs:"
+msgstr ""
+
+msgid ""
+"the name of the top-level environment of the program, which can be checked "
+"using the ``__name__ == '__main__'`` expression; and"
+msgstr ""
+
+msgid "the ``__main__.py`` file in Python packages."
+msgstr ""
+
+msgid ""
+"Both of these mechanisms are related to Python modules; how users interact "
+"with them and how they interact with each other.  They are explained in "
+"detail below.  If you're new to Python modules, see the tutorial section :"
+"ref:`tut-modules` for an introduction."
+msgstr ""
+
+msgid "``__name__ == '__main__'``"
+msgstr ""
+
+msgid ""
+"When a Python module or package is imported, ``__name__`` is set to the "
+"module's name.  Usually, this is the name of the Python file itself without "
+"the ``.py`` extension::"
+msgstr ""
+
+msgid ""
+"If the file is part of a package, ``__name__`` will also include the parent "
+"package's path::"
+msgstr ""
+
+msgid ""
+"However, if the module is executed in the top-level code environment, its "
+"``__name__`` is set to the string ``'__main__'``."
+msgstr ""
+
+msgid "What is the \"top-level code environment\"?"
+msgstr ""
+
+msgid ""
+"``__main__`` is the name of the environment where top-level code is run. "
+"\"Top-level code\" is the first user-specified Python module that starts "
+"running. It's \"top-level\" because it imports all other modules that the "
+"program needs. Sometimes \"top-level code\" is called an *entry point* to "
+"the application."
+msgstr ""
+
+msgid "The top-level code environment can be:"
+msgstr ""
+
+msgid "the scope of an interactive prompt::"
+msgstr ""
+
+msgid "the Python module passed to the Python interpreter as a file argument:"
+msgstr ""
+
+msgid ""
+"the Python module or package passed to the Python interpreter with the :"
+"option:`-m` argument:"
+msgstr ""
+
+msgid "Python code read by the Python interpreter from standard input:"
+msgstr ""
+
+msgid ""
+"Python code passed to the Python interpreter with the :option:`-c` argument:"
+msgstr ""
+
+msgid ""
+"In each of these situations, the top-level module's ``__name__`` is set to "
+"``'__main__'``."
+msgstr ""
+
+msgid ""
+"As a result, a module can discover whether or not it is running in the top-"
+"level environment by checking its own ``__name__``, which allows a common "
+"idiom for conditionally executing code when the module is not initialized "
+"from an import statement::"
+msgstr ""
+
+msgid ""
+"For a more detailed look at how ``__name__`` is set in all situations, see "
+"the tutorial section :ref:`tut-modules`."
+msgstr ""
+
+msgid "Idiomatic Usage"
+msgstr ""
+
+msgid ""
+"Some modules contain code that is intended for script use only, like parsing "
+"command-line arguments or fetching data from standard input.  If a module "
+"like this was imported from a different module, for example to unit test it, "
+"the script code would unintentionally execute as well."
+msgstr ""
+
+msgid ""
+"This is where using the ``if __name__ == '__main__'`` code block comes in "
+"handy. Code within this block won't run unless the module is executed in the "
+"top-level environment."
+msgstr ""
+
+msgid ""
+"Putting as few statements as possible in the block below ``if __name__ == "
+"'__main__'`` can improve code clarity and correctness. Most often, a "
+"function named ``main`` encapsulates the program's primary behavior::"
+msgstr ""
+
+msgid ""
+"Note that if the module didn't encapsulate code inside the ``main`` function "
+"but instead put it directly within the ``if __name__ == '__main__'`` block, "
+"the ``phrase`` variable would be global to the entire module.  This is error-"
+"prone as other functions within the module could be unintentionally using "
+"the global variable instead of a local name.  A ``main`` function solves "
+"this problem."
+msgstr ""
+
+msgid ""
+"Using a ``main`` function has the added benefit of the ``echo`` function "
+"itself being isolated and importable elsewhere. When ``echo.py`` is "
+"imported, the ``echo`` and ``main`` functions will be defined, but neither "
+"of them will be called, because ``__name__ != '__main__'``."
+msgstr ""
+
+msgid "Packaging Considerations"
+msgstr ""
+
+msgid ""
+"``main`` functions are often used to create command-line tools by specifying "
+"them as entry points for console scripts.  When this is done, `pip <https://"
+"pip.pypa.io/>`_ inserts the function call into a template script, where the "
+"return value of ``main`` is passed into :func:`sys.exit`. For example::"
+msgstr ""
+
+msgid ""
+"Since the call to ``main`` is wrapped in :func:`sys.exit`, the expectation "
+"is that your function will return some value acceptable as an input to :func:"
+"`sys.exit`; typically, an integer or ``None`` (which is implicitly returned "
+"if your function does not have a return statement)."
+msgstr ""
+
+msgid ""
+"By proactively following this convention ourselves, our module will have the "
+"same behavior when run directly (i.e. ``python3 echo.py``) as it will have "
+"if we later package it as a console script entry-point in a pip-installable "
+"package."
+msgstr ""
+
+msgid ""
+"In particular, be careful about returning strings from your ``main`` "
+"function. :func:`sys.exit` will interpret a string argument as a failure "
+"message, so your program will have an exit code of ``1``, indicating "
+"failure, and the string will be written to :data:`sys.stderr`.  The ``echo."
+"py`` example from earlier exemplifies using the ``sys.exit(main())`` "
+"convention."
+msgstr ""
+
+msgid ""
+"`Python Packaging User Guide <https://packaging.python.org/>`_ contains a "
+"collection of tutorials and references on how to distribute and install "
+"Python packages with modern tools."
+msgstr ""
+
+msgid "``__main__.py`` in Python Packages"
+msgstr ""
+
+msgid ""
+"If you are not familiar with Python packages, see section :ref:`tut-"
+"packages` of the tutorial.  Most commonly, the ``__main__.py`` file is used "
+"to provide a command-line interface for a package. Consider the following "
+"hypothetical package, \"bandclass\":"
+msgstr ""
+
+msgid ""
+"``__main__.py`` will be executed when the package itself is invoked directly "
+"from the command line using the :option:`-m` flag. For example:"
+msgstr ""
+
+msgid ""
+"This command will cause ``__main__.py`` to run. How you utilize this "
+"mechanism will depend on the nature of the package you are writing, but in "
+"this hypothetical case, it might make sense to allow the teacher to search "
+"for students::"
+msgstr ""
+
+msgid ""
+"Note that ``from .student import search_students`` is an example of a "
+"relative import.  This import style can be used when referencing modules "
+"within a package.  For more details, see :ref:`intra-package-references` in "
+"the :ref:`tut-modules` section of the tutorial."
+msgstr ""
+
+msgid ""
+"The contents of ``__main__.py`` typically isn't fenced with ``if __name__ == "
+"'__main__'`` blocks.  Instead, those files are kept short, functions to "
+"execute from other modules.  Those other modules can then be easily unit-"
+"tested and are properly reusable."
+msgstr ""
+
+msgid ""
+"If used, an ``if __name__ == '__main__'`` block will still work as expected "
+"for a ``__main__.py`` file within a package, because its ``__name__`` "
+"attribute will include the package's path if imported::"
+msgstr ""
+
+msgid ""
+"This won't work for ``__main__.py`` files in the root directory of a .zip "
+"file though.  Hence, for consistency, minimal ``__main__.py`` like the :mod:"
+"`venv` one mentioned below are preferred."
+msgstr ""
+
+msgid ""
+"See :mod:`venv` for an example of a package with a minimal ``__main__.py`` "
+"in the standard library. It doesn't contain a ``if __name__ == '__main__'`` "
+"block. You can invoke it with ``python -m venv [directory]``."
+msgstr ""
+
+msgid ""
+"See :mod:`runpy` for more details on the :option:`-m` flag to the "
+"interpreter executable."
+msgstr ""
+
+msgid ""
+"See :mod:`zipapp` for how to run applications packaged as *.zip* files. In "
+"this case Python looks for a ``__main__.py`` file in the root directory of "
+"the archive."
+msgstr ""
+
+msgid "``import __main__``"
+msgstr ""
+
+msgid ""
+"Regardless of which module a Python program was started with, other modules "
+"running within that same program can import the top-level environment's "
+"scope (:term:`namespace`) by importing the ``__main__`` module.  This "
+"doesn't import a ``__main__.py`` file but rather whichever module that "
+"received the special name ``'__main__'``."
+msgstr ""
+
+msgid "Here is an example module that consumes the ``__main__`` namespace::"
+msgstr ""
+
+msgid "Example usage of this module could be as follows::"
+msgstr ""
+
+msgid "Now, if we started our program, the result would look like this:"
+msgstr ""
+
+msgid ""
+"The exit code of the program would be 1, indicating an error. Uncommenting "
+"the line with ``my_name = \"Dinsdale\"`` fixes the program and now it exits "
+"with status code 0, indicating success:"
+msgstr ""
+
+msgid ""
+"Note that importing ``__main__`` doesn't cause any issues with "
+"unintentionally running top-level code meant for script use which is put in "
+"the ``if __name__ == \"__main__\"`` block of the ``start`` module. Why does "
+"this work?"
+msgstr ""
+
+msgid ""
+"Python inserts an empty ``__main__`` module in :attr:`sys.modules` at "
+"interpreter startup, and populates it by running top-level code. In our "
+"example this is the ``start`` module which runs line by line and imports "
+"``namely``. In turn, ``namely`` imports ``__main__`` (which is really "
+"``start``). That's an import cycle! Fortunately, since the partially "
+"populated ``__main__`` module is present in :attr:`sys.modules`, Python "
+"passes that to ``namely``. See :ref:`Special considerations for __main__ "
+"<import-dunder-main>` in the import system's reference for details on how "
+"this works."
+msgstr ""
+
+msgid ""
+"The Python REPL is another example of a \"top-level environment\", so "
+"anything defined in the REPL becomes part of the ``__main__`` scope::"
+msgstr ""
+
+msgid ""
+"Note that in this case the ``__main__`` scope doesn't contain a ``__file__`` "
+"attribute as it's interactive."
+msgstr ""
+
+msgid ""
+"The ``__main__`` scope is used in the implementation of :mod:`pdb` and :mod:"
+"`rlcompleter`."
+msgstr ""