# 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, 2022

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.13\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-04-18 14:18+0000\n"

"PO-Revision-Date: 2021-06-28 00:57+0000\n"

"Last-Translator: Dmytro Kazanzhy, 2022\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 ":mod:`!configparser` --- Configuration file parser"

msgstr ""

msgid "**Source code:** :source:`Lib/configparser.py`"

msgstr "**Вихідний код:** :source:`Lib/configparser.py`"

msgid ""

"This module provides the :class:`ConfigParser` class which implements a "

"basic configuration language which provides a structure similar to what's "

"found in Microsoft Windows INI files. You can use this to write Python "

"programs which can be customized by end users easily."

msgstr ""

"Цей модуль надає клас :class:`ConfigParser`, який реалізує базову мову "

"конфігурації, яка забезпечує структуру, подібну до тієї, що міститься у "

"файлах Microsoft Windows INI. Ви можете використовувати це для написання "

"програм на Python, які можуть бути легко налаштовані кінцевими користувачами."

msgid ""

"This library does *not* interpret or write the value-type prefixes used in "

"the Windows Registry extended version of INI syntax."

msgstr ""

"Ця бібліотека *не* інтерпретує та не записує префікси типу значень, які "

"використовуються в розширеній версії синтаксису INI реєстру Windows."

msgid "Module :mod:`tomllib`"

msgstr ""

msgid ""

"TOML is a well-specified format for application configuration files. It is "

"specifically designed to be an improved version of INI."

msgstr ""

msgid "Module :mod:`shlex`"

msgstr "Модуль :mod:`shlex`"

msgid ""

"Support for creating Unix shell-like mini-languages which can also be used "

"for application configuration files."

msgstr ""

msgid "Module :mod:`json`"

msgstr "Модуль :mod:`json`"

msgid ""

"The ``json`` module implements a subset of JavaScript syntax which is "

"sometimes used for configuration, but does not support comments."

msgstr ""

msgid "Quick Start"

msgstr "Швидкий початок"

msgid "Let's take a very basic configuration file that looks like this:"

msgstr "Давайте візьмемо простий файл конфігурації, який виглядає так:"

msgid ""

"[DEFAULT]\n"

"ServerAliveInterval = 45\n"

"Compression = yes\n"

"CompressionLevel = 9\n"

"ForwardX11 = yes\n"

"\n"

"[forge.example]\n"

"User = hg\n"

"\n"

"[topsecret.server.example]\n"

"Port = 50022\n"

"ForwardX11 = no"

msgstr ""

msgid ""

"The structure of INI files is described `in the following section "

"<#supported-ini-file-structure>`_. Essentially, the file consists of "

"sections, each of which contains keys with values. :mod:`configparser` "

"classes can read and write such files. Let's start by creating the above "

"configuration file programmatically."

msgstr ""

"Структура файлів INI описана `в наступному розділі <#supported-ini-file-"

"structure>`_. По суті, файл складається з розділів, кожен з яких містить "

"ключі зі значеннями. :mod:`configparser` класи можуть читати та записувати "

"такі файли. Почнемо зі створення наведеного вище файлу конфігурації "

"програмним шляхом."

msgid ""

">>> import configparser\n"

">>> config = configparser.ConfigParser()\n"

">>> config['DEFAULT'] = {'ServerAliveInterval': '45',\n"

"... 'Compression': 'yes',\n"

"... 'CompressionLevel': '9'}\n"

">>> config['forge.example'] = {}\n"

">>> config['forge.example']['User'] = 'hg'\n"

">>> config['topsecret.server.example'] = {}\n"

">>> topsecret = config['topsecret.server.example']\n"

">>> topsecret['Port'] = '50022' # mutates the parser\n"

">>> topsecret['ForwardX11'] = 'no' # same here\n"

">>> config['DEFAULT']['ForwardX11'] = 'yes'\n"

">>> with open('example.ini', 'w') as configfile:\n"

"... config.write(configfile)\n"

"..."

msgstr ""

msgid ""

"As you can see, we can treat a config parser much like a dictionary. There "

"are differences, `outlined later <#mapping-protocol-access>`_, but the "

"behavior is very close to what you would expect from a dictionary."

msgstr ""

"Як бачите, ми можемо розглядати аналізатор конфігурації так само, як "

"словник. Є відмінності, `викладені пізніше <#mapping-protocol-access>`_, але "

"поведінка дуже близька до того, що ви очікуєте від словника."

msgid ""

"Now that we have created and saved a configuration file, let's read it back "

"and explore the data it holds."

msgstr ""

"Тепер, коли ми створили та зберегли файл конфігурації, давайте перечитаємо "

"його та дослідимо дані, які він містить."

msgid ""

">>> config = configparser.ConfigParser()\n"

">>> config.sections()\n"

"[]\n"

">>> config.read('example.ini')\n"

"['example.ini']\n"

">>> config.sections()\n"

"['forge.example', 'topsecret.server.example']\n"

">>> 'forge.example' in config\n"

"True\n"

">>> 'python.org' in config\n"

"False\n"

">>> config['forge.example']['User']\n"

"'hg'\n"

">>> config['DEFAULT']['Compression']\n"

"'yes'\n"

">>> topsecret = config['topsecret.server.example']\n"

">>> topsecret['ForwardX11']\n"

"'no'\n"

">>> topsecret['Port']\n"

"'50022'\n"

">>> for key in config['forge.example']:\n"

"... print(key)\n"

"user\n"

"compressionlevel\n"

"serveraliveinterval\n"

"compression\n"

"forwardx11\n"

">>> config['forge.example']['ForwardX11']\n"

"'yes'"

msgstr ""

msgid ""

"As we can see above, the API is pretty straightforward. The only bit of "

"magic involves the ``DEFAULT`` section which provides default values for all "

"other sections [1]_. Note also that keys in sections are case-insensitive "

"and stored in lowercase [1]_."

msgstr ""

"Як ми бачимо вище, API досить простий. Єдина магія стосується розділу "

"``DEFAULT``, який надає значення за умовчанням для всіх інших розділів [1]_. "

"Зауважте також, що ключі в розділах нечутливі до регістру та зберігаються в "

"нижньому регістрі [1]_."

msgid ""

"It is possible to read several configurations into a single :class:"

"`ConfigParser`, where the most recently added configuration has the highest "

"priority. Any conflicting keys are taken from the more recent configuration "

"while the previously existing keys are retained. The example below reads in "

"an ``override.ini`` file, which will override any conflicting keys from the "

"``example.ini`` file."

msgstr ""

msgid ""

"[DEFAULT]\n"

"ServerAliveInterval = -1"

msgstr ""

msgid ""

">>> config_override = configparser.ConfigParser()\n"

">>> config_override['DEFAULT'] = {'ServerAliveInterval': '-1'}\n"

">>> with open('override.ini', 'w') as configfile:\n"

"... config_override.write(configfile)\n"

"...\n"

">>> config_override = configparser.ConfigParser()\n"

">>> config_override.read(['example.ini', 'override.ini'])\n"

"['example.ini', 'override.ini']\n"

">>> print(config_override.get('DEFAULT', 'ServerAliveInterval'))\n"

"-1"

msgstr ""

msgid ""

"This behaviour is equivalent to a :meth:`ConfigParser.read` call with "

"several files passed to the *filenames* parameter."

msgstr ""

"Така поведінка еквівалентна виклику :meth:`ConfigParser.read` з кількома "

"файлами, переданими в параметр *filenames*."

msgid "Supported Datatypes"

msgstr "Підтримувані типи даних"

msgid ""

"Config parsers do not guess datatypes of values in configuration files, "

"always storing them internally as strings. This means that if you need "

"other datatypes, you should convert on your own:"

msgstr ""

"Синтаксичні аналізатори конфігурації не вгадують типи даних значень у файлах "

"конфігурації, завжди зберігаючи їх усередині як рядки. Це означає, що якщо "

"вам потрібні інші типи даних, ви повинні конвертувати самостійно:"

msgid ""

">>> int(topsecret['Port'])\n"

"50022\n"

">>> float(topsecret['CompressionLevel'])\n"

"9.0"

msgstr ""

msgid ""

"Since this task is so common, config parsers provide a range of handy getter "

"methods to handle integers, floats and booleans. The last one is the most "

"interesting because simply passing the value to ``bool()`` would do no good "

"since ``bool('False')`` is still ``True``. This is why config parsers also "

"provide :meth:`~ConfigParser.getboolean`. This method is case-insensitive "

"and recognizes Boolean values from ``'yes'``/``'no'``, ``'on'``/``'off'``, "

"``'true'``/``'false'`` and ``'1'``/``'0'`` [1]_. For example:"

msgstr ""

"Оскільки це завдання дуже поширене, аналізатори конфігурації надають ряд "

"зручних методів отримання для обробки цілих чисел, чисел з плаваючою точкою "

"та логічних значень. Останнє є найцікавішим, тому що проста передача "

"значення в ``bool()`` не принесе користі, оскільки ``bool('False')`` все ще "

"``True``. Ось чому аналізатори конфігурації також надають :meth:"

"`~ConfigParser.getboolean`. Цей метод не враховує регістр і розпізнає "

"логічні значення з ``'yes'``/``'no'``, ``'on'``/``'off'``, ``'true'`` /"

"``'false'`` і ``'1'``/``'0'`` [1]_. Наприклад:"

msgid ""

">>> topsecret.getboolean('ForwardX11')\n"

"False\n"

">>> config['forge.example'].getboolean('ForwardX11')\n"

"True\n"

">>> config.getboolean('forge.example', 'Compression')\n"

"True"

msgstr ""

msgid ""

"Apart from :meth:`~ConfigParser.getboolean`, config parsers also provide "

"equivalent :meth:`~ConfigParser.getint` and :meth:`~ConfigParser.getfloat` "

"methods. You can register your own converters and customize the provided "

"ones. [1]_"

msgstr ""

"Крім :meth:`~ConfigParser.getboolean`, аналізатори конфігурації також "

"надають еквівалентні методи :meth:`~ConfigParser.getint` і :meth:"

"`~ConfigParser.getfloat`. Ви можете зареєструвати власні конвертери та "

"налаштувати надані. [1]_"

msgid "Fallback Values"

msgstr "Запасні значення"

msgid ""

"As with a dictionary, you can use a section's :meth:`~ConfigParser.get` "

"method to provide fallback values:"

msgstr ""

msgid ""

">>> topsecret.get('Port')\n"

"'50022'\n"

">>> topsecret.get('CompressionLevel')\n"

"'9'\n"

">>> topsecret.get('Cipher')\n"

">>> topsecret.get('Cipher', '3des-cbc')\n"

"'3des-cbc'"

msgstr ""

msgid ""

"Please note that default values have precedence over fallback values. For "

"instance, in our example the ``'CompressionLevel'`` key was specified only "

"in the ``'DEFAULT'`` section. If we try to get it from the section "

"``'topsecret.server.example'``, we will always get the default, even if we "

"specify a fallback:"

msgstr ""

msgid ""

">>> topsecret.get('CompressionLevel', '3')\n"

"'9'"

msgstr ""

msgid ""

"One more thing to be aware of is that the parser-level :meth:`~ConfigParser."

"get` method provides a custom, more complex interface, maintained for "

"backwards compatibility. When using this method, a fallback value can be "

"provided via the ``fallback`` keyword-only argument:"

msgstr ""

msgid ""

">>> config.get('forge.example', 'monster',\n"

"... fallback='No such things as monsters')\n"

"'No such things as monsters'"

msgstr ""

msgid ""

"The same ``fallback`` argument can be used with the :meth:`~ConfigParser."

"getint`, :meth:`~ConfigParser.getfloat` and :meth:`~ConfigParser.getboolean` "

"methods, for example:"

msgstr ""

"Той самий резервний аргумент можна використовувати з методами :meth:"

"`~ConfigParser.getint`, :meth:`~ConfigParser.getfloat` і :meth:"

"`~ConfigParser.getboolean`, наприклад:"

msgid ""

">>> 'BatchMode' in topsecret\n"

"False\n"

">>> topsecret.getboolean('BatchMode', fallback=True)\n"

"True\n"

">>> config['DEFAULT']['BatchMode'] = 'no'\n"

">>> topsecret.getboolean('BatchMode', fallback=True)\n"

"False"

msgstr ""

msgid "Supported INI File Structure"

msgstr "Підтримувана структура файлу INI"

msgid ""

"A configuration file consists of sections, each led by a ``[section]`` "

"header, followed by key/value entries separated by a specific string (``=`` "

"or ``:`` by default [1]_). By default, section names are case sensitive but "

"keys are not [1]_. Leading and trailing whitespace is removed from keys and "

"values. Values can be omitted if the parser is configured to allow it [1]_, "

"in which case the key/value delimiter may also be left out. Values can also "

"span multiple lines, as long as they are indented deeper than the first line "

"of the value. Depending on the parser's mode, blank lines may be treated as "

"parts of multiline values or ignored."

msgstr ""

"Файл конфігурації складається з розділів, кожен із яких очолюється "

"заголовком ``[section]``, за яким ідуть записи ключ/значення, розділені "

"певним рядком (``=`` або ``:`` за умовчанням [1]_) . За замовчуванням назви "

"розділів чутливі до регістру, але ключі не [1]_. Пробіли на початку та в "

"кінці видаляються з ключів і значень. Значення можна опустити, якщо "

"синтаксичний аналізатор налаштовано на це дозволено [1]_, у цьому випадку "

"роздільник ключ/значення також може бути пропущений. Значення також можуть "

"охоплювати кілька рядків, якщо вони мають відступ глибший, ніж перший рядок "

"значення. Залежно від режиму аналізатора, порожні рядки можуть розглядатися "

"як частини багаторядкових значень або ігноруватися."

msgid ""

"By default, a valid section name can be any string that does not contain '\\"

"\\n'. To change this, see :attr:`ConfigParser.SECTCRE`."

msgstr ""

msgid ""

"The first section name may be omitted if the parser is configured to allow "

"an unnamed top level section with ``allow_unnamed_section=True``. In this "

"case, the keys/values may be retrieved by :const:`UNNAMED_SECTION` as in "

"``config[UNNAMED_SECTION]``."

msgstr ""

msgid ""

"Configuration files may include comments, prefixed by specific characters "

"(``#`` and ``;`` by default [1]_). Comments may appear on their own on an "

"otherwise empty line, possibly indented. [1]_"

msgstr ""

"Файли конфігурації можуть містити коментарі, перед якими стоять певні "

"символи (``#`` і ``;`` за замовчуванням [1]_). Коментарі можуть з’явитися "

"самостійно в порожньому рядку, можливо, з відступом. [1]_"

msgid "For example:"

msgstr "Наприклад:"

msgid ""

"[Simple Values]\n"

"key=value\n"

"spaces in keys=allowed\n"

"spaces in values=allowed as well\n"

"spaces around the delimiter = obviously\n"

"you can also use : to delimit keys from values\n"

"\n"

"[All Values Are Strings]\n"

"values like this: 1000000\n"

"or this: 3.14159265359\n"

"are they treated as numbers? : no\n"

"integers, floats and booleans are held as: strings\n"

"can use the API to get converted values directly: true\n"

"\n"

"[Multiline Values]\n"

"chorus: I'm a lumberjack, and I'm okay\n"

" I sleep all night and I work all day\n"

"\n"

"[No Values]\n"

"key_without_value\n"

"empty string value here =\n"

"\n"

"[You can use comments]\n"

"# like this\n"

"; or this\n"

"\n"

"# By default only in an empty line.\n"

"# Inline comments can be harmful because they prevent users\n"

"# from using the delimiting characters as parts of values.\n"

"# That being said, this can be customized.\n"

"\n"

" [Sections Can Be Indented]\n"

" can_values_be_as_well = True\n"

" does_that_mean_anything_special = False\n"

" purpose = formatting for readability\n"

" multiline_values = are\n"

" handled just fine as\n"

" long as they are indented\n"

" deeper than the first line\n"

" of a value\n"

" # Did I mention we can indent comments, too?"

msgstr ""

msgid "Unnamed Sections"

msgstr ""

msgid ""

"The name of the first section (or unique) may be omitted and values "

"retrieved by the :const:`UNNAMED_SECTION` attribute."

msgstr ""

msgid ""

">>> config = \"\"\"\n"

"... option = value\n"

"...\n"

"... [ Section 2 ]\n"

"... another = val\n"

"... \"\"\"\n"

">>> unnamed = configparser.ConfigParser(allow_unnamed_section=True)\n"

">>> unnamed.read_string(config)\n"

">>> unnamed.get(configparser.UNNAMED_SECTION, 'option')\n"

"'value'"

msgstr ""

msgid "Interpolation of values"

msgstr "Інтерполяція значень"

msgid ""

"On top of the core functionality, :class:`ConfigParser` supports "

"interpolation. This means values can be preprocessed before returning them "

"from ``get()`` calls."

msgstr ""

"Окрім основних функцій, :class:`ConfigParser` підтримує інтерполяцію. Це "

"означає, що значення можна попередньо обробити перед поверненням із викликів "

"``get()``."

msgid ""

"The default implementation used by :class:`ConfigParser`. It enables values "

"to contain format strings which refer to other values in the same section, "

"or values in the special default section [1]_. Additional default values "

"can be provided on initialization."

msgstr ""

"Стандартна реалізація, яку використовує :class:`ConfigParser`. Це дозволяє "

"значенням містити рядки формату, які посилаються на інші значення в тому "

"самому розділі, або значення в спеціальному розділі за замовчуванням [1]_. "

"Під час ініціалізації можна надати додаткові значення за замовчуванням."

msgid ""

"[Paths]\n"

"home_dir: /Users\n"

"my_dir: %(home_dir)s/lumberjack\n"

"my_pictures: %(my_dir)s/Pictures\n"

"\n"

"[Escape]\n"

"# use a %% to escape the % sign (% is the only character that needs to be "

"escaped):\n"

"gain: 80%%"

msgstr ""

msgid ""

"In the example above, :class:`ConfigParser` with *interpolation* set to "

"``BasicInterpolation()`` would resolve ``%(home_dir)s`` to the value of "

"``home_dir`` (``/Users`` in this case). ``%(my_dir)s`` in effect would "

"resolve to ``/Users/lumberjack``. All interpolations are done on demand so "

"keys used in the chain of references do not have to be specified in any "

"specific order in the configuration file."

msgstr ""

"У наведеному вище прикладі :class:`ConfigParser` з *інтерполяцією*, "

"встановленою на ``BasicInterpolation()``, перетворює ``%(home_dir)s`` на "

"значення ``home_dir`` (``/Users`` у цьому випадку ). ``%(my_dir)s`` фактично "

"перетворювався б на ``/Users/lumberjack``. Усі інтерполяції виконуються на "

"вимогу, тому ключі, які використовуються в ланцюжку посилань, не потрібно "

"вказувати в певному порядку у файлі конфігурації."

msgid ""

"With ``interpolation`` set to ``None``, the parser would simply return "

"``%(my_dir)s/Pictures`` as the value of ``my_pictures`` and ``%(home_dir)s/"

"lumberjack`` as the value of ``my_dir``."

msgstr ""

"Якщо ``interpolation`` встановлено на ``None``, аналізатор просто "

"повертатиме ``%(my_dir)s`` як значення ``my_pictures`` і ``%(home_dir)s/"

"lumberjack`` як значення ``my_dir``."

msgid ""

"An alternative handler for interpolation which implements a more advanced "

"syntax, used for instance in ``zc.buildout``. Extended interpolation is "

"using ``${section:option}`` to denote a value from a foreign section. "

"Interpolation can span multiple levels. For convenience, if the ``section:"

"`` part is omitted, interpolation defaults to the current section (and "

"possibly the default values from the special section)."

msgstr ""

"Альтернативний обробник для інтерполяції, який реалізує розширеніший "

"синтаксис, який використовується, наприклад, у ``zc.buildout``. Розширена "

"інтерполяція використовує ``${section:option}`` для позначення значення з "

"іноземного розділу. Інтерполяція може охоплювати кілька рівнів. Для "

"зручності, якщо частина ``section:`` опущена, інтерполяція за замовчуванням "

"використовується для поточного розділу (і, можливо, до значень за "

"замовчуванням зі спеціального розділу)."

msgid ""

"For example, the configuration specified above with basic interpolation, "

"would look like this with extended interpolation:"

msgstr ""

"Наприклад, зазначена вище конфігурація з базовою інтерполяцією виглядатиме "

"так з розширеною інтерполяцією:"

msgid ""

"[Paths]\n"

"home_dir: /Users\n"

"my_dir: ${home_dir}/lumberjack\n"

"my_pictures: ${my_dir}/Pictures\n"

"\n"

"[Escape]\n"

"# use a $$ to escape the $ sign ($ is the only character that needs to be "

"escaped):\n"

"cost: $$80"

msgstr ""

msgid "Values from other sections can be fetched as well:"

msgstr "Також можна отримати значення з інших розділів:"

msgid ""

"[Common]\n"

"home_dir: /Users\n"

"library_dir: /Library\n"

"system_dir: /System\n"

"macports_dir: /opt/local\n"

"\n"

"[Frameworks]\n"

"Python: 3.2\n"

"path: ${Common:system_dir}/Library/Frameworks/\n"

"\n"

"[Arthur]\n"

"nickname: Two Sheds\n"

"last_name: Jackson\n"

"my_dir: ${Common:home_dir}/twosheds\n"

"my_pictures: ${my_dir}/Pictures\n"

"python_dir: ${Frameworks:path}/Python/Versions/${Frameworks:Python}"

msgstr ""

msgid "Mapping Protocol Access"

msgstr "Доступ до протоколу відображення"

msgid ""

"Mapping protocol access is a generic name for functionality that enables "

"using custom objects as if they were dictionaries. In case of :mod:"

"`configparser`, the mapping interface implementation is using the "

"``parser['section']['option']`` notation."

msgstr ""

"Доступ до протоколу зіставлення — це загальна назва функціональних "

"можливостей, які дають змогу використовувати спеціальні об’єкти як словники. "

"У випадку :mod:`configparser` реалізація інтерфейсу зіставлення використовує "

"нотацію ``parser['section']['option']``."

msgid ""

"``parser['section']`` in particular returns a proxy for the section's data "

"in the parser. This means that the values are not copied but they are taken "

"from the original parser on demand. What's even more important is that when "

"values are changed on a section proxy, they are actually mutated in the "

"original parser."

msgstr ""

"``parser['section']`` зокрема повертає проксі для даних розділу в "

"аналізаторі. Це означає, що значення не копіюються, а беруться з "

"оригінального аналізатора на вимогу. Ще важливішим є те, що коли значення "

"змінюються на проксі-сервері розділу, вони фактично змінюються в "

"оригінальному парсері."

msgid ""

":mod:`configparser` objects behave as close to actual dictionaries as "

"possible. The mapping interface is complete and adheres to the :class:"

"`~collections.abc.MutableMapping` ABC. However, there are a few differences "

"that should be taken into account:"

msgstr ""

":mod:`configparser` об’єкти поводяться якомога ближче до справжніх "

"словників. Інтерфейс зіставлення завершений і відповідає :class:"

"`~collections.abc.MutableMapping` ABC. Однак є кілька відмінностей, які слід "

"взяти до уваги:"

msgid ""

"By default, all keys in sections are accessible in a case-insensitive manner "

"[1]_. E.g. ``for option in parser[\"section\"]`` yields only "

"``optionxform``'ed option key names. This means lowercased keys by "

"default. At the same time, for a section that holds the key ``'a'``, both "

"expressions return ``True``::"

msgstr ""

"За замовчуванням усі ключі в розділах доступні без урахування регістру [1]_. "

"наприклад ``for option in parser[\"section\"]`` дає лише ``optionxform`` "

"імена ключів опцій. Це означає, що ключі в нижньому регістрі за "

"замовчуванням. Водночас для розділу, який містить ключ ``'a``, обидва вирази "

"повертають ``True``::"

msgid ""

"\"a\" in parser[\"section\"]\n"

"\"A\" in parser[\"section\"]"

msgstr ""

msgid ""

"All sections include ``DEFAULTSECT`` values as well which means that ``."

"clear()`` on a section may not leave the section visibly empty. This is "

"because default values cannot be deleted from the section (because "

"technically they are not there). If they are overridden in the section, "

"deleting causes the default value to be visible again. Trying to delete a "

"default value causes a :exc:`KeyError`."

msgstr ""

"Усі розділи також містять значення ``DEFAULTSECT``, що означає, що ``."

"clear()`` у розділі не може залишати розділ видимо порожнім. Це тому, що "

"значення за замовчуванням не можна видалити з розділу (оскільки технічно їх "

"там немає). Якщо їх перевизначено в розділі, видалення призведе до того, що "

"значення за замовчуванням знову стане видимим. Спроба видалити значення за "

"замовчуванням викликає :exc:`KeyError`."

msgid "``DEFAULTSECT`` cannot be removed from the parser:"

msgstr "``DEFAULTSECT`` не можна видалити з аналізатора:"

msgid "trying to delete it raises :exc:`ValueError`,"

msgstr "спроба його видалити викликає :exc:`ValueError`,"

msgid "``parser.clear()`` leaves it intact,"

msgstr "``parser.clear()`` залишає його недоторканим,"

msgid "``parser.popitem()`` never returns it."

msgstr "``parser.popitem()`` ніколи не повертає його."

msgid ""

"``parser.get(section, option, **kwargs)`` - the second argument is **not** a "

"fallback value. Note however that the section-level ``get()`` methods are "

"compatible both with the mapping protocol and the classic configparser API."

msgstr ""

"``parser.get(section, option, **kwargs)`` - другий аргумент **не** є "

"резервним значенням. Однак зауважте, що методи ``get()`` на рівні розділу "

"сумісні як з протоколом відображення, так і з класичним API конфігуратора."

msgid ""

"``parser.items()`` is compatible with the mapping protocol (returns a list "

"of *section_name*, *section_proxy* pairs including the DEFAULTSECT). "

"However, this method can also be invoked with arguments: ``parser."

"items(section, raw, vars)``. The latter call returns a list of *option*, "

"*value* pairs for a specified ``section``, with all interpolations expanded "

"(unless ``raw=True`` is provided)."

msgstr ""

"``parser.items()`` сумісний із протоколом відображення (повертає список пар "

"*section_name*, *section_proxy*, включаючи DEFAULTSECT). Однак цей метод "

"також можна викликати за допомогою аргументів: ``parser.items(section, raw, "

"vars)``. Останній виклик повертає список пар *option*, *value* для вказаного "

"``розділу`` з усіма розширеними інтерполяціями (якщо не надано ``raw=True``)."

msgid ""

"The mapping protocol is implemented on top of the existing legacy API so "

"that subclasses overriding the original interface still should have mappings "

"working as expected."

msgstr ""

"Протокол відображення реалізовано поверх існуючого застарілого API, так що "

"підкласи, які замінюють вихідний інтерфейс, все ще повинні мати "

"відображення, що працюють належним чином."

msgid "Customizing Parser Behaviour"

msgstr "Налаштування поведінки аналізатора"

msgid ""

"There are nearly as many INI format variants as there are applications using "

"it. :mod:`configparser` goes a long way to provide support for the largest "

"sensible set of INI styles available. The default functionality is mainly "

"dictated by historical background and it's very likely that you will want to "

"customize some of the features."

msgstr ""

"Існує майже стільки ж варіантів формату INI, скільки програм, які його "

"використовують. :mod:`configparser` робить довгий шлях, щоб забезпечити "

"підтримку найбільшого розумного набору доступних стилів INI. "

"Функціональність за замовчуванням здебільшого продиктована історичним "

"минулим, і дуже ймовірно, що ви захочете налаштувати деякі функції."

msgid ""

"The most common way to change the way a specific config parser works is to "

"use the :meth:`!__init__` options:"

msgstr ""

msgid "*defaults*, default value: ``None``"

msgstr "*за замовчуванням*, значення за замовчуванням: ``None``"

msgid ""

"This option accepts a dictionary of key-value pairs which will be initially "

"put in the ``DEFAULT`` section. This makes for an elegant way to support "

"concise configuration files that don't specify values which are the same as "

"the documented default."

msgstr ""

"Цей параметр приймає словник пар ключ-значення, який спочатку буде розміщено "

"в розділі ``DEFAULT``. Це створює елегантний спосіб підтримки стислих "

"конфігураційних файлів, які не вказують значення, які збігаються з "

"документованими за замовчуванням."

msgid ""

"Hint: if you want to specify default values for a specific section, use :"

"meth:`~ConfigParser.read_dict` before you read the actual file."

msgstr ""

msgid "*dict_type*, default value: :class:`dict`"

msgstr "*dict_type*, значення за умовчанням: :class:`dict`"

msgid ""

"This option has a major impact on how the mapping protocol will behave and "

"how the written configuration files look. With the standard dictionary, "

"every section is stored in the order they were added to the parser. Same "

"goes for options within sections."

msgstr ""

"Цей параметр значно впливає на роботу протоколу відображення та вигляд "

"записаних конфігураційних файлів. У стандартному словнику кожен розділ "

"зберігається в порядку їх додавання до синтаксичного аналізатора. Те саме "

"стосується параметрів у розділах."

msgid ""

"An alternative dictionary type can be used for example to sort sections and "

"options on write-back."

msgstr ""

"Альтернативний тип словника можна використовувати, наприклад, для сортування "

"розділів і параметрів під час зворотного запису."

msgid ""

"Please note: there are ways to add a set of key-value pairs in a single "

"operation. When you use a regular dictionary in those operations, the order "

"of the keys will be ordered. For example:"

msgstr ""

"Зверніть увагу: є способи додати набір пар ключ-значення за одну операцію. "

"Якщо ви використовуєте звичайний словник у цих операціях, порядок ключів "

"буде впорядкованим. Наприклад:"

msgid ""

">>> parser = configparser.ConfigParser()\n"

">>> parser.read_dict({'section1': {'key1': 'value1',\n"

"... 'key2': 'value2',\n"

"... 'key3': 'value3'},\n"

"... 'section2': {'keyA': 'valueA',\n"

"... 'keyB': 'valueB',\n"

"... 'keyC': 'valueC'},\n"

"... 'section3': {'foo': 'x',\n"

"... 'bar': 'y',\n"

"... 'baz': 'z'}\n"

"... })\n"

">>> parser.sections()\n"

"['section1', 'section2', 'section3']\n"

">>> [option for option in parser['section3']]\n"

"['foo', 'bar', 'baz']"

msgstr ""

msgid "*allow_no_value*, default value: ``False``"

msgstr "*allow_no_value*, значення за умовчанням: ``False``"

msgid ""

"Some configuration files are known to include settings without values, but "

"which otherwise conform to the syntax supported by :mod:`configparser`. The "

"*allow_no_value* parameter to the constructor can be used to indicate that "

"such values should be accepted:"

msgstr ""

"Відомо, що деякі конфігураційні файли містять налаштування без значень, але "

"в іншому випадку вони відповідають синтаксису, який підтримує :mod:"

"`configparser`. Параметр *allow_no_value* для конструктора можна "

"використовувати, щоб вказати, що такі значення повинні бути прийняті:"

msgid ""

">>> import configparser\n"

"\n"

">>> sample_config = \"\"\"\n"

"... [mysqld]\n"

"... user = mysql\n"

"... pid-file = /var/run/mysqld/mysqld.pid\n"

"... skip-external-locking\n"

"... old_passwords = 1\n"

"... skip-bdb\n"

"... # we don't need ACID today\n"

"... skip-innodb\n"

"... \"\"\"\n"

">>> config = configparser.ConfigParser(allow_no_value=True)\n"

">>> config.read_string(sample_config)\n"

"\n"

">>> # Settings with values are treated as before:\n"

">>> config[\"mysqld\"][\"user\"]\n"

"'mysql'\n"

"\n"

">>> # Settings without values provide None:\n"

">>> config[\"mysqld\"][\"skip-bdb\"]\n"

"\n"

">>> # Settings which aren't specified still raise an error:\n"

">>> config[\"mysqld\"][\"does-not-exist\"]\n"

"Traceback (most recent call last):\n"

" ...\n"

"KeyError: 'does-not-exist'"

msgstr ""

msgid "*delimiters*, default value: ``('=', ':')``"

msgstr "*роздільники*, значення за умовчанням: ``('=', ':')``"

msgid ""

"Delimiters are substrings that delimit keys from values within a section. "

"The first occurrence of a delimiting substring on a line is considered a "

"delimiter. This means values (but not keys) can contain the delimiters."

msgstr ""

"Роздільники — це підрядки, які відокремлюють ключі від значень у розділі. "

"Перше входження розділювального підрядка в рядок вважається роздільником. Це "

"означає, що значення (але не ключі) можуть містити розділювачі."

msgid ""

"See also the *space_around_delimiters* argument to :meth:`ConfigParser."

"write`."

msgstr ""

"Дивіться також аргумент *space_around_delimiters* для :meth:`ConfigParser."

"write`."

msgid "*comment_prefixes*, default value: ``('#', ';')``"

msgstr "*comment_prefixes*, значення за умовчанням: ``('#', ';')``"

msgid "*inline_comment_prefixes*, default value: ``None``"

msgstr "*inline_comment_prefixes*, значення за умовчанням: ``None``"

msgid ""

"Comment prefixes are strings that indicate the start of a valid comment "

"within a config file. *comment_prefixes* are used only on otherwise empty "

"lines (optionally indented) whereas *inline_comment_prefixes* can be used "

"after every valid value (e.g. section names, options and empty lines as "

"well). By default inline comments are disabled and ``'#'`` and ``';'`` are "

"used as prefixes for whole line comments."

msgstr ""

"Префікси коментарів — це рядки, які вказують на початок дійсного коментаря у "

"конфігураційному файлі. *comment_prefixes* використовуються лише в порожніх "

"рядках (необов’язково з відступом), тоді як *inline_comment_prefixes* можна "

"використовувати після кожного дійсного значення (наприклад, назв розділів, "

"параметрів і порожніх рядків). За замовчуванням вбудовані коментарі "

"вимкнено, а ``'#'`` і ``';''`` використовуються як префікси для цілих "

"рядкових коментарів."

msgid ""

"In previous versions of :mod:`configparser` behaviour matched "

"``comment_prefixes=('#',';')`` and ``inline_comment_prefixes=(';',)``."

msgstr ""

"У попередніх версіях :mod:`configparser` поведінка відповідала "

"``comment_prefixes=('#',';')`` та ``inline_comment_prefixes=(';',)``."

msgid ""

"Please note that config parsers don't support escaping of comment prefixes "

"so using *inline_comment_prefixes* may prevent users from specifying option "

"values with characters used as comment prefixes. When in doubt, avoid "

"setting *inline_comment_prefixes*. In any circumstances, the only way of "

"storing comment prefix characters at the beginning of a line in multiline "

"values is to interpolate the prefix, for example::"

msgstr ""

"Зауважте, що аналізатори конфігурації не підтримують екранування префіксів "

"коментарів, тому використання *inline_comment_prefixes* може перешкодити "

"користувачам вказувати значення параметрів із символами, які "

"використовуються як префікси коментарів. Якщо сумніваєтеся, уникайте "

"встановлення *inline_comment_prefixes*. За будь-яких обставин єдиний спосіб "

"зберегти символи префікса коментаря на початку рядка в багаторядкових "

"значеннях — це інтерполювати префікс, наприклад::"

msgid ""

">>> from configparser import ConfigParser, ExtendedInterpolation\n"

">>> parser = ConfigParser(interpolation=ExtendedInterpolation())\n"

">>> # the default BasicInterpolation could be used as well\n"

">>> parser.read_string(\"\"\"\n"

"... [DEFAULT]\n"

"... hash = #\n"

"...\n"

"... [hashes]\n"

"... shebang =\n"

"... ${hash}!/usr/bin/env python\n"

"... ${hash} -*- coding: utf-8 -*-\n"

"...\n"

"... extensions =\n"

"... enabled_extension\n"

"... another_extension\n"

"... #disabled_by_comment\n"

"... yet_another_extension\n"

"...\n"

"... interpolation not necessary = if # is not at line start\n"

"... even in multiline values = line #1\n"

"... line #2\n"

"... line #3\n"

"... \"\"\")\n"

">>> print(parser['hashes']['shebang'])\n"

"\n"

"#!/usr/bin/env python\n"

"# -*- coding: utf-8 -*-\n"

">>> print(parser['hashes']['extensions'])\n"

"\n"

"enabled_extension\n"

"another_extension\n"

"yet_another_extension\n"

">>> print(parser['hashes']['interpolation not necessary'])\n"

"if # is not at line start\n"

">>> print(parser['hashes']['even in multiline values'])\n"

"line #1\n"

"line #2\n"

"line #3"

msgstr ""

msgid "*strict*, default value: ``True``"

msgstr "*строгий*, значення за умовчанням: ``True``"

msgid ""

"When set to ``True``, the parser will not allow for any section or option "

"duplicates while reading from a single source (using :meth:`~ConfigParser."

"read_file`, :meth:`~ConfigParser.read_string` or :meth:`~ConfigParser."

"read_dict`). It is recommended to use strict parsers in new applications."

msgstr ""

msgid ""

"In previous versions of :mod:`configparser` behaviour matched "

"``strict=False``."

msgstr ""

"У попередніх версіях :mod:`configparser` поведінка відповідала "

"``strict=False``."

msgid "*empty_lines_in_values*, default value: ``True``"

msgstr "*empty_lines_in_values*, значення за умовчанням: ``True``"

msgid ""

"In config parsers, values can span multiple lines as long as they are "

"indented more than the key that holds them. By default parsers also let "

"empty lines to be parts of values. At the same time, keys can be "

"arbitrarily indented themselves to improve readability. In consequence, "

"when configuration files get big and complex, it is easy for the user to "

"lose track of the file structure. Take for instance:"

msgstr ""

"У синтаксичних аналізаторах конфігурації значення можуть охоплювати кілька "

"рядків, якщо вони мають відступ більше, ніж ключ, який їх містить. За "

"замовчуванням аналізатори також дозволяють порожнім рядкам бути частинами "

"значень. У той же час самі клавіші можуть мати довільний відступ для "

"покращення читабельності. Як наслідок, коли файли конфігурації стають "

"великими та складними, користувачеві легко втратити структуру файлу. "

"Візьмемо, наприклад:"

msgid ""

"[Section]\n"

"key = multiline\n"

" value with a gotcha\n"

"\n"

" this = is still a part of the multiline value of 'key'"

msgstr ""

msgid ""

"This can be especially problematic for the user to see if she's using a "

"proportional font to edit the file. That is why when your application does "

"not need values with empty lines, you should consider disallowing them. "

"This will make empty lines split keys every time. In the example above, it "

"would produce two keys, ``key`` and ``this``."

msgstr ""

"Це може бути особливо проблематично для користувача, щоб побачити, чи він "

"використовує пропорційний шрифт для редагування файлу. Ось чому, якщо вашій "

"програмі не потрібні значення з порожніми рядками, вам слід подумати про їх "

"заборону. Це змусить порожні рядки кожного разу розділяти ключі. У "

"наведеному вище прикладі буде створено два ключі, ``key`` і ``this``."

msgid ""

"*default_section*, default value: ``configparser.DEFAULTSECT`` (that is: "

"``\"DEFAULT\"``)"

msgstr ""

"*default_section*, значення за замовчуванням: ``configparser.DEFAULTSECT`` "

"(тобто: ``\"DEFAULT\"``)"

msgid ""

"The convention of allowing a special section of default values for other "

"sections or interpolation purposes is a powerful concept of this library, "

"letting users create complex declarative configurations. This section is "

"normally called ``\"DEFAULT\"`` but this can be customized to point to any "

"other valid section name. Some typical values include: ``\"general\"`` or "

"``\"common\"``. The name provided is used for recognizing default sections "

"when reading from any source and is used when writing configuration back to "

"a file. Its current value can be retrieved using the ``parser_instance."

"default_section`` attribute and may be modified at runtime (i.e. to convert "

"files from one format to another)."

msgstr ""

"Угода про дозвіл спеціального розділу значень за замовчуванням для інших "

"розділів або для цілей інтерполяції є потужною концепцією цієї бібліотеки, "