# 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:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-05-08 18:34+0000\n"

"PO-Revision-Date: 2025-09-16 00:01+0000\n"

"Last-Translator: python-doc bot, 2025\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:`!configparser` --- Configuration file parser"

msgstr ""

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

msgstr "**Kod źródłowy:** :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 ""

msgid ""

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

"the Windows Registry extended version of INI syntax."

msgstr ""

msgid ""

"Be cautious when parsing data from untrusted sources. A malicious INI file "

"may cause the decoder to consume considerable CPU and memory resources. "

"Limiting the size of data to be parsed is recommended."

msgstr ""

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 "moduł :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 "moduł :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 ""

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 ""

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 ""

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 ""

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 ""

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

"50022\n"

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

"9.0"

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 ""

msgid ""

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

"False\n"

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

"True\n"

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

"True"

msgstr ""

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

"False\n"

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

"True\n"

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

"True"

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 ""

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 ""

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

"'50022'\n"

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

"'9'\n"

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

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

"'3des-cbc'"

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 ""

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

"'9'"

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 ""

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 ""

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 ""

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 ""

msgid "For example:"

msgstr "Na przykład::"

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 ""

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 ""

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 ""

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 ""

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 ""

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 ""

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 ""

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 ""

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 ""

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 ""

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

msgstr ""

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

msgstr ""

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

msgstr ""

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

msgstr ""

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 ""

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 ""

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 ""

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 ""

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 ""

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 ""

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 ""

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 ""

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 ""

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 ""

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

msgstr ""

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

msgstr ""

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 ""

msgid ""

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

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

msgstr ""

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 ""

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 ""

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 ""

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

msgstr ""

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 ""

msgid ""

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

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

msgstr ""

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 ""

msgid "*interpolation*, default value: ``configparser.BasicInterpolation``"

msgstr ""

msgid ""

"Interpolation behaviour may be customized by providing a custom handler "

"through the *interpolation* argument. ``None`` can be used to turn off "

"interpolation completely, ``ExtendedInterpolation()`` provides a more "

"advanced variant inspired by ``zc.buildout``. More on the subject in the "

"`dedicated documentation section <#interpolation-of-values>`_. :class:"

"`RawConfigParser` has a default value of ``None``."

msgstr ""

msgid "*converters*, default value: not set"

msgstr ""

msgid ""

"Config parsers provide option value getters that perform type conversion. "

"By default :meth:`~ConfigParser.getint`, :meth:`~ConfigParser.getfloat`, "

"and :meth:`~ConfigParser.getboolean` are implemented. Should other getters "

"be desirable, users may define them in a subclass or pass a dictionary where "

"each key is a name of the converter and each value is a callable "

"implementing said conversion. For instance, passing ``{'decimal': decimal."

"Decimal}`` would add :meth:`!getdecimal` on both the parser object and all "

"section proxies. In other words, it will be possible to write both "

"``parser_instance.getdecimal('section', 'key', fallback=0)`` and "

"``parser_instance['section'].getdecimal('key', 0)``."

msgstr ""

msgid ""

"If the converter needs to access the state of the parser, it can be "

"implemented as a method on a config parser subclass. If the name of this "

"method starts with ``get``, it will be available on all section proxies, in "

"the dict-compatible form (see the ``getdecimal()`` example above)."

msgstr ""

msgid ""

"More advanced customization may be achieved by overriding default values of "

"these parser attributes. The defaults are defined on the classes, so they "

"may be overridden by subclasses or by attribute assignment."

msgstr ""

msgid ""

"By default when using :meth:`~ConfigParser.getboolean`, config parsers "

"consider the following values ``True``: ``'1'``, ``'yes'``, ``'true'``, "

"``'on'`` and the following values ``False``: ``'0'``, ``'no'``, ``'false'``, "

"``'off'``. You can override this by specifying a custom dictionary of "

"strings and their Boolean outcomes. For example:"

msgstr ""

msgid ""

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

">>> custom['section1'] = {'funky': 'nope'}\n"

">>> custom['section1'].getboolean('funky')\n"

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

"...\n"

"ValueError: Not a boolean: nope\n"

">>> custom.BOOLEAN_STATES = {'sure': True, 'nope': False}\n"

">>> custom['section1'].getboolean('funky')\n"

"False"

msgstr ""

msgid ""

"Other typical Boolean pairs include ``accept``/``reject`` or ``enabled``/"

"``disabled``."

msgstr ""

msgid ""

"This method transforms option names on every read, get, or set operation. "

"The default converts the name to lowercase. This also means that when a "

"configuration file gets written, all keys will be lowercase. Override this "

"method if that's unsuitable. For example:"

msgstr ""

msgid ""

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

"... [Section1]\n"

"... Key = Value\n"

"...\n"

"... [Section2]\n"

"... AnotherKey = Value\n"

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

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

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

">>> list(typical['Section1'].keys())\n"

"['key']\n"

">>> list(typical['Section2'].keys())\n"

"['anotherkey']\n"

">>> custom = configparser.RawConfigParser()\n"

">>> custom.optionxform = lambda option: option\n"

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

">>> list(custom['Section1'].keys())\n"

"['Key']\n"

">>> list(custom['Section2'].keys())\n"

"['AnotherKey']"

msgstr ""

msgid ""

"The optionxform function transforms option names to a canonical form. This "

"should be an idempotent function: if the name is already in canonical form, "

"it should be returned unchanged."

msgstr ""

msgid ""

"A compiled regular expression used to parse section headers. The default "

"matches ``[section]`` to the name ``\"section\"``. Whitespace is considered "

"part of the section name, thus ``[ larch ]`` will be read as a section of "

"name ``\" larch \"``. Override this attribute if that's unsuitable. For "

"example:"

msgstr ""

msgid ""

">>> import re\n"

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

"... [Section 1]\n"

"... option = value\n"

"...\n"

"... [ Section 2 ]\n"

"... another = val\n"

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

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

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

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

"['Section 1', ' Section 2 ']\n"

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

">>> custom.SECTCRE = re.compile(r\"\\[ *(?P<header>[^]]+?) *\\]\")\n"

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

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

"['Section 1', 'Section 2']"

msgstr ""

msgid ""

"While ConfigParser objects also use an ``OPTCRE`` attribute for recognizing "

"option lines, it's not recommended to override it because that would "

"interfere with constructor options *allow_no_value* and *delimiters*."

msgstr ""

msgid "Legacy API Examples"

msgstr ""

msgid ""

"Mainly because of backwards compatibility concerns, :mod:`!configparser` "

"provides also a legacy API with explicit ``get``/``set`` methods. While "

"there are valid use cases for the methods outlined below, mapping protocol "

"access is preferred for new projects. The legacy API is at times more "

"advanced, low-level and downright counterintuitive."

msgstr ""

msgid "An example of writing to a configuration file::"

msgstr ""