configparser.po

# 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:
# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-16 12:56+0000\n"
"PO-Revision-Date: 2026-09-14 08:40+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: Persian (https://github.com/python/python-docs-fa/)\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 3.6\n"

msgid ":mod:`!configparser` --- Configuration file parser"
msgstr ":mod:`!configparser` --- پارسر پرونده پیکربندی"

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` را ارائه می‌دهد که یک زبان پیکربندی پایه را پیاده‌سازی می‌کند و ساختاری مشابه آنچه در پرونده‌های INI ویندوز مایکروسافت یافت می‌شود، دارد. شما می‌توانید از آن برای نوشتن برنامه‌های پایتون استفاده کنید که کاربران نهایی بتوانند به‌راحتی آن‌ها را سفارشی‌سازی کنند."

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 Registry را تفسیر یا نوشتن *نمی‌کند*."

msgid "Module :mod:`tomllib`"
msgstr "ماژول :mod:`tomllib`"

msgid "TOML is a well-specified format for application configuration files. It is specifically designed to be an improved version of INI."
msgstr "TOML قالبی با مشخصات دقیق برای پرونده‌های پیکربندی برنامه‌ها است. این قالب به‌طور خاص به‌عنوان نسخه‌ای بهبودیافته از INI طراحی شده است."

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 "ماژول ``json`` زیرمجموعه‌ای از سینتکس JavaScript را پیاده‌سازی می‌کند که گاهی برای پیکربندی به کار می‌رود، اما از کامنت پشتیبانی نمی‌کند."

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

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

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

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 "می‌توان چند پیکربندی را در یک :class:`ConfigParser` خواند، که در آن آخرین پیکربندی اضافه‌شده بیشترین اولویت را دارد. کلیدهای متعارض از پیکربندی جدیدتر گرفته می‌شوند، در حالی که کلیدهای از پیش موجود حفظ می‌شوند. مثال زیر پرونده ``override.ini`` را می‌خواند که کلیدهای متعارض موجود در پرونده ``example.ini`` را بازنویسی می‌کند."

msgid ""
"[DEFAULT]\n"
"ServerAliveInterval = -1"
msgstr ""
"[DEFAULT]\n"
"ServerAliveInterval = -1"

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

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 ""
">>> 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 "از آن‌جا که این کار بسیار رایج است، پارسرهای پیکربندی (config parsers) مجموعه‌ای از متدهای getter کاربردی را برای مدیریت اعداد صحیح، اعداد اعشاری و بولی‌ها ارائه می‌کنند. آخرین مورد جالب‌ترین است، زیرا صرفاً فرستادن مقدار به ``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 ""
">>> 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 "علاوه بر :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 "مانند دیکشنری، می‌توانید از متد :meth:`~ConfigParser.get` یک بخش برای ارائه مقادیر جایگزین استفاده کنید:"

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 "لطفاً توجه داشته باشید که مقادیر پیش‌فرض بر مقادیر جایگزین (fallback) اولویت دارند. برای مثال، در مثال ما کلید ``'CompressionLevel'`` فقط در بخش ``'DEFAULT'`` تعیین شده است. اگر سعی کنیم آن را از بخش ``'topsecret.server.example'`` دریافت کنیم، همیشه مقدار پیش‌فرض را دریافت خواهیم کرد، حتی اگر یک مقدار جایگزین (fallback) تعیین کنیم:"

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 "نکته دیگری که باید از آن آگاه باشید این است که متد :meth:`~ConfigParser.get` در سطح پارسر، رابطی سفارشی و پیچیده‌تر را فراهم می‌کند که برای سازگاری با نسخه‌های پیشین حفظ شده است. هنگام استفاده از این متد، می‌توانید یک مقدار جایگزین (fallback) را از طریق آرگومان فقط کلیدواژه‌ای ``fallback`` ارائه دهید:"

msgid ""
">>> config.get('forge.example', 'monster',\n"
"...            fallback='No such things as monsters')\n"
"'No such things as monsters'"
msgstr ""
">>> config.get('forge.example', 'monster',\n"
"...            fallback='No such things as monsters')\n"
"'No such things as monsters'"

msgid "The same ``fallback`` argument can be used with the :meth:`~ConfigParser.getint`, :meth:`~ConfigParser.getfloat` and :meth:`~ConfigParser.getboolean` methods, for example:"
msgstr "می‌توان از همان آرگومان ``fallback`` در متدهای :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 ""
">>> '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"

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 "به‌طور پیش‌فرض، یک نام بخش معتبر می‌تواند هر رشته‌ای باشد که حاوی '\\\\n' نیست. برای تغییر این، :attr:`ConfigParser.SECTCRE` را ببینید."

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 "اگر پارسر به‌گونه‌ای پیکربندی شده باشد که با ``allow_unnamed_section=True`` اجازه‌ی وجود یک بخش سطح‌بالای بی‌نام داده شود، می‌توان نام اولین بخش را حذف کرد. در این حالت، می‌توان کلیدها/مقدارها را با استفاده از :const:`UNNAMED_SECTION`، مانند ``config[UNNAMED_SECTION]``، بازیابی کرد."

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

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 "نام اولین بخش (یا یکتا) می‌تواند حذف شود و مقادیر از طریق ویژگی :const:`UNNAMED_SECTION` بازیابی شوند."

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

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` از درون‌یابی (interpolation) پشتیبانی می‌کند. این بدان معناست که می‌توان مقادیر را پیش از بازگرداندن آن‌ها از فراخوانی‌های ``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 ""
"[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%%"

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` که *درون‌یابی (interpolation)* آن روی ``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/Pictures`` را به‌عنوان مقدار ``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 "یک هندلر جایگزین برای درون‌یابی (interpolation) که سینتکس پیشرفته‌تری را پیاده‌سازی می‌کند و برای نمونه در ``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 ""
"[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"

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

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` تا حد ممکن مانند دیکشنری‌های واقعی رفتار می‌کنند. رابط نگاشت کامل است و از ABC :class:`~collections.abc.MutableMapping` پیروی می‌کند. با این حال، چند تفاوت وجود دارد که باید در نظر گرفته شوند:"

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 ""
"\"a\" in parser[\"section\"]\n"
"\"A\" in parser[\"section\"]"

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 کلاسیک configparser سازگار هستند."

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* را برای یک ``section`` مشخص برمی‌گرداند، به‌طوری که همه درون‌یابی‌ها (interpolations) بسط یافته‌اند (مگر آنکه ``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 "رایج‌ترین روش برای تغییر شیوه‌ی کار یک پارسر پیکربندی (config parser) مشخص، استفاده از گزینه‌های :meth:`!__init__` است:"

msgid "*defaults*, default value: ``None``"
msgstr "*defaults*، مقدار پیش‌فرض: ``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 "نکته: اگر می‌خواهید مقادیر پیش‌فرض برای یک بخش مشخص تعیین کنید، قبل از خواندن پرونده واقعی از :meth:`~ConfigParser.read_dict` استفاده کنید."

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 "برای مثال، می‌توان از یک نوع دیکشنری جایگزین برای مرتب‌سازی بخش‌ها و گزینه‌ها در زمان بازنویسی (write-back) استفاده کرد."

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

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

msgid "*delimiters*, default value: ``('=', ':')``"
msgstr "*delimiters*، مقدار پیش‌فرض: ``('=', ':')``"

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

msgid "*strict*, default value: ``True``"
msgstr "*strict*، مقدار پیش‌فرض: ``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 "هنگامی که روی ``True`` تنظیم شود، پارسر هنگام خواندن از یک منبع واحد (با استفاده از :meth:`~ConfigParser.read_file`، :meth:`~ConfigParser.read_string` یا :meth:`~ConfigParser.read_dict`) اجازه نمی‌دهد هیچ بخش یا گزینه‌ای تکرار شود. توصیه می‌شود در برنامه‌های کاربردی جدید از پارسرهای سخت‌گیر استفاده شود."

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 ""
"[Section]\n"
"key = multiline\n"
"  value with a gotcha\n"
"\n"
" this = is still a part of the multiline value of 'key'"

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 "قراردادِ وجود یک بخش ویژه از مقادیر پیش‌فرض برای سایر بخش‌ها یا اهداف درون‌یابی (interpolation)، مفهوم قدرتمندی در این کتابخانه است که به کاربران امکان می‌دهد پیکربندی‌های اعلامی پیچیده‌ای ایجاد کنند. این بخش معمولاً ``\"DEFAULT\"`` نامیده می‌شود، اما می‌توان آن را سفارشی‌سازی کرد تا به هر نام بخش معتبر دیگری اشاره کند. برخی مقادیر معمول عبارت‌اند از: ``\"general\"`` یا ``\"common\"``. نام ارائه‌شده برای شناسایی بخش‌های پیش‌فرض هنگام خواندن از هر منبعی استفاده می‌شود و همچنین هنگام نوشتن پیکربندی به یک پرونده نیز به کار می‌رود. مقدار فعلی آن را می‌توان با استفاده از ویژگی ``parser_instance.default_section`` دریافت کرد و می‌توان آن را در ران‌تایم تغییر داد (یعنی برای تبدیل پرونده‌ها از یک قالب به قالب دیگر)."

msgid "*interpolation*, default value: ``configparser.BasicInterpolation``"
msgstr "*interpolation*، مقدار پیش‌فرض: ``configparser.BasicInterpolation``"

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 "می‌توان رفتار درون‌یابی (interpolation) را با ارائه یک هندلر سفارشی از طریق آرگومان *interpolation* سفارشی‌سازی کرد. می‌توان از ``None`` برای غیرفعال کردن کامل درون‌یابی استفاده کرد؛ ``ExtendedInterpolation()`` گونه‌ای پیشرفته‌تر را فراهم می‌کند که از ``zc.buildout`` الهام‌گرفته است. اطلاعات بیشتر درباره این موضوع در `بخش اختصاصی مستندات <#interpolation-of-values>`_ آمده است. :class:`RawConfigParser` دارای مقدار پیش‌فرض ``None`` است."

msgid "*converters*, default value: not set"
msgstr "*converters*، مقدار پیش‌فرض: تنظیم‌نشده"

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 "پارسرهای پیکربندی، دریابنده‌های مقدار گزینه را فراهم می‌کنند که تبدیل نوع را انجام می‌دهند. به‌طور پیش‌فرض :meth:`~ConfigParser.getint`، :meth:`~ConfigParser.getfloat` و :meth:`~ConfigParser.getboolean` پیاده‌سازی شده‌اند. در صورت نیاز به دریابندههای دیگر، کاربران می‌توانند آن‌ها را در یک زیرکلاس تعریف کنند یا یک دیکشنری ارسال کنند که هر کلید آن نام مبدل و هر مقدار آن یک شیء فراخوانی‌پذیر است که تبدیل مذکور را پیاده‌سازی می‌کند. برای مثال، ارسال ``{'decimal': decimal.Decimal}`` باعث می‌شود :meth:`!getdecimal` هم به شیء پارسر و هم به تمام پراکسی‌های بخش اضافه شود. به بیان دیگر، امکان نوشتن هر دو ``parser_instance.getdecimal('section', 'key', fallback=0)`` و ``parser_instance['section'].getdecimal('key', 0)`` وجود خواهد داشت."

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 "اگر مبدل نیاز به دسترسی به وضعیت پارسر داشته باشد، می‌توان آن را به‌صورت متدی در یک زیرکلاس پارسر پیکربندی پیاده‌سازی کرد. اگر نام این متد با ``get`` آغاز شود، در همه پراکسی‌های بخش، در قالب سازگار با دیکشنری در دسترس خواهد بود (مثال ``getdecimal()`` بالا را ببینید)."

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 "به‌طور پیش‌فرض هنگام استفاده از :meth:`~ConfigParser.getboolean`، پارسرهای پیکربندی مقادیر زیر را ``True`` در نظر می‌گیرند: ``'1'``، ``'yes'``، ``'true'``، ``'on'`` و مقادیر زیر را ``False`` در نظر می‌گیرند: ``'0'``، ``'no'``، ``'false'``، ``'off'``. می‌توانید این پیش‌فرض را با مشخص کردن یک دیکشنری سفارشی از رشته‌ها و نتایج بولی آن‌ها تغییر دهید. برای مثال:"

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

msgid "Other typical Boolean pairs include ``accept``/``reject`` or ``enabled``/``disabled``."
msgstr "سایر جفت‌های بولی رایج شامل ``accept``/``reject`` یا ``enabled``/``disabled`` هستند."

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

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 "تابع optionxform نام گزینه‌ها را به یک صورت کانونیکال تبدیل می‌کند. این باید یک تابع هم‌توان (idempotent) باشد: اگر نام از قبل در صورت کانونیکال باشد، باید بدون تغییر بازگردانده شود."

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 "یک عبارت باقاعده کامپایل‌شده که برای تجزیه سرآیند‌های بخش استفاده می‌شود. مقدار پیش‌فرض ``[section]`` را با نام ``\"section\"`` تطبیق می‌دهد. فضای سفید به‌عنوان بخشی از نام بخش در نظر گرفته می‌شود، بنابراین ``[  larch  ]`` به‌عنوان بخشی با نام ``\"  larch  \"`` خوانده می‌شود. اگر این مناسب نیست، این ویژگی را بازنویسی کنید. برای مثال:"

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

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 "اگرچه اشیای ConfigParser همچنین از یک ویژگی ``OPTCRE`` برای تشخیص سطرهای گزینه استفاده می‌کنند، توصیه نمی‌شود آن را بازنویسی کنید، زیرا این کار با گزینه‌های سازنده یعنی *allow_no_value* و *delimiters* تداخل ایجاد می‌کند."

msgid "Legacy API Examples"
msgstr "نمونه‌های API قدیمی"

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 "عمدتاً به دلیل ملاحظات سازگاری با نسخه‌های قبلی، :mod:`!configparser` همچنین یک API قدیمی با متدهای صریح ``get``/``set`` ارائه می‌دهد. اگرچه برای متدهایی که در زیر توضیح داده شده‌اند موارد استفاده معتبری وجود دارد، دسترسی از طریق پروتکل نگاشت برای پروژه‌های جدید ترجیح داده می‌شود. API قدیمی گاهی اوقات پیشرفته‌تر، سطح پایین‌تر و کاملاً غیرشهودی است."

msgid "An example of writing to a configuration file::"
msgstr "مثالی از نوشتن در یک پرونده پیکربندی::"

msgid ""
"import configparser\n"
"\n"
"config = configparser.RawConfigParser()\n"
"\n"
"# Please note that using RawConfigParser's set functions, you can assign\n"
"# non-string values to keys internally, but will receive an error when\n"
"# attempting to write to a file or when you get it in non-raw mode. Setting\n"
"# values using the mapping protocol or ConfigParser's set() does not allow\n"
"# such assignments to take place.\n"
"config.add_section('Section1')\n"
"config.set('Section1', 'an_int', '15')\n"
"config.set('Section1', 'a_bool', 'true')\n"
"config.set('Section1', 'a_float', '3.1415')\n"
"config.set('Section1', 'baz', 'fun')\n"
"config.set('Section1', 'bar', 'Python')\n"
"config.set('Section1', 'foo', '%(bar)s is %(baz)s!')\n"
"\n"
"# Writing our configuration file to 'example.cfg'\n"
"with open('example.cfg', 'w') as configfile:\n"
"    config.write(configfile)"
msgstr ""
"import configparser\n"
"\n"
"config = configparser.RawConfigParser()\n"
"\n"
"# Please note that using RawConfigParser's set functions, you can assign\n"
"# non-string values to keys internally, but will receive an error when\n"
"# attempting to write to a file or when you get it in non-raw mode. Setting\n"
"# values using the mapping protocol or ConfigParser's set() does not allow\n"
"# such assignments to take place.\n"
"config.add_section('Section1')\n"
"config.set('Section1', 'an_int', '15')\n"
"config.set('Section1', 'a_bool', 'true')\n"
"config.set('Section1', 'a_float', '3.1415')\n"
"config.set('Section1', 'baz', 'fun')\n"
"config.set('Section1', 'bar', 'Python')\n"
"config.set('Section1', 'foo', '%(bar)s is %(baz)s!')\n"
"\n"
"# Writing our configuration file to 'example.cfg'\n"
"with open('example.cfg', 'w') as configfile:\n"
"    config.write(configfile)"

msgid "An example of reading the configuration file again::"
msgstr "مثالی از خواندن دوباره‌ی پرونده پیکربندی::"

msgid ""
"import configparser\n"
"\n"
"config = configparser.RawConfigParser()\n"
"config.read('example.cfg')\n"
"\n"
"# getfloat() raises an exception if the value is not a float\n"
"# getint() and getboolean() also do this for their respective types\n"
"a_float = config.getfloat('Section1', 'a_float')\n"
"an_int = config.getint('Section1', 'an_int')\n"
"print(a_float + an_int)\n"
"\n"
"# Notice that the next output does not interpolate '%(bar)s' or '%(baz)s'.\n"
"# This is because we are using a RawConfigParser().\n"
"if config.getboolean('Section1', 'a_bool'):\n"
"    print(config.get('Section1', 'foo'))"
msgstr ""
"import configparser\n"
"\n"
"config = configparser.RawConfigParser()\n"
"config.read('example.cfg')\n"
"\n"
"# getfloat() raises an exception if the value is not a float\n"
"# getint() and getboolean() also do this for their respective types\n"
"a_float = config.getfloat('Section1', 'a_float')\n"
"an_int = config.getint('Section1', 'an_int')\n"
"print(a_float + an_int)\n"
"\n"
"# Notice that the next output does not interpolate '%(bar)s' or '%(baz)s'.\n"
"# This is because we are using a RawConfigParser().\n"
"if config.getboolean('Section1', 'a_bool'):\n"
"    print(config.get('Section1', 'foo'))"

msgid "To get interpolation, use :class:`ConfigParser`::"
msgstr "برای درون‌یابی (interpolation)، از :class:`ConfigParser` استفاده کنید::"

msgid ""
"import configparser\n"
"\n"
"cfg = configparser.ConfigParser()\n"
"cfg.read('example.cfg')\n"
"\n"
"# Set the optional *raw* argument of get() to True if you wish to disable\n"
"# interpolation in a single get operation.\n"
"print(cfg.get('Section1', 'foo', raw=False))  # -> \"Python is fun!\"\n"
"print(cfg.get('Section1', 'foo', raw=True))   # -> \"%(bar)s is %(baz)s!\"\n"
"\n"
"# The optional *vars* argument is a dict with members that will take\n"
"# precedence in interpolation.\n"
"print(cfg.get('Section1', 'foo', vars={'bar': 'Documentation',\n"
"                                       'baz': 'evil'}))\n"
"\n"
"# The optional *fallback* argument can be used to provide a fallback value\n"
"print(cfg.get('Section1', 'foo'))\n"
"      # -> \"Python is fun!\"\n"
"\n"
"print(cfg.get('Section1', 'foo', fallback='Monty is not.'))\n"
"      # -> \"Python is fun!\"\n"
"\n"
"print(cfg.get('Section1', 'monster', fallback='No such things as monsters.'))\n"
"      # -> \"No such things as monsters.\"\n"
"\n"
"# A bare print(cfg.get('Section1', 'monster')) would raise NoOptionError\n"
"# but we can also use:\n"
"\n"
"print(cfg.get('Section1', 'monster', fallback=None))\n"
"      # -> None"
msgstr ""
"import configparser\n"
"\n"
"cfg = configparser.ConfigParser()\n"
"cfg.read('example.cfg')\n"
"\n"
"# Set the optional *raw* argument of get() to True if you wish to disable\n"
"# interpolation in a single get operation.\n"
"print(cfg.get('Section1', 'foo', raw=False))  # -> \"Python is fun!\"\n"
"print(cfg.get('Section1', 'foo', raw=True))   # -> \"%(bar)s is %(baz)s!\"\n"
"\n"
"# The optional *vars* argument is a dict with members that will take\n"
"# precedence in interpolation.\n"
"print(cfg.get('Section1', 'foo', vars={'bar': 'Documentation',\n"
"                                       'baz': 'evil'}))\n"
"\n"
"# The optional *fallback* argument can be used to provide a fallback value\n"
"print(cfg.get('Section1', 'foo'))\n"
"      # -> \"Python is fun!\"\n"
"\n"
"print(cfg.get('Section1', 'foo', fallback='Monty is not.'))\n"
"      # -> \"Python is fun!\"\n"
"\n"
"print(cfg.get('Section1', 'monster', fallback='No such things as monsters.'))\n"
"      # -> \"No such things as monsters.\"\n"
"\n"
"# A bare print(cfg.get('Section1', 'monster')) would raise NoOptionError\n"
"# but we can also use:\n"
"\n"
"print(cfg.get('Section1', 'monster', fallback=None))\n"
"      # -> None"

msgid "Default values are available in both types of ConfigParsers.  They are used in interpolation if an option used is not defined elsewhere. ::"
msgstr "مقادیر پیش‌فرض در هر دو نوع ConfigParser در دسترس هستند. اگر گزینه‌ی استفاده‌شده در جای دیگری تعریف‌نشده باشد، این مقادیر در درون‌یابی (interpolation) استفاده می‌شوند. ::"

msgid ""
"import configparser\n"
"\n"
"# New instance with 'bar' and 'baz' defaulting to 'Life' and 'hard' each\n"
"config = configparser.ConfigParser({'bar': 'Life', 'baz': 'hard'})\n"
"config.read('example.cfg')\n"
"\n"
"print(config.get('Section1', 'foo'))     # -> \"Python is fun!\"\n"
"config.remove_option('Section1', 'bar')\n"
"config.remove_option('Section1', 'baz')\n"
"print(config.get('Section1', 'foo'))     # -> \"Life is hard!\""
msgstr ""
"import configparser\n"
"\n"
"# New instance with 'bar' and 'baz' defaulting to 'Life' and 'hard' each\n"
"config = configparser.ConfigParser({'bar': 'Life', 'baz': 'hard'})\n"
"config.read('example.cfg')\n"
"\n"
"print(config.get('Section1', 'foo'))     # -> \"Python is fun!\"\n"
"config.remove_option('Section1', 'bar')\n"
"config.remove_option('Section1', 'baz')\n"
"print(config.get('Section1', 'foo'))     # -> \"Life is hard!\""

msgid "ConfigParser Objects"
msgstr "اشیای ConfigParser"

msgid "The main configuration parser.  When *defaults* is given, it is initialized into the dictionary of intrinsic defaults.  When *dict_type* is given, it will be used to create the dictionary objects for the list of sections, for the options within a section, and for the default values."
msgstr "پارسر اصلی پیکربندی. هنگامی که *defaults* داده شود، در دیکشنری پیش‌فرض‌های ذاتی مقداردهی اولیه می‌شود. هنگامی که *dict_type* داده شود، برای ایجاد اشیای دیکشنری برای فهرست بخش‌ها، برای گزینه‌های درون یک بخش، و برای مقادیر پیش‌فرض استفاده خواهد شد."

msgid "When *delimiters* is given, it is used as the set of substrings that divide keys from values.  When *comment_prefixes* is given, it will be used as the set of substrings that prefix comments in otherwise empty lines. Comments can be indented.  When *inline_comment_prefixes* is given, it will be used as the set of substrings that prefix comments in non-empty lines."
msgstr "هنگامی که *delimiters* داده شده باشد، از آن به‌عنوان مجموعه‌ای از زیررشته‌ها استفاده می‌شود که کلیدها را از مقادیر جدا می‌کنند. هنگامی که *comment_prefixes* داده شده باشد، از آن به‌عنوان مجموعه‌ای از زیررشته‌ها استفاده خواهد شد که به‌عنوان پیشوند کامنت‌ها در سطرهایی که در غیر این صورت خالی هستند، عمل می‌کنند. کامنت‌ها می‌توانند تورفتگی داشته باشند. هنگامی که *inline_comment_prefixes* داده شده باشد، از آن به‌عنوان مجموعه‌ای از زیررشته‌ها استفاده خواهد شد که به‌عنوان پیشوند کامنت‌ها در سطرهای غیرخالی عمل می‌کنند."

msgid "When *strict* is ``True`` (the default), the parser won't allow for any section or option duplicates while reading from a single source (file, string or dictionary), raising :exc:`DuplicateSectionError` or :exc:`DuplicateOptionError`.  When *empty_lines_in_values* is ``False`` (default: ``True``), each empty line marks the end of an option.  Otherwise, internal empty lines of a multiline option are kept as part of the value. When *allow_no_value* is ``True`` (default: ``False``), options without values are accepted; the value held for these is ``None`` and they are serialized without the trailing delimiter."
msgstr "هنگامی که *strict* برابر ``True`` باشد (پیش‌فرض)، پارسر هنگام خواندن از یک منبع واحد (پرونده، رشته یا دیکشنری) از وجود هرگونه بخش یا گزینه تکراری جلوگیری می‌کند و :exc:`DuplicateSectionError` یا :exc:`DuplicateOptionError` را پرتاب می‌کند.  هنگامی که *empty_lines_in_values* برابر ``False`` باشد (پیش‌فرض: ``True``)، هر خط خالی پایان یک گزینه را مشخص می‌کند.  در غیر این صورت، سطرهای خالی داخلی یک گزینه چندخطی به‌عنوان بخشی از مقدار حفظ می‌شوند. هنگامی که *allow_no_value* برابر ``True`` باشد (پیش‌فرض: ``False``)، گزینه‌های بدون مقدار پذیرفته می‌شوند؛ مقدار ذخیره‌شده برای این گزینه‌ها ``None`` است و آن‌ها بدون جداکننده پایانی سریال‌سازی می‌شوند."

msgid "When *default_section* is given, it specifies the name for the special section holding default values for other sections and interpolation purposes (normally named ``\"DEFAULT\"``).  This value can be retrieved and changed at runtime using the ``default_section`` instance attribute. This won't re-evaluate an already parsed config file, but will be used when writing parsed settings to a new config file."
msgstr "هنگامی که *default_section* داده شود، نام بخش ویژه‌ای را مشخص می‌کند که مقادیر پیش‌فرض برای سایر بخش‌ها و برای اهداف درون‌یابی را نگه می‌دارد (این بخش معمولاً ``\"DEFAULT\"`` نام دارد). این مقدار را می‌توان در ران‌تایم با استفاده از ویژگی نمونه‌ی ``default_section`` بازیابی و تغییر داد. این کار یک پرونده‌ی پیکربندی از پیش تجزیه‌شده را دوباره ارزیابی نمی‌کند، اما هنگام نوشتن تنظیمات تجزیه‌شده در یک پرونده‌ی پیکربندی جدید استفاده خواهد شد."

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>`_."
msgstr "رفتار درون‌یابی (interpolation) را می‌توان با ارائه یک هندلر سفارشی  از طریق آرگومان *interpolation* سفارشی‌سازی کرد. می‌توان از ``None`` برای غیرفعال کردن کامل درون‌یابی استفاده کرد، و ``ExtendedInterpolation()`` یک گونه پیشرفته‌تر ارائه می‌دهد که از ``zc.buildout`` الهام گرفته است. اطلاعات بیشتر درباره این موضوع در `بخش اختصاصی مستندات <#interpolation-of-values>`_."

msgid "All option names used in interpolation will be passed through the :meth:`optionxform` method just like any other option name reference.  For example, using the default implementation of :meth:`optionxform` (which converts option names to lower case), the values ``foo %(bar)s`` and ``foo %(BAR)s`` are equivalent."
msgstr "تمام نام‌های گزینه‌ای که در درون‌یابی (interpolation) استفاده می‌شوند، دقیقاً مانند هر ارجاع دیگری به نام گزینه، از متد :meth:`optionxform` عبور می‌کنند. برای مثال، با استفاده از پیاده‌سازی پیش‌فرض :meth:`optionxform` (که نام گزینه‌ها را به حروف کوچک تبدیل می‌کند)، مقادیر ``foo %(bar)s`` و ``foo %(BAR)s`` معادل هستند."

msgid "When *converters* is given, it should be a dictionary where each key represents the name of a type converter and each value is a callable implementing the conversion from string to the desired datatype.  Every converter gets its own corresponding :meth:`!get*` method on the parser object and section proxies."
msgstr "هنگامی که *converters* داده شود، باید یک دیکشنری باشد که در آن هر کلید نشان‌دهنده‌ی نام یک مبدل نوع است و هر مقدار یک شیء فراخوانی‌پذیر است که تبدیل از رشته به نوع داده مورد نظر را پیاده‌سازی می‌کند. هر مبدل متد :meth:`!get*` متناظر با خود را روی شیء پارسر و پراکسی‌های بخش دریافت می‌کند."

msgid "When *allow_unnamed_section* is ``True`` (default: ``False``), the first section name can be omitted. See the `\"Unnamed Sections\" section <#unnamed-sections>`_."
msgstr "هنگامی که *allow_unnamed_section* ``True`` باشد (پیش‌فرض: ``False``)، می‌توان نام بخش نخست را حذف کرد. بخش «بخش‌های بی‌نام» <#unnamed-sections>`_ را ببینید."

msgid "The default *dict_type* is :class:`collections.OrderedDict`."
msgstr "*dict_type* پیش‌فرض :class:`collections.OrderedDict` است."

msgid "*allow_no_value*, *delimiters*, *comment_prefixes*, *strict*, *empty_lines_in_values*, *default_section* and *interpolation* were added."
msgstr "*allow_no_value*، *delimiters*، *comment_prefixes*، *strict*، *empty_lines_in_values*، *default_section* و *interpolation* افزوده شدند."

msgid "The *converters* argument was added."
msgstr "آرگومان *converters* افزوده شد."

msgid "The *defaults* argument is read with :meth:`read_dict`, providing consistent behavior across the parser: non-string keys and values are implicitly converted to strings."
msgstr "آرگومان *defaults* با :meth:`read_dict` خوانده می‌شود و رفتار سازگاری را در سراسر پارسر فراهم می‌کند: کلیدها و مقدارهای غیررشته‌ای به‌صورت ضمنی به رشته تبدیل می‌شوند."

msgid "The default *dict_type* is :class:`dict`, since it now preserves insertion order."
msgstr "مقدار پیش‌فرض *dict_type*، :class:`dict` است، زیرا اکنون ترتیب درج را حفظ می‌کند."

msgid "Raise a :exc:`MultilineContinuationError` when *allow_no_value* is ``True``, and a key without a value is continued with an indented line."
msgstr "هنگامی که *allow_no_value* برابر ``True`` باشد و یک کلید بدون مقدار با یک خط دارای تورفتگی ادامه یابد، یک :exc:`MultilineContinuationError` پرتاب می‌شود."

msgid "The *allow_unnamed_section* argument was added."
msgstr "آرگومان *allow_unnamed_section* افزوده شد."

msgid "Return a dictionary containing the instance-wide defaults."
msgstr "یک دیکشنری شامل پیش‌فرض‌های سراسری نمونه برمی‌گرداند."

msgid "Return a list of the sections available; the *default section* is not included in the list."
msgstr "فهرستی از بخش‌های موجود را برمی‌گرداند؛ *بخش پیش‌فرض* در این فهرست گنجانده نشده است."

msgid "Add a section named *section* to the instance.  If a section by the given name already exists, :exc:`DuplicateSectionError` is raised.  If the *default section* name is passed, :exc:`ValueError` is raised.  The name of the section must be a string; if not, :exc:`TypeError` is raised."
msgstr "یک بخش با نام *section* به نمونه اضافه می‌کند. اگر بخشی با نام داده‌شده از قبل وجود داشته باشد، استثنای :exc:`DuplicateSectionError` پرتاب می‌شود. اگر نام *بخش پیش‌فرض* داده شود، استثنای :exc:`ValueError` پرتاب می‌شود. نام بخش باید یک رشته باشد؛ در غیر این صورت، استثنای :exc:`TypeError` پرتاب می‌شود."

msgid "Non-string section names raise :exc:`TypeError`."
msgstr "نام‌بخش‌های غیررشته‌ای باعث پرتاب :exc:`TypeError` می‌شوند."

msgid "Indicates whether the named *section* is present in the configuration. The *default section* is not acknowledged."
msgstr "نشان می‌دهد که آیا *section* نام‌برده در پیکربندی وجود دارد یا خیر. *بخش پیش‌فرض* شناسایی نمی‌شود."

msgid "Return a list of options available in the specified *section*."
msgstr "فهرستی از گزینه‌های موجود در *section* مشخص‌شده را برمی‌گرداند."

msgid "If the given *section* exists, and contains the given *option*, return :const:`True`; otherwise return :const:`False`.  If the specified *section* is :const:`None` or an empty string, DEFAULT is assumed."
msgstr "اگر *section* داده‌شده وجود داشته باشد و شامل *option* داده‌شده باشد، :const:`True` را برمی‌گرداند؛ در غیر این صورت :const:`False` را برمی‌گرداند. اگر *section* مشخص‌شده :const:`None` یا یک رشته خالی باشد، DEFAULT در نظر گرفته می‌شود."

msgid "Attempt to read and parse an iterable of filenames, returning a list of filenames which were successfully parsed."
msgstr "تلاش می‌کند یک پیمایش‌پذیر از نام پرونده‌ها را بخواند و تجزیه کند، و فهرستی از نام پرونده‌هایی را که با موفقیت تجزیه شده‌اند برمی‌گرداند."

msgid "If *filenames* is a string, a :class:`bytes` object or a :term:`path-like object`, it is treated as a single filename.  If a file named in *filenames* cannot be opened, that file will be ignored.  This is designed so that you can specify an iterable of potential configuration file locations (for example, the current directory, the user's home directory, and some system-wide directory), and all existing configuration files in the iterable will be read."
msgstr "اگر *filenames* یک رشته، یک شیء :class:`bytes` یا یک شیء شبه‌مسیر (:term:`path-like object`) باشد، به‌عنوان یک نام پرونده واحد در نظر گرفته می‌شود. اگر نتوان پرونده‌ای را که در *filenames* ذکر شده است باز کرد، از آن پرونده چشم‌پوشی خواهد شد. این به گونه‌ای طراحی شده است که شما بتوانید یک پیمایش‌پذیر از محل‌های احتمالی برای پرونده‌های پیکربندی مشخص کنید (برای مثال، پوشه جاری، پوشه خانه کاربر، و یک پوشه سراسری سیستم)، و همه پرونده‌های پیکربندی موجود در آن پیمایش‌پذیر خوانده خواهند شد."

msgid "If none of the named files exist, the :class:`ConfigParser` instance will contain an empty dataset.  An application which requires initial values to be loaded from a file should load the required file or files using :meth:`read_file` before calling :meth:`read` for any optional files::"
msgstr "اگر هیچ‌کدام از پرونده‌های نام‌برده‌شده وجود نداشته باشند، نمونه‌ی :class:`ConfigParser` حاوی یک مجموعه‌داده خالی خواهد بود. برنامه‌ای که نیازمند بارگذاری مقادیر اولیه از یک پرونده است، باید پرونده یا پرونده‌های موردنیاز را با استفاده از :meth:`read_file` بارگذاری کند، پیش از فراخوانی :meth:`read` برای هر پرونده اختیاری::"

msgid ""
"import configparser, os\n"
"\n"
"config = configparser.ConfigParser()\n"
"config.read_file(open('defaults.cfg'))\n"
"config.read(['site.cfg', os.path.expanduser('~/.myapp.cfg')],\n"
"            encoding='cp1250')"
msgstr ""
"import configparser, os\n"
"\n"
"config = configparser.ConfigParser()\n"
"config.read_file(open('defaults.cfg'))\n"
"config.read(['site.cfg', os.path.expanduser('~/.myapp.cfg')],\n"
"            encoding='cp1250')"

msgid "Added the *encoding* parameter. Previously, all files were read using the default encoding for :func:`open`."
msgstr "پارامتر *encoding* افزوده شد. پیش از این، تمام پرونده‌ها با کدگذاری پیش‌فرض :func:`open` خوانده می‌شدند."

msgid "The *filenames* parameter accepts a :term:`path-like object`."
msgstr "پارامتر *filenames* یک شیء شبه‌مسیر (:term:`path-like object`) را می‌پذیرد."

msgid "The *filenames* parameter accepts a :class:`bytes` object."
msgstr "پارامتر *filenames* یک شیء :class:`bytes` را می‌پذیرد."

msgid "Read and parse configuration data from *f* which must be an iterable yielding Unicode strings (for example files opened in text mode)."
msgstr "داده‌های پیکربندی را از *f* بخوانید و تجزیه کنید؛ *f* باید پیمایش‌پذیری باشد که رشته‌های یونیکد تولید می‌کند (برای مثال پرونده‌هایی که در حالت متنی باز شده‌اند)."

msgid "Optional argument *source* specifies the name of the file being read.  If not given and *f* has a :attr:`!name` attribute, that is used for *source*; the default is ``'<???>'``."
msgstr "آرگومان اختیاری *source* نام پرونده‌ای که خوانده می‌شود را مشخص می‌کند. اگر داده نشود و *f* ویژگی :attr:`!name` داشته باشد، از آن برای *source* استفاده می‌شود؛ مقدار پیش‌فرض ``'<???>'`` است."

msgid "Replaces :meth:`!readfp`."
msgstr "جایگزین :meth:`!readfp` می‌شود."

msgid "Parse configuration data from a string."
msgstr "تجزیه داده‌های پیکربندی از یک رشته."

msgid "Optional argument *source* specifies a context-specific name of the string passed.  If not given, ``'<string>'`` is used.  This should commonly be a filesystem path or a URL."
msgstr "آرگومان اختیاری *source* نامی وابسته به زمینه برای رشته‌ی داده‌شده مشخص می‌کند. اگر داده نشود، از ``'<string>'`` استفاده می‌شود. این معمولاً باید یک مسیر سامانه فایل‌بندی یا یک URL باشد."

msgid "Load configuration from any object that provides a dict-like ``items()`` method.  Keys are section names, values are dictionaries with keys and values that should be present in the section.  If the used dictionary type preserves order, sections and their keys will be added in order. Values are automatically converted to strings."
msgstr "پیکربندی از هر شیءای که متد ``items()`` دیکشنری‌مانند را فراهم می‌کند، بارگذاری می‌شود. کلیدها نام بخش‌ها هستند؛ مقدارها دیکشنری‌هایی هستند که کلیدها و مقدارهای آن‌ها باید در آن بخش وجود داشته باشند. اگر نوع دیکشنری استفاده‌شده ترتیب را حفظ کند، بخش‌ها و کلیدهای آن‌ها به‌ترتیب اضافه خواهند شد. مقدارها به‌طور خودکار به رشته تبدیل می‌شوند."

msgid "Optional argument *source* specifies a context-specific name of the dictionary passed.  If not given, ``<dict>`` is used."
msgstr "آرگومان اختیاری *source* نامی مختص به زمینه برای دیکشنری ارسال‌شده مشخص می‌کند. اگر داده نشود، از ``<dict>`` استفاده می‌شود."

msgid "This method can be used to copy state between parsers."
msgstr "می‌توان از این متد برای کپی وضعیت بین پارسرها استفاده کرد."

msgid "Get an *option* value for the named *section*.  If *vars* is provided, it must be a dictionary.  The *option* is looked up in *vars* (if provided), *section*, and in *DEFAULTSECT* in that order.  If the key is not found and *fallback* is provided, it is used as a fallback value.  ``None`` can be provided as a *fallback* value."
msgstr "مقدار یک *option* را برای *section* مشخص‌شده دریافت کنید. اگر *vars* ارائه شده باشد، باید یک دیکشنری باشد. *option* به‌ترتیب در *vars* (در صورت ارائه)، *section* و در *DEFAULTSECT* جستجو می‌شود. اگر کلید پیدا نشود و *fallback* ارائه شده باشد، به‌عنوان مقدار جایگزین استفاده می‌شود. می‌توان ``None`` را به‌عنوان مقدار *fallback* ارائه کرد."

msgid "All the ``'%'`` interpolations are expanded in the return values, unless the *raw* argument is true.  Values for interpolation keys are looked up in the same manner as the option."
msgstr "تمام درون‌یابی‌های ``'%'`` در مقادیر بازگشتی بسط داده می‌شوند، مگر اینکه آرگومان *raw* صحیح باشد. مقادیر کلیدهای درون‌یابی به همان شیوه‌ای که گزینه جست‌وجو می‌شود، جست‌وجو می‌شوند."

msgid "Arguments *raw*, *vars* and *fallback* are keyword only to protect users from trying to use the third argument as the *fallback* fallback (especially when using the mapping protocol)."
msgstr "آرگومان‌های *raw*، *vars* و *fallback* فقط کلیدواژه‌ای هستند تا از تلاش کاربران برای استفاده از سومین آرگومان به‌عنوان مقدار جایگزین (fallback) برای *fallback* جلوگیری شود (به‌ویژه هنگام استفاده از پروتکل نگاشت)."

msgid "A convenience method which coerces the *option* in the specified *section* to an integer.  See :meth:`get` for explanation of *raw*, *vars* and *fallback*."
msgstr "متدی آسان‌کننده که *option* را در *section* مشخص‌شده به عدد صحیح تبدیل می‌کند. برای توضیح *raw*، *vars* و *fallback* به :meth:`get` مراجعه کنید."

msgid "A convenience method which coerces the *option* in the specified *section* to a floating-point number.  See :meth:`get` for explanation of *raw*, *vars* and *fallback*."
msgstr "متد آسان‌کننده‌ای که *option* را در *section* مشخص‌شده به یک عدد ممیز شناور تبدیل می‌کند. برای توضیحات مربوط به *raw*، *vars* و *fallback* به :meth:`get` مراجعه کنید."

msgid "A convenience method which coerces the *option* in the specified *section* to a Boolean value.  Note that the accepted values for the option are ``'1'``, ``'yes'``, ``'true'``, and ``'on'``, which cause this method to return ``True``, and ``'0'``, ``'no'``, ``'false'``, and ``'off'``, which cause it to return ``False``.  These string values are checked in a case-insensitive manner.  Any other value will cause it to raise :exc:`ValueError`.  See :meth:`get` for explanation of *raw*, *vars* and *fallback*."
msgstr "یک متد سهولت‌بخش که *option* را در *section* مشخص‌شده به یک مقدار بولی تبدیل می‌کند. توجه داشته باشید که مقادیر پذیرفته‌شده برای گزینه عبارت‌اند از ``'1'``، ``'yes'``، ``'true'`` و ``'on'`` که باعث می‌شوند این متد ``True`` را برگرداند، و ``'0'``، ``'no'``، ``'false'`` و ``'off'`` که باعث می‌شوند این متد ``False`` را برگرداند. این مقادیر رشته‌ای به‌صورت غیرحساس به بزرگی و کوچکی حروف بررسی می‌شوند. هر مقدار دیگری باعث می‌شود این متد :exc:`ValueError` را پرتاب کند. برای توضیح *raw*، *vars* و *fallback* به :meth:`get` مراجعه کنید."

msgid "When *section* is not given, return a list of *section_name*, *section_proxy* pairs, including DEFAULTSECT."
msgstr "هنگامی که *section* داده نشده باشد، فهرستی از جفت‌های *section_name* و *section_proxy* شامل DEFAULTSECT را برمی‌گرداند."

msgid "Otherwise, return a list of *name*, *value* pairs for the options in the given *section*.  Optional arguments have the same meaning as for the :meth:`get` method."
msgstr "در غیر این صورت، فهرستی از جفت‌های *name*، *value* برای گزینه‌های موجود در *section* داده‌شده برمی‌گرداند. آرگومان‌های اختیاری همان معنایی را دارند که برای متد :meth:`get` دارند."

msgid "Items present in *vars* no longer appear in the result.  The previous behaviour mixed actual parser options with variables provided for interpolation."
msgstr "آیتم‌های موجود در *vars* دیگر در نتیجه ظاهر نمی‌شوند. رفتار پیشین، گزینه‌های واقعی پارسر را با متغیرهای ارائه‌شده برای درون‌یابی (interpolation) مخلوط می‌کرد."

msgid "If the given section exists, set the given option to the specified value; otherwise raise :exc:`NoSectionError`.  *option* and *value* must be strings; if not, :exc:`TypeError` is raised."
msgstr "اگر بخش داده‌شده وجود داشته باشد، گزینه‌ی داده‌شده را به مقدار مشخص‌شده تنظیم می‌کند؛ در غیر این صورت :exc:`NoSectionError` پرتاب می‌شود. *option* و *value* باید رشته باشند؛ در غیر این صورت :exc:`TypeError` پرتاب می‌شود."

msgid "Write a representation of the configuration to the specified :term:`file object`, which must be opened in text mode (accepting strings).  This representation can be parsed by a future :meth:`read` call.  If *space_around_delimiters* is true, delimiters between keys and values are surrounded by spaces."
msgstr "بازنمایی‌ای از پیکربندی را در :term:`file object` مشخص بنویسید، که باید در حالت متنی باز شده باشد (و رشته‌ها را بپذیرد). این بازنمایی را می‌توان با یک فراخوانی بعدی :meth:`read` تجزیه کرد. اگر *space_around_delimiters* برابر true باشد، جداکننده‌های بین کلیدها و مقدارها با فاصله احاطه می‌شوند."

msgid "Raises InvalidWriteError if this would write a representation which cannot be accurately parsed by a future :meth:`read` call from this parser."
msgstr "در صورتی که این عمل منجر به نوشتن بازنمایی‌ای شود که یک فراخوانی آینده :meth:`read` از این پارسر نتواند آن را به‌دقت تجزیه کند، InvalidWriteError را پرتاب می‌کند."

msgid "Comments in the original configuration file are not preserved when writing the configuration back. What is considered a comment, depends on the given values for *comment_prefix* and *inline_comment_prefix*."
msgstr "کامنت‌های موجود در پرونده پیکربندی اصلی، هنگام نوشتن مجدد پیکربندی حفظ نمی‌شوند. اینکه چه چیزی کامنت در نظر گرفته می‌شود، به مقادیر داده‌شده برای *comment_prefix* و *inline_comment_prefix* بستگی دارد."

msgid "Remove the specified *option* from the specified *section*.  If the section does not exist, raise :exc:`NoSectionError`.  If the option existed to be removed, return :const:`True`; otherwise return :const:`False`."
msgstr "*option* مشخص‌شده را از *section* مشخص‌شده حذف می‌کند. اگر بخش وجود نداشته باشد، :exc:`NoSectionError` را پرتاب می‌کند. اگر گزینه برای حذف وجود داشته باشد، :const:`True` را برمی‌گرداند؛ در غیر این صورت :const:`False` را برمی‌گرداند."

msgid "Remove the specified *section* from the configuration.  If the section in fact existed, return ``True``.  Otherwise return ``False``."
msgstr "*section* مشخص‌شده را از پیکربندی حذف می‌کند. اگر بخش در واقع وجود داشته باشد، ``True`` برمی‌گرداند. در غیر این صورت ``False`` برمی‌گرداند."

msgid "Transforms the option name *option* as found in an input file or as passed in by client code to the form that should be used in the internal structures.  The default implementation returns a lower-case version of *option*; subclasses may override this or client code can set an attribute of this name on instances to affect this behavior."
msgstr "نام گزینه *option* را، همان‌گونه که در یک پرونده ورودی یافت می‌شود یا توسط کد کلاینت ارسال می‌شود، به شکلی تبدیل می‌کند که باید در ساختارهای داخلی استفاده شود. پیاده‌سازی پیش‌فرض، نسخه‌ای با حروف کوچک از *option* را برمی‌گرداند؛ زیرکلاس‌ها می‌توانند این را بازنویسی کنند یا کد کلاینت می‌تواند ویژگی‌ای به این نام را روی نمونه‌ها تنظیم کند تا بر این رفتار اثر بگذارد."

msgid "You don't need to subclass the parser to use this method, you can also set it on an instance, to a function that takes a string argument and returns a string.  Setting it to ``str``, for example, would make option names case sensitive::"
msgstr "برای استفاده از این متد نیازی نیست پارسر را زیرکلاس کنید؛ می‌توانید آن را بر روی یک نمونه نیز به تابعی تنظیم کنید که یک آرگومان رشته‌ای دریافت می‌کند و یک رشته برمی‌گرداند. برای مثال، تنظیم آن به ``str`` باعث می‌شود نام گزینه‌ها به بزرگی و کوچکی حروف حساس شوند::"

msgid ""
"cfgparser = ConfigParser()\n"
"cfgparser.optionxform = str"
msgstr ""
"cfgparser = ConfigParser()\n"
"cfgparser.optionxform = str"

msgid "Note that when reading configuration files, whitespace around the option names is stripped before :meth:`optionxform` is called."
msgstr "توجه داشته باشید که هنگام خواندن پرونده‌های پیکربندی، فاصله‌های سفید اطراف نام گزینه‌ها پیش از فراخوانی :meth:`optionxform` حذف می‌شود."

msgid "A special object representing a section name used to reference the unnamed section (see :ref:`unnamed-sections`)."
msgstr "یک شیء خاص که نشان‌دهنده‌ی نام بخش است و برای ارجاع به بخش بی‌نام استفاده می‌شود (به :ref:`unnamed-sections` مراجعه کنید)."

msgid "The maximum depth for recursive interpolation for :meth:`~configparser.ConfigParser.get` when the *raw* parameter is false.  This is relevant only when the default *interpolation* is used."
msgstr "حداکثر عمق درون‌یابی بازگشتی برای :meth:`~configparser.ConfigParser.get` زمانی که پارامتر *raw* نادرست باشد. این مورد تنها زمانی مرتبط است که از *interpolation* پیش‌فرض استفاده شود."

msgid "RawConfigParser Objects"
msgstr "اشیای RawConfigParser"

msgid "Legacy variant of the :class:`ConfigParser`.  It has interpolation disabled by default and allows for non-string section names, option names, and values via its unsafe ``add_section`` and ``set`` methods, as well as the legacy ``defaults=`` keyword argument handling."
msgstr "گونه‌ای قدیمی از :class:`ConfigParser`. درون‌یابی در آن به‌طور پیش‌فرض غیرفعال است و از طریق متدهای ناامن ``add_section`` و ``set`` و نیز مدیریت قدیمی آرگومان کلیدواژه‌ای ``defaults=``، امکان استفاده از نام‌های بخش، نام‌های گزینه و مقادیر غیررشته‌ای را فراهم می‌کند."

msgid "Consider using :class:`ConfigParser` instead which checks types of the values to be stored internally.  If you don't want interpolation, you can use ``ConfigParser(interpolation=None)``."
msgstr "در عوض، استفاده از :class:`ConfigParser` را در نظر بگیرید که نوع مقادیری را که باید به‌صورت داخلی ذخیره شوند بررسی می‌کند. اگر درون‌یابی نمی‌خواهید، می‌توانید از ``ConfigParser(interpolation=None)`` استفاده کنید."

msgid "Add a section named *section* or :const:`UNNAMED_SECTION` to the instance."
msgstr "یک بخش با نام *section* یا :const:`UNNAMED_SECTION` به نمونه اضافه می‌کند."

msgid "If the given section already exists, :exc:`DuplicateSectionError` is raised. If the *default section* name is passed, :exc:`ValueError` is raised. If :const:`UNNAMED_SECTION` is passed and support is disabled, :exc:`UnnamedSectionDisabledError` is raised."
msgstr "اگر بخش داده‌شده از قبل وجود داشته باشد، :exc:`DuplicateSectionError` پرتاب می‌شود. اگر نام *بخش پیش‌فرض* داده شود، :exc:`ValueError` پرتاب می‌شود. اگر :const:`UNNAMED_SECTION` داده شود و پشتیبانی غیرفعال باشد، :exc:`UnnamedSectionDisabledError` پرتاب می‌شود."

msgid "Type of *section* is not checked which lets users create non-string named sections.  This behaviour is unsupported and may cause internal errors."
msgstr "نوع *section* بررسی نمی‌شود و این به کاربران امکان می‌دهد بخش‌هایی با نام‌های غیررشته‌ای ایجاد کنند. این رفتار پشتیبانی نمی‌شود و ممکن است باعث خطاهای داخلی شود."

msgid "Added support for :const:`UNNAMED_SECTION`."
msgstr "پشتیبانی از :const:`UNNAMED_SECTION` افزوده شد."

msgid "If the given section exists, set the given option to the specified value; otherwise raise :exc:`NoSectionError`.  While it is possible to use :class:`RawConfigParser` (or :class:`ConfigParser` with *raw* parameters set to true) for *internal* storage of non-string values, full functionality (including interpolation and output to files) can only be achieved using string values."
msgstr "اگر بخش داده‌شده وجود داشته باشد، گزینه‌ی داده‌شده به مقدار مشخص‌شده تنظیم می‌شود؛ در غیر این صورت :exc:`NoSectionError` پرتاب می‌شود. اگرچه می‌توان از :class:`RawConfigParser` (یا :class:`ConfigParser` با پارامترهای *raw* که به true تنظیم شده‌اند) برای ذخیره‌سازی *داخلی* مقادیر غیررشته‌ای استفاده کرد، اما قابلیت کامل (شامل درون‌یابی و خروجی به پرونده‌ها) تنها با استفاده از مقادیر رشته‌ای امکان‌پذیر است."

msgid "This method lets users assign non-string values to keys internally.  This behaviour is unsupported and will cause errors when attempting to write to a file or get it in non-raw mode.  **Use the mapping protocol API** which does not allow such assignments to take place."
msgstr "این متد به کاربران اجازه می‌دهد که مقادیر غیررشته‌ای را به‌صورت داخلی به کلیدها منتسب کنند. این رفتار پشتیبانی نمی‌شود و هنگام تلاش برای نوشتن در یک پرونده یا دریافت آن در حالت غیرخام، باعث بروز خطاها خواهد شد. **از API پروتکل نگاشت استفاده کنید** که چنین انتساب‌هایی را مجاز نمی‌داند."

msgid "Exceptions"
msgstr "استثناها"

msgid "Base class for all other :mod:`!configparser` exceptions."
msgstr "کلاس پایه برای تمام استثناهای دیگر :mod:`!configparser`."

msgid "Exception raised when a specified section is not found."
msgstr "استثنایی که هنگام پیدا نشدن بخش مشخص‌شده پرتاب می‌شود."

msgid "Exception raised if :meth:`~ConfigParser.add_section` is called with the name of a section that is already present or in strict parsers when a section if found more than once in a single input file, string or dictionary."
msgstr "استثنایی پرتاب می‌شود اگر :meth:`~ConfigParser.add_section` با نام بخشی که از قبل موجود است فراخوانی شود، یا در پارسرهای سخت‌گیر وقتی بخشی بیش از یک بار در یک پرونده ورودی، رشته یا دیکشنری واحد یافت شود."

msgid "Added the optional *source* and *lineno* attributes and parameters to :meth:`!__init__`."
msgstr "ویژگی‌ها و پارامترهای اختیاری *source* و *lineno* به :meth:`!__init__` اضافه شدند."

msgid "Exception raised by strict parsers if a single option appears twice during reading from a single file, string or dictionary. This catches misspellings and case sensitivity-related errors, e.g. a dictionary may have two keys representing the same case-insensitive configuration key."
msgstr "استثنایی که توسط پارسرهای سخت‌گیر در صورتی پرتاب می‌شود که یک گزینه هنگام خواندن از یک پرونده، رشته یا دیکشنری واحد دو بار ظاهر شود. این امر غلط‌های املایی و خطاهای مربوط به حساسیت به حروف کوچک و بزرگ را شناسایی می‌کند، برای مثال ممکن است یک دیکشنری دو کلید داشته باشد که نشان‌دهنده‌ی یک کلید پیکربندی بدون حساسیت به حروف کوچک و بزرگ باشند."

msgid "Exception raised when a specified option is not found in the specified section."
msgstr "استثنایی که هنگامی پرتاب می‌شود که گزینه‌ی مشخص‌شده در بخش مشخص‌شده یافت نشود."

msgid "Base class for exceptions raised when problems occur performing string interpolation."
msgstr "کلاس پایه برای استثناهایی که هنگام بروز مشکلات در انجام درون‌یابی رشته پرتاب می‌شوند."

msgid "Exception raised when string interpolation cannot be completed because the number of iterations exceeds :const:`MAX_INTERPOLATION_DEPTH`.  Subclass of :exc:`InterpolationError`."
msgstr "استثنایی که هنگامی پرتاب می‌شود که درون‌یابی رشته نمی‌تواند تکمیل شود، زیرا تعداد تکرارها از :const:`MAX_INTERPOLATION_DEPTH` فراتر می‌رود. زیرکلاسی از :exc:`InterpolationError`."

msgid "Exception raised when an option referenced from a value does not exist. Subclass of :exc:`InterpolationError`."
msgstr "استثنایی که هنگامی پرتاب می‌شود که گزینه‌ای که از یک مقدار به آن ارجاع داده شده است وجود نداشته باشد. زیرکلاسی از :exc:`InterpolationError`."

msgid "Exception raised when the source text into which substitutions are made does not conform to the required syntax.  Subclass of :exc:`InterpolationError`."
msgstr "استثنایی که در صورتی پرتاب می‌شود که متن منبعی که جایگذاری‌ها در آن انجام می‌شوند، با سینتکس مورد نیاز مطابقت نداشته باشد. زیرکلاسی از :exc:`InterpolationError` است."

msgid "Exception raised when attempting to parse a file which has no section headers."
msgstr "استثنایی که هنگام تلاش برای تجزیه‌ی پرونده‌ای که هیچ سرآیند بخشی ندارد پرتاب می‌شود."

msgid "Exception raised when errors occur attempting to parse a file."
msgstr "استثنایی که هنگام بروز خطا در تلاش برای تجزیه‌ی یک پرونده پرتاب می‌شود."

msgid "The ``filename`` attribute and :meth:`!__init__` constructor argument were removed.  They have been available using the name ``source`` since 3.2."
msgstr "ویژگی ``filename`` و آرگومان سازنده‌ی :meth:`!__init__` حذف شده‌اند. این موارد از 3.2 با استفاده از نام ``source`` در دسترس بوده‌اند."

msgid "Exception raised when a key without a corresponding value is continued with an indented line."
msgstr "استثنایی که هنگامی پرتاب می‌شود که یک کلید بدون مقدار متناظر، با یک خط تورفته ادامه یابد."

msgid "Exception raised when attempting to use the :const:`UNNAMED_SECTION` without enabling it."
msgstr "استثنایی که هنگام تلاش برای استفاده از :const:`UNNAMED_SECTION` بدون فعال‌سازی آن پرتاب می‌شود."

msgid "Exception raised when an attempted :meth:`ConfigParser.write` would not be parsed accurately with a future :meth:`ConfigParser.read` call."
msgstr "استثنایی که هنگامی پرتاب می‌شود که تلاش برای فراخوانی :meth:`ConfigParser.write` نتواند با یک فراخوانی :meth:`ConfigParser.read` در آینده به‌طور دقیق تجزیه شود."

msgid "Ex: Writing a key beginning with the :attr:`ConfigParser.SECTCRE` pattern would parse as a section header when read. Attempting to write this will raise this exception."
msgstr "مثال: نوشتن کلیدی که با الگوی :attr:`ConfigParser.SECTCRE` آغاز می‌شود، هنگام خواندن به‌عنوان سرآیند بخش تجزیه می‌شود. تلاش برای نوشتن این مورد باعث پرتاب این استثنا می‌شود."

msgid "Footnotes"
msgstr "پانویس‌ها"

msgid "Config parsers allow for heavy customization.  If you are interested in changing the behaviour outlined by the footnote reference, consult the `Customizing Parser Behaviour`_ section."
msgstr "پارسرهای پیکربندی امکان سفارشی‌سازی گسترده‌ای را فراهم می‌کنند. اگر به تغییر رفتار شرح‌داده‌شده در ارجاع پانویس علاقه‌مند هستید، به بخش `Customizing Parser Behaviour`_ مراجعه کنید."

msgid ".ini"
msgstr ".ini"

msgid "file"
msgstr "پرونده"

msgid "configuration"
msgstr "پیکربندی"

msgid "ini file"
msgstr "پرونده ini"

msgid "Windows ini file"
msgstr "پرونده ini ویندوز"

msgid "% (percent)"
msgstr "% (درصد)"

msgid "interpolation in configuration files"
msgstr "درون‌یابی در پرونده‌های پیکربندی"

msgid "$ (dollar)"
msgstr "$ (دلار)"